How does this Lambda expression work?

Question

Hi

Given this code example:-

public readonly Dictionary<Type, Func<Object>> providers = new Dictionary<Type, Func<Object>>();

public void Bind<T>(T instance)
{
providers[typeof(T)] = () => instance;
}

My question is why is a Lambda expression used for the assignment of the parameter "instance" to providers[typeof(T)]?

I tried assigning the "instance" parameter on its own but got a cast\conversion error.

Regards

Steven

Vulpes · Answer

Imagine for a moment that we had this more straightforward delegate declaration: string instance = "Steven"; Func func = () => instance; string s = (string)func(); // invoke delegate and cast object returned to string. Console.WriteLine(s); // Steven So, we're invoking the delegate func, using the usual C# syntax (i.e. func()) given that it doesn't take an argument. Instead the lambda expression which we're assigning to func is 'capturing' the local variable, instance and returning that. t.providers[typeof(string)] is analogous to func in the above example because it's a delegate of type Func . So to invoke it we just need to add the parentheses to the end and cast the return type to string: string s = (string)t.providers[typeof(string)](); The Dictionary is associating a type object for a given type with a delegate which returns a value of type object. The Bind() method ensures that the actual type of the bound value is the same as the type object because both of them have to be of type T.

Vulpes · Answer

I received an e-mail notification of a post which has now disappeared but I'll just say that these lines won't compile: providers[typeof(T)](() => instance); providers[typeof(T)](instance); because Func doesn't take a parameter. For them to compile, you'd have to change the Dictionary Declaration so that its second type parameter was a delegate which did cater for a single parameter of type Func or type object, respectively.

Vulpes · Answer

All the Bind method does is to assign a value (namely the lambda expression) for a particular key to the Dictionary. Once that's done (and even though its parameter 'instance' is being captured by the lambda), the Bind method takes no further part in proceedings. So the lambda expression (and the captured parameter) continue to exist even though the Bind method which created them has terminated execution. This is achieved behind the scenes by the compiler creating a hidden class and making the captured variable a field of that class. When the delegate is invoked, the class is instantiated and bound to the delegate. Consequently, the lambda expression and the captured variable live as long as the delegate to which the former is assigned.

S · Answer

Right so when invoking the delegate Func with () this knows to execute the Lambda expression in the Bind method even if the Bind method isnt even in play here? or is it the fact the Bind method is called before passing in an instance like so:- string name = "somename"; t.Bind(name); var getResult = t.providers[typeof(String)](); // Execute the Delegate Func using () which then executes the // Lambda expression in the Bind method, due to the Bind method being invoked? Regards

Vulpes · Answer

The role of the Bind method is to associate a lambda expression which returns an object with a key of type System.Type. The lambda expression 'captures' the parameter passed into the Bind() method and returns it as an object. Once that has been done the Bind method plays no further part. As you say, the delegate to which the lambda expression is converted is invoked using the () syntax. You can't (and don't need to) pass it a parameter within the () because the delegate doesn't take one. You'd only need to pass it a parameter or parameters of the appropriate type(s) if the delegate declaration (or a corresponding lambda expression) specified that parameters were needed.

S · Answer

Thanks Vulpes, Given your statement:- object obj = t.providers[typeof(string)](); " By doing this we're invoking the lambda expression () => instance, which returns a value of type object". How is the Lambda expression being invoked, is it because of the parenthesis () which is invoking the Func and then the Lambda in the Bind method? if so how, as there is no mention of the Bind method here? Also, I tried the following providers[typeof(T)](() => instance); However I get an error that "Func does not have 1 arguement" so is this syntax only applicable if Func has an input parameter declared? otherwise, the use of the assignment operator = is required for no arguements? Regards Steven

Vulpes · Answer

Correct on the first point, Steven. You're also correct that () => instance is the Func delegate(or, to be strictly accurate, is automatically convertible to it). However, there's a big difference between typeof(string) and t.providers[typeof(string)]. The first is an object of type System.Type. The second is a Func delegate, namely the lambda expression referred to above. It may be that the notation is confusing you here. If you had something more usual such as a Dictionary , dict say, and if key were a string, then you could get the corresponding int value using the Dictionary's indexer: int val = dict[key]; The only difference now is that the types of the key and value are a bit more complicated: Func func = t.providers[typeof(string)]; string s = (string)func(); // invoke delegate and cast result from object to string

S · Answer

So the Lambda expression is set only in the Bind method right? With regards to " typeof(string) is the key and t.providers[typeof(string)] is the value corresponding to that key." I dont see how these two are any different? id expect () => instance to be the Func delegate? Sorry for my lack of understanding...

Vulpes · Answer

Remembering that it's a Dictionary >, typeof(string) is the key and t.providers[typeof(string)] is the value corresponding to that key. As the above value is a delegate of type Func , to invoke it, all we need to do is add () at the end: object obj = t.providers[typeof(string)](); By doing this we're invoking the lambda expression () => instance, which returns a value of type object. As we know that 'instance' actually contains the string "Steven", we can recover it with a cast: string s = (string)obj; Any clearer?

S · Answer

Vulpes Apologies for revisiting Going back on a statement you said as follows:- "t.providers[typeof(string)] is analogous to func in the above example because it's a delegate of type Func " I thought providers[typeof(string)] was the "Key" part of the Dictionary of type Type and the "Value" part of the Dictionary a Delegate of type Func ? also, how is Func being invoked, is it due to the fact of the assignment which takes place in the Bind method? ie providers[typeof(T)] = () => instance;

S · Answer

Got it! many thanks Vulpes!

S · Answer

Thanks Vulpes Sorry for being dense but how is:- t.providers[typeof(string)](); invoking the lambda expression? as all that is being passed is the Key which is the Type? I thought type parameters and formal parameters work in conjunction with each other ie Key and Value, or is it that the Bind method is handling this with the assignment of the Lambda? Also am I right in saying the Dictionary is just a surrogate in effect for resolving the Type and Instance rather than having anything actually added to it? Regards

Vulpes · Answer

That's right, Steven. The Dictionary's value is a delegate (i.e. the lambda expression) which doesn't get executed until it's actually invoked. Here's a quick example I've put together to show how you might use the Bind method: using System; using System.Collections.Generic; using System.Linq; class Test { public readonly Dictionary > providers = new Dictionary >(); static void Main() { Test t = new Test(); string instance = "Steven"; t.Bind(instance); string s = (string)t.providers[typeof(string)](); // invoke the lambda expression Console.WriteLine(s); Console.ReadKey(); } public void Bind (T instance) { providers[typeof(T)] = () => instance; } }

S · Answer

Thanks Vulpes, so basically providers[typeof(T)] satisifies the Dictionary part and the assignment () => instance satisfies the Func part? Also, how is the Bind method working exactly as it takes an input parameter of generic type T and then in the method body the Lambda expression goes to it? is this after it has assigned the passed in value to the Dictionary?

Vulpes · Answer

The generic Dictionary, providers, has a key of type System.Type and a value of type Func . Func is a delegate which takes no parameters and returns a value of type System.Object. So, providers[typeof(T)] is setting the value of the Dictionary for the key typeof(T). It has to be a delegate of the above type and the lambda expression: () => instance fits the bill because: 1. It takes no parameters and returns a value of type T which (like all .NET types) is implicitly convertible to System.Object. 2. Any lambda expression is always convertible to a compatible delegate which is clearly the case here. The instance parameter on its own won't suffice as it's a value of type T not Func .