Why don't I add parantheses when assigning a method to a delegate?

Question

What is the reason why I can't put parenthesis after my Method name when assigning it to a delegate type.

Here is code:

public delegate Simple Simple(); //Create a delegate that returns its own type.

class Program
{
    public class Exercise
    {
        public static Simple Welcome()
        {
            Console.WriteLine("Welcome!");
            return null;

        }
    }
    static void Main(string[] args)
    {
        Simple msg;
        msg = Exercise.Welcome(); //Since Welcome returns Simple, I can execute it.

        msg();
        Console.Read();
    }
}

Answer 1

It lets the compiler distinguish a method call from a reference to a method group. If you add parenthesis, the compiler will call the method and uses the return value of that method call, instead of the method group itself.

Answer 2

Because () executes the method. And as you said yourself, you're assigning it, not executing it. If you used parentheses where you indicate, you'd be assigning the result of executing the method, not assigning the method.

Answer 3

Consider this code:

delegate Foo Foo(); // yes, this is legal - a delegate to method that returns
                    // the same kind of delegate (possibly to a different method,
                    // or null)

class Program
{
    static Foo GetFoo() { return null; }

    static void Main()
    {
         Foo foo;

         foo = GetFoo;   // assign a delegate for method GetFoo to foo

         foo = GetFoo(); // assign a delegate returned from an invocation
                         // of GetFoo() to foo
    }
}

Hopefully it makes it clear why the parentheses have to be significant.