We Keep Coding

Alter/modify data from an existing keyValuePair

I have this
foreach (KeyValuePair<string, Object> tempData in tempList.ToDictionary(x => x.Key, y => y.Value))
{
tempData["fahrzeugA"] = "s";
}
But using tempData["fahrzeugA"] = "s"; will not work.
I get:
Cannot apply indexing with [] to an expression of type
'System.Collections.Generic.KeyValuePair'
What is the correct syntax if I have an existing key fahrzeugA, which I want to alter ?

You can apply this :
var tempList = new List<Test>();
var dic = tempList.ToDictionary(x => x.Key, y => y.Value);
foreach (var tempData in dic)
{
dic[tempData.Key] = "s";
}

You can't change the key value pair since it is an immutable struct. The only way to change it is to create a new instance. That instance would live independent from the dictionary.
If you want to change the value in the dictionary, use the indexer property on the dictionary to change the value.
And even then, the dictionary will go out of scope immediately, so there is no use setting it. It won't affect the original list.

Check KeyValuePair.Value Property. It's readonly and can't be altered.
ToDictionary creates a new object. You can't alter original object by accessing its elements' value.
You have to remove this specific item from original list and add new item of the same key back.
var removeIndex = tempList.FindIndex(kp => kp.Key == "fahrzeugA");
tempList.RemoveAt(removeIndex);
tempList.Add(new KeyValuePair<string, string>("fahrzeugA", "s"));
If there are multiple "fahrzeugA" items (it's valid in list but not valid in dictionary), use RemoveAll instead.

If your tempList is List<KeyValuePair<string, Object>> type:
for (var i = 0; i < tempList.Count; ++i) {
if (tempList[i].Key == "fahrzeugA") {
tempList[i] = new KeyValuePair<string, object> ("fahrzeugA", "s"); // KeyValuePair<string, object> might be changed with your own type if you use something else.
break; // If you want to modify only first KeyValuePair.
}
}

If you have successfully turned your tempList into a dictionary, there can only be one "fahrzeugA" (since all keys must be unique), so looping makes no sense.
You should be able to just say:
var dictionary = tempList.ToDictionary(x => x.Key, y => y.Value);
dictionary["fahrzeugA"] = "s";
If you don't want to create the dictionary in the first place, you could do this:
var matchingKeyValuePair = tempList.SingleOrDefault(x => x.Key == "fahrzeugA");
if (matchingKeyValuePair != null) matchingKeyValuePair.Value = "s";
If you are using a list of .NET KeyValuePair<TKey, TValue>, which is an immutable struct, you can replace the value with a new KeyValuePair, like this:
var matchingIndex = tempList.FindIndex(x => x.Key == "fahrzeugA");
if (matchingIndex >= 0)
tempList[matchingIndex] = new KeyValuePair<string, string>("fahrzeugA", "s");
Note, this assumes that you only have one item with a key of "fahrzeugA".

Remap Lookup keys in C# using LINQ

I have my Lookup looking like this:
Lookup<string, DataModel> lookup;
Besides that I have dictionary containing key mappings:
Dictionary<string, KeyModel> keyMappings;
What I want to do is to re-map string keys in lookup to the KeyModel entities in the following way:
Lookup <string, DataModel> lookup;
||
||
Dictionary<string, KeyModel> keyMappings;
___________|
v
Lookup<KeyModel, DataModel> result;

Given:
Dictionary<string, KeyModel> keyMappings = ...;
ILookup<string, DataModel> lookup = ...;
the response is:
ILookup<KeyModel, DataModel> lookup2 = lookup
.SelectMany(x => x, (grouping, element) => new { Key = keyMappings[grouping.Key], Element = element })
.ToLookup(x => x.Key, x => x.Element);
So you first re-linearize the ILookup<,> by using SelectMany, and then recreate the ILookup<,>.
Clearly you need your KeyModel to define the GetHashCode() and the Equals(), or you need an IEqualityComparer<KeyModel> to pass as the parameter of the ToLookup()

You can use a simple foreach-loop.
First you need to transform your Lookup into a Dictionary. See here.
foreach (KeyValuePair<string, DataModel> kvp in lookup) {
KeyModel outValue;
if (keyMappings.TryGetValue(kvp.Key, out outValue))
{
result.Add(outValue, lookup[kvp.Key]);
}}
Not the fastest solution, maybe someone is coming up with a nice LINQ.

How to make a dictionary from a list and a list of keyvalue pairs

I have a list of KeyValuePair, of int and a custom object, Function. I also have a list of function Ids. Both lists are sorted alphabetically. I need to match up the function Ids from the 1 list to the function Ids from the other list. So, say the list of KVP looks like:
1, (Function.name = foo, function.Id = 4)
2, (Function.name = bar, function.Id = 7)
And the list of just Ids is:
142
154
I need a dictionary of:
{4, 142}
{7, 154}
So a mash up of the function Ids from both lists.
How can I do this?
Here is what I've tried:
Dictionary<int, int> map = new Dictionary<int, int>();
List<KeyValuePair<int, Function>> sorted = SortFunctions();
IEnumerator sortEnum = sorted.GetEnumerator();
IEnumerator dicEnum = FunctionIds.GetEnumerator();
while ((sortEnum.MoveNext()) && (dicEnum.MoveNext()))
{
//Not sure what to do next? Just map[sortEnum.Next()] = dicEnum.Next()?
}
//Also was trying to use zip.. many many errors
List<string> sortedFuncs = sorted.ToList();
Dictionary<int, int> map2 = functionIds.ToDictionary(x => x, x => sortedFuncs.Value.Id[functionIds.IndexOf(x)]);

You should be able to chain Zip with ToDictionary:
List<KeyValuePair<int, Function>> sorted = SortFunctions();
Dictionary<int, int> map2 =
sorted.Zip(FunctionIds, (s, i) => new {key = s.Value.Id, value = i})
.ToDictionary(x => x.key, x => x.value);
Explanation:
Zip enumerates through the two lists and creates an anonymous type consisting of the Id from the Value of the KeyValuePair in sorted and the integer from FunctionIds. Those values are stored in the key and value property of the anonymous type.
ToDictionary then enumerates that collection and creates a dictionary using the key and the value from the anonymous type (x).

c# if key exist in dictionary still add the value in dictionary

From a datatable I am fetching the value and putting in a Dictionary<string,string>:
Dictionary<string, string> mydic= new Dictionary<string, string>();
my datatable for ex is
Value RowOrder
page1 01
page2 00
page3 00
I am using LINQ to fetch the RowOrder according to value given and putting into mydic:
string id = (from DataRow dr in table3.Rows where (string)dr["Value"] == formula
select (string)dr["RowOrder"]).FirstOrDefault();
mydic.Add(id,Value);
If I run this, error is showing:
"An item with the same key has already been added."
How to overcome this. I want page1, page2, page3 should be added with values 01, 00, 00 respectively

You need to check whether the dictionary already has the key before adding to it:
if(!mydic.ContainsKey(id))
{
mydic.Add(id, Value);
}
A dictionary cannot contain two items with the same key, if you are expecting duplicate id values you need to consider using a different data structure.
Perhaps a List<Tuple<string, string>>?

Check if key exists before adding
if (mydic.ContainsKey(id))
mydic[id] = Value; // or throw exception
else
mydic.Add(id, Value);
BTW if you want to convert your DataTable to Dictionary<string, string> with RowOrder as key, and first (or last) Value as value, you can use LINQ:
var mydic = table3.AsEnumerable()
.GroupBy(r => r.Field<string>("RowOrder"))
.Select(g => g.First()) // or last to use last value for key
.ToDictionary(r => r.Field<string>("RowOrder"),
r.Field<string>("Value"));

You can use GroupBy, here a single line approach using Linq-To-DataSet:
Dictionary<string, string> mydic = table3.AsEnumerable()
.GroupBy(row => row.Field<string>("Value"))
.ToDictionary(grp => grp.Key, grp => grp.First().Field<string>("RowOrder"));

Use
mydic[id] = Value;
instead of mydic.Add();
The Add method should be used if you want to ensure only one item with a given key is inserted.
Note that this overwrite the previously written value.
If you want to have more items with the same key you should use a
Dictionary<string, IList<string>>
or some other datastructure I don't know of but I would be very glad to hear about since I used that kind of dictionary more than once

You may use a Lookup<string,string>:
List<Tuple<string, string>> tuples = new List<Tuple<string, string>>();
tuples.Add(new Tuple<string, string>("01", "page1"));
tuples.Add(new Tuple<string, string>("00", "page2"));
tuples.Add(new Tuple<string, string>("00", "page3"));
var lookup = tuples.ToLookup(t => t.Item1,t=> t.Item2 );
And you may use it like:
var result = lookup["00"];
foreach (var item in result)
{
Console.WriteLine(item);
}
Which outputs:
page2
page3

Most elegant way to convert string array into a dictionary of strings

Is there a built-in function for converting a string array into a dictionary of strings or do you need to do a loop here?

Assuming you're using .NET 3.5, you can turn any sequence (i.e. IEnumerable<T>) into a dictionary:
var dictionary = sequence.ToDictionary(item => item.Key,
item => item.Value)
where Key and Value are the appropriate properties you want to act as the key and value. You can specify just one projection which is used for the key, if the item itself is the value you want.
So for example, if you wanted to map the upper case version of each string to the original, you could use:
var dictionary = strings.ToDictionary(x => x.ToUpper());
In your case, what do you want the keys and values to be?
If you actually just want a set (which you can check to see if it contains a particular string, for example), you can use:
var words = new HashSet<string>(listOfStrings);

You can use LINQ to do this, but the question that Andrew asks should be answered first (what are your keys and values):
using System.Linq;
string[] myArray = new[] { "A", "B", "C" };
myArray.ToDictionary(key => key, value => value);
The result is a dictionary like this:
A -> A
B -> B
C -> C

IMO, When we say an Array we are talking about a list of values that we can get a value with calling its index (value => array[index]), So a correct dictionary is a dictionary with a key of index.
And with thanks to #John Skeet, the proper way to achieve that is:
var dictionary = array
.Select((v, i) => new {Key = i, Value = v})
.ToDictionary(o => o.Key, o => o.Value);
Another way is to use an extension method like this:
public static Dictionary<int, T> ToDictionary<T>(this IEnumerable<T> array)
{
return array
.Select((v, i) => new {Key = i, Value = v})
.ToDictionary(o => o.Key, o => o.Value);
}

If you need a dictionary without values, you might need a HashSet:
var hashset = new HashSet<string>(stringsArray);

What do you mean?
A dictionary is a hash, where keys map to values.
What are your keys and what are your values?
foreach(var entry in myStringArray)
myDictionary.Add(????, entry);

I'll assume that the question has to do with arrays where the keys and values alternate. I ran into this problem when trying to convert redis protocol to a dictionary.
private Dictionary<T, T> ListToDictionary<T>(IEnumerable<T> a)
{
var keys = a.Where((s, i) => i % 2 == 0);
var values = a.Where((s, i) => i % 2 == 1);
return keys
.Zip(values, (k, v) => new KeyValuePair<T, T>(k, v))
.ToDictionary(kv => kv.Key, kv => kv.Value);
}

Dictionary<int, string> dictionaryTest = new Dictionary<int, string>();
for (int i = 0; i < testArray.Length; i++)
{
dictionaryTest.Add(i, testArray[i]);
}
foreach (KeyValuePair<int, string> item in dictionaryTest)
{
Console.WriteLine("Array Position {0} and Position Value {1}",item.Key,item.Value.ToString());
}

The Question is not very clear, but Yes you can convert a string to Dictionary provided the string is delimited with some characters to support Dictionary<Key,Value> pair
So if a string is like a=first;b=second;c=third;d=fourth you can split it first based on ; then on = to create a Dictionary<string,string> the below extension method does the same
public static Dictionary<string, string> ToDictionary(this string stringData, char propertyDelimiter = ';', char keyValueDelimiter = '=')
{
Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
Array.ForEach<string>(stringData.Split(propertyDelimiter), s =>
{
if(s != null && s.Length != 0)
keyValuePairs.Add(s.Split(keyValueDelimiter)[0], s.Split(keyValueDelimiter)[1]);
});
return keyValuePairs;
}
and can use it like
var myDictionary = "a=first;b=second;c=third;d=fourth".ToDictionary();
since the default parameter is ; & = for the extension method.

You can create a dictionary from an IEnumerable<T>, including an array, via:
var dictionary = myEnumerable.ToDictionary(element => element.Key,
element => element.Value)
where Key and Value are the key and value you want to store in each dictionary element. Available in .NET Framework 3.5+/.NET Core 1.0+/.NET 5.0+. Official documentation.
If you want the dictionary values to be the elements from the original enumerable:
var dictionary = myEnumerable.ToDictionary(element => element.Key)
If you only need high-performance set operations, you may be able to use:
var words = new HashSet<string>(listOfStrings);
In simple terms, the HashSet class can be thought of as a Dictionary<TKey,TValue> collection without values. Official documentation.
(Note that a 'sequence' in an entirely unrelated object.
Originally submitted an existing answer edit but it was rejected by the author so posting separately, including with links to the official Microsoft documentation.)