We Keep Coding

C# Select only few member pairs from Object array and store it in Dictionary [duplicate]

This question already has answers here:
How to convert array to dictionary
(2 answers)
Closed 5 years ago.
I have an Object array of my class (Item) like below,
class Item
{
int id;
int value;
bool isSelected;
}
Item itemArr[] = new Item [MAXCOUNT];
To retrieve the selected Item ids and store into list, I am using below code
List<int> listOfItems = new List<int>();
listOfItems.AddRange(itemArr.Where(p => (p.IsSelected)
.Select(p => p.ID)).ToArray());
I have one more Dictionary which indicates item id as key and item value as value,
Dictionary<int,int> itemidValueMap = new Dictionary<int,int>();
How to get item id and value pair and store it into this dictionary?
This question is not duplicate. I need to select only the elements which satisfies the condition and store only them in dictionary. But previous question says about adding all the elements into dictionary.

To get the selected IDs your query should look like this:
List<int> selectedIDs = itemArr.Where(item => item.IsSelected).Select(item => item.id).ToList();
Note that the result is a List<int>, not a List<Item>.
To get your dictionary try this:
var idToValue = itemArr.ToDictionary(item => item.id, item => item.value);
This only works if your IDs are unique. If they are not, you'll need to group them, but I don't know how you want to aggregate the values of items with the same ID.
If you want that dictionary only for selected items, you simply insert the Where clause again:
var idToValue = itemArr.Where(item => item.IsSelected).ToDictionary(item => item.id, item => item.value);

To construct the dictionary use ToDictionary:
var dictionary = itemArr.Where(p => p.IsSelected)
.ToDictionary(key => key.id, value => value.value);
If you have the same id a few times it will cause an exception (keys are not unique) so use ToLookup or first GroupBy and then ToDictionary.
var lookup = itemArr.Where(p => p.IsSelected)
.ToLookup(key => key.id, value => value.value);
var dictionary = itemArr.Where(p => p.IsSelected)
.GroupBy(i => i.id)
.ToDictionary(key => key.Key, value => value.Select(i => i.value));
As a side note you can populate the ID list a bit nicer:
var listOfItems = itemArr.Where(p => p.IsSelected).Select(p => p.ID).ToList();

You need to change this
listOfItems.AddRange(itemArr.Where
(p => (p.IsSelected).Select(p => p.ID)).ToArray());
to
listOfItems.AddRange(itemArr.Where
(p => p.IsSelected).ToArray());
then
Dictionary<int,int> itemidValueMap = listOfItems.ToDictionary(item => item.id,
item => item.value)

Store value in dictionary or retrieve from concatened key

I have a dictionary that aggregates the same items and sum a specific value from:
var test = list.GroupBy(x => new { ID=x.ItemID, Uti=x.UtilityName })
.ToDictionary(x => x.Key,
x => x.Sum(t => Convert.ToDecimal(t.EnergyConsumptionQt)
));
This returns a dictionary with a key value that is a concatenation of string ID and string Uti.
I would like to either:
Create a Dictionary<string, decimal> in which the key is the combination / concatenation ItemID+UtilityName (ID + Uti), or a way to get the values from the test variable above, as the current one I do not know how to specify the value I want from as everything that I try returns: cannot convert 'X' to ''.

Do it this way:
var test = list.GroupBy(x => new { ID=x.ItemID, Uti=x.UtilityName })
.ToDictionary(x => x.Key.ID.ToString()+x.Key.Uti,
x => x.Sum(t => Convert.ToDecimal(t.EnergyConsumptionQt)
));

The problem with your initial approach is that the annonymous type is a reference type so the dictionary uses the reference as a key (rather than the values you want to be combined).
As such if you subsequently try to accesss an element with for example:
var elem = test[new {ID=1, Uti="myUtiName"}]
then you actually create a NEW object which does not exist in test so you would get a KeyNotFoundException thrown.
If you use a value type for your dictionary key instead then the dictionary will behave as you are expecting. Perhaps have a struct - something like this maybe:
struct DictKey
{
public string UtilityName { get; set; }
public int Id { get; set; }
}
then your test variable can be initialised with:
var test = list
.GroupBy(x => new DictKey { Id=x.ItemID, UtilityName=x.UtilityName })
.ToDictionary(x => x.Key,
x => x.Sum(t => Convert.ToDecimal(t.EnergyConsumptionQt)));
and you can access it's elements with something like:
var elem = test[new DictKey{Id=1, UtilityName="myUtiName"}]

LINQ sort dictionary by value

I am trying to sort values Descending before pushing them into dictionary. The query works fine but i just need to add sorting functionality.
Following is my original LINQ query
List<Model> list = query1.Where(x => x.ItemsPrice.Any())
.GroupBy(x => new { Student = query2.FirstOrDefault(y => y.Id == x. Id).Student.Name })
.Select(x => new Model
{
StudentName = x.Key.Student,
ClassItems = x.SelectMany(y => y. ItemsPrice)
.GroupBy(y => y. Price.item.Name)
.ToDictionary(y => y.Key, y => y.Sum(z => z.TotalPrice()))
}).ToList();
I am trying the following code but it is giving this error
can not implicitly convert IOrderedEnumerables to System.Collection.Generic.Dictioanry.
.ToDictionary(y => y.Key, y => y.Sum(z => z.TotalPrice())).OrderByDescending(y => y.Value)

Something like this should work for you:
public class MyComparer : IComparer<int>
{
public int Compare(int x, int y)
{
return x.CompareTo(y);
}
}
// ...
private void DoStuff()
{
var dict = new Dictionary<int, int> {{3, 300}, {2, 200}};
var sortedDict = new SortedDictionary<int, int>(dict, new MyComparer());
}
Or in your specific scenario:
private class DescendingComparer : IComparer<string>
{
int IComparer<string>.Compare(string a, string b)
{
return StringComparer.InvariantCulture.Compare(b, a);
}
}
// ....
ClassItems = new SortedDictionary<string, float>(x.SelectMany(y => y. ItemsPrice)
.GroupBy(y => y. Price.item.Name)
.ToDictionary(y => y.Key, y => y.Sum(z => z.TotalPrice())),
new DescendingComparer());
Note: adjust the key and value type of the sorted dictionary as well as the comparer type according to your needs!

The order that items are stored in a dictionary is not guaranteed. Don't rely on it. When you retrieve items from the dictionary, you can sort it at that point.
"For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair structure representing a value and its key. The order in which the items are returned is undefined."
-- MSDN
As Markus pointed out, if you really need order in your dictionary, use the OrderedDictionary<,> class or the SortedDictionary<,> class.

Using LINQ to build a Dictionary from a List of delimited strings

I have a list of strings that look like this:
abc|key1|486997
def|key1|488979
ghi|key2|998788
gkl|key2|998778
olz|key1|045669
How can I use LINQ and ToDictionary to produce a Dictionary<string, List<string>> that looks like
key1 : { abc|key1|486997, def|key1|488979, olz|key1|045669 }
key2 : { ghi|key2|998788, gkl|key2|998778 }
Basically I want to be able to extract the second element as the key use ToDictionary() to create the dictionary in one go-round.
I'm currently doing this ..
var d = new Dictionary<string, List<string>>();
foreach(var l in values)
{
var b = l.Split('|');
var k = b.ElementAtOrDefault(1);
if (!d.ContainsKey(k))
d.Add(k, new List<string>());
d[k].Add(l);
}
I've seen the questions on building dictionaries from a single string of delimited values, but I'm
wondering if there's an elegant way to do this when starting with a list of delimited strings instead.

var list = new []
{
"abc|key1|486997",
"def|key1|488979",
"ghi|key2|998788",
"gkl|key2|998778",
"olz|key1|045669"
};
var dict = list.GroupBy(x => x.Split('|')[1])
.ToDictionary(x => x.Key, x => x.ToList());
You can also transform it to a lookup (that is very similary to a Dictionary<K,IEnumerable<V>>) in one shot:
var lookup = list.ToLookup(x => x.Split('|')[1]);

var data = new[]
{
"abc|key1|486997",
"def|key1|488979",
"ghi|key2|998788",
"gkl|key2|998778",
"olz|key1|045669"
};
var dictionary = data.Select(row => row.Split('|'))
.GroupBy(row => row[1])
.ToDictionary(group => group.Key, group => group);

If your data is guaranteed to be consistent like that, you could do something like this:
var data = new[]
{
"abc|key1|486997",
"def|key1|488979",
"ghi|key2|998788",
"gkl|key2|998778",
"olz|key1|045669"
};
var items = data
.GroupBy(k => k.Split('|')[1])
.ToDictionary(k => k.Key, v => v.ToList());

Convert List<MyObject> to Dictionary <obj.string, List<obj.ID>>

I would like to take a list of objects and convert it to a dictionary where the key is a field in the object, and the value is a list of a different field in the objects that match on the key. I can do this now with a loop but I feel this should be able to be accomplished with linq and not having to write the loop. I was thinking a combination of GroupBy and ToDictionary but have been unsuccessful so far.
Here's how I'm doing it right now:
var samplesWithSpecificResult = new Dictionary<string, List<int>>();
foreach(var sample in sampleList)
{
List<int> sampleIDs = null;
if (samplesWithSpecificResult.TryGetValue(sample.ResultString, out sampleIDs))
{
sampleIDs.Add(sample.ID);
continue;
}
sampleIDs = new List<int>();
sampleIDs.Add(sample.ID);
samplesWithSpecificResult.Add(sample.ResultString, sampleIDs);
}
The farthest I can get with .GroupBy().ToDictionay() is Dictionary<sample.ResultString, List<sample>>.
Any help would be appreciated.

Try the following
var dictionary = sampleList
.GroupBy(x => x.ResultString, x => x.ID)
.ToDictionary(x => x.Key, x => x.ToList());
The GroupBy clause will group every Sample instance in the list by its ResultString member, but it will keep only the Id part of each sample. This means every element will be an IGrouping<string, int>.
The ToDictionary portion uses the Key of the IGrouping<string, int> as the dictionary Key. IGrouping<string, int> implements IEnumerable<int> and hence we can convert that collection of samples' Id to a List<int> with a call to ToList, which becomes the Value of the dictionary for that given Key.

Yeah, super simple. The key is that when you do a GroupBy on IEnumerable<T>, each "group" is an object that implements IEnumerable<T> as well (that's why I can say g.Select below, and I'm projecting the elements of the original sequence with a common key):
var dictionary =
sampleList.GroupBy(x => x.ResultString)
.ToDictionary(
g => g.Key,
g => g.Select(x => x.ID).ToList()
);
See, the result of sampleList.GroupBy(x => x.ResultString) is an IEnumerable<IGrouping<string, Sample>> and IGrouping<T, U> implements IEnumerable<U> so that every group is a sequence of Sample with the common key!

Dictionary<string, List<int>> resultDictionary =
(
from sample in sampleList
group sample.ID by sample.ResultString
).ToDictionary(g => g.Key, g => g.ToList());
You might want to consider using a Lookup instead of the Dictionary of Lists
ILookup<string, int> idLookup = sampleList.ToLookup(
sample => sample.ResultString,
sample => sample.ID
);
used thusly
foreach(IGrouping<string, int> group in idLookup)
{
string resultString = group.Key;
List<int> ids = group.ToList();
//do something with them.
}
//and
List<int> ids = idLookup[resultString].ToList();

var samplesWithSpecificResult =
sampleList.GroupBy(s => s.ResultString)
.ToDictionary(g => g.Key, g => g.Select(s => s.ID).ToList());
What we 're doing here is group the samples based on their ResultString -- this puts them into an IGrouping<string, Sample>. Then we project the collection of IGroupings to a dictionary, using the Key of each as the dictionary key and enumerating over each grouping (IGrouping<string, Sample> is also an IEnumerable<Sample>) to select the ID of each sample to make a list for the dictionary value.