I want to understand the lambda expression in @Html.DisplayFor(modelItem => item.FirstName)

I’m fairly new at C# and MVC and have used lambdas on certain occasions, such as for anonymous methods and on LINQ.

Usually I see lambda expressions that look something like this:

(x => x.Name), (x => { Console.WriteLine(x))

I understand that lambda = "goes to". I have never seen a lambda expression where the left parameter is not used.

I don’t know how to translate this lambda expression though

@Html.DisplayFor(modelItem => item.FirstName)

Can anyone shed some light on this one for me? Shouldn’t this be

(modelItem => modelItem.FirstName)?

I got this from Microsoft's Introduction to ASP.NET MVC tutorial.

A lambda expression is a way to write an anonymous function, i.e. a function without a name. What you have on the left side of the "arrow" are the function parameters, and what you have on the right side are the function body. Thus, (x => x.Name) logically translates to something like string Function(Data x) { return x.Name } the types string and Data will obviously vary and be derived from the context.

The absence of the left-side parameter translates into a function without parameters, so that this (() => someVariable) logically translates to this: string Function() { return someVariable; }

At this point you might start wondering, where someVariable comes from, it's not a function parameter and it is not defined in the function. You would be correct, a function like this would never compile. However the lambda function like this is perfectly fine, as it allows outer-scope variables be lifted and used this way. (Internally a wrapper class is created where the variables that are used in the lambda expression become fields.)

Now let's see what model => item.FirstName means. Logically it would translate to string Function(Model model) { return item.FirstName; }. Basically this is a function with a parameter, but this parameter is not used.

And now, the last bit of the information. Although lambda expressions represent functions in the end, sometimes they are created not with the purpose of actually being executed (although potentially they can). A lambda expression can be represented in the form of an expression tree. This means that instead of executing it it can be parsed.

In this particular case the MVC engine does not run the function that the lambda expression represents. Instead the expression is parsed so that MVC engine knows what html to emit for this particular line. If your data item does not come from your model object directly, the left part of the lambda expression does not matter.

i think it's about the foreach loop. example:

@foreach(var item in model) 
{ 
 <td> 
     @html.displayfor(model => item.firstName) </td>
 </td>     
}

var item needs to be used because each item in the sequence is an anonymous type. model => item.firstName means (input parameter) => expression. you can't use the input parameter because we store the current "item" in item.

It is using a parameterless lambada. See this question

Basically DisplayFor doesn't use the lambda function parameter model (it could be anything I'd say use _ or ()) and just uses the lambda function within the for loop to use displayfor against it. DisplayFor requires a lambda function.

I also struggled a lot to understand the codes generated by Visual Studio. Instead of providing a general explanation about lambda expression, I would like to put a context using ASP.NET MVC framework.

Suppose we prepared a Model class (e.g. Destination) with 2 attributes: City and ProvinceCode.

public class Destination
{
    public string City { get; set; }
    public string ProvinceCode { get; set; }
}

After generating the Controller and View, we should get the generated codes by Visual Studio as mentioned. Yet, the generated codes are somewhat hard to understand, especially for the data rows

@Html.DisplayFor(modelItem => item.City)

I just guess that the MVC team should think that Html helper class should be consistently used in the cshtml file. Thus, they tried to use tricks to pass the C# compiler. In this case, modelItem is not even used as an input parameter of this lambda expression. We can't use () as the type is NOT correct. That is why, if we replace model or any model object, the lambda expression works.

To be honest, I would like to rewrite the generated codes in a more readable form. Instead of using the Html helper class, we can simply render the correct output as follows:

@foreach (var item in Model) {
<tr>        
    <td>  
        @* Code Generated by Visual Studio. modelItem is a dummy param *@
        @Html.DisplayFor(modelItem => item.City)
    </td>
    <td>
        @* A better way - simply get rid of Html helper class *@
        @item.ProvinceCode
    </td>
</tr>
}