如何翻译此 C# 示例中的 Lambda 运算符函数？

Question

I am trying to understand this block of code:

List<string> selectedValues = CheckBoxList1.Items.Cast<ListItem>()
    .Where(li => li.Selected)
    .Select(li => li.Value)
    .ToList();

From my research I understand the point of the Lambda function (to provide a function that can be used as a parameter in-line) but why in this case is it being used?

To add only items to selectedValues that are li.Selected, and only add the value of those selected items to the list called selectedValues? If this is the case, is there no other more readable way to do so? How else could this be written? Is my understanding correct?

Thanks for your time.

Answer 1

The block of code in questions does the following:

1. Get all items in CheckBox1.Items
2. Cast them to the type of ListItem
3. Filter for only the items that are selected
4. Select the value of those, now filtered, items.
5. Cast the result to a list.

You could also write the code as follows:

List<string> selectedValues = new List<string>();
foreach (object item in CheckBoxList1.Items) {
    var listItem = (ListItem)item;
    if (listItem.Selected) {
       selectedValues.Add(listItem.Value);
    }
 }

Answer 2

You did read the lambda correctly. lambda are easier to get if you think of it as a step by step execution. To me they are more readable and they are all coherent. They follow the same structure all the way while there are many ways to write the same thing, the lambda for this example will always be the same.

Another way to write it (note that here i code everything the lambda actually verifies) :

List<string> selectedValues = new List<string>();

for(int i = 0; i < CheckBoxList1.Items.Count(); i++)
{
    ListItem item = CheckBoxList1.Items[i] as ListItem;

    if(item != null)
    {
        if(item.Selected == true)
        {
            selectedValues.Add(item.Value);
        }
    }
}

Answer 3

Your code is pretty expressive about what it should do or doing.

Lambda expression is just a delegate pointing to an anonymous method which a method with body but it has no name using which it can be invoked.

When we write the following:

CheckBoxList1.Items.Cast<ListItem>().Where(x => x.Selected)

Compiler would generate a method like following:

internal bool <M>b__0_0(ListItem x)
{
    return x.Selected;
}

and a delegate type to hold reference to that method :

public static Func<ListItem, bool> <>9__0_0;

and will call the method for each item in the collection.

We can rewrite the code without using lambda expression for understanding like :

public bool IsSelectedWhere(ListItem item)
{
    return item.Selected;
}

public object SelectValue(ListItem item)
{
    return item.Value;
}

and we can call like:

 CheckBoxList1.Items.Cast<ListItem>().Where(IsSelectedWhere)
.Select(SelectValue)
.ToList();

The benefit of lambda expression is that we don't need to define methods in the code and we just write them as expression and compiler takes care of generating a method and calling it using Func<T> .

Hope it helps to some extent.