Delegate Array

Question

J'expérimente l'appel de fonctions déléguées à partir d'un tableau de délégués. J'ai été capable de créer le tableau des délégués, mais comment puis-je appeler le délégué?

public delegate void pd(); 

public static class MyClass 
{ 

    static void p1() 
    { 
     //... 
    } 

    static void p2() 
    { 
     //... 
    } 

    //... 

    static pd[] delegates = new pd[] { 

     new pd(MyClass.p1), 
     new pd(MyClass.p2) 
     /* ... */ 
    }; 
} 

public class MainClass 
{ 
    static void Main() 
    { 
     // Call pd[0] 
     // Call pd[1] 
    } 
} 

EDIT: La raison du tableau est que je dois appeler les fonctions de délégué par un indice au besoin. Ils ne sont pas exécutés en réponse à un événement. Je vois une erreur critique (stupide) dans mon code car j'ai essayé d'exécuter la fonction déléguée en utilisant le type pd [] plutôt que le nom du tableau (délégués).

Answer 1

Si elles sont toutes du même type, pourquoi ne pas les combiner en un seul délégué Multicast?

static pd delegateInstance = new pd(MyClass.p1) + new pd(MyClass.p2) ...; 

... 
pd(); 

Answer 2

public class MainClass 
{ 
    static void Main() 
    { 
     pd[0](); 
     pd[1](); 
    } 
} 

Answer 3

En .Net, un délégué est en fait réellement un délégué « multicast » (il hérite de cette classe intégrée de base), et contient donc une liste chaînée interne qui peut contenir un certain nombre de délégués cibles.

Vous pouvez accéder à cette liste en appelant la méthode GetInvocationList() sur le délégué lui-même. Cette méthode renvoie un tableau de délégués ...

La seule restriction est que tous les délégués à l'intérieur de la liste chaînée d'un délégué donné doivent avoir la même signature (être du même type de délégué). Si vous avez besoin que votre collection contienne des délégués de types disparates, vous devez construire votre propre liste ou classe de collection.

Mais si cela est ok, alors vous pouvez "appeler" les délégués dans une liste d'invocation de délégué donné comme celui-ci:

public delegate void MessageArrivedHandler(MessageBase msg); 
public class MyClass 
{ 
    public event MessageArrivedHandler MessageArrivedClientHandler; 

    public void CallEachDelegate(MessageBase msg) 
    { 
      if (MessageArrivedClientHandler == null) 
       return; 
      Delegate[] clientList = MessageArrivedClientHandler.GetInvocationList(); 
      foreach (Delegate d in clientList) 
      { 
       if (d is MessageArrivedHandler) 
        (d as MessageArrivedHandler)(msg); 
      } 
    } 
} 

Answer 4

public partial class Form1 : Form 
{ 
    public Form1() 
    { 
     InitializeComponent(); 
     pd[0](); 
     pd[1](); 
    } 

    public delegate void delegates(); 

    static delegates[] pd = new delegates[] 
          { 
           new delegates(MyClass.p1), 
           new delegates(MyClass.p2) 
          }; 

    public static class MyClass 
    { 
     public static void p1() 
     { 
      MessageBox.Show("1"); 
     } 

     public static void p2() 
     { 
      MessageBox.Show("2"); 
     } 
    } 
} 

Answer 5

public partial class Form1 : Form 
{ 
    public Form1() 
    { 
     InitializeComponent(); 
     pd[0](1); 
     pd[1](2); 
    } 

    public delegate void delegates(int par); 
    static delegates[] pd = new delegates[] 
            { 
             new delegates(MyClass.p1), 
             new delegates(MyClass.p2) 
            }; 
    public static class MyClass 
    { 

     public static void p1(int par) 
     { 
      MessageBox.Show(par.ToString()); 
     } 

     public static void p2(int par) 
     { 
      MessageBox.Show(par.ToString()); 
     } 


    } 

}