Utilisation des pouvoirs d'Action délégués en C#

voici un petit exemple qui montre l'utilité de l'Action du délégué

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Action<String> print = new Action<String>(Program.Print);

        List<String> names = new List<String> { "andrew", "nicole" };

        names.ForEach(print);

        Console.Read();
    }

    static void Print(String s)
    {
        Console.WriteLine(s);
    }
}

notez que la méthode foreach itère la collection de noms et exécute la méthode print contre chaque membre de la collection. C'est un peu un changement de paradigme pour nous développeurs C# alors que nous nous dirigeons vers un style de programmation plus fonctionnel. (Pour plus d'information sur l'informatique derrière elle lire ce qui suit: http://en.wikipedia.org/wiki/Map_(plus-order_function) .

maintenant si vous utilisez C# 3 vous pouvez slick ce vers le haut d'un peu avec une expression lambda comme ainsi:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<String> names = new List<String> { "andrew", "nicole" };

        names.ForEach(s => Console.WriteLine(s));

        Console.Read();
    }
}

Eh bien, une chose que vous pourriez faire est si vous avez un commutateur:

switch(SomeEnum)
{
  case SomeEnum.One:
      DoThings(someUser);
      break;
  case SomeEnum.Two:
      DoSomethingElse(someUser);
      break;
}

et avec la puissance des actions, vous pouvez transformer ce commutateur en un dictionnaire:

Dictionary<SomeEnum, Action<User>> methodList = 
    new Dictionary<SomeEnum, Action<User>>()

methodList.Add(SomeEnum.One, DoSomething);
methodList.Add(SomeEnum.Two, DoSomethingElse); 

...

methodList[SomeEnum](someUser);

ou vous pouvez aller plus loin:

SomeOtherMethod(Action<User> someMethodToUse, User someUser)
{
    someMethodToUse(someUser);
}  

....

var neededMethod = methodList[SomeEnum];
SomeOtherMethod(neededMethod, someUser);

quelques exemples. Bien sûr, L'utilisation la plus évidente serait les méthodes D'extension Linq.

vous pouvez utiliser des actions pour les gestionnaires d'événements courts:

btnSubmit.Click += (sender, e) => MessageBox.Show("You clicked save!");

j'ai utilisé le délégué d'action comme ceci dans un projet une fois:

private static Dictionary<Type, Action<Control>> controldefaults = new Dictionary<Type, Action<Control>>() { 
            {typeof(TextBox), c => ((TextBox)c).Clear()},
            {typeof(CheckBox), c => ((CheckBox)c).Checked = false},
            {typeof(ListBox), c => ((ListBox)c).Items.Clear()},
            {typeof(RadioButton), c => ((RadioButton)c).Checked = false},
            {typeof(GroupBox), c => ((GroupBox)c).Controls.ClearControls()},
            {typeof(Panel), c => ((Panel)c).Controls.ClearControls()}
    };

qui tout ce qu'il fait est de stocker une action(appel de méthode) contre un type de contrôle de sorte que vous pouvez effacer tous les contrôles sur un formulaire de retour à là par défaut.

pour un exemple d'utilisation de L'Action<>.

de la Console.WriteLine a une signature qui satigne Action<string> .

    static void Main(string[] args)
    {
        string[] words = "This is as easy as it looks".Split(' ');

        // Passing WriteLine as the action
        Array.ForEach(words, Console.WriteLine);         
    }

Espérons que cette aide

Je l'utilise quand je traite des appels de fils croisés illégaux par exemple:

DataRow dr = GetRow();
this.Invoke(new Action(() => {
   txtFname.Text = dr["Fname"].ToString();
   txtLname.Text = dr["Lname"].ToString(); 
   txtMI.Text = dr["MI"].ToString();
   txtSSN.Text = dr["SSN"].ToString();
   txtSSN.ButtonsRight["OpenDialog"].Visible = true;
   txtSSN.ButtonsRight["ListSSN"].Visible = true;
   txtSSN.Focus();
}));

je dois donner crédit à Reed Copsey donc utilisateur 65358 pour la solution. Ma question complète avec des réponses est donc Question 2587930

je l'ai utilisé comme un rappel dans un gestionnaire d'événement. Quand je relance l'événement, je passe dans une méthode prenant une chaîne de caractères un paramètre. Voici à quoi ressemble la levée de l'événement:

SpecialRequest(this,
    new BalieEventArgs 
    { 
            Message = "A Message", 
            Action = UpdateMethod, 
            Data = someDataObject 
    });

La Méthode:

   public void UpdateMethod(string SpecialCode){ }

est la déclaration de classe de l'événement Args:

public class MyEventArgs : EventArgs
    {
        public string Message;
        public object Data;
        public Action<String> Action;
    }

de cette façon je peux appeler la méthode passée du gestionnaire d'événements avec un certain paramètre pour mettre à jour les données. Je l'utilise pour la demande de certains information de l'utilisateur.

nous utilisons beaucoup de fonctionnalité action delegate dans les tests. Quand nous avons besoin de construire un objet par défaut et plus tard besoin de le modifier. J'ai fait un peu l'exemple. Pour construire l'objet personne par défaut (John Doe), nous utilisons la fonction BuildPerson() . Plus tard, nous ajoutons Jane Doe aussi, mais nous modifions sa date de naissance, son nom et sa taille.

public class Program
{
        public static void Main(string[] args)
        {
            var person1 = BuildPerson();

            Console.WriteLine(person1.Firstname);
            Console.WriteLine(person1.Lastname);
            Console.WriteLine(person1.BirthDate);
            Console.WriteLine(person1.Height);

            var person2 = BuildPerson(p =>
            {
                p.Firstname = "Jane";
                p.BirthDate = DateTime.Today;
                p.Height = 1.76;
            });

            Console.WriteLine(person2.Firstname);
            Console.WriteLine(person2.Lastname);
            Console.WriteLine(person2.BirthDate);
            Console.WriteLine(person2.Height);

            Console.Read();
        }

        public static Person BuildPerson(Action<Person> overrideAction = null)
        {
            var person = new Person()
            {
                Firstname = "John",
                Lastname = "Doe",
                BirthDate = new DateTime(2012, 2, 2)
            };

            if (overrideAction != null)
                overrideAction(person);

            return person;
        }
    }

    public class Person
    {
        public string Firstname { get; set; }
        public string Lastname { get; set; }
        public DateTime BirthDate { get; set; }
        public double Height { get; set; }
    }