I have the following line of code:

var groups = inputRows.GroupBy(x => new { x.stateCIP, x.facultyRank });

I want to pass groups into another class method:

OutputFileWriter.write(groups);

However, I do not know what type to declare the input parameter for the write method since it won't take var.

public static void write(?????? groups)

I have attached a photo of the message I get when I mouse over the var groups area:

• c#
• variables
• lambda
• ienumerable
• var

One way would be to create a class with two properties, the stateCIP and facultyRank and then use that instead of creating an anonymous type that you are doing right now. Then you can pass that instead of the anonymous type into your method

so instead of var groups = inputRows.GroupBy(x => new { x.stateCIP, x.facultyRank })

try

var groups = inputRows.GroupBy(x => new MyClass(StateCIP = x.stateCIP, FacultyRank = x.facultyRank });

then you can do

public static void write(IEnumerable<MyClass> groups)

or if you want to do more with the groups objects that just iterate over them, like add or remove items from groups in the Write method, then in you calling method convert the IEnumerable to List using:

var groups = inputRows.GroupBy(x => new MyClass(StateCIP = x.stateCIP, FacultyRank = x.facultyRank }).ToList();

and then write your method as

public static void write(IList<T> groups)

Maybe something like this:

public class MyObject
{
     public string stateCIP { get; set; }
     public string facultyRank { get; set; }
}

The the call like this:

var groups = inputRows.GroupBy(x => new MyObject()
{
    stateCIP= x.stateCIP,
    facultyRank= x.facultyRank
}).ToList();

And then the function like this:

public static void write(List<IGrouping<MyObject,YourTableEntity>> groups)
{
}

The solution to pass like a method is to pass like

IEnumerable

for example you can write something like this:

public static void write(IEnumerable groups)

or you can make it templated like:

public static void write<T>(IEnumerable<T> groups)

To give credit where it is due, this is an enhancement of Tigran's answer.

Your query returns an IEnumerable<IGrouping<'a, InputRow>>, so your method can generically accept that, if you replace the anonymous type with a type parameter (here T). By using a more specific type than just IEnumerable<T> (Tigran's suggestion), you get to treat the elements of the sequence as IGrouping objects:

public static void write<T>(IEnumerable<IGrouping<T, InputRow>> groups)
{
    foreach (var group in groups)
        foreach (var inputRow in group)
            //do something...
}

This will work very well if you do not need access to the members of the Key (i.e., the instances of the anonymous type). And here, you wouldn't need them, since those values are also available in the InputRow type, as implied by the query expression.

If you are using .NET 4.0 and you do not need the grouping information since it is in the individual items within the group you can use this:

public static void write(IEnumerable<IEnumerable<InputRow>> groups)