I have a nested Dictionary structure like this:
Dictionary<string, Dictionary<string, string>> dict;
I'm trying to access the elements using two foreach loops but the compiler won't let me use the following as the loop variable for my inner loop:
Dictionary<string, string>
This is what I have:
foreach (string key in dict.Keys) {
foreach (Dictionary<string, string> innerDict in dict[key]) {
// ...
}
}
The compiler says:
Cannot convert type 'System.Collections.Generic.KeyValuePair<string,string>'
to 'System.Collections.Generic.Dictionary<string,string>'
I can use KeyValuePair<string,string> in the inner loop, but I would like to access the dictionary object itself as a whole (so that I can do something like this: if (dict.ContainsKey(innerDict)) { ... })
The minimum code change to fix it is like this (but see the correct approach in the next code snippet in this answer):
Dictionary<string, Dictionary<string, string>> dict;
foreach (string key in dict.Keys)
{
foreach (var innerDict in dict[key].Select(k => k.Value))
{
}
}
Your problem was that when you enumerate over a dictionary, you get a sequence of Key/Value pairs. In your case, the Value was the inner dictionary, and it is that which you needed.
I'm using the Linq "Select()" operation to convert each key/value pair into just the value part, i.e. the dictionary which is the value in the key/value pair.
However, that's a long-winded and inefficient way to go about getting each inner dictionary along with its key. Here's how it should be done:
foreach (var item in dict)
{
string key = item.Key;
Dictionary<string, string> innerDict = item.Value;
// Do something with key and innerDict.
}
I'm assuming that you are trying to visit each inner dictionary in turn while knowning that inner dictionary's key in the outer dictionary.
Note that I only copied the values from item.Key and item.Value into local variables to illustrate their types. You could just use item.Key and item.Value directly, of course.
If you really only want the inner dictionaries themselves (and you don't need the key for each inner dictionary), you can just do it like so (as Nuffin suggested):
foreach (var innerDict in dict.Values)
{
// Use inner dictionary
}
That's because the value of the string key is not a list. Change the declaration of the Dictionary to Dictionary<string, List<Dictionary<string, string>>> dict; if that's what you want.
Or you could just grab the dictionary inside the first foreach loop like this:
Dictionary<string, string> val = dict[key];
and use it from there. But either way, you're trying to iterate against something that's not enumerable.
I think you may have the Dictionary defined like you want -you just don't need an inner loop.
You could just keep it short by using:
foreach (Dictionary<string, string> d in dict.Values) {
}
It works, no complaints from the compiler.
Also notice that your code doesn't work because in that context, dict[key] is not a collection of dictionaries, but a single dictionary.
I think you are misunderstanding the underlying Dictionary structure.
Dictionary<string, Dictionary<string, string>>
The above results in a parent containing a single dictionary object. When you attempt to use foreach over this object the compiler does not know what to do. It might be easier to understand if you use the following code
Dictionary<string,string> dictionaryObject;
foreach (string item in dictionaryObject)
{ }
The above will also result in the same error.
You can resolve your issue by iterating over the keys or values of the dictionary object, for example,
foreach (string key in dict.Keys)
{
foreach (string innerKey in dict[key].Keys)
{
System.Diagnostics.Debug.WriteLine(dict[key][innerKey]);
}
}
You will still have the dictionary to reference just like you wish, even when you use the KVP. Try this:
foreach (var outerKVP in dict {
foreach (var innerKVP in dict[outerKVP.Key]) {
var theString = dict[outerKVP.Key][innerKVP.Key];
}
}
foreach (Dictionary<string, string> innerDict in dict[key]) {
// ...
}
This fails because dict[key] is a Dictionary<string,string>, so enumerating it with foreach will yield elements of type KeyValuePair<string,string>.
If you want to access the inner dictionary, just do so and drop the foreach loop.
Dictionary<string, string> innerDict = dict[key];
Should be not so hard:
Dictionary<string, Dictionary<string, string>> dict = new Dictionary<string,Dictionary<string,string>>();
foreach (var kvp in dict)
{
var innerDict = kvp.Value;
foreach (var innerKvp in innerDict)
{
Console.WriteLine(kvp.Key + " " + innerKvp.Key + " " + innerKvp.Value);
}
}
Related
The syntax for iterating over a dictionary with a foreach loop is:
foreach (KeyValuePair<key, value> item in dictionary)
Inside the foreach loop the key is accessed with item.key and the value with item.value.
This got me thinking, can this be used without the use of a foreach loop as a convenient (although niche) way to represent a specific dictionary pair?
I am not looking for some weird work arounds, like running a foreach loop and saving the KeyValuePair into a variable once the target key is reached, because at this point it would be more convenient to just use 2 variables.
Like this
var dic = new Dictionary<string, int>();
dic["a"] = 42;
KeyValuePair<string, int> keyVal;
foreach(var kv in dic) {
keyVal = kv; << gets the last entry from the dictioanry
}
Note that the dictionary does not store KeyValuePairs, it creates one for the enumeration, so the simple thing to do is this (because we are not expensively recreating something)
var dic = new Dictionary<string, int>();
dic["a"] = 42;
KeyValuePair<string, int> keyVal = new KeyValuePair<string, int>("a", dic["a"]);
this is more efficient than the (neat) LINQ Sinlge method
The IDictionary<TKey, TValue> interface implements IEnumerable<KeyValuePair<TKey,TValue>>. This means you can simply use Single() to get the entry you want.
IDictionary<string, int> dict = ...;
KeyValuePair<string, int> entry = dict.Single(it => it.Key == "yourKey");
try this
var dict = new Dictionary<string, string>() {
{"hi","Hello World!"},
{"adieu","Goodby"}
};
string hi = dict["hi"]; //Hello World!
or if you want a list
List<KeyValuePair<string,string>> list = dict.ToList();
result
[{"Key":"hi","Value":"Hello World!"},{"Key":"adieu","Value":"Goodby"}]
am just learning c# and wanted to use the type instead of var in foreach loop while using the dictionary, but it gave me error when i used Dictionary
Dictionary<int, string> names = new Dictionary<int string>();
names[10] = "some test";
names[11] = "another text";
foreach(Dictionary<int,string> name in names)
{
Console.WriteLine(name);
}
Ultimately, the dictionary doesn't contain multiple dictionaries; it contains (semantically, at least): multiple key/value pairs - hence that is what foreach gives you, via multiple KeyValuePair<int, string> values. You can use this without even needing to know about the type:
foreach (var pair in names)
{
Console.WriteLine(pair.Key);
Console.WriteLine(pair.Value);
}
(which is identical to foreach (KeyValuePair<int, string> pair in names))
or:
foreach ((var key, var value) in names)
{
Console.WriteLine(key);
Console.WriteLine(value);
}
(you can also use var (key, value) or (int key, string name) as the enumerator declaration)
I thought it would have been relatively straightforward, I am here first runing this code that uses a 3rd party software to return a set of values as a dictionary:
List<Dictionary<string, long>> result = 3rdPartyConnection.GetPlans(id, params);
I then try to loop these results (so I can populate a viewmodel with them and other values) using the following code, first I declare a new list using the viewmodel, then I loop through the results to populate the model:
List<OptionViewModel> AvailableOptions = new List<OptionViewModel>();
foreach (KeyValuePair<string, long> item in result)
{
OptionViewModel c = new OptionViewModel();
c.Code = item.Key;
c.Value = item.Value;
AvailableOptions.Add(c);
}
But it only generates the following error:
Error 257 Cannot convert type 'System.Collections.Generic.Dictionary<string,long>' to 'System.Collections.Generic.KeyValuePair<string,long>'
I don't understand what the problem is, from what I've read on c# this is how you loop through a dictionary. I have a feeling this is a simple oversight of some kind on my part....
It is a List<> of dictionaries, not a single Dictionary<,>. Use two foreach loops inside each other.
Sometimes it is better to use var in foreach loops: foreach (var item in ...) It helps you figure out what the iteration variable type is, without introducing a cast.
You will need to iterate through the List first, going through each dictionary, at which point you can then iterate through the key-value pairs:
foreach (Dictionary<string, long> dic in result)
{
foreach(KeyValuePair<string, long> item in dic)
{
OptionViewModel c = new OptionViewModel();
c.Code = item.Key;
c.Value = item.Value;
AvailableOptions.Add(c);
}
}
The following code loops through a list and gets the values, but how would I write a similar statement that gets both the keys and the values
foreach (string value in list.Values)
{
Console.WriteLine(value);
}
e.g something like this
foreach (string value in list.Values)
{
Console.WriteLine(value);
Console.WriteLine(list.key);
}
code for the list is:
SortedList<string, string> list = new SortedList<string, string>();
foreach (KeyValuePair<string, string> kvp in list)
{
Console.WriteLine(kvp.Value);
Console.WriteLine(kvp.Key);
}
From msdn:
GetEnumerator returns an enumerator of type KeyValuePair<TKey, TValue> that iterates through the SortedList<TKey, TValue>.
As Jon stated, you can use var keyword instead of writing type name of iteration variable (type will be inferred from usage):
foreach (var kvp in list)
{
Console.WriteLine(kvp.Value);
Console.WriteLine(kvp.Key);
}
Apologies...
this was wrong topic (loop through values). My issue was looping through the key value pairs, not just the values.
Will leave this here if there are no objections as a possible option to get values from SortedList collection.
I just tried to figure out this error as well and my solution was to use the DictionaryEntry type to replace the erroring out KeyValuePair type.
Found from MS reference
https://msdn.microsoft.com/en-us/library/system.collections.dictionaryentry(v=vs.100).aspx
In my case, I had code creating a SortedList type collection and neither the var or KeyValuePair types worked (var errored out when trying to read the key/value from the collection item and the KeyValuePair errored out in the initial loop definition. Both errored out with "Specified cast is not valid" )
So here is sample of code that worked for me:
SortedList _dims = GetList("mysortedlist");
foreach (DictionaryEntry kvp in _dims)
{
Console.WriteLine(kvp.Key.ToString());
Console.WriteLine(kvp.Value.ToString());
}
HTH
Dave
Just iterated using the keys and get the value for each key:
SortedList<string, string> info = new SortedList<string, string>();
info.Add("path", "път");
info.Add("folder", "директория");
info.Add("directory", "директория");
info.Add("file", "Файл");
foreach (string key in info.Keys)
{
Console.WriteLine("\t{0}\t{1}", key, info[key]);
}
bool value = list[key];
this can help you.
How do I enumerate a dictionary?
Suppose I use foreach() for dictionay enumeration. I can't update a key/value pair inside foreach(). So I want some other method.
To enumerate a dictionary you either enumerate the values within it:
Dictionary<int, string> dic;
foreach(string s in dic.Values)
{
Console.WriteLine(s);
}
or the KeyValuePairs
foreach(KeyValuePair<int, string> kvp in dic)
{
Console.WriteLine("Key : " + kvp.Key.ToString() + ", Value : " + kvp.Value);
}
or the keys
foreach(int key in dic.Keys)
{
Console.WriteLine(key.ToString());
}
If you wish to update the items within the dictionary you need to do so slightly differently, because you can't update the instance while enumerating. What you'll need to do is enumerate a different collection that isn't being updated, like so:
Dictionary<int, string> newValues = new Dictionary<int, string>() { 1, "Test" };
foreach(KeyValuePair<int, string> kvp in newValues)
{
dic[kvp.Key] = kvp.Value; // will automatically add the item if it's not there
}
To remove items, do so in a similar way, enumerating the collection of items we want to remove rather than the dictionary itself.
List<int> keys = new List<int>() { 1, 3 };
foreach(int key in keys)
{
dic.Remove(key);
}
In answer to the problem "I can't update value/key inside foreach()", you cannot modify a collection while enumerating it. I would approach this by making a copy of the Keys collection:
Dictionary<int,int> dic=new Dictionary<int, int>();
//...fill the dictionary
int[] keys = dic.Keys.ToArray();
foreach (int i in keys)
{
dic.Remove(i);
}
Foreach. There are three ways: You can enumerate over the Keys property, over the Values property or over the dictionary itself which is an enumerator of KeyValuePair<TKey, TValue>.
I just answered the same (updated) question for lists, so here's the same thing for dictionaries.
public static void MutateEach(this IDictionary<TKey, TValue> dict, Func<TKey, TValue, KeyValuePair<TKey, TValue>> mutator)
{
var removals = new List<TKey>();
var additions = new List<KeyValuePair<TKey, TValue>>();
foreach (var pair in dict)
{
var newPair = mutator(pair.Key, pair.Value);
if ((newPair.Key != pair.Key) || (newPair.Value != pair.Value))
{
removals.Add(pair.Key);
additions.Add(newPair);
}
}
foreach (var removal in removals)
dict.Remove(removal);
foreach (var addition in additions)
dict.Add(addition.Key, addition.Value);
}
Note that we have to do the updates outside the loop, so we aren't modifying the dictionary as we enumerate it. Also this detects clashes caused by making two keys the same - it will throw (due to the use of Add).
Example - make all keys lowercase and trim all values, with a Dictionary<string, string>:
myDict.MutateEach(key => key.ToLower(), value => value.Trim());
If the keys are not unique when made lowercase, this will throw.