Question

Quelqu'un peut-il s'il vous plaît briser ce délégué est dans une explication simple, courte et laconique qui englobe à la fois le but et les avantages généraux? J'ai essayé d'envelopper ma tête autour de cela et il est tout simplement pas sombrer dans.

Était-ce utile?

La solution

Dans les termes les plus simples possibles, il est essentiellement un pointeur vers une méthode.

Vous pouvez avoir une variable qui est titulaire d'un type délégué (comme vous auriez une variable int qui peut contenir un type int). Vous pouvez exécuter la méthode que les points de délégués à en appelant simplement votre variable comme une fonction.

Cela vous permet d'avoir des fonctions variables comme vous pourriez avoir des données variables. Votre objet peut accepter des délégués d'autres objets et les appeler, sans avoir à définir lui-même toutes les fonctions possibles.

Cela est très pratique lorsque vous voulez un objet à faire des choses en fonction de critères définis par l'utilisateur. Par exemple, le filtrage d'une liste basée sur une expression true / false définie par l'utilisateur. Vous pouvez laisser l'utilisateur de spécifier la fonction de délégué à utiliser comme filtre pour évaluer chaque élément de la liste contre.

Autres conseils

J'ai une fonction:

public long GiveMeTwoTimesTwo()
{
    return 2 * 2;
}

Cette fonction suce. Et si je veux 3 * 3?

public long GiveMeThreeTimesThree()
{
    return 3 * 3;
}

Trop taper. Je suis paresseux!

public long SquareOf(int n)
{
    return n * n;
}

Ma fonction SquareOf ne se soucie pas ce que n est. Il fonctionnera correctement pour tout n transmis. Il ne sait pas exactement quel numéro n est, mais fait savent que n est un entier. Vous ne pouvez pas passer "Haha not an integer" dans SquareOf.

Voici une autre fonction:

public void DoSomethingRad()
{
    int x = 4;
    long y = SquareOf(x);
    Console.WriteLine(y);
}

Contrairement à son nom, DoSomethingRad ne fait réellement rien rad. Cependant, il n'écrit le SquareOf (4) qui est 16. Peut-on changer pour être moins ennuyeux?

public void DoSomethingRad(int numberToSquare)
{
    long y = SquareOf(numberToSquare);
    Console.WriteLine(y);
}

DoSomethingRad est encore assez clairement l'échec. Mais au moins maintenant nous pouvons passer plusieurs à la case départ, donc il ne sera pas écrire 16 à chaque fois. (Il va écrire 1 ou 4, ou 9, ou 16, ou ... zzzz encore ennuyeux un peu).

Ce serait bien s'il y avait un moyen de changer ce qui se passe au nombre passé dans Peut-être que nous ne voulons pas qu'il carré. peut-être que nous voulons couper en cubes ou soustraire de 69 (nombre choisi au hasard de ma tête).

Sur une inspection plus poussée, il semble que la seule partie de SquareOf que DoSomethingRad prend soin est sur le point que nous pouvons le donner un entier (numberToSquare) et qu'il nous donne un long (parce que nous mettons la valeur de retour dans y et y est un long).

public long CubeOf(int n)
{
    return n * n * n;
}

public void DoSomethingLeet(int numberToSquare)
{
    long y = CubeOf(numberToSquare);
    Console.WriteLine(y);
}

Voyez comment similaire DoSomethingLeet est à DoSomethingRad? Si seulement il y avait un moyen de passer dans comportement (DoX()) au lieu de simplement données (int n) ...

Alors maintenant, si nous voulons écrire un carré d'un nombre, nous pouvons DoSomethingRad et si nous voulons écrire le cube d'un nombre, nous pouvons DoSomethingLeet. Donc, si nous voulons écrire le nombre de 69 soustraites, devons-nous faire une autre méthode, DoSomethingCool? Non, car cela prend vraiment trop bien taper (et plus important encore, il entrave notre capacité à modifier le comportement intéressant en changeant un seul aspect de notre programme).

Nous arrivons donc à:

public long Radlicious(int doSomethingToMe, Func<int, long> doSomething)
{
    long y = doSomething(doSomethingToMe);
    Console.WriteLine(y);
}

On peut appeler cette méthode en écrivant ceci:

Radlicious(77, SquareOf);

Func<int, long> est un type particulier de délégué. Il stocke le comportement qui accepte des entiers et recrache longs. Nous ne sommes pas sûr de ce que la méthode il pointe va faire avec tout entier donné que nous passons; tout ce que nous savons est que, quoi qu'il arrive, nous allons obtenir un long retour.

Nous ne devons pas donner des paramètres à SquareOf car Func<int, long> décrit le comportement , pas des données. L'appel Radlicious(77, SquareOf) donne juste Radlicious le comportement général de SquareOf ( « Je prends un numéro et retourne sa place »), pas ce que SquareOf fera à tout spécifique entier.

Maintenant, si vous avez compris ce que je dis, vous me avez déjà un fait monter, car je me ne suis pas vraiment ce genre de choses.

* RÉPONSE END, BEGIN ERRANCE IDIOTIE *

Je veux dire, il semble que ints pourrait être perçue comme un comportement vraiment ennuyeux:

static int Nine()
{
    return 9;
}

Cela dit, la ligne entre ce qui est des données et le comportement semble flou, avec ce qui est normalement perçu comme des données est tout simplement un comportement ennuyeux-cul.

Bien sûr, on pourrait imaginer super comportement « intéressant », qui prend toutes sortes de paramètres abstraits, mais nécessite une tonne d'informations pour pouvoir l'appeler. Et si elle nous doit fournir le code source qu'il compiler et exécuter pour nous?

Eh bien, notre abstraction semble nous avoir obtenu tout le chemin du retour à la case départ. Nous avons un comportement si abstraite nécessite l'intégralité du code source de notre programme pour déterminer ce qu'il va faire. C'est behavio totalement indéterminéer: la fonction peut faire quoi que ce soit , mais il doit être fourni avec tout pour déterminer ce qu'il fait. D'autre part, le comportement bien déterminé, comme Nine(), n'a pas besoin d'informations supplémentaires, mais ne peut pas faire autre chose que 9 de retour.

Alors quoi? Je ne sais pas.

Un délégué est un pointeur sur un procédé. Vous pouvez ensuite utiliser votre délégué en tant que paramètre d'autres méthodes.

est un lien vers un tutoriel simple.

La question que j'avais été «Alors, pourquoi devrais-je faire cela? Vous ne vraiment « obtenir » jusqu'à ce que vous résoudre un problème de programmation avec eux.

Il est intéressant que personne ne l'a mentionné l'un des principaux avantages de la délégation - il est préférable de sous-classage quand on sait que l'héritage est pas une solution miracle et crée généralement plus de problèmes qu'elle en résout. Il est la base de nombreux modèles de conception, notamment la stratégie motif.

Une instance de délégué est une référence à un procédé. La raison pour laquelle ils sont utiles est que vous pouvez créer un délégué qui est lié à une méthode particulière sur un cas particulier d'un type. L'instance de délégué vous permet d'invoquer cette méthode sur cette instance particulière, même si l'objet sur lequel vous appellerez la méthode a laissé votre champ lexical.

L'utilisation la plus courante pour les instances de délégués comme celui-ci est de soutenir le concept de callbacks au niveau de la langue.

Il fait référence à une méthode simple. Ils viennent dans une grande utilité avec le travail avec le filetage.

est un exemple ici à droite de mon code.

 //Start our advertisiment thread
    rotator = new Thread(initRotate);
    rotator.Priority = ThreadPriority.Lowest;
    rotator.Start();

    #region Ad Rotation
    private delegate void ad();
    private void initRotate()
    {
        ad ad = new ad(adHelper);
        while (true)
        {
            this.Invoke(ad);
            Thread.Sleep(30000);
        }

    }

    private void adHelper()
    {
        List<string> tmp = Lobby.AdRotator.RotateAd();
        picBanner.ImageLocation = @tmp[0].ToString();
        picBanner.Tag = tmp[1].ToString();            
    }
    #endregion

Si vous utilisez un délégué na pas vous ne seriez pas en mesure de crossthread et appeler la fonction Lobby.AdRotator.

Comme d'autres l'ont dit, un délégué est une référence à une fonction. L'une des utilisations plus bénéfiques (OMI) est des événements. Lorsque vous enregistrez un événement que vous enregistrez une fonction pour l'événement pour appeler, et les délégués sont parfaits pour cette tâche.

Dans les termes les plus élémentaires, un délégué est juste une variable qui contient (une référence à) une fonction. Les délégués sont utiles car ils vous permettent de passer d'une fonction autour comme une variable sans souci «où » la fonction provenait en fait de.

Il est important de noter, bien sûr, que la fonction ne soit pas copié quand il est en cours de emmitouflé dans une variable; il est juste d'être lié par référence. Par exemple:

class Foo
{
    public string Bar
    {
        get;
        set;
    }

    public void Baz()
    {
        Console.WriteLine(Bar);
    }
}

Foo foo = new Foo();
Action someDelegate = foo.Baz;

// Produces "Hello, world".
foo.Bar = "Hello, world";
someDelegate();

Dans la plupart des termes plus simples, la responsabilité d'exécuter une méthode est déléguée à un autre objet. Dites le président d'une nation meurt et le président des Etats-Unis est censé être présent pour les funérailles avec un message de condoléances. Si le président des Etats-Unis ne sont pas en mesure d'aller, il déléguer cette responsabilité à quelqu'un soit le vice-président ou le secrétaire de l'Etat.

Idem

va dans le code. Un délégué est un type, il est un objet qui est capable d'exécuter le procédé.

par exemple.

Class Person
{
   public string GetPersonName(Person person)
   {
     return person.FirstName + person.LastName;
   }

   //Calling the method without the use of delegate
   public void PrintName()
   {
      Console.WriteLine(GetPersonName(this));
   }

   //using delegate
   //Declare delegate which matches the methods signature
   public delegate string personNameDelegate(Person person);

  public void PrintNameUsingDelegate()
  {
      //instantiate
      personNameDelegate = new personNameDelegate(GetPersonName);

      //invoke
      personNameDelegate(this);
  }

}

La méthode GetPersonName est appelé en utilisant l'objet délégué personNameDelegate. nous pouvons avoir encore la méthode PrintNameUsingDelegate de prendre un délégué en tant que paramètre.

public void PrintNameUsingDelegate(personNameDelegate pnd, Person person)
{
   pnd(person);
}

L'avantage est que si quelqu'un veut imprimer le nom comme lastname_firstname, il / elle vient d'envelopper cette méthode dans personNameDelegate et passer à cette fonction. Aucun autre changement de code est nécessaire.

Les délégués sont particulièrement importants dans

  1. Événements
  2. Asynchronous appelle
  3. LINQ (comme des expressions lambda)

Si vous allez déléguer une tâche à quelqu'un, le délégué serait la personne qui reçoit le travail.

Dans la programmation, il est une référence au bloc de code qui sait réellement comment faire quelque chose. Souvent, cela est un pointeur sur la fonction ou la méthode qui va traiter un certain point.

Dans les termes absolus plus simple que je peux trouver est la suivante: Un délégué forcera les charges de travail entre les mains d'une classe qui connaît à peu près ce qu'il faut faire. Pensez-y comme un enfant qui ne veut pas grandir pour être comme son grand frère complètement, mais encore besoin ses conseils et ses commandes. Au lieu d'hériter toutes les méthodes de son frère (c.-à-subclassing), il fait juste son frère faire le travail ou le petit frère fait quelque chose qui nécessite des actions à prendre par le grand frère. Lorsque vous tombez dans les lignes de protocoles, le grand frère définit ce qui est absolument nécessaire, ou il peut vous donner la flexibilité de choisir ce que vous voulez lui faire faire dans certains événements (par exemple des protocoles formels et informels, comme indiqué en Objective-C).

L'avantage absolu de ce concept est que vous n'avez pas besoin de créer une sous-classe. Si vous voulez quelque chose à tomber en ligne, suivre les ordres quand un événement se produit, le délégué permet à une classe développée pour le tenir la main et de donner des ordres si nécessaire.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top