C# scoping operator

back in school, we wrote a compiler where curly braces had the default behavior of executing all expressions, and returning the last value... so you could write something like:

int foo = { prin开发者_运维百科tf("bar"); 1 };

Is there something equivalent in C#? For instance, if I want to write a lambda function that has a side effect.

The point less being about the lambda side effect (just an example), more if there is this functionality... for instance in lisp, you have progn

In principle, the answer from Vlad is correct and you don't need to declare the lambda function as a delegate in advance.

Except, the situation is not as simple in C#, because the compiler cannot decide whether the syntactical lambda expression should be compiled as a delegate (e.g. Func<int>) or an expression tree (e.g. Expression<Func<int>>) and also, it can be any other compatible delegate type. So, you need to create the delegate:

int foo = new Func<int>(() => { 
  Console.WriteLine("bar"); return 1; })(); 

You can simplify the code slightly by defining a method that simply returns the delegate and then calling the method - the C# compiler will infer the delegate type automatically:

static Func<R> Scope<R>(Func<R> f) { return f; }

// Compiler automatically compiles lambda function
// as delegate and infers the type arguments of 'Scope'
int foo = Scope(() => { Console.WriteLine("bar"); return 1; })(); 

I agree that this is an ugly trick that shouldn't be used :-), but it is an interesting fact that it can be done!

There's nothing stopping you from having side-effects in a lambda expression.

Func<int> expr = () =>
{
    Console.WriteLine("bar");
    return 1;
};
int foo = expr();

int foo = (() => { printf("bar"); return 1; })();

Edit: thanks for the constructive critique, it ought to be

int i = ((Func<int>)(() => { printf("bar"); return 1; }))();

We've considered making even-more-brief syntaxes than ()=>{M();} for definition of a lambda, but haven't managed to actually find a syntax that both reads nicely and is not easily confused with blocks, collection/object initializers, or array initializers. You're stuck with lambda syntax for now.

You're talking about an anonymous function: http://msdn.microsoft.com/en-us/library/bb882516.aspx, I think.