słowo kluczowe delegata a notacja lambda

Podoba mi się odpowiedź Amy, ale myślałem, że będę pedantyczny. Pytanie mówi, "raz jest skompilowany" - co sugeruje, że oba wyrażenia zostały skompilowane. W jaki sposób mogą się skompilować, ale jeden z nich jest konwertowany do delegata, a drugi do drzewa wyrażeń? Jest to trudne - trzeba użyć innej funkcji metod anonimowych, jedynej, której nie współdzielą wyrażenia lambda. Jeśli podasz metodę anonimową bez podawania listy parametrów w ogóle to jest kompatybilny z dowolnym typem delegata zwracającym void i bez żadnych parametrów out. Uzbrojeni w tę wiedzę, powinniśmy być w stanie skonstruować dwa przeciążenia, aby wyrażenia były całkowicie jednoznaczne, ale bardzo różne.

Możemy użyć sztuczki z parametrami delegata, jeśli zmienimy trochę ciała:

using System;
using System.Linq.Expressions;

public class Test
{
    static void Main()
    {
        int x = 0;
        Foo( () => x );
        Foo( delegate { return x; } );
    }

    static void Foo(Func<int, int> action)
    {
        Console.WriteLine("I suspect the anonymous method...");
    }

    static void Foo(Expression<Func<int>> func)
    {
        Console.WriteLine("I suspect the lambda expression...");
    }
}

using System;
using System.Linq.Expressions;

public class Base
{
    public void Foo(Action action)
    {
        Console.WriteLine("I suspect the lambda expression...");
    }
}

public class Derived : Base
{
    public void Foo(Action<int> action)
    {
        Console.WriteLine("I suspect the anonymous method...");
    }
}

class Test
{
    static void Main()
    {
        Derived d = new Derived();
        int x = 0;
        d.Foo( () => { x = 0; } );
        d.Foo( delegate { x = 0; } );
    }
}

W dwóch powyższych przykładach nie ma różnicy, zero.

Wyrażenie:

() => { x = 0 }

Jest wyrażeniem Lambda z ciałem instrukcji, więc nie może być skompilowane jako drzewo wyrażeń. W rzeczywistości nie kompiluje się, ponieważ potrzebuje średnika po 0:

() => { x = 0; } // Lambda statement body
() => x = 0      // Lambda expression body, could be an expression tree. 

Amy B ma rację. Zauważ, że używanie drzew wyrażeń może być korzystne. LINQ to SQL sprawdzi drzewo wyrażeń i przekonwertuje je na SQL.

Możesz również wykonywać sztuczki z lamdami i drzewami wyrażeń, aby skutecznie przekazać nazwy członków klasy do frameworka w bezpieczny dla refaktoryzacji sposób. Moq jest tego przykładem.

Istnieje różnica

Przykład:

var mytask = Task.Factory.StartNew(() =>
{
    Thread.Sleep(5000);
    return 2712;
});
mytask.ContinueWith(delegate
{
    _backgroundTask.ContinueTask(() =>lblPercent.Content = mytask.Result.ToString(CultureInfo.InvariantCulture));
});   

I zamieniam na lambda: (błąd)

var mytask = Task.Factory.StartNew(() =>
{
    Thread.Sleep(5000);
    return 2712;
});
mytask.ContinueWith(()=>
{
    _backgroundTask.ContinueTask(() =>lblPercent.Content = mytask.Result.ToString(CultureInfo.InvariantCulture));
});

Kilka podstaw tutaj.

Jest to metoda anonimowa

(string testString) => { Console.WriteLine(testString); };

Ponieważ Metody anonimowe nie mają nazw, potrzebujemy delegata, do którego możemy przypisać obie te metody lub wyrażenia. np.

delegate void PrintTestString(string testString); // declare a delegate

PrintTestString print = (string testString) => { Console.WriteLine(testString); }; 
print();

s => s.Age > someValue && s.Age < someValue    // will return true/false

Możemy użyć delegata func do użycia tego wyrażenia.

Func< Student,bool> checkStudentAge = s => s.Age > someValue && s.Age < someValue ;

bool result = checkStudentAge ( Student Object);