Why can’t an anonymous method be assigned to a var or Dynamic?

Question

The following code:

var mostra = delegate(string x)
{
    Console.WriteLine(x);
};
mostra("teste");

The . Net should not identify the var as a Action<string>?

And the same for dynamic?

Answer 1

Miguel Angelo’s answer already answers the question. I’ll just post some information that might help find some other solution in some cases. Of course, for the question, the simplest and most obvious solution is the second alternative to his answer.

The var is not a magic solution and should always be used, is just a facilitator and when it is not possible to use it just do as it was before that is to use the type explicitly. I don’t like the solutions of cast, even though they work. It would only be useful in the case of dynamic since this command "hides" the compile-time type.

Note that this is such a difficult problem to solve that even in Runtime it is not possible to identify unambiguously which type is correct, hence the dynamic also does not solve.

Why is it difficult to infer in this case?

Eric Lippert, the creator of this feature in the compiler, already explained in his response in the OS because infer the type of delegate would be too complicated or even impossible.

Abuse of variable use

One thing to think about is whether you need a variable in this case. One thing I realize to be very common is programmers finding that variable is something absolutely necessary in a program. And it’s not. Variable is just a project pattern (Pattern design).

Of course the code would be unreadable but it is possible to program without the use of variables. And amaze, respecting the DRY.

I’m not preaching this but as I say exceptions are being abused I say that programmers abuse variables all the time. Probably because they don’t understand that variable is just a place to store data temporarily. Do not understand that if there is no advantage in keeping this data, should not keep it.

Interestingly because they don’t understand this, they make the wrong mistake too. When variables can be used, they end up not using it. I’m talking about this in that and in that reply. People don’t understand that expressions can be replaced by variables, so where she knows she needs an expression, she is forced to create an expression when a variable is enough. I never get tired of seeing this freak:

if (booleanoQualquer == true)

Of course, the variable can be used as a form of documentation of the steps that are being made but it is not its main function, it is a side effect.

Completion

So it’s nice to know that the real problem is with var and not with the inference itself. It is possible to infer when there is enough information to infer. If it were not in the var yes in a place where one expects an expression of a specific type, the compiler can find out if they are compatible. This is well shown in this blog. See the code of it running.

If you don’t have to actually use a variable, don’t use it and gain the inference in most cases.

I’m not saying you abused because I know it was just a self-contained example.

Answer 2

Enough for you to ask yourself what kind of var then?

In the case of your example:

var mostra = delegate(string x)
{
    Console.WriteLine(x);
};
mostra("teste");

mostra would be a delegate of what kind? Action<string>? Or would it be some other guy... for example, I could invent some kind of a delagate:

delegate void Xpto(string str);

And now?

There is no way to know, because delegates are objects that have type in . Net.

How then

There are a few ways for you to indicate delegate type to C#:

var mostra = (Action<string>)delegate(string x)
{
    Console.WriteLine(x);
};
mostra("teste");

Or else:

Action<string> mostra = delegate(string x)
{
    Console.WriteLine(x);
};
mostra("teste");

Or else:

var mostra = (Action<string>)(x => Console.WriteLine(x));
mostra("teste");

The latter being an alternative from my first example, only using a lambda to generate delegate.