Ungerade Rückgabesyntaxanweisung

Ich weiß, dass das seltsam klingen mag, aber ich weiß nicht einmal, wie ich diese Syntax im Internet durchsuchen soll, und ich bin mir auch nicht sicher, was genau das bedeutet.

Also habe ich mir MoreLINQ-Code angesehen und dann diese Methode bemerkt

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));

    return _(); IEnumerable<TSource> _()
    {
        var knownKeys = new HashSet<TKey>(comparer);
        foreach (var element in source)
        {
            if (knownKeys.Add(keySelector(element)))
                yield return element;
        }
    }
}

Was ist diese seltsame Rückgabeanweisung? return _();?

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... 
  }

Betrachten Sie das einfachere Beispiel

void Main()
{
    Console.WriteLine(Foo()); // Prints 5
}

public static int Foo()
{
    return _();

    // declare the body of _()
    int _()
    {
        return 5;
    }
}

_() ist eine lokale Funktion, die in der Methode deklariert ist, die die return-Anweisung enthält.