Quand & pourquoi utiliser des délégués ?

Question

Je suis relativement nouveau en c#, et je me demandais quand utiliser les Délégués de façon appropriée. ils sont largement utilisés dans les événements de la déclaration , mais quand dois-je utiliser dans mon propre code et pourquoi sont-ils utiles?, pourquoi ne pas utiliser autre chose?

Je me demande aussi quand je dois utiliser les délégués et j'ai pas d'autre alternative.

Thx pour l'aider.

EDIT: je crois que j'ai trouvé un usage nécessaire de Délégués ici

Answer 1

Un délégué est une référence à une méthode. Alors que les objets peuvent être facilement envoyés comme paramètres dans méthodes, constructeur ou que ce soit, les méthodes sont un peu plus compliqués. Mais chaque fois dans un certain temps, vous pourriez vous sentir la nécessité d’envoyer une méthode comme un paramètre à une autre méthode, et c’est quand vous aurez besoin de délégués.

Answer 2

Je suis d'accord avec tout ce qui est dit déjà, juste essayer de mettre quelques mots sur elle.

Un délégué peut être vu comme un espace réservé pour un/des méthode(s).

Par la définition d'un délégué, vous dites à l'utilisateur de votre classe ", n'hésitez pas à mettre toute méthode qui correspondent à cette signature ici et elle sera appelée à chaque fois que mon délégué est appelé".

L'utilisation typique est de le cours des événements. Tous les OnEventX délégué aux méthodes de l'utilisateur définit.

Les délégués sont d'utile à offrir à l' utilisateur de vos objets d'une certaine capacité à adapter leur comportement. La plupart du temps, vous pouvez utiliser d'autres moyens d'atteindre le même but, et je ne crois pas que vous pouvez jamais être forcé de créer des délégués. C'est juste le moyen le plus facile dans certaines situations, pour obtenir la chose à faire.

Answer 3

Dites que vous voulez écrire une procédure pour intégrer certaines valeurs réelles de la fonction f (x) sur un certain intervalle de temps [a, b]. Disons que nous voulons utiliser les 3 Points de Gauss de la méthode pour ce faire (tout va le faire, bien sûr).

Idéalement, nous voulons une fonction qui ressemble à ceci:

// 'f' is the integrand we want to integrate over [a, b] with 'n' subintervals.
static double Gauss3(Integrand f, double a, double b, int n) {
  double res = 0;

  // compute result
  // ...

  return res;
}

Nous pouvons donc passer dans tous Integrand, f, et d'obtenir son intégrale sur l'intervalle fermé.

Juste ce type devrait Integrand ?

Sans Les Délégués

Eh bien, sans les délégués, nous avions besoin d'une sorte d'interface avec une seule méthode, disons eval déclarée comme suit:

// Interface describing real-valued functions of one variable.
interface Integrand {
  double eval(double x);
}

Alors que nous aurions besoin de créer tout un tas de classes implémentant cette interface, comme suit:

// Some function
class MyFunc1 : Integrand {
  public double eval(double x) {
    return /* some_result */ ;
  }
}

// Some other function
class MyFunc2 : Integrand {
  public double eval(double x) {
    return /* some_result */ ;
  }
}

// etc

Puis à les utiliser dans notre Gauss3 méthode, nous avons besoin de l'invoquer comme suit:

double res1 = Gauss3(new MyFunc1(), -1, 1, 16);
double res2 = Gauss3(new MyFunc2(), 0, Math.PI, 16);

Et Gauss3 doit ressembler à l'exemple suivant:

static double Gauss3(Integrand f, double a, double b, int n) {
  // Use the integrand passed in:
  f.eval(x);
}

Nous avons donc besoin de faire tout ça juste pour utiliser nos fonctions arbitraires en Guass3.

Avec Les Délégués

public delegate double Integrand(double x);

Maintenant, nous pouvons définir quelques statique (ou pas) de fonctions en adhérant à ce prototype:

class Program {
   static double MyFunc1(double x) { /* ... */ }
   static double MyFunc2(double x) { /* ... */ }
   // ... etc ...

   public static double Gauss3(Integrand f, ...) { 
      // Now just call the function naturally, no f.eval() stuff.
      double a = f(x); 
      // ...
   }

   // Let's use it
   static void Main() {
     // Just pass the function in naturally (well, its reference).
     double res = Gauss3(MyFunc1, a, b, n);
     double res = Gauss3(MyFunc2, a, b, n);    
   }
}

Pas d'interfaces, pas maladroit .eval trucs, pas de l'instanciation d'objets, de simples la fonction de pointeur de l'utilisation, pour une tâche simple.

Bien sûr, les délégués sont plus que juste des pointeurs de fonction sous le capot, mais c'est une question distincte (la fonction de chaînage et d'événements).

Answer 4

Les délégués sont extrêmement utiles lorsque l'on veut déclarer un bloc de code que vous souhaitez passer. Par exemple lors de l'utilisation d'un générique mécanisme de nouvelle tentative.

Pseudo:

function Retry(Delegate func, int numberOfTimes)
    try
    {
       func.Invoke();
    }
    catch { if(numberOfTimes blabla) func.Invoke(); etc. etc. }

Ou lorsque vous voulez faire la fin de l'évaluation de blocs de code, comme une fonction de l'endroit où vous avez quelques Transform d'action, et que vous voulez avoir un BeforeTransform et AfterTransform d'action que vous pouvez évaluer au sein de votre fonction de Transformation, sans avoir à savoir si l' BeginTransform est rempli, ou ce qu'il a à le transformer.

Et bien sûr, lors de la création de gestionnaires d'événements. Vous ne voulez pas d'évaluer le code maintenant, mais uniquement lorsque cela est nécessaire, de sorte que vous vous inscrivez à un délégué, qui peut être appelée lorsque l'événement se produit.

Answer 5

Les Délégués Aperçu

Les délégués sont les suivantes propriétés:

• Les délégués sont similaires à C++ pointeurs de fonction, mais sont de type coffre-fort.

• Les délégués permettre méthodes pour être passés en paramètres.

• Les délégués peuvent être utilisées pour définir des méthodes de rappel.

• Les délégués peuvent être enchaînés les uns aux autres; par exemple, plusieurs méthodes peuvent être
  appelé à un événement unique.

• Les méthodes n'ont pas besoin de correspondre à la déléguer la signature exactement. Pour plus d'
  d'informations, consultez la Covariance et
  Contra-variance

• C# version 2.0 introduit la notion de Méthodes Anonymes, qui permis de blocs de code à transmettre comme les paramètres en place d'un séparément
  méthode définie.