¿Qué significa este código C # con una “flecha” y cómo se llama?

Estaba intentando habilitar SSL en mi progtwig de cliente C # y encontré el siguiente código en esta respuesta :

System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => { return true; }; 

Agregué el código a mi progtwig y resolvió el problema, pero no entiendo exactamente cómo funciona.

La parte izquierda System.Net.ServicePointManager.ServerCertificateValidationCallback es una callback y += modifica esa callback. Pero, ¿qué significa la construcción restante? Pasé 20 minutos buscando, al menos, cómo se llama correctamente y dónde puedo encontrar más información sobre cómo leer eso, pero todo fue en vano. Supongo que de alguna manera está relacionado con LINQ y buscó “LINQ arrow”, pero no encontró nada razonable.

¿Cómo se llama esa construcción (blah,blah,blah)=>{return true;} y dónde puedo encontrar más información sobre tales construcciones?

Esa es una expresión lambda. Es un delegado anónimo muy especial. Básicamente, estás definiendo un método y no dando un nombre. Sus parámetros están a la izquierda de => y el cuerpo del método está a la derecha de => . En tu caso particular,

 (se, cert, chain, sslerror) => { return true; }; 

es un método anónimo definido por una expresión lambda. Este método particular tiene cuatro parámetros

 object se X509Certificate cert X509Chain chain SslPolicyErrors sslerror 

y el cuerpo del método es

 return true; 

Es como si hubieras dicho

 class ServerCertificateValidation { public bool OnRemoteCertificateValidation( object se, X509Certificate cert, X509Chain chain, SslPolicyErrors sslerror ) { return true; } } 

y entonces

 var validation = new ServerCertificateValidation(); System.Net.ServicePointManager.ServerCertificateValidationCallback += validation.OnRemoteCertificateValidation; 

¿Cómo se llama esa construcción (blah,blah,blah)=>{return true;} y dónde puedo encontrar más información sobre tales construcciones?

Se llama de la misma manera que cualquier otro método. Por ejemplo, puedes hacer esto:

 Func adder = (m, n) => m + n; 

Aquí estoy definiendo un método que come un par de int y devuelve un int . Esa int se obtiene sumndo los valores de los parámetros de entrada. Se puede invocar como cualquier otro método.

 int four = adder(2, 2); 

Aquí hay un artículo sobre MSDN en expresiones lambda y un artículo sobre el operador lambda . Si realmente estás interesado, el nombre proviene del cálculo lambda .

Se llama una expresión lambda .

http://msdn.microsoft.com/en-us/library/bb311046.aspx – El operador lambda.

 (blah,blah,blah)=>{return true;} 

es una expresión lambda No se parece a las lambdas a las que estás acostumbrado porque no usa ningún argumento que se le pase. El comstackdor convertirá esta lambda en una función de delegado para usted, sin tener que pasar por el largo e irritante proceso de creación de una función completa que implementa la especificación de delegado que utiliza ServicePointManager.ServerCertificateValidationCallback.

Jason lo explica muy bien. Aquí hay un ejemplo que usa un evento que se escucha usando diferentes técnicas:

 using System; namespace Events { class Program { static void Main(string[] args) { Events e = new Events(); e.FireEvents(); Console.ReadLine(); } } public class Events { private event EventHandler EventTest; public Events() { EventTest += new EventHandler(function); EventTest += delegate { Console.WriteLine("written by an anonymous method."); }; EventTest += (o, e) => { Console.WriteLine("written by a lambda expression"); }; } private void function(object sender, EventArgs e) { Console.WriteLine("written by a function."); } public void FireEvents() { if (EventTest != null) EventTest(this, new EventArgs()); } } } 

Para completar (para resultados de búsqueda, etc.): en versiones más recientes de C # (desde 6.0), la syntax => se ha extendido desde solo lambdas para delegates y árboles de expresiones, para cubrir los miembros con cuerpo de expresión . Esto significa que una gama de miembros simples, como propiedades, métodos, etc., puede implementarse como cuerpos de expresión; por ejemplo:

 public int Foo { get { return innerObj.SomeProp; } } public void Bar() { Write("Thing"); } 

puede ser escrito:

 public int Foo => innerObj.SomeProp; public void Bar() => Write("Thing"); 

Este fragmento se llama función anónima. Construye un método anónimo alrededor del delegado de callback y siempre devuelve verdadero.