Discussion :

[agparchitecture]

Bonjour/bonsoir à tous,

je continue mon apprentissage de C# et je viens de découvrir les delegate qui conviendrait, à mon avis, à une utilisation pour un draganddrop sur un treeview depuis plusieures source. J'ai donc implémenter celà

La partie dragdrop du treeview

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
		private void trv_DragDrop(object sender, DragEventArgs e)
		{
			if( e.Data == null ) return;
 
			TreeNode targetNode = trv.GetNodeAt( trv.PointToClient(new Point(e.X, e.Y)) );
			if(targetNode == null ) return;
 
			e.Effect = ( e.KeyState == 4 )? DragDropEffects.Copy : DragDropEffects.Move;
 
                       DelDropProcessing delDataProcessing = dataDropedOnTreeview.GetDelegate( e.Data );
                      delDataProcessing( targetNode, _nodeToMove, e.Effect, e.Data );
 
			targetNode.Expand();
		}

La class de traitement des données

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
        public delegate void DelDropProcessing(TreeNode destinationNode, TreeNode nodeToMove,  DragDropEffects effect, IDataObject data);
 
	public static class dataDropedOnTreeview 
	{
 
        public static DelDropProcessing GetDelegate(IDataObject data)
	{
		if( data.GetDataPresent(typeof(TreeNode)) )
                          return new DelDropProcessing( TreeNodeData );
 
		if( data.GetDataPresent(typeof(ListViewItem)))
                         return new DelDropProcessing( ListViewData );
 
            return new DelDropProcessing( NoDataReader );
        }
 
        public static void NoDataReader( TreeNode destinationNode, TreeNode nodeToMove, DragDropEffects effect, IDataObject data )
        {
			//Ne fait rien car pas un type de données connu
	}
 
        public static void TreeNodeData ( TreeNode destinationNode, TreeNode nodeToMove, DragDropEffects effect, IDataObject data )
	{
			//traitement des données
	}
 
	public static void ListViewData ( TreeNode destinationNode, TreeNode nodeToMove, DragDropEffects effect, IDataObject data )
	{
			//traitement des données
	}
}

J'aurais donc souhaiter savoir :

1. Est-ce l'utilisation correct des delegate?
2. Est-ce bien le type de situation pour l'utilisation des delegate
3. Je ne vois pas en quoi les delegate simplifie le code puisque je me retrouve quand même à devoir fair des if repetitif ou un switch case pour definir le delegate à utiliser et donc je pourrais faire celà avec de simple fonction
4. Avez vous des remarques sur le bout de code ou toute autre conseil à me fournir

Je vous remercie d'avance

[phil_tema]

Perso j'utilise les delegate pour les opérations inter thread par exemple :
un thread dans une classe qui veut mettre à jour un contrôle ProgressBar dans une Form
Le thread génère un event, qui est capté par la Form mais il faut un delegate pour mettre
la ProgressBar à jour car sinon on se paye une opération interthread invalide !

PS : il y a peut-être mieux mais ça fonctionne !

Code du Thread :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public delegate void updateProgBarEventHandler(int percent);
 
public class MyClass
{
 
public event updateProgBarEventHandler UpdateProgBarEvent;
 
//...
 
private void ThreadProc()
{
//...
UpdateProgBarEvent?(50) // ou 50 est la valeur en %
}
 
}

Code de la Form :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
private delegate void UpdateProgBarDelegate(int percent);
 
public Form()
{
MyClass.UpdateProgBarEvent += new updateProgBarEventHandler(Form_OnProgEvent);
}
 
private void Form_OnProgEvent(int percent)
{
this.Invoke(new UpdateProgBarDelegate(UpdateProgbar, percent));
}
 
private void UpdateProgBar(int percent)
{
ProgressBar.Value = percent; // ici la barre est mise à jour
}

[François DORIN]

Un delegate est un pointeur de fonctionS (oui oui, au pluriel).

Ici, l'usage du delegate tel qu'il est fait n'apporte pas grand chose. Il n'apporte pas grand chose simplement parce que les fonctions sont déjà définies et connues au sein de la classe dataDropedOnTreeview. Et donc, comme tu le soulignes, l'utilisation d'un delegate n'apporte pas grand chose ici.

Par contre, les delegate peuvent être utilisés ici pour réaliser quelque chose de similaire au patron visiteur (sans avoir besoin de déclarer de classes supplémentaires, juste des méthodes)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public static class dataDropedOnTreeview
{
   public static DelDropProcessing Processing { get; set; }
 
   static dataDropedOnTreeview()
   {
      // On note l'ajout de deux fonctions dans le delegate. 
      // lors de l'appel du delegate, les deux fonctions seront appelées
      this.Processing += TreeNodeData;
      this.Processing += ListViewData;
   }
 
   // Plus besoin de la méthode NoDataReader
 
   public static void TreeNodeData ( TreeNode destinationNode, TreeNode nodeToMove, DragDropEffects effect, IDataObject data )
   {
       if (data is TreeNodeData treeNodeData)
       {
           // avant le traitement des données, on vérifie que la donnée est du bon type
           //traitement des données
       }
   }
 
   public static void ListViewData ( TreeNode destinationNode, TreeNode nodeToMove, DragDropEffects effect, IDataObject data )
   {
      if (data is ListViewData listViewData)
      {
          // idem          
	  //traitement des données
      }
   }
}

Et pour appeler le delegate :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
dataDropedOnTreeview.Processing(targetNode, _nodeToMove, e.Effect, e.data);

Les avantages que j'y vois :

• ce sont les méthodes qui se chargent de vérifier si elles doivent au pas gérer un appel. On évite donc une cascade de if ou un switch, et toute la responsabilité de la gestion est dans une seule méthode
• l'enregistrement d'une nouvelle méthode est assez simple (on rajoute une méthode au delegate), sans avoir besoin de connaitre le type de données manipulées
• lors de l'appel au delegate, il n'est plus nécessaire de l'instancier avant en précisant le type qui sera utilisée, puis de repréciser les données lors de l'appel effectif.
• potentiellement, une même donnée pourra être traité par plusieurs delegate si cela est nécessaire.