Nel tuo caso, vuoi usare a delegate.
Vediamo come funziona un delegato e come possiamo arrivare a una forma più semplice comprendendone il concetto:
// Create a normal function
void OnButtonClick()
{
MessageBox.Show("Hello World!");
}
// Now we create a delegate called ButtonClick
delegate void ButtonClick();
Vedete, il delegato assume la forma di una normale funzione ma senza alcun argomento (potrebbe prendere qualsiasi quantità di argomenti proprio come qualsiasi altro metodo, ma per semplicità non lo fa).
Ora, usiamo quello che abbiamo; definiremo il delegato così come definiamo qualsiasi altra variabile:
ButtonClick ButtonClicked = new ButtonClick(OnButtonClick);
Fondamentalmente abbiamo creato una nuova variabile chiamata ButtonClicked, che ha un tipo di ButtonClick (che è un delegato) e che, quando utilizzato, eseguirà il metodo nel metodo OnButtonClick ().
Per usarlo chiamiamo semplicemente:ButtonClicked();
Quindi l'intero codice sarebbe:
delegate void ButtonClick();
void OnButtonClick()
{
MessageBox.Show("Hello World!");
}
void Foo()
{
ButtonClick ButtonClicked = new ButtonClick(OnButtonClick);
ButtonClicked(); // Execute the function.
}
Da qui, possiamo passare alle espressioni lambda e vedere come potrebbero essere utili nella tua situazione:
ci sono molti delegati già definiti dalle librerie .NET, con alcuni come Action, che non accettano alcun parametro e non restituiscono alcun valore. È definito come public delegate void Action();
È sempre possibile utilizzarlo in base alle proprie esigenze anziché alla necessità di definire un nuovo delegato ogni volta. Nel contesto precedente, ad esempio, avresti potuto scrivere
Action ButtonClicked = new Action(OnButtonClick);
ButtonClicked();
che avrebbe fatto lo stesso.
Ora che hai visto diversi modi di usare i delegati, usiamo la nostra prima espressione lambda. Le espressioni lambda sono funzioni anonime; quindi, sono normali funzioni ma senza un nome. Sono di quelle forme:
x => DoSomethingWithX(x);
(x) => DoSomethingWithX(x);
(x,y) => DoSometingWithXY(x,y);
() => Console.WriteLine("I do not have parameters!");
Nel nostro caso, non abbiamo alcun parametro, quindi useremo l'ultima espressione. Possiamo usarlo proprio come la funzione OnButtonClick, ma otteniamo il vantaggio di non avere una funzione denominata. Possiamo invece fare qualcosa del genere:
Action ButtonClicked = new Action( () => MessageBox.Show("Hello World!") );
o anche più facile,
Action ButtonClicked = () => MessageBox.Show("Hello World!");
quindi chiama semplicemente ButtonClicked();Naturalmente puoi anche avere più righe di codice, ma non voglio confonderti di più. Sarebbe così però:
Action ButtonClicked = () =>
{
MessageBox.Show("Hello World!");
};
ButtonClicked();
Puoi anche giocare, ad esempio, puoi eseguire una funzione come questa:
new Action(() => MessageBox.Show("Hello World!"))();
Ci scusiamo per il lungo post, spero che non sia stato troppo confuso :)
EDIT: ho dimenticato di menzionare che una forma alternativa che, anche se non usata spesso, potrebbe rendere più facile la comprensione delle espressioni lambda:
new Action(delegate() {
Console.WriteLine("I am parameterless");
})();
Inoltre, usando generics:
// Defines a delegate that has one parameter of type string. You could pass as many parameters as you want.
new Action<string>(delegate(string x) {
Console.WriteLine(x);
})("I am a string parameter!");
A sua volta potresti usare espressioni lambda, ma non hai bisogno (ma potresti in alcuni casi) di definire il tipo di parametro, ad esempio il codice sopra potrebbe semplicemente essere scritto come:
new Action<string>(x => {
Console.WriteLine(x);
})("I am a string parameter!");
o:
new Action<string>(x => Console.WriteLine(x))("I am a string parameter!");
EDIT2:
Action<string>è una rappresentazione di public void delegate Action(string obj);
Action<string,string>è una rappresentazione di public void delegate Action(string obj, string obj2);
In generale, Action<T>è una rappresentazione dipublic void delegate Action<T>(T obj);
EDIT3: So che il post è stato qui per un po ', ma penso che sia davvero bello non menzionare: puoi farlo, che è principalmente legato alla tua domanda:
dynamic aFunction = (Func<string, DialogResult>)MessageBox.Show;
aFunction("Hello, world!");
o semplicemente:
Func<string, DialogResult> aFunction = MessageBox.Show;
aFunction("Hello, world!");