LINQ Group By into a Dictionary Object

Related searches

I am trying to use LINQ to create a Dictionary<string, List<CustomObject>> from a List<CustomObject>. I can get this to work using "var", but I don't want to use anonymous types. Here is what I have

var x = (from CustomObject o in ListOfCustomObjects
      group o by o.PropertyName into t
      select t.ToList());

I have also tried using Cast<>() from the LINQ library once I have x, but I get compile problems to the effect of it being an invalid cast.

Dictionary<string, List<CustomObject>> myDictionary = ListOfCustomObjects
    .GroupBy(o => o.PropertyName)
    .ToDictionary(g => g.Key, g => g.ToList());

How to GroupBy LIST and convert to dictionary in LinQEverything , Later, I will group them by subcategoryname using GroupBy clause in LinQ and then convert the grouped list into a generic dictionary. LINQ ToDictionary () Method In LINQ, ToDictionary operator is used to convert list/collection (IEnumerable<T>) items to a new dictionary object (Dictionary<TKey,TValue>) and it will optimize list/collection items by getting only required values. Syntax of LINQ ToDictionary Operator

I cannot comment on @Michael Blackburn, but I guess you got the downvote because the GroupBy is not necessary in this case.

Use it like:

var lookupOfCustomObjects = listOfCustomObjects.ToLookup(o=>o.PropertyName);
var listWithAllCustomObjectsWithPropertyName = lookupOfCustomObjects[propertyName]

Additionally, I've seen this perform way better than when using GroupBy().ToDictionary().

Using Linq to create a Dictionary of sub-Lists by grouping from a , This is really easy - but it's hard to work out for the first time. For example, get a list of files, and group them by the date which is in the 2nd to� In this example, I am going create bunch of products with some sample data. Later, I will group them by subcategoryname using GroupBy clause in LinQ and then convert the grouped list into a generic dictionary. As you can see below, I have created a simple product class for our example. Product.cs: I have created …

For @atari2600, this is what the answer would look like using ToLookup in lambda syntax:

var x = listOfCustomObjects
    .GroupBy(o => o.PropertyName)
    .ToLookup(customObject => customObject);

Basically, it takes the IGrouping and materializes it for you into a dictionary of lists, with the values of PropertyName as the key.

Grouping over a list of dictionaries, So the data is a list of dictionaries - each dictionary containing value-pairs ( column name, column value) for a "row" in the list. I need to group over the results ,� To understand, how to use group by clause in your LINQ query, first we create a class called “Student”, then we create a collection object of that class, then try to use group by clause with query syntax and method syntax.

The following worked for me.

var temp = ctx.Set<DbTable>()
  .GroupBy(g => new { })
  .ToDictionary(d =>;

Grouping into more groups in one iteration, If you don't mind duplicate entries in your groups and throwing on duplicate public static IDictionary<string, Dictionary<object, HashSet<T>>> I find in order to be consistent with other LINQ APIs and to make the usage of� SELECT Category FROM Recipes GROUP BY Category In LINQ query syntax, the same query would read this way: var categories = from r in db.Recipes group r by r.Category into g select g.Key; If you’re like me, this looks a little bizarre. Remember, though, Group By doesn’t just get rid of the duplicate rows.

The following example shows how to group source elements by using something other than a property of the object for the group key. In this example, the key is the first letter of the student's last name. Paste the following method into the StudentClass class. Change the calling statement in the Main method to sc.GroupBySubstring().

Read : 101 LINQ Samples in that LINQ - Grouping Operators from Microsoft MSDN site . var x = from t in types group t by t.Type into grp select new { type = grp.key, count = grp.Count() }; forsingle object make use of stringbuilder and append it that will do or convert this in form of dictionary

that I retrieve from the database. However, I would like it keyed by a property in MyObject for grouping purposes. What is the best way with LINQ to cast my list to: Dictionary<long, List<MyObject>> I have the following: myObjectList.ToDictionary(x => x.KeyedProperty) But it returns: Dictionary<long, MyObject>

  • What if you try var x = (from CustomObject o in ListOfCustomObjects group o by o.PropertyName into t select t).ToList();
  • Is there any reason why you need to do this rather than using ToLookup, which is designed for this?
  • Jon, could you please post an example of how ToLookup works in this situation? I am not familiar with that LINQ method.
  • @JonSkeet You're awesome! (I mean, everyone knew that already, but still.) Reason I wasn't planning on using ToLookup was cause I'd never heard of it until now. Now I know!
  • Just for completeness' sake, using var isn't using an "anonymous" type, it's using an "implicit" type. Anonymous types are new classes created by the compiler to handle the construction new { thing = "stuff" };. Implicit types are existing classes, var is just a convenient way to reference them when the variable is being assigned immediately, the variable type can be inferred from the type of the object being assigned to it. You can even implicitly type a variable referencing an anonymous type, i.e.: var a = new { thing = "stuff" };
  • Unless you're needing a property from 'CustomObject' as the list value (not shown in this answer) it's worth checking his codeliness Jon Skeet's comment to the question recommending ToLookup().
  • this is the way to do it if a non immutable result is desired. ToLookup is immutable.
  • My 2 Cents (just 'cause it kept me struggling for an hour :) ): when grouping by a property, make sure the Property HAS a value! Otherwise the Todict-method fails generating key (for String-Properties at least...) :)
  • .GroupBy(o => o.PropertyName).ToDictionary(g => g.Key, g => g.ToList()) This could be a part of extension Linq library. so we only has to do .ToDictionary(o=>o.PropertyName)
  • @Jaider, there already is such functionality: just replace ToDictionary with ToLookup.
  • I was performing a transliteration, not responding to the question in the best possible manner.
  • Why a downvote? Is this not accurate/answering the question?
  • In case you missed it, @RuudvK mentioned in his answer that he suspects the downvote is because the GroupBy is unnecessary. ToLookup has an overload that'll get the job done.
  • I did miss that response, thanks for tagging me. Makes sense, the Grouping is syntactically unnecessary, i was only leaving it in to make the transition from query syntax to method syntax clearer .
  • GroupBy (the overload with just one parameter) returns a IEnumerable<IGrouping<TKey, TSource>> the subsequent ToLookup then turns it into a quite complicated type that is not even similar to a IDictionary<TKey,IList<TSource>> just the ToLookup returns the proper type.