Question

Could someone tell me how does it work? I would be grateful. Dunno how to debug this.

using System;

    class Prg
    {
        private static Func<double, Func<double, double>> Add(int c)
        {
            return x => y => x + y++ + (c *= 2);
        }

        public static void Main(string[] args)
        {
            int a = 1;
            int b = 100;
            var F = Add(2);
            var G = F(a);
            G(b);
            Console.WriteLine(G(b));
        }
    }

EDIT: I have got another one if you want to enjoy our C# exam.. Here is the code.

delegate int F(); 
class Prg { int a = 10; 
  public F Adder(int x) { 
    int i = x; 
    return delegate { 
      return a += i++; }; 
  } 
  static void Main() { 
    Prg p = new Prg(); 
    F f = p.Adder(5); 
    p.Adder(10); 
    f(); 
    System.Console.Write(f()); 
}  } 

Answer 1

I will start with: don’t write such code, ever.

And if you really want to know what is happening:

1. in line var F = Add(2), method Add() creates and returns a lambda expression with c==2. What is important here, is that c is caught by lambda (you can read about capturing variables on msdn.
2. In line var G = F(x) you are simply calling your function with parameter a = 1 and you get another function as a result, double -> double to be exact.
3. In line G(b) you are calling your function, exactly this one: x + y++ + (c *= 2); Now:
   • x is equal to 1
   • y is your parameter, it is equal to 100
   • c is equal to 2, but it is captured, so it is actually a reference to some allocated field
   • Result of this expression is 105 (100++ returns 100, 2 *= 2 returns 4), so you get 1 + 100 + 4 = 105. But, what is more important, variable c, which is captures is now equal to 4. y was just a parameter, so it did not change.
4. In line Console.... you are invoking your function again. This time, parameter is again equal to 100, so a result would be identical, but your captured variable c is now equal to 4, so a result you receive 1 + (100+) + (4 *= 2) -> 1 + 100 + 8 -> 109

Here’s a short example that might shine some light on what has happened there:

class Prg
{
    public static void Main(string[] args)
    {
        int captured = 5;
        int param = 3;

        var func = new Func<int, int>(x => x * captured);

        Console.WriteLine(func(param));
        captured = 6;
        Console.WriteLine(func(param));

    }
}