user496949
user496949

Reputation: 86055

understand the following lambda

I have a method like

void Test(Func<bool> f)
{
    f.Invoke();
}

I pass in the Test( ()=>GetItem("123") )

f.Invoke() actually called GetItem("123").

I want to know how does f know GetItem has a parameter?

Upvotes: 2

Views: 99

Answers (4)

Unmesh Kondolikar
Unmesh Kondolikar

Reputation: 9312

What you are passing to Test is a parameter-less delegate which calls your GetItem method. So your Test method does not know anything about parameters to GetItem. It only knows about the delegate it is calling.

Test( ()=>GetItem("123") )

is equal to

Test(delegate { return GetItem("abc") ; } );

which is like calling

Test(MyMethod)   
...
bool MyMethod()
{
    return GetItem("123");
}

Upvotes: 2

jason
jason

Reputation: 241583

Good question. You can think of the delegate

() => GetItem("123")

as being a compiled version of the following expression tree

Expression.Lambda<Func<bool>>(
    Expression.Call(
        null,
        typeof(X).GetMethod("GetItem"),
        new Expression[] { Expression.Constant("123", typeof(string)) }
    ), 
    new ParameterExpression[0]
);

Here I am assuming that GetItem is a method defined in a class X and that its return type is declared as bool.

The point is that the delegate captures all the information it needs to be invoked. When you invoke this delegate in Test, you have no idea that the method GetItem is behind the scenes, or that it is being invoked with the parameter "123". The delegate is keeping track of that information and Test is agnostic to those details. It just wants something that it can invoke that ultimately returns a bool. In your particular instance, that bool happens to be the result of GetItem("123").

f.Invoke() actually called GetItem("123")

Actually it didn't. It called () => GetItem("123") which merely returns the value of GetItem("123"). See the difference?

Upvotes: 2

Nader Shirazie
Nader Shirazie

Reputation: 10776

Your function Test takes a function as a parameter. It will invoke whatever function is passed in as an argument.

In this case, when you create your lambda () => GetItem("123"), you are creating a function that takes no arguments, and invokes GetItem("123").

Test has no knowledge about the value of the parameter passed to GetItem, nor does it need to, because the value of the parameter is hardcoded in the lambda.

Upvotes: 4

Neowizard
Neowizard

Reputation: 3017

You're question is a bit confusing. F doesn't know what's required by Getitem.

When you created the lambda, a "pointer" was returned to the place in the memory where a method is located. That method contains the line of code return Getitem("123"). When you invoke F, what actually happens is a kind of jump to a pointer. F is like a "pointer" to that place in the memory where the function is located.

So, to answer your question, F doesn't know what Getitem needs, F just calls the function your wrote, and that function has the "123" parameter hard coded.

Remember that lambda is a type of Delegate

Upvotes: 3

Related Questions