C# lambdas with list as parameters

Question

Selecting from a list of lists in a lambda expression, I access the elements with ElementAt. However, it would be nicer to have the elements of my list directly as parameters for my lamda expression:

using System.Linq;
using System.Collections.Generic;

public class Program {
    public static void Main()
    {
        List<List<int>> mylist = new List<List<int>>();
        mylist.Add(new List<int>{1,2});
        mylist.Add(new List<int>{3,4});
        
        // returns a list with summed values of the input lists     
        List <int> sums = mylist.Select(x => x.ElementAt(0) +x.ElementAt(1)).ToList();

        // Can I somehow use the elements in my lists as parameters to lambda?  
        // List <int> sums = mylist.Select((x, y) => x + y).ToList();
    }
}

This is possible for tuples C# 7 tuples and lambdas

But can I do this without converting my list to Tuples?

Does this answer your question? [C# 7 tuples and lambdas](https://stackoverflow.com/questions/43082026/c-sharp-7-tuples-and-lambdas) — aloisdg, Mar 23 '22 at 15:12
What are you trying to achieve? If you're trying to flatten the list, you can use: `mylist.SelectMany(l => l).ToList();` — Maroun, Mar 23 '22 at 15:12
In `Select((x,y) =>`, `x` would be the first element, and `y` would be the second element? — gunr2171, Mar 23 '22 at 15:12
It's really unclear to me what you'd expect `x` and `y` to be here. It would help if you could provide a [mcve]. — Jon Skeet, Mar 23 '22 at 15:12
I think OP is trying to deconstruct in the lambda like in F# or JS. — aloisdg, Mar 23 '22 at 15:13
In your particular example, you could just do `mylist.Select(x => x.Sum())`, no? — Kirk Woll, Mar 23 '22 at 15:47

score 0 · Answer 1 · answered Mar 30 '22 at 17:25

Your first option, assuming you are genuinely using + and aren't merely using + to disguise your actual use case, is to use x.Sum():

var sums = mylist.Select(x => x.Sum());

If + is a placeholder for some other operation, you'll instead want to look at Aggregate:

var sums = mylist.Select(list => list.Aggregate((x, y) => x + y));

(Note that (x, y) => x + y is the exact lambda you give as an example in your question.)

Here's a funtioning program to demonstrate, simply uncomment the appropriate line for the technique you wish to observe:

using System;
using System.Collections.Generic;
using System.Linq;

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            var mylist = new List<List<int>>()
            {
                new List<int> { 1, 2 },
                new List<int> { 3, 4 }
            };

            // Uncomment one of the following:
            // var sums = mylist.Select(x => x.Sum());
            // var sums = mylist.Select(list => list.Aggregate((x, y) => x + y));

            foreach (var sum in sums)
                Console.WriteLine(sum);

            Console.ReadKey();
        }
    }
}

C# lambdas with list as parameters

1 Answers1