W jaki sposób wieloparametrowe wyrażenie linq inicjuje ich parametry?

Question

W tym post rozwiązaniem problemu jest:

list.Where((item, index) => index < list.Count - 1 && list[index + 1] == item)

Koncepcja Wieloparametrowa (tj (item, index)) jest nieco zaskakujący do mnie, a ja nie wiem poprawne słowo zawężania mój wyniki google. Więc 1) Jak to się nazywa? I co ważniejsze, 2) Jak zainicjować zmienną nierefunkcyjną? W takim przypadku w jaki sposób jest index skompilowany jako int i zainicjowany na 0?

Dzięki.

Answer 1

wyrażenia lambda mieć różne opcje składni:

() => ... // no parameters 
x => ... // single parameter named x, compiler infers type 
(x) => ... // single parameter named x, compiler infers type 
(int x) => ... // single parameter named x, explicit type 
(x, y) => ... // two parameters, x and y; compiler infers types 
(int x, string y) => ... // two parameters, x and y; explicit types 

Subtelność jest to, że Where ma przeciążenie, która akceptuje Func<T, int, bool>, reprezentująca wartość i Indeks odpowiednio (i zwracając bool na mecz). Więc to jest realizacja Where który dostarcza indeks - coś jak:

static class Example 
{ 
    public static IEnumerable<T> Where<T>(this IEnumerable<T> source, 
     Func<T, int, bool> predicate) 
    { 
     int index = 0; 
     foreach (var item in source) 
     { 
      if (predicate(item, index++)) yield return item; 
     } 
    } 
} 

Answer 2

Przy użyciu LINQ, należy pamiętać, że są przechodzącą delegata metody metody Where. Konkretne przeciążenie Where, które wywołujesz, przyjmuje metodę z podpisem Func<T,int,bool> i wywoła tę metodę dla każdego elementu w list. Wewnętrznie ta szczególna metoda jest utrzymanie liczby dla każdego elementu powtórzyć, a nazywając dostarczonego delegata przy użyciu tej wartości jako drugi parametr:

var result=suppliedDelegate(item,count) 

Answer 3

Ta odpowiedź jest trochę bardziej techniczny ... Pamiętaj, że są po prostu lambdas syntatic skróty do anonimowi delegaci (które są metodami anonimowymi). Edycja: Mogą to być drzewa wyrażeń w zależności od podpisu Where (patrz komentarz Marka).

list.Where((item, index) => index < list.Count - 1 && list[index + 1] == item) 

funkcjonalnie równoważne

// inline, no lambdas 
list.Where(delegate(item, index) { return index < list.Count - 1 && list[index + 1] == item; }); 

// if we assign the lambda (delegate) to a local variable: 
var lambdaDelegate = (item, index) => index < list.Count - 1 && list[index + 1] == item; 

list.Where(lambdaDelegate); 

// without using lambdas as a shortcut: 
var anonymousDelegate = delegate(item, index) 
    { 
     return index < list.Count - 1 && list[index + 1] == item; 
    } 

list.Where(anonymousDelegate); 

// and if we don't use anonymous methods (which is what lambdas represent): 
function bool MyDelegate<TSource>(TSource item, int index) 
{ 
    return index < list.Count - 1 && list[index + 1] == item; 
} 

list.Where(MyDelegate); 

Metoda Where ma następujący podpis:

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

co odpowiada:

delegate bool WhereDelegate<TSource>(TSource source, int index); 
public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, WhereDelegate<TSource> predicate); 

to jest gdzie zdefiniowany jest przedmiot i indeks.

Za kulisami Where może zrobić coś takiego (tylko domyślać, można dekompilować, aby zobaczyć):

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) 
{ 
    int index = 0; 

    foreach (TSource item in source) 
    { 
     if (predicate(index, source)) 
      yield return item; 

     index++; 
    } 
} 

więc to, gdzie wskaźnik jest inicjowany i zostanie przeniesiony do swojego delegata (anonimowy, lambda, lub Inaczej).