Je pense que je comprends le concept d'un délégué en C# comme un pointeur vers une méthode, mais je ne peux pas trouver de bons exemples d'où il serait judicieux de les utiliser. Quels sont les exemples qui sont significativement plus élégant/mieux avec les délégués ou ne peuvent pas être résolus en utilisant d'autres méthodes?C# - Quelqu'un peut-il me dire pourquoi et où dois-je utiliser les délégués?
Que voulez-vous dire exactement par les délégués? Voici deux façons dont ils peuvent être utilisés:
void Foo(Func<int, string> f) {
//do stuff
string s = f(42);
// do more stuff
}
et
void Bar() {
Func<int, string> f = delegate(i) { return i.ToString(); }
//do stuff
string s = f(42);
// do more stuff
}
Le point dans la deuxième est que vous pouvez déclarer de nouvelles fonctions à la volée, en tant que délégués. Cela peut être largement remplacé par des expressions lambda, et est utile chaque fois que vous avez un petit morceau de logique que vous voulez 1) passer à une autre fonction, ou 2) simplement exécuter à plusieurs reprises. LINQ est un bon exemple. Chaque fonction LINQ prend une expression lambda comme argument, en spécifiant le comportement. Par exemple, si vous avez un List<int> l alors l.Select(x=>(x.ToString()) appellera ToString() sur chaque élément de la liste. Et l'expression lambda que j'ai écrite est implémentée en tant que délégué.
Le premier cas montre comment le produit pourrait être mis en œuvre. Vous prenez un délégué comme argument, puis vous l'appelez si nécessaire. Cela permet à l'appelant de personnaliser le comportement de la fonction. En prenant à nouveau Select() comme exemple, la fonction elle-même garantit que le délégué que vous lui passerez sera appelé sur chaque élément de la liste, et la sortie de chacun sera retournée. Qu'est-ce que délégué fait ne est à vous. Cela en fait une fonction étonnamment flexible et générale.
Bien sûr, ils sont également utilisés pour vous abonner à des événements. En un mot, les délégués vous permettent de référencer des fonctions, en les utilisant comme argument dans les appels de fonction, en les affectant à des variables et tout ce que vous voulez faire.
Je l'utilise principalement pour la programmation asynchrone facile. Lancer une méthode en utilisant une méthode Begin Begin ... est vraiment facile si vous voulez tirer et oublier.
Un délégué peut également être utilisé comme une interface lorsque les interfaces ne sont pas disponibles. Par exemple. appeler des méthodes à partir de classes COM, de classes externes .Net, etc.
Il n'y a pas vraiment de solutions que les delgates résoudront qui ne peuvent être résolues avec d'autres méthodes, mais qui fournissent une solution plus élégante.
Avec des délégués, n'importe quelle fonction peut être utilisée tant qu'elle a les paramètres requis.
L'alternative est souvent d'utiliser une sorte de système d'événements construit sur mesure dans le programme, la création d'un surcroît de travail et plus de zones pour les bugs au fluage dans
Les 1.0 .NET délégués:
this.myButton.Click += new EventHandler(this.MyMethod);
Le Délégués .NET 2.0:
this.myOtherButton.Click += delegate {
var res = PerformSomeAction();
if(res > 5)
PerformSomeOtherAction();
};
Ils semblent plutôt utiles. Et:
new Thread(new ThreadStart(delegate {
// do some worker-thread processing
})).Start();
C'est tout simplement génial! Compris – SMUsamaShah
Les événements sont l'exemple le plus évident. Comparez comment le modèle d'observateur est implémenté en Java (interfaces) et C# (délégués).
De plus, un grand nombre des nouvelles fonctionnalités C# 3 (par exemple les expressions lambda) sont basées sur des délégués et simplifient encore davantage leur utilisation.
Par exemple dans les applications multithread. Si vous souhaitez que plusieurs threads utilisent un certain contrôle, vous devez utiliser des délégués. Désolé, le code est en VisualBasic.
Tout d'abord vous déclarez un délégué
Private Delegate Sub ButtonInvoke(ByVal enabled As Boolean)
Ecrire une fonction à bouton activer/désactiver à partir de plusieurs threads
Private Sub enable_button(ByVal enabled As Boolean)
If Me.ButtonConnect.InvokeRequired Then
Dim del As New ButtonInvoke(AddressOf enable_button)
Me.ButtonConnect.Invoke(del, New Object() {enabled})
Else
ButtonConnect.Enabled = enabled
End If
End Sub
Je les utilise tout le temps avec LINQ, en particulier avec des expressions lambda, pour fournir une fonction pour évaluer une condition ou retourner une sélection. Utilisez-les également pour fournir une fonction permettant de comparer deux éléments pour le tri. Ce dernier est important pour les collections génériques où le tri par défaut peut ou non être approprié.
var query = collection.Where(c => c.Kind == ChosenKind)
.Select(c => new { Name = c.Name, Value = c.Value })
.OrderBy((a,b) => a.Name.CompareTo(b.Name));
L'un des avantages de Delegates réside dans son exécution asynchrone. Lorsque vous appelez une méthode de façon asynchrone, vous ne savez pas quand elle terminera l'exécution. Vous devez donc passer un délégué à cette méthode pour pointer vers une autre méthode qui sera appelée lorsque la première méthode aura terminé son exécution. Dans la deuxième méthode, vous pouvez écrire du code qui vous informe que l'exécution est terminée.
D'autres commentaires ont porté sur le monde ... mais je async commenterons de toute façon depuis mon « saveur » favori de faire comme a été mentionné:
ThreadPool.QueueUserWorkItem(delegate
{
// This code will run on it's own thread!
});
En outre, une grande raison de délégués est pour "CallBacks". Disons que je fais un peu de fonctionnalité (de façon asynchrone), et vous me voulez appeler une méthode (disons « AlertWhenDone ») ... vous pouvez passer dans un « délégué » à votre méthode comme suit:
TimmysSpecialClass.DoSomethingCool(this.AlertWhenDone);
en dehors de leur rôle dans les événements qui vous connaissez probablement si vous avez utilisé winForms ou asp.net, les délégués sont utiles pour faire des classes plus souples (par exemple, la façon dont ils sont utilisés dans LINQ).
flexibilité pour des choses « Trouver » est assez commun. Vous avez une collection de choses, et vous voulez fournir un moyen de trouver des choses. Plutôt que de deviner chaque façon que quelqu'un pourrait vouloir trouver des choses, vous pouvez maintenant permettre à l'appelant de fournir l'algorithme afin qu'il puisse rechercher votre collection comme bon lui semble.
Voici un exemple de code trivial:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Delegates
{
class Program
{
static void Main(string[] args)
{
Collection coll = new Collection(5);
coll[0] = "This";
coll[1] = "is";
coll[2] = "a";
coll[3] = "test";
var result = coll.Find(x => x == "is");
Console.WriteLine(result);
result = coll.Find(x => x.StartsWith("te"));
Console.WriteLine(result);
}
}
public class Collection
{
string[] _Items;
public delegate bool FindDelegate(string FindParam);
public Collection(int Size)
{
_Items = new string[Size];
}
public string this[int i]
{
get { return _Items[i]; }
set { _Items[i] = value; }
}
public string Find(FindDelegate findDelegate)
{
foreach (string s in _Items)
{
if (findDelegate(s))
return s;
}
return null;
}
}
}
Sortie
est
Test
Techniquement délégué est un type de référence utilisé pour encapsuler une méthode avec un type signature spécifique et retour
est-il un avantage à utiliser un délégué en traitant des appels externes à une base de données?
Par exemple peut coder A:
static void Main(string[] args) {
DatabaseCode("test");
}
public void DatabaseCode(string arg) {
.... code here ...
}
améliorer dans le code B:
static void Main(string[] args) {
DatabaseCodeDelegate slave = DatabaseCode;
slave ("test");
}
public void DatabaseCode(string arg) {
.... code here ...
}
public delegate void DatabaseCodeDelegate(string arg);
Il semble que ce soit subjectif, mais une zone où il y a des points forts de vue contradictoires?
Gosh, j'ai posé cette question il y a presque un an et maintenant il est difficile d'imaginer la vie avant les délégués/expressions lambda! Je dois dire que les réponses ici sont encore quelques-uns des meilleurs exemples sur le net. Tel est le pouvoir de SO. – Alex