Qual è la differenza tra Delegate e Azione in C#

Question

Se ho cercato, otterrò sicuramente degli esempi di mostrare cos'è un Delegato e un'azione. Ho letto i libri base dando esempi di delegati.

Ma quello che voglio sapere è il loro uso nel mondo reale. Per favore non dare esempio Hello World o la classe Animal sono troppo semplici

Ad es. :

1. Quali sono la differenza tra loro
2. Quando utilizzare un delegato o un'azione
3. Quando non usare un delegato o un'azione
4. quando possono essere un eccesso di uccidere

Answer 1

Actionè un Delegate. È definito in questo modo:

public delegate void Action(); 

È possibile creare i propri tipi di delegati in modo simile a come si creerebbero metodi astratti; scrivi la firma ma nessuna implementazione. Quindi si creano istanze di questi delegati prendendo il riferimento di un metodo.

class Program 
{ 
    public static void FooMethod() 
    { 
     Console.WriteLine("Called foo"); 
    } 

    static void Main() 
    { 
     Action foo = FooMethod; // foo now references FooMethod() 
     foo(); // outputs "Called foo" 
    } 
} 

Answer 2

Quando si definisce un delegato si sta essenzialmente definendo la firma di un metodo (tipo di ritorno e argomenti).

Un'azione è un delegato che è già stato definito (void return e no args).

public delegate void Action() 

Si può andare alla definizione e vederla da soli. O qui nei documenti. http://msdn.microsoft.com/en-us/library/system.action.aspx

Quasi sempre utilizzo i delegati generici esistenti (di cui l'azione è uno) quando la firma del metodo che sto cercando corrisponde alle firme supportate. Una cosa bella dell'utilizzo dei delegati generici è che sono ben noti. La maggior parte degli sviluppatori sa che un'azione è nullo/non valido. Se dovessi definire la mia versione di Action tutti avrebbero bisogno di cercare la sua firma, e ho appena duplicato qualcosa che esiste già.

Per esempi ... L'azione sembra essere un po 'più rara in quanto lo scopo di un metodo di vuoto/vuoto può essere solo per la mutazione. Func è molto comune (anche un delegato generico). Ci sono esempi del suo utilizzo su tutto il framework, specialmente in linq. Guarda dove, ad esempio. http://msdn.microsoft.com/en-us/library/bb534803.aspx. È un significato di Func prende un elemento del tipo della collezione su cui stai lavorando come parametro e restituisce un bool. Nel contesto dell'istruzione where che ha il ritorno Func vero, significa includerlo nei risultati viceversa per false.

public static IEnumerable<TSource> Where<TSource>(
    this IEnumerable<TSource> source, 
    Func<TSource, bool> predicate 
) 

Answer 3

Dal Kenneth & Siege già sottolineato il codice & MSDN mi limiterò a cercare di riempire con l'esempio del mondo reale.

Considerare un delegato che definisce "in movimento".

Un delegato di "Azione" nel mondo reale sarebbe "Esegui" o "Cammina". Non ti interessa a quale velocità ti muovi, quale percorso prendi o segnala il tempo impiegato per muoversi.

Un delegato di non azione potrebbe ad esempio definire a quale velocità si esegue e restituire il tempo necessario per completarlo.

public delegate void MoveAction(); 
public delegate int MoveDelegate(int speed); 

Estensione esempi di assedio ..

class Program 
{ 
    public static void Run() 
    { 
     Console.WriteLine("Running"); 
    } 

    public static int RunAtSpeed(int speed) 
    { 
     // logic to run @ speed and return time 
     Console.WriteLine("Running @ {0}", speed); 
     return 10; 
    } 

    public static int WalkAtSpeed(int speed) 
    { 
     // logic to walk @ speed and return time 
     Console.WriteLine("Walking @ {0}", speed); 
     return 20; 
    } 

    static void Main() 
    { 
     Action foo = Run; 
     foo(); 

     MoveDelegate run = RunAtSpeed; 
     int result1 = run(5); 

     MoveDelegate walk = WalkAtSpeed; 
     int result2 = walk(1); 
    } 
} 

Answer 4

Qual è azione: Molto semplicemente azione, func <>, predicato tutti sono di tipo delegato.

Perché abbiamo bisogno di azione: Azione incapsula diverso numero di parametri e diverso tipo di tipo di ritorno, che sono sufficienti per lo sviluppo di applicazioni in molti casi. Questi sono forniti nel namespace System. Sei libero di creare il tuo delegato.

Nota: esistono 17 diversi tipi di azioni e Func ciascuno con da zero a 16 argomenti generici parametrizzati.

L'azione non ha alcun valore di ritorno. Func ha un singolo tipo di ritorno generico parametrizzato.

IMHO, predicato delegato non è stato necessario per essere definito come la sua davvero equivalente a Funz che prende un ARG e restituisce bool.

Answer 5

Il codice di esempio del mondo reale che è stato più volte richiesto, è già stato fornito in una risposta precedente dall'utente "Console.WriteLine".

Per quanto riguarda il motivo per cui è stato fornito, da quello che ho capito, Action è un modo per risparmiare continuando a definire nuovi delegati. Poiché si tratta di un delegato predefinito di determinati tipi di firma, si risparmia la seccatura di creare delegati diversi per ogni scopo previsto. Devi solo usare il delegato di azione predefinito per puntare ai tuoi metodi ed eseguirli. Lo stesso vale per i delegati di Func.

Più di una comodità, piuttosto che una nuova funzionalità. Aiuta a mantenere il tuo codice breve e comprensibile, con meno problemi.

Per quanto riguarda le vostre domande punto-saggio,

1. Quali sono le differenza tra loro

Nessuna differenza. L'azione è un delegato predefinito, destinato a farti risparmiare la fatica di definire ripetutamente nuovi delegati.

2. Quando utilizzare un delegato o un'azione

Tipicamente, un delegato (e di azione) viene utilizzato in luoghi in cui è necessario disporre di funzionalità tavolo-driven. cioè, forse un dizionario di metodi corrispondenti ad alcuni requisiti particolari. Nota che l'uso di Action qui rende facile cambiare il metodo finale chiamato, per indirizzare dinamicamente ad altri metodi (magari in base ad alcune impostazioni selezionate dall'utente?)

---

class Program 
{ 
    static void Main() 
    { 
    Dictionary<string, Action> dict = new Dictionary<string, Action>(); 
    dict["loadFile"] = new Action(LoadFile); 
    dict["saveFile"] = new Action(SaveFile); 

    dict["loadFile"].Invoke(); 
    dict["saveFile"].Invoke(); 
    } 

    static void SaveFile() 
    { 
    Console.WriteLine("File saved!"); 
    } 

    static void LoadFile() 
    { 
    Console.WriteLine("Loading File..."); 
    } 
} 

---

Un altro uso tipico è per i metodi di callback. Esempio potrebbe essere il punto in cui si utilizza una classe BubbleSort, passando il metodo comparatore come delegato alla classe, che verrebbe utilizzato dalla classe BubbleSort per consentire al codice di definire la logica di confronto, mentre si prende cura di tutto il resto. Questo può essere utilizzato anche dai thread che hai avviato e il thread chiama il delegato quando alcune azioni intermedie devono essere informate sul tuo codice.

È possibile consultare questo post SO per vedere un ottimo esempio di quanto sopra. https://stackoverflow.com/a/3794229/1336068

3. quando non utilizzare un delegato o un'azione

L'unico motivo che posso pensare di non usarle quando la situazione lo richiede, è se il vostro il delegato verrà chiamato milioni di volte in una breve durata. Vi è un leggero sovraccarico e se ciò causa un ritardo dell'applicazione, potrebbe essere necessario trovare un modo migliore per risolverlo utilizzando il riferimento diretto alle funzioni, anziché tramite un delegato.

4. quando possono essere un eccesso di uccidere

Quando li si utilizza gratuitamente, senza alcuna reale necessità. Altrimenti, nella maggior parte delle situazioni, possono essere un modo elegante per risolvere gli scenari di cui sopra.

Inoltre, leggere questo SO rispondere per vedere le distinzioni tra i metodi normali, i delegati per ottenere una migliore comprensione di dove utilizzare i delegati/azione/func https://stackoverflow.com/a/17380580/1336068