Quand utiliserez-vous le formulaire ?

Question

Quelle est votre utilisation de délégués en C#?

Answer 1

Maintenant que nous avons les expressions lambda et les méthodes anonymes en C#, j'utilise les délégués beaucoup plus. En C# 1, où il fallait toujours avoir une méthode pour implémenter la logique, à l'aide d'un délégué souvent n'a pas de sens. Ces jours, j'ai utiliser des délégués pour:

• Les gestionnaires d'événements (pour l'interface graphique et plus)
• Départ fils
• Rappels (par exemple pour des Api asynchrones)
• LINQ et similaires (la Liste.Trouver etc)
• Partout où je veux appliquer efficacement le "modèle" de code avec une certaine logique spécialisé à l'intérieur (où le délégué de la spécialisation)

Answer 2

Les délégués sont très utiles pour de nombreux usages.

Un tel but est de les utiliser pour le filtrage des séquences de données. Dans ce cas, vous pourriez utiliser un prédicat délégué qui accepte un argument et renvoie true ou false en fonction de la mise en œuvre du délégué lui-même.

Voici un exemple stupide - je suis sûr que vous pouvez en tirer quelque chose de plus utile:

using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
    	List<String> names = new List<String>
    	{
    		"Nicole Hare",
    		"Michael Hare",
    		"Joe Hare",
    		"Sammy Hare",
    		"George Washington",
    	};

        // Here I am passing "inMyFamily" to the "Where" extension method
        // on my List<String>.  The C# compiler automatically creates 
        // a delegate instance for me.
    	IEnumerable<String> myFamily = names.Where(inMyFamily);

    	foreach (String name in myFamily)
    		Console.WriteLine(name);
    }

    static Boolean inMyFamily(String name)
    {
    	return name.EndsWith("Hare");
    }
}

Answer 3

Trouvé une autre réponse intéressante:

Un collègue de travail, juste m'a posé cette question - quel est le point de délégués .NET? Ma réponse a été très court et qu'il n'avait pas trouvé en ligne: pour retarder l'exécution d'une méthode.

Source: LosTechies

Comme LINQ est en train de faire.

Answer 4

Vous pouvez utiliser les délégués pour déclarer une fonction de typage des variables et des paramètres.

Exemple

Considérer les "ressources d'emprunt". Vous souhaitez contrôler la création et la réhabilitation d'une ressource, tout en permettant le code client "d'emprunter" la ressource entre les deux.

Il déclare un type délégué.

public delegate void DataReaderUser( System.Data.IDataReader dataReader );

Toute méthode correspondant à cette signature peut être utilisée pour instancier un délégué de ce type. En C# 2.0, ce qui peut être fait de façon implicite, simplement en utilisant la méthode du nom, ainsi que par l'utilisation de méthodes anonymes.

Cette méthode utilise le type de paramètre. Remarque le délégué de l'invocation.

public class DataProvider
{
    protected string _connectionString;

    public DataProvider( string psConnectionString )
    {
    	_connectionString = psConnectionString;
    }

    public void UseReader( string psSELECT, DataReaderUser readerUser )
    {
    	using ( SqlConnection connection = new SqlConnection( _connectionString ) )
    	try
    	{
    		SqlCommand command = new SqlCommand( psSELECT, connection );
    		connection.Open();
    		SqlDataReader reader = command.ExecuteReader();

    		while ( reader.Read() )
    			readerUser( reader );  // the delegate is invoked
    	}
    	catch ( System.Exception ex )
    	{
    		// handle exception
    		throw ex;
    	}
    }
}

La fonction peut être appelée avec une méthode anonyme comme suit. Notez que la méthode anonyme pouvez utiliser les variables déclarées en dehors de lui-même. C'est très pratique (même si l'exemple est un peu artificiel).

string sTableName = "test";
string sQuery = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='" + sTableName + "'";

DataProvider.UseReader( sQuery,
    delegate( System.Data.IDataReader reader )
    {
    	Console.WriteLine( sTableName + "." + reader[0] );
    } );

Answer 5

Les délégués peuvent souvent être utilisé à la place d'une interface avec une méthode, une commune peut, par exemple, le pattern observer. Dans d'autres langues si vous souhaitez recevoir une notification que quelque chose s'est passé, vous pouvez définir quelque chose comme:

class IObserver{ void Notify(...); }

En C# c'est plus souvent exprimée à l'aide d'événements, où le gestionnaire est un délégué, par exemple:

myObject.SomeEvent += delegate{ Console.WriteLine("..."); };

Un autre grand endroit pour utiliser les délégués si lorsque vous devez passer un prédicat dans une fonction, par exemple lors de la sélection d'un ensemble d'éléments d'une liste:

myList.Where(i => i > 10);

Le ci-dessus est un exemple du lambda de la syntaxe, ce qui pourrait également avoir été écrite comme suit:

myList.Where(delegate(int i){ return i > 10; });

Un autre endroit où il peut être utile d'utiliser des délégués est l'inscription de l'usine de fonctions, par exemple:

myFactory.RegisterFactory(Widgets.Foo, () => new FooWidget());
var widget = myFactory.BuildWidget(Widgets.Foo);

J'espère que cela aide!