Wyrażenia C # Lambda: dlaczego powinienem ich używać?

Anonimowe funkcje i wyrażenia są przydatne dla jednorazowych metod, które nie korzystają z dodatkowej pracy wymaganej do utworzenia pełnej metody.

Rozważ ten przykład:

 string person = people.Find(person => person.Contains("Joe"));

Kontra

 public string FindPerson(string nameContains, List<string> persons)
 {
     foreach (string person in persons)
         if (person.Contains(nameContains))
             return person;
     return null;
 }

Są funkcjonalnie równoważne.

Uznałem je za przydatne w sytuacji, gdy chciałem zadeklarować obsługę jakiegoś zdarzenia kontrolki, używając innej kontrolki. Aby zrobić to normalnie, trzeba będzie przechowywać odniesienia controls ' w polach klasy, tak, że można ich używać w innej metodzie niż zostały utworzone.

private ComboBox combo;
private Label label;

public CreateControls()
{
    combo = new ComboBox();
    label = new Label();
    //some initializing code
    combo.SelectedIndexChanged += new EventHandler(combo_SelectedIndexChanged);
}

void combo_SelectedIndexChanged(object sender, EventArgs e)
{
    label.Text = combo.SelectedValue;
}

Dzięki wyrażeniom lambda można go używać w następujący sposób:

public CreateControls()
{
    ComboBox combo = new ComboBox();
    Label label = new Label();
    //some initializing code
    combo.SelectedIndexChanged += (s, e) => {label.Text = combo.SelectedValue;};
}

Lambda wyczyścił składnię anonimowego delegata C # 2.0...na przykład

Strings.Find(s => s == "hello");

Zrobiono w C# 2.0 TAK:

Strings.Find(delegate(String s) { return s == "hello"; });

Funkcjonalnie, robią dokładnie to samo, to tylko o wiele bardziej zwięzła składnia.

Jest to tylko jeden sposób użycia wyrażenia lambda. Możesz użyć wyrażenia lambda w dowolnym miejscu , w którym możesz użyć delegata. To pozwala robić takie rzeczy:

List<string> strings = new List<string>();
strings.Add("Good");
strings.Add("Morning")
strings.Add("Starshine");
strings.Add("The");
strings.Add("Earth");
strings.Add("says");
strings.Add("hello");

strings.Find(s => s == "hello");

Ten kod przeszukaÄ ‡ listÄ ™ wpisăłw pasujÄ ... cych do sĹ ' owa "hello". Innym sposobem, aby to zrobić, jest przekazanie delegata do metody Find, jak to:

List<string> strings = new List<string>();
strings.Add("Good");
strings.Add("Morning")
strings.Add("Starshine");
strings.Add("The");
strings.Add("Earth");
strings.Add("says");
strings.Add("hello");

private static bool FindHello(String s)
{
    return s == "hello";
}

strings.Find(FindHello);

EDIT :

  strings.Find(delegate(String s) { return s == "hello"; });

Lambda ' s znacznie poprawił składnię.

Microsoft dał nam czystszy, wygodniejszy sposób tworzenia anonimowych delegatów zwanych wyrażeniami Lambda. Jednak nie zwraca się zbyt wiele uwagi na wyrażenia część tego stwierdzenia. Microsoft wydał całą przestrzeń nazw, System.Linq.Expressions , która zawiera klasy do tworzenia drzew wyrażeń opartych na wyrażeniach lambda. Drzewa wyrażeń składają się z obiektów, które reprezentują logikę. Na przykład X = y + z jest wyrażeniem, które może być częścią drzewa wyrażeń w .Net. rozważ następujący (prosty) przykład:

using System;
using System.Linq;
using System.Linq.Expressions;


namespace ExpressionTreeThingy
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<Func<int, int>> expr = (x) => x + 1; //this is not a delegate, but an object
            var del = expr.Compile(); //compiles the object to a CLR delegate, at runtime
            Console.WriteLine(del(5)); //we are just invoking a delegate at this point
            Console.ReadKey();
        }
    }
}

Ten przykład jest trywialny. I jestem pewien, że myślisz: "jest to bezużyteczne, ponieważ mogłem bezpośrednio utworzyć delegata zamiast tworzyć wyrażenie i kompilować je w czasie wykonywania". I miałbyś rację. Ale to stanowi fundament dla drzew ekspresji. Istnieje wiele wyrażeń dostępnych w przestrzeniach nazw wyrażeń i możesz tworzyć własne. Myślę, że to widzisz. może to być przydatne, gdy nie wiesz dokładnie, jaki algorytm powinien być w czasie projektowania lub kompilacji. Widziałem gdzieś przykład użycia tego do napisania kalkulatora naukowego. Można go również używać do systemów bayesowskich lub do programowania genetycznego (AI). Kilka razy w swojej karierze musiałem napisać funkcjonalność podobną do Excela, która pozwalała użytkownikom na wprowadzanie prostych wyrażeń (dodawanie, podwarianty, itp.), aby operować na dostępnych danych. W pre-.Net 3.5 musiałem uciekać się do jakiś język skryptowy zewnętrzny do C#, lub musiał użyć funkcji emitowania kodu w reflection do tworzenia kodu. Net w locie. Teraz użyłbym drzew wyrazu.

Zapisuje konieczność posiadania metod, które są używane tylko raz w określonym miejscu przed zdefiniowaniem z dala od miejsca, w którym są używane. Dobre zastosowania są jako komparatory dla ogólnych algorytmów, takich jak sortowanie, gdzie można następnie zdefiniować niestandardową funkcję sortowania, gdzie wywołujesz sortowanie, a nie dalej zmuszając cię do szukania gdzie indziej, aby zobaczyć, na czym sortujesz.

I to nie jest tak naprawdę innowacja. LISP posiada funkcje lambda od około 30 lat lub więcej.

Wyrażenie lambda jest jak anonimowa metoda napisana w miejsce instancji delegata.

delegate int MyDelagate (int i);
MyDelagate delSquareFunction = x => x * x;

Rozważmy wyrażenie lambda x => x * x;

Wartość parametru wejściowego to x (po lewej stronie=>)

Logika funkcji to x * x (po prawej stronie=>)

Kod wyrażenia lambda może być blokiem instrukcji zamiast wyrażeniem.

x => {return x * x;};

Przykład

Uwaga: Func jest predefiniowanym rodzajem delegat.

    Console.WriteLine(MyMethod(x => "Hi " + x));

    public static string MyMethod(Func<string, string> strategy)
    {
        return strategy("Lijo").ToString();
    }

Referencje

1. W Jaki Sposób delegat i interfejs mogą być używane zamiennie?

Można również znaleźć użycie wyrażeń lambda w pisaniu ogólnych kodów do działania na swoich metodach.

Na przykład: funkcja Ogólna do obliczania czasu zajętego przez wywołanie metody. (tj. Action tutaj)

public static long Measure(Action action)
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    action();
    sw.Stop();
    return sw.ElapsedMilliseconds;
}

I możesz wywołać powyższą metodę używając wyrażenia lambda w następujący sposób:

var timeTaken = Measure(() => yourMethod(param));

Wyrażenie pozwala na uzyskanie wartości zwracanej z metody i out param, jak również

var timeTaken = Measure(() => returnValue = yourMethod(param, out outParam));

Często używasz funkcjonalności tylko w jednym miejscu, więc tworzenie metody po prostu zaśmieca klasę.

Wyrażenie Lambda jest zwięzłym sposobem reprezentowania anonimowej metody. Zarówno metody anonimowe, jak i wyrażenia Lambda pozwalają zdefiniować implementację metody inline, jednak metoda anonimowa jawnie wymaga zdefiniowania typów parametrów i typu zwracanego dla metody. Wyrażenie Lambda używa funkcji wnioskowania typu W C# 3.0, która pozwala kompilatorowi wnioskować typ zmiennej na podstawie kontekstu. Jest to bardzo wygodne, ponieważ oszczędza nam to wiele pisanie!

Jest to sposób na małą operację i umieszczenie jej bardzo blisko miejsca, w którym jest używana(w przeciwieństwie do deklarowania zmiennej blisko jej punktu użycia). To ma sprawić, że Twój kod będzie bardziej czytelny. Anonimizując wyrażenie, znacznie utrudniasz komuś złamanie kodu klienta, jeśli ta funkcja jest używana gdzie indziej i modyfikowana w celu jej "ulepszenia".

Podobnie, dlaczego musisz używać foreach? Możesz zrobić wszystko w foreach za pomocą pętli plain for lub po prostu za pomocą IEnumerable bezpośrednio. Odpowiedź: nie potrzebujesz , ale to sprawia, że Twój kod jest bardziej czytelny.

Innowacja polega na bezpieczeństwie typu i przejrzystości. Chociaż nie deklarujesz typów wyrażeń lambda, są one wywnioskowane i mogą być używane przez wyszukiwanie kodu, analizę statyczną, narzędzia refaktoryzacji i odbicie środowiska uruchomieniowego.

Na przykład, zanim użyłeś SQL i mogłeś uzyskać atak SQL injection, ponieważ haker przekazał ciąg znaków, w którym normalnie Oczekiwano liczby. Teraz użyjesz LINQ lambda expression, która jest przed tym chroniona.

Budowanie API LINQ w przypadku czystych delegatów nie jest to możliwe, ponieważ wymaga połączenia drzew wyrażeń przed ich oceną.

W 2016 roku większość popularnych języków ma wsparcie wyrażenia lambda , A C# był jednym z pionierów tej ewolucji wśród głównych języków imperatywnych.

To chyba najlepsze wyjaśnienie dlaczego używać wyrażeń lambda - > https://youtu.be/j9nj5dTo54Q

Podsumowując, ma to poprawić czytelność kodu, zmniejszyć ryzyko błędów poprzez ponowne użycie zamiast powielania kodu i wykorzystać optymalizację za kulisami.