What does this C# code with an "arrow" (=>, an equal sign and greater than sign) mean and how is it called?

I was trying to enable SSL in my C# client program and found the following code in this answer:

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

I added the code to my program and it solved the problem, but I completely don't get how exactly it wor开发者_如何学Pythonks.

The left part System.Net.ServicePointManager.ServerCertificateValidationCallback is some callback and += modifies that callback. But what does the remaining construct mean? I spent 20 minutes searching to at least find how it is properly called and where I can find more info on how to read that, but all in vain. I suppose it is somehow related to LINQ and searched for "LINQ arrow", but didn't find anything reasonable.

How is that (blah,blah,blah)=>{return true;} construct called and where can I find more info on such constructs?

That is a lambda expression. It is a very special anonymous delegate. Basically you are defining a method and not giving a name. Its parameters are to the left of the => and the method body is to the right of the =>. In your particular case,

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

is an anonymous method defined by a lambda expression. This particular method has four parameters

object se
X509Certificate cert
X509Chain chain
SslPolicyErrors sslerror

and the method body is

return true;

It's as if you had said

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

and then

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

How is that (blah,blah,blah)=>{return true;} construct called and where can I find more info on such constructs?

It's called the same way that any other method is called. For example, you can do this:

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

Here I am defining a method that eats a pair of int and returns an int. That int is obtained by adding the values of the input parameters. It can be invoked like any other method.

int four = adder(2, 2); 

Here's an article on MSDN on lambda expressions and an article on the lambda operator. If you're really interested, the name comes from lambda calculus.

For completeness (for search results, etc): in more recent versions of C# (since 6.0), the => syntax has been extended from just lambdas for delegates and expression trees, to cover expression-bodied members. This means that a range of simple members such as properties, methods, etc - can be implemented as expression bodies; for example:

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

can be written:

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

The =>-Operator represents a lambda expression.

But for those of you who visit the question nowadays, another use-case might be the arrow as a shorthand for a property getter. This feature got introduced in C# 6. So instead of writing

public string Foo
{
    get
    {
        return this.bar;
    }
}

you can use following snippet:

public string Foo 
{
    get => this.bar;
}

or even shorter:

public string Foo => this.bar;

It's called a lambda expression.

http://msdn.microsoft.com/en-us/library/bb311046.aspx - The lambda operator.

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

is a lambda expression. It doesn't look like the lambdas you're used to because it doesn't use any arguments which get passed to it. The compiler will turn this lambda into a delegate function for you, without you having to go through the long, annoying process of creating a whole function which implements the delegate specification that ServicePointManager.ServerCertificateValidationCallback uses.

Jason explains it very well. Here is an example using an event that is listened to using different techniques:

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<EventArgs> EventTest;

        public Events()
        {
            EventTest += new EventHandler<EventArgs>(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()); 
        }
    }
}

This snippet is called anonymous function. It builds an anonymous method around the callback delegate and allways returns true.