C # Лямбда-выражения: зачем их использовать?

Question

Я быстро прочитал документацию Microsoft Lambda Expression .

Этот пример помог мне лучше понять:

delegate int del(int i);
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25

Тем не менее, я не понимаю, почему это такая инновация. Это просто метод, который умирает, когда «переменная метода» заканчивается, верно? Почему я должен использовать это вместо реального метода?

Answer 1

Лямбда-выражения представляют собой более простой синтаксис для анонимных делегатов и могут использоваться везде, где может использоваться анонимный делегат. Однако обратное неверно; Лямбда-выражения могут быть преобразованы в деревья выражений, что позволяет использовать магию, такую ​​как LINQ to SQL.

Ниже приведен пример выражения LINQ to Objects , в котором используются анонимные делегаты, а затем лямбда-выражения, чтобы показать, насколько они проще для глаз:

// anonymous delegate
var evens = Enumerable
                .Range(1, 100)
                .Where(delegate(int x) { return (x % 2) == 0; })
                .ToList();

// lambda expression
var evens = Enumerable
                .Range(1, 100)
                .Where(x => (x % 2) == 0)
                .ToList();

Лямбда-выражения и анонимные делегаты имеют преимущество перед написанием отдельной функции: они реализуют замыкания , которые могут позволить передавать локальное состояние функции без добавления параметров в функцию или создание одноразовых объектов.

Деревья выражений - это очень мощная новая функция C # 3.0, которая позволяет API смотреть на структуру выражения, а не просто получать ссылку на метод, который может быть выполнен. API просто должен превратить параметр делегата в параметр Expression<T>, и компилятор сгенерирует дерево выражений из лямбды-выражения вместо анонимного делегата:

void Example(Predicate<int> aDelegate);

называется как:

Example(x => x > 5);

становится:

void Example(Expression<Predicate<int>> expressionTree);

Последнему будет передано представление абстрактного синтаксического дерева , которое описывает выражение x > 5. LINQ to SQL полагается на это поведение, чтобы иметь возможность превращать выражения C # в выражения SQL, требуемые для фильтрации / упорядочения / и т. Д. На стороне сервера.

Answer 2

Анонимные функции и выражения полезны для одноразовых методов, для которых не требуется дополнительная работа, необходимая для создания полного метода.

Рассмотрим этот пример:

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

против

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

Они функционально эквивалентны.

Answer 3

Я нашел их полезными в ситуации, когда я хотел объявить обработчик для события некоторого элемента управления, используя другой элемент управления. Чтобы сделать это обычно, вы должны хранить ссылки элементов управления в полях класса, чтобы вы могли использовать их в другом методе, чем они были созданы.

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

благодаря лямбда-выражениям вы можете использовать его так:

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

Намного проще.

Answer 4

Лямбда убрала синтаксис анонимного делегата C # 2.0 ... например

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

Было сделано в C # 2.0 следующим образом:

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

Функционально, они делают одно и то же, просто более краткий синтаксис.

Answer 5

Это всего лишь один из способов использования лямбда-выражения. Вы можете использовать лямбда-выражение везде, где вы можете использовать делегата. Это позволяет вам делать такие вещи:

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

Этот код будет искать в списке запись, которая соответствует слову "привет". Другой способ сделать это - передать делегат методу Find следующим образом:

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

В C # 2.0 это можно сделать с помощью синтаксиса анонимного делегата:

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

Лямбда значительно очистил этот синтаксис.

Answer 6

Microsoft предоставила нам более чистый и удобный способ создания анонимных делегатов, называемых лямбда-выражениями. Однако не так много внимания уделяется части выражений этого утверждения. Microsoft выпустила целое пространство имен System.Linq.Expressions , которое содержит классы для создания деревьев выражений на основе лямбда-выражений. Деревья выражений состоят из объектов, которые представляют логику. Например, x = y + z - это выражение, которое может быть частью дерева выражений в .Net. Рассмотрим следующий (простой) пример:

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

Этот пример тривиален. И я уверен, что вы думаете: «Это бесполезно, поскольку я мог бы непосредственно создать делегат вместо создания выражения и его компиляции во время выполнения». И ты был бы прав. Но это обеспечивает основу для деревьев выражений. Существует несколько выражений, доступных в пространствах имен Expressions, и вы можете создавать свои собственные. Я думаю, вы можете видеть, что это может быть полезно, когда вы не знаете точно, каким должен быть алгоритм во время проектирования или компиляции. Я видел где-то пример использования этого для написания научного калькулятора. Вы также можете использовать его для байесовских систем или генетического программирования (AI). Несколько раз в моей карьере мне приходилось писать функции, подобные Excel, которые позволяли пользователям вводить простые выражения (сложение, подстановки и т. Д.) Для работы с доступными данными. В pre-.Net 3.5 мне приходилось прибегать к некоторому языку сценариев, внешнему по отношению к C #, или использовать рефлексию кода для отражения, чтобы создавать код .Net на лету. Теперь я бы использовал деревья выражений.

Answer 7

Это избавляет от необходимости иметь методы, которые используются только один раз в определенном месте, от определения далеко от места, где они используются. Хорошо использовать в качестве компараторов для общих алгоритмов, таких как сортировка, где вы можете затем определить пользовательскую функцию сортировки, где вы вызываете сортировку, а не дальше, заставляя вас искать в другом месте, чтобы увидеть, что вы сортируете.

И это не совсем инновация. LISP выполняет лямбда-функции в течение 30 и более лет.

Answer 8

Вы также можете найти использование лямбда-выражений при написании универсальных кодов для действий с вашими методами.

Например: универсальная функция для расчета времени, затраченного на вызов метода. (т. е. Action здесь)

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

И вы можете вызвать вышеуказанный метод, используя лямбда-выражение следующим образом:

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

Выражение позволяет вам получить возвращаемое значение из вашего метода, а также из параметра

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

Answer 9

Лямбда-выражение похоже на анонимный метод, написанный вместо экземпляра делегата.

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

Рассмотрим лямбда-выражение x => x * x;

Значением входного параметра является x (слева от =>)

Логика функции: x * x (справа от =>)

Код лямбда-выражения может быть блоком выражения вместо выражения.

x => {return x * x;};

Пример

Примечание: Func - это предопределенный общий делегат.

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

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

Ссылки

1. Как делегат и интерфейс могут использоваться взаимозаменяемо?

Answer 10

Лямбда-выражение - это краткий способ представления анонимного метода. Как анонимные методы, так и лямбда-выражения позволяют определять встроенную реализацию метода, однако анонимный метод явно требует, чтобы вы определили типы параметров и тип возвращаемого значения для метода. Лямбда-выражение использует функцию вывода типа C # 3.0, которая позволяет компилятору выводить тип переменной на основе контекста. Это очень удобно, потому что это экономит нам много печатать!