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
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!