Dies ist C # 7.0, das lokale Funktionen unterstützt ....
public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
this IEnumerable<TSource> source,
Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
{
if (source == null) throw new
ArgumentNullException(nameof(source));
if (keySelector == null) throw
new ArgumentNullException(nameof(keySelector));
// This is basically executing _LocalFunction()
return _LocalFunction();
// This is a new inline method,
// return within this is only within scope of
// this method
IEnumerable<TSource> _LocalFunction()
{
var knownKeys = new HashSet<TKey>(comparer);
foreach (var element in source)
{
if (knownKeys.Add(keySelector(element)))
yield return element;
}
}
}
Aktuelles C # mit Func<T>
public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
this IEnumerable<TSource> source,
Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
{
if (source == null) throw new
ArgumentNullException(nameof(source));
if (keySelector == null) throw
new ArgumentNullException(nameof(keySelector));
Func<IEnumerable<TSource>> func = () => {
var knownKeys = new HashSet<TKey>(comparer);
foreach (var element in source)
{
if (knownKeys.Add(keySelector(element)))
yield return element;
}
};
// This is basically executing func
return func();
}
Der Trick ist, dass _ () nach seiner Verwendung deklariert wird, was vollkommen in Ordnung ist.
Praktische Nutzung lokaler Funktionen
Das obige Beispiel ist nur eine Demonstration der Verwendung der Inline-Methode. Wenn Sie die Methode jedoch nur einmal aufrufen, ist dies höchstwahrscheinlich nicht von Nutzen.
Wie in den Kommentaren von Phoshi und Luaan erwähnt , bietet die Verwendung der lokalen Funktion im obigen Beispiel einen Vorteil. Da eine Funktion mit Ertragsrückgabe nur ausgeführt wird, wenn jemand sie wiederholt, wird in diesem Fall eine Methode außerhalb der lokalen Funktion ausgeführt und eine Parameterüberprüfung durchgeführt, selbst wenn der Wert von niemandem wiederholt wird.
Oft haben wir Code in der Methode wiederholt. Schauen wir uns dieses Beispiel an.
public void ValidateCustomer(Customer customer){
if( string.IsNullOrEmpty( customer.FirstName )){
string error = "Firstname cannot be empty";
customer.ValidationErrors.Add(error);
ErrorLogger.Log(error);
throw new ValidationError(error);
}
if( string.IsNullOrEmpty( customer.LastName )){
string error = "Lastname cannot be empty";
customer.ValidationErrors.Add(error);
ErrorLogger.Log(error);
throw new ValidationError(error);
}
... on and on...
}
Ich könnte dies optimieren mit ...
public void ValidateCustomer(Customer customer){
void _validate(string value, string error){
if(!string.IsNullOrWhitespace(value)){
// i can easily reference customer here
customer.ValidationErrors.Add(error);
ErrorLogger.Log(error);
throw new ValidationError(error);
}
}
_validate(customer.FirstName, "Firstname cannot be empty");
_validate(customer.LastName, "Lastname cannot be empty");
... on and on...
}
return _(); IEnumerable<TSource> _()
?