it-swarm-ru.tech

В чем разница между лямбдами и делегатами в .NET Framework?

Мне часто задают этот вопрос, и я подумал, что хотел бы узнать, как лучше описать разницу.

66
ScottKoon

На самом деле это две совершенно разные вещи. «Делегат» - это имя переменной, которая содержит ссылку на метод или лямбду, а лямбда - это метод без постоянного имени.

Лямбды очень похожи на другие методы, за исключением пары тонких отличий.

  1. Обычный метод определен в «заявлении» и привязан к постоянному имени, тогда как лямбда определяется «на лету» в «выражении» и не имеет постоянного имени.
  2. Некоторые лямбда-выражения можно использовать с деревьями выражений .NET, а методы - нет.

Делегат определяется следующим образом:

delegate Int32 BinaryIntOp(Int32 x, Int32 y);

Переменной типа BinaryIntOp может быть назначен либо метод, либо labmda, если сигнатура одинакова: два аргумента Int32 и возврат Int32.

Лямбда может быть определена так:

BinaryIntOp sumOfSquares = (a, b) => a*a + b*b;

Следует также отметить, что, хотя общие типы Func и Action часто рассматриваются как «лямбда-типы», они аналогичны любым другим делегатам. Приятная вещь о них заключается в том, что они по существу определяют имя для любого типа делегата, который вам может понадобиться (до 4 параметров, хотя вы, конечно, можете добавить и свой собственный). Поэтому, если вы используете широкий спектр типов делегатов, но не более одного раза, вы можете избежать загромождения своего кода объявлениями делегатов с помощью Func и Action.

Вот иллюстрация того, как Func и Action «не только для лямбд»:

Int32 DiffOfSquares(Int32 x, Int32 y)
{
  return x*x - y*y;
}

Func<Int32, Int32, Int32> funcPtr = DiffOfSquares;

Еще одна полезная вещь, которую нужно знать, это то, что типы делегатов (не сами методы) с одинаковой сигнатурой, но разными именами не будут неявно приводиться друг к другу. Это включает в себя делегатов Func и Action. Однако, если подпись идентична, вы можете явно привести между ними.

Пройдя лишнюю милю .... В C # функции гибки, с использованием лямбд и делегатов. Но в C # нет «первоклассных функций». Вы можете использовать имя функции, назначенное переменной-делегату, чтобы по существу создать объект, представляющий эту функцию. Но это действительно трюк с компилятором. Если вы начнете оператор, написав имя функции, за которым следует точка (то есть попытайтесь получить доступ к элементам самой функции), вы обнаружите, что там нет членов, на которые можно ссылаться. Даже те, что из Object. Это не позволяет программисту делать полезные (и потенциально опасные) вещи, такие как добавление методов расширения, которые могут быть вызваны для любой функции. Лучшее, что вы можете сделать, - это расширить сам класс Delegate, что, безусловно, также полезно, но не так сильно.

Обновление: также см. ответ Карга иллюстрирующий разницу между анонимными делегатами и методами & лямбдами.

Обновление 2: Джеймс Харт делает важное, хотя и очень техническое замечание, что лямбды и делегаты не являются сущностями .NET (т. Е. CLR не имеет понятия делегата или лямбды), а скорее являются фреймворком и языковыми конструкциями.

79
Chris Ammerman

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

Вы действительно спросили, в чем разница между лямбдами и делегатами в .NET Framework; это может быть одной из многих вещей. Вы спрашиваете:

  • В чем разница между лямбда-выражениями и анонимными делегатами в языке C # (или VB.NET)?

  • В чем разница между объектами System.Linq.Expressions.LambdaExpression и объектами System.Delegate в .NET 3.5?

  • Или что-то между этими крайностями или вокруг них?

Некоторые люди, кажется, пытаются дать вам ответ на вопрос «в чем разница между лямбда-выражениями C # и .NET System.Delegate?», Который не имеет большого смысла.

Платформа .NET сама по себе не понимает концепции анонимных делегатов, лямбда-выражений или замыканий - все это определяется языковыми спецификациями. Подумайте о том, как компилятор C # преобразует определение анонимного метода в метод в сгенерированном классе с переменными-членами для хранения состояния закрытия; в .NET нет ничего анонимного в делегате; это просто анонимно программисту C #, пишущему это. Это в равной степени относится и к лямбда-выражению, назначенному типу делегата.

.NETДЕЛАЕТпонимает идею делегата - типа, который описывает сигнатуру метода, экземпляры которого представляют собой либо связанные вызовы определенных методов для определенных объектов, либо несвязанные вызовы определенного метода для конкретного тип, который может быть вызван для любого объекта этого типа, где указанный метод придерживается указанной подписи. Такие типы все наследуются от System.Delegate.

.NET 3.5 также представляет пространство имен System.Linq.Expressions, которое содержит классы для описания выражений кода, и которое также может представлять связанные или несвязанные вызовы методов для определенных типов или объектов. Затем экземпляры LambdaExpression могут быть скомпилированы в фактические делегаты (посредством чего генерируется код динамического метода, основанного на структуре выражения, и возвращается указатель делегата на него).

В C # вы можете создавать экземпляры типов System.Expressions.Expression, присваивая лямбда-выражение переменной указанного типа, что создаст соответствующий код для построения выражения во время выполнения.

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

И лямбда-выражения поддерживают генерацию выражений.

27
James Hart

Одно из отличий состоит в том, что анонимный делегат может опускать параметры, тогда как лямбда должна соответствовать точной сигнатуре. Дано:

public delegate string TestDelegate(int i);

public void Test(TestDelegate d)
{}

вы можете вызвать его следующими четырьмя способами (обратите внимание, что во второй строке есть анонимный делегат без параметров):

Test(delegate(int i) { return String.Empty; });
Test(delegate { return String.Empty; });
Test(i => String.Empty);
Test(D);

private string D(int i)
{
    return String.Empty;
}

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

Test(() => String.Empty); //Not allowed, lambda must match signature
Test(D2); //Not allowed, method must match signature

private string D2()
{
    return String.Empty;
}
18
Karg

Делегаты эквивалентны указателям на функции/указателям на методы/обратным вызовам (выбирайте сами), а лямбда-выражения в значительной степени упрощают анонимные функции. По крайней мере, это то, что я говорю людям.

13
Dan Shield

У меня нет большого опыта в этом, но я бы описал это так: делегат является оберткой для любой функции, тогда как лямбда-выражение само по себе является анонимной функцией.

3
chessguy

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

Func<int, int> f = x => x + 1;
Expression<Func<int, int>> exprTree = x => x + 1;

Первая строка создает делегат, а вторая - дерево выражений.

3
Curt Hagenlocher

Делегат - это ссылка на метод с определенным списком параметров и типом возвращаемого значения. Может включать или не включать объект.

Лямбда-выражение - это форма анонимной функции.

2
Peter Ritchie

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

Это то же самое, я считаю

Delegate delegate = x => "hi!";
Delegate delegate = delegate(object x) { return "hi";};
2
Gilligan

Делегат является сигнатурой функции; что-то вроде 

delegate string MyDelegate(int param1);

Делегат не реализует тело. 

Лямбда - это вызов функции, который совпадает с подписью делегата. Для вышеуказанного делегата вы можете использовать любой из;

(int i) => i.ToString();
(int i) => "ignored i";
(int i) => "Step " + i.ToString() + " of 10";

Однако тип Delegate имеет плохое имя; создание объекта типа Delegate фактически создает переменную, которая может содержать функции - будь то лямбда-выражения, статические методы или методы класса.

2
Steve Cooper

Совершенно очевидно, что вопрос должен был звучать так: «В чем разница между лямбдами и anonymous делегатами?» Из всех ответов здесь только один человек понял это правильно - главное отличие в том, что лямбды могут использоваться как для создания деревьев выражений, так и для делегатов.

Вы можете прочитать больше на MSDN: http://msdn.Microsoft.com/en-us/library/bb397687.aspx

2
Philip Beber

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

Вы можете получить делегат, который указывает на лямбда-выражение как метод, приведя его к делегату или передав его в качестве параметра методу, который ожидает определенный тип делегата, который компилятор применит для вас. Используя его внутри оператора LINQ, лямбда будет преобразована компилятором в дерево выражений, а не просто в делегат.

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

1
justin.m.chase

Делегаты - это просто структурная типизация функций. Вы могли бы сделать то же самое с номинальной типизацией и реализацией анонимного класса, который реализует интерфейс или абстрактный класс, но в итоге получается много кода, когда требуется только одна функция.

Лямбда происходит от идеи лямбда-исчисления церкви Алонзо в 1930-х годах. Это анонимный способ создания функций. Они становятся особенно полезными для составления функций

Поэтому, хотя некоторые могут сказать, что лямбда - это синтаксический сахар для делегатов, я бы сказал, что делегаты - это мост, облегчающий переход людей на лямбды в c #.

1
Steve g

Я предполагаю, что ваш вопрос касается c #, а не .NET, из-за неоднозначности вашего вопроса, поскольку .NET не остается в одиночестве - то есть без c # - понимания делегатов и лямбда-выражений.

Делегат (normal, в отличие от так называемых делегатов generic, позже cf) следует рассматривать как разновидность c ++ typedef типа указателя на функцию, например в c ++:

R (*thefunctionpointer) ( T ) ;

typedef - это тип thefunctionpointer, который является типом указателей на функцию, принимающую объект типа T и возвращающий объект типа R. Вы бы использовали это так:

thefunctionpointer = &thefunction ;
R r = (*thefunctionpointer) ( t ) ; // where t is of type T

где thefunction будет функцией, принимающей T и возвращающей R.

В C # вы бы пошли на

delegate R thedelegate( T t ) ; // and yes, here the identifier t is needed

и вы бы использовали это так:

thedelegate thedel = thefunction ;
R r = thedel ( t ) ; // where t is of type T

где thefunction будет функцией, принимающей T и возвращающей R. Это для делегатов, так называемых нормальных делегатов.

Теперь у вас также есть обобщенные делегаты в c #, которые являются обобщенными делегатами, то есть i.e., которые, так сказать, «шаблонизированы», используя при этом выражение c ++. Они определены так:

public delegate TResult Func<in T, out TResult>(T arg);

И вы можете использовать их так:

Func<double, double> thefunctor = thefunction2; // call it a functor because it is
                                                // really as a functor that you should
                                                // "see" it
double y = thefunctor(2.0);

где thefunction2 - это функция, принимающая в качестве аргумента и возвращающая double.

Теперь представьте, что вместо thefunction2 я хотел бы использовать «функцию», которая пока нигде не определена оператором, и которую я никогда не буду использовать позже. Тогда c # позволяет нам использовать выражение этой функции. Под выражением я подразумеваю его «математическое» (или функциональное, чтобы придерживаться программ) выражение, например: double x я буду ассоциироватьdoublex*x. В математике вы пишете это, используя латексный символ "\ mapsto" . В c # функциональная нотация была заимствована: =>. Например :

Func<double, double> thefunctor = ( (double x) => x * x ); // outer brackets are not
                                                           // mandatory

(double x) => x * x является выражением . Это не тип, тогда как делегаты (общие или нет).

Мораль? В конце концов, что такое делегат (соответственно универсальный делегат), если не тип указателя функции (соответственно упакованный + умный + тип указателя универсальной функции), а? Что-то другое ! Смотрите это и это .

0
ujsgeyrr1f0d0d0r0h1h0j0j_juj

Вот пример, который я выложил некоторое время на своем хромом блоге. Скажем, вы хотите обновить метку из рабочего потока. У меня есть 4 примера того, как обновить эту метку с 1 до 50, используя делегаты, анон делегаты и 2 типа лямбд.

 private void button2_Click(object sender, EventArgs e) 
     { 
         BackgroundWorker worker = new BackgroundWorker(); 
         worker.DoWork += new DoWorkEventHandler(worker_DoWork); 
         worker.RunWorkerAsync(); 
     } 

     private delegate void UpdateProgDelegate(int count); 
     private void UpdateText(int count) 
     { 
         if (this.lblTest.InvokeRequired) 
         { 
             UpdateProgDelegate updateCallBack = new UpdateProgDelegate(UpdateText); 
             this.Invoke(updateCallBack, new object[] { count }); 
         } 
         else 
         { 
             lblTest.Text = count.ToString(); 
         } 
     } 

     void worker_DoWork(object sender, DoWorkEventArgs e) 
     {   
         /* Old Skool delegate usage.  See above for delegate and method definitions */ 
         for (int i = 0; i < 50; i++) 
         { 
             UpdateText(i); 
             Thread.Sleep(50); 
         } 

         // Anonymous Method 
         for (int i = 0; i < 50; i++) 
         { 
             lblTest.Invoke((MethodInvoker)(delegate() 
             { 
                 lblTest.Text = i.ToString(); 
             })); 
             Thread.Sleep(50); 
         } 

         /* Lambda using the new Func delegate. This lets us take in an int and 
          * return a string.  The last parameter is the return type. so 
          * So Func<int, string, double> would take in an int and a string 
          * and return a double.  count is our int parameter.*/ 
         Func<int, string> UpdateProgress = (count) => lblTest.Text = count.ToString(); 
         for (int i = 0; i < 50; i++) 
         { 
             lblTest.Invoke(UpdateProgress, i); 
             Thread.Sleep(50); 
         } 

         /* Finally we have a totally inline Lambda using the Action delegate 
          * Action is more or less the same as Func but it returns void. We could 
          * use it with parameters if we wanted to like this: 
          * Action<string> UpdateProgress = (count) => lblT…*/ 
         for (int i = 0; i < 50; i++) 
         { 
             lblTest.Invoke((Action)(() => lblTest.Text = i.ToString())); 
             Thread.Sleep(50); 
         } 
     }
0
Echostorm

Некоторые основные здесь . «Делегат» на самом деле имя переменной, которая содержит ссылку на метод или лямбду

Это анонимный метод - (String testString) => {Console.WriteLine (testString); };

Поскольку у анонимного метода нет никакого имени, нам нужен делегат, в котором мы можем назначить оба этих метода или выражения. Например.

делегат void PrintTestString (строка testString); // объявляем делегата

PrintTestString print = (string testString) => {Console.WriteLine (testString); }; Распечатать();


То же самое с лямбда-выражением. Обычно нам нужен делегат, чтобы использовать их

s => s.Age> someValue && s.Age <someValue // вернет true/false

Мы можем использовать делегат func, чтобы использовать это выражение.

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

bool result = checkStudentAge (Student Object);

0
Yogesh Prajapati

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

something.Sort((x, y) => return x.CompareTo(y));

гораздо более кратким, чем то, что вы можете сделать с делегатом:

something.Sort(sortMethod);
...

private int sortMethod(SomeType one, SomeType two)
{
    one.CompareTo(two)
}
0
Michael Meadows