Délégué De La Matrice De

Je suis expérimenter avec l'appel de déléguer des fonctions d'un délégué du tableau. J'ai été en mesure de créer le tableau de délégués, mais comment dois-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 pour laquelle le tableau est que j'ai besoin d'appeler le délégué des fonctions par un index en tant que de besoin. Ils ne sont pas exécutés en réponse à un événement. Je vois une critique (stupide) erreur dans mon code que j'avais essayé d'exécuter la fonction de délégué à l'aide de la pd[] type plutôt que le nom de la matrice (les délégués).

OriginalL'auteur pro3carp3 | 2008-10-31

arrays c#delegates

14

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();
```
L'une des raisons de ne pas serait individuellement gérer les exceptions levées par l'un des délégués, plutôt que de juste attraper le premier.
Comme pour mon edit, les délégués ne sont pas exécutées en réponse à un événement, mais appelés individuellement à l'aide d'un indice dans le tableau.
oui, si vous voulez 🙂 @pro3carp3 - dans ce cas vous avez juste besoin d'un accès par index par normal pour un tableau. Il n'y a rien de spécial à ce sujet étant un délégué ici.
Merci, Jon. J'ai fait une erreur stupide, et la pensée qu'il me manquait quelque chose.

OriginalL'auteur Jon Skeet
7
```
public class MainClass
{
    static void Main()
    {
        pd[0]();
        pd[1]();
    }
}
```
Techniquement, cela devrait être MyClass.pd[0](). pd est un type, et MyClass.pd est membre statique de MyClass.
Pourquoi ne pas combiner les PD!

OriginalL'auteur Romain Verdier
7

.Net, un délégué est en fait en réalité un "multicast" délégué (il hérite de ce construit-dans la classe de base), et, par conséquent, possède une liste chaînée qui peut contenir n'importe quel nombre de cibles délégués.

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 d'un délégué de liste liée doit avoir la même signature, (être du même type délégué). Si vous avez besoin de votre collection pour être en mesure de contenir les délégués de différents types, alors vous avez besoin pour construire votre propre liste ou de la classe de collection.

Mais si c'est ok, on peut "appeler" les délégués dans un délégué de liste d'invocation comme ceci:
```
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);
          }
     }
}
```
OriginalL'auteur Charles Bretana

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");
        }
    }
}

C'est "délégué" pas "délégués"

OriginalL'auteur Garric

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());
        }


    }

}

OriginalL'auteur Garric

Vous devez vous connecter pour publier un commentaire.