Verwenden optionaler und benannter Parameter mit Action- und Func-Delegaten

Wie hier erwähnt -

Um das zu verwenden, müssen Sie also eine konkrete Implementierung (benutzerdefinierter Delegat) extrahieren, die zur Kompilierzeit bekannt ist und die Parameter auf der Aufrufseite durch optionale Parameter ersetzt, und benannte Parameter können ebenfalls verwendet werden.

Deklarieren Sie einen benutzerdefinierten Delegaten -

public delegate int FuncDelegate(int x, int y = 20);

Jetzt können Sie es im Methodenkörper verwenden -

FuncDelegate sum = delegate(int x, int y) { return x + y; };
int result = sum (x : 20, y: 40 );
result = sum(20);

Außerdem nur compile time constant can be used in default parameters list .Aber DateTime.Now is not a compile time constant das kann also nicht verwendet werden, um einen optionalen Wert für Ihren Parameter anzugeben.

Für den Aktionsteil wird dies also funktionieren -

public delegate void ActionDelegate(string message,
                                    DateTime dateTime = default(DateTime));

Benutze jetzt hier den Delegaten -

ActionDelegate print =
                delegate(string message, DateTime dateTime)
                { Console.WriteLine(dateTime.ToString()); };
print(dateTime: DateTime.Now, message: "SomeThing");

Sie haben eine Antwort für den optionalen Parameter Teil. In Bezug auf den benannten Parameter , ist es durchaus möglich, Namen für Argumente anzugeben, aber nur x und y sind nicht die Parameternamen für Action/Func generische Delegierte. Wenn Sie einen Delegierten wie folgt deklariert haben:

delegate void D(int p);

//now
D x = a => { };

x(a: 1); //is illegal, since 'a' is not the name of the parameter but 'p'; so 
x(p: 1) //is legal

a kann wirklich nicht dieser Parametername sein, weil a ist nur ein Teil der Signatur der aktuellen Methode, auf die Ihr Delegat verweist (dh die anonyme Methode). Es ist nicht wirklich Teil der Unterschrift des ursprünglichen Delegierten. Stellen Sie sich dieses Szenario vor:

D x = a => { };

//and somewhere else
x = b => { };

//and yet again
x = SomeMethod;

// now should it be x(a: 1) or x(b: 1) or x(parameterNameOfMethodSomeMethod: 1)?

Nur p macht dort Sinn.

Im Fall von Action/Func Sie werden wie folgt deklariert:

public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);

Sie sehen also die Parameterbenennung richtig? Also in diesem Fall:

Func<int, int, int> sum = delegate(int x, int y) { return x + y; };
Action<string, DateTime> print =
    delegate(string message, DateTime datetime) { Console.WriteLine("{0} {1}", message, datetime); };

//and you should be calling them like:

Console.WriteLine(sum(arg1: 20, arg2: 40));
print(arg2: DateTime.Now, arg1: "Hello"); //note the order change here

Natürlich ist es in diesem Szenario bedeutungslos, da Sie keinen optionalen Parameter verwenden.