C# scoping operator

Question

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 = { printf("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

Answer 1

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

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

Answer 2

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

Answer 3

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

---

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

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

Answer 4

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!

Answer 5

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.