We Keep Coding

How can I extract values from a list of an unknown value type?

I can't seem to figure out how to convert a orderedDictionary with values consisting of lists of childinstances and lists of tuples containing childinstances into a list of the childinstances as their parent type (Item) without calling each list type in the OrderedDictionary explicitly...
//Here is a sample of an entry in the OrderedDictionary
{ "Contextuals", new List<Contextual>{} },
//and some of the entries are lists of tuples; where the int represents an ammount value of "stacked" objects:
{"Consumables", new List<Tuple<Consumable,int>>{} },
So I have a loop that iterates through said dictionary:
(I tried using the type of object in place of UnknownListType but am not sure if that would be valid since I can't iterate through an object as a list without stating it's explicit type.)
//convertedList collects all the childinstances as their base type (Item)
List<Item> convertedList = new List<Item>();
foreach (KeyValuePair<string, UnknownListType> storedItemCategory in TestDict)
{
//how would i properly check the value type of an UnknownListType as a list, this is what i would guess would be the way to do it:
if (storedItemCategory.Value.GetType().GetGenericArguments()[0].IsSubclassOf(typeof(Item)))
{
//now how would i convert "storedItemCategory.Value" into a list of items before concatenating it to convertedList?
}
//else... (extracting the instance of a list of type tuple<UnknownChildInstanceType,int> would be here but isn't really needed to explain the problem)
}
I'll probably just end up reworking the Dictionary itself where the values are always in the same place If no one has an idea of how this could be implemented.

Your dictionary must be declared somewhere, for example Dictionary<string,TValueList>. Whatever TValueList is, that tells you the type for the loop variable. You have written KeyValuePair<string, UnknownListType> … did you mean that the dictionary actually has type Dictionary<string, UnknownListType> or did you mean that you don't know the type?
My guess would be that the list type, TValueList (or UnknownListType, as you call it), is IList or some other nongeneric type. Then you would simply access that IList and downcast the members to the type indicated by the string key. Something like this:
static public IList<TValue> GetConsolidatedList<TValue>(this Dictionary<string, IList> dictionary)
{
IEnumerable<IList> lists = dictionary.Where(kvp => kvp.Key == typeof(TValue).Name).Select(kvp => kvp.Value);
List<TValue> consolidated = lists.Where( list => list.Count > 0 && list[0] is ValueTuple<TValue,int>).SelectMany(list => list.Cast<(TValue,int)>()).Select( tuple => tuple.Item1).ToList();
consolidated.AddRange(lists.Where(list => list.Count > 0 && list[0] is TValue).SelectMany(list => list.Cast<TValue>()));
return consolidated;
}
Note here I am suggesting to use ValueTuple instead of Tuple. This is more efficient and also enables naming the elements of the tuple for example in the syntax (TValue value, int count)
Having said all that, it seems to me that you would be better off using more type information in the structure. It might make sense to have two dictionaries, one of type Dictionary<string,IList<IValue>> and another of type Dictionary<string,IList<(IValue, int)>>, then have your classes implement interface IValue. If you need to deal with the two dictionaries as one then just put them both into a single class that implements the desired operations.

Order Dictionary from Keys from another Dictionary

I have two dictionaries:
Dictionary<string, Tuple<T, T>> dict1
Dictionary<Enum, Tuple<string, DateTime, DateTime>> dict2
The string value in the first item in the tuple is sometimes equal to the key in the first dictionary. I would like to sort the second dictionary by the enum value and then sort the first dictionary based on the order that dict2 has. How would I be able to do that while retaining the other keys that might be in dict1? I'm able to get as far as sorting the dictionary.
var positions = new Dictionary<Enum, string>();
//This foreach loop can be simplified by a linq expression.
foreach (var position in dict2)
{
var isFound = dict1.Any(x => x.Key == position.Value.Item1.Value);
if (isFound)
{
clubPositions.Add(position.Key, position.Value.Item1.Value);
}
}
var sortedPositions = positions.OrderByDescending(x => x.Key);

You are looking for the SortedDictionary documented on MSDN here. You will need to instantiate them as such:
var dict1 = new SortedDictionary<string, Tuple<DateTime, DateTime>>();
var dict2 = new SortedDictionary<Enum, Tuple<string, DateTime, DateTime>>();
Once you have the sorted dictionaries instances you can use LINQ to map or filter or do whatever else is desired on them. When items are added to the dictionaries they are automatically sorted based on either the ICompare<T> for the given TKey (or the default IComparer if not explicitly provided).
One downside is the fact that this sorts based on the key alone, there is no concept of sorting based on values.

The way I understand the question is not to sort the first dictionary, but to be able to iterate its elements in order defined by the second dictionary keys. If that's correct, the following should do the trick:
var orderedKeys = new HashSet<string>(dict2.OrderBy(e => e.Key).Select(e => e.Value.Item1));
var orderedEntries = orderedKeys.Where(dict1.ContainsKey)
.Select(key => new KeyValuePair<string, Tuple<T, T>>(key, dict1[key]))
.Concat(dict1.Where(e => !orderedKeys.Contains(e.Key)));
Note that it will put the entries that has no corresponding key last in the order.

You can not sort dictionary as it uses hash algorithm for constant search.

A regular dictionary cannot be sorted. You could use a SortedDictionary, it exists for this exact purpose.

What type is the best for loose numerically-indexed lists in C#?

What I need is something like an array but letting me to assign an element to whatever an index at any time and check if there is already a value assigned to particular index approximately like
MyArray<string> a = new MyArray<string>();
a[10] = "ten";
bool isTheFifthElementDefined = a[5] != null; // false
Perhaps Dictionary<int, string> with its ContainsKey method could do, but isn't there a more appropriate data structure if I want an ordered collection with numeric keys only?
I am also going to need to iterate through the defined elements (with foreach or linq preferably) accessing both the value and the key of current element.

As you mentioned Dictionary seems more appropriate for this.But you can do it with generic lists,for example, when you are creating your list you can specify an element count,and you can give a default temporary value for all your elements.
List<string> myList = new List<string>(Enumerable.Repeat("",5000));
myList[2300] = "bla bla bla..";
For int:
List<int> myList = new List<int>(Enumerable.Repeat(0,5000));
For custom type:
List<MyClass> myList = new List<MyClass>(Enumerable.Repeat(new MyClass(), 100));
Ofcourse It is not the best solution...
Note: Also you can use SortedList instead of Dictionary if you want an ordered collection by keys:
SortedList<TKey, TValue> : Represents a collection of key/value pairs that are sorted by key based on the associated IComparer implementation.

If you need key/value pairs you cannot use a list, you'll need a Dictionary.
The implementation is pretty snappy so don't be too afraid about performance (as long as you don't put too much values in it).
You can iterate over it with
foreach(KeyValuePair<int, string> kvp in dict)
{
}
If you need to order it you can use a list:
List<int> ordered = new List(dict.Keys);
ordered.Sort();
foreach(int key in ordered)
{
}

Get index of a key/value pair in a C# dictionary based on the value

I would like to know if some property or method exists that gets the index of a specific value.
I found that dictionaries have the Contains() method which returns true if the value passed in exists, so this method almost implements what I need.
I know that I can loop through all the value pairs and check the condition, but I ask because maybe there's an optimized way of doing this.

Let's say you have a Dictionary called fooDictionary
fooDictionary.Values.ToList().IndexOf(someValue);
Values.ToList()
converts your dictionary values into a List of someValue objects.
IndexOf(someValue)
searches your new List looking for the someValue object in question
and returns the Index which would match the index of the Key/Value pair in the dictionary.
This method does not care about the dictionary keys, it simply returns the index of the value that you are looking for.
This does not however account for the issue that there may be several matching "someValue" objects.

There's no such concept of an "index" within a dictionary - it's fundamentally unordered. Of course when you iterate over it you'll get the items in some order, but that order isn't guaranteed and can change over time (particularly if you add or remove entries).
Obviously you can get the key from a KeyValuePair just by using the Key property, so that will let you use the indexer of the dictionary:
var pair = ...;
var value = dictionary[pair.Key];
Assert.AreEqual(value, pair.Value);
You haven't really said what you're trying to do. If you're trying to find some key which corresponds to a particular value, you could use:
var key = dictionary.Where(pair => pair.Value == desiredValue)
.Select(pair => pair.Key)
.FirstOrDefault();
key will be null if the entry doesn't exist.
This is assuming that the key type is a reference type... if it's a value type you'll need to do things slightly differently.
Of course, if you really want to look up values by key, you should consider using another dictionary which maps the other way round in addition to your existing dictionary.

Consider using System.Collections.Specialized.OrderedDictionary, though it is not generic, or implement your own (example).
OrderedDictionary does not support IndexOf, but it's easy to implement:
public static class OrderedDictionaryExtensions
{
public static int IndexOf(this OrderedDictionary dictionary, object value)
{
for(int i = 0; i < dictionary.Count; ++i)
{
if(dictionary[i] == value) return i;
}
return -1;
}
}

You can find index by key/values in dictionary
Dictionary<string, string> myDictionary = new Dictionary<string, string>();
myDictionary.Add("a", "x");
myDictionary.Add("b", "y");
int i = Array.IndexOf(myDictionary.Keys.ToArray(), "a");
int j = Array.IndexOf(myDictionary.Values.ToArray(), "y");

You can use LINQ to help you with this.
Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1, "hi");
dict.Add(2, "NotHi");
dict.Add(3, "Bah");
var item = (from d in dict
where d.Value == "hi"
select d.Key).FirstOrDefault();
Console.WriteLine(item); //Prints 1

If searching for a value, you will have to loop through all the data. But to minimize code involved, you can use LINQ.
Example:
Given Dictionary defined as following:
Dictionary<Int32, String> dict;
You can use following code :
// Search for all keys with given value
Int32[] keys = dict.Where(kvp => kvp.Value.Equals("SomeValue")).Select(kvp => kvp.Key).ToArray();
// Search for first key with given value
Int32 key = dict.First(kvp => kvp.Value.Equals("SomeValue")).Key;

In your comment to max's answer, you say that what you really wanted to get is the key in, and not the index of, the KeyValuePair that contains a certain value. You could edit your question to make it more clear.
It is worth pointing out (EricM has touched upon this in his answer) that a value might appear more than once in the dictionary, in which case one would have to think which key he would like to get: e.g. the first that comes up, the last, all of them?
If you are sure that each key has a unique value, you could have another dictionary, with the values from the first acting as keys and the previous keys acting as values. Otherwise, this second dictionary idea (suggested by Jon Skeet) will not work, as you would again have to think which of all the possible keys to use as value in the new dictionary.
If you were asking about the index, though, EricM's answer would be OK. Then you could get the KeyValuePair in question by using:
yourDictionary.ElementAt(theIndexYouFound);
provided that you do not add/remove things in yourDictionary.
PS: I know it's been almost 7 years now, but what the heck. I thought it best to formulate my answer as addressing the OP, but of course by now one can say it is an answer for just about anyone else but the OP. Fully aware of that, thank you.

no , there is nothing similar IndexOf for Dictionary although you can make use of ContainsKey method to get whether a key belongs to dictionary or not

How to insert an item into a key/value pair object?

I just need to be able to insert a key/value pair into an object at a specific position. I'm currently working with a Hashtable which, of course, doesn't allow for this functionality. What would be the best approach?
UPDATE: Also, I do need the ability to lookup by the key.
For example (oversimplified and pseudocoded but should convey the point):
// existing Hashtable
myHashtable.Add("somekey1", "somevalue1");
myHashtable.Add("somekey2", "somevalue2");
myHashtable.Add("somekey3", "somevalue3");
// Some other object that will allow me to insert a new key/value pair.
// Assume that this object has been populated with the above key/value pairs.
oSomeObject.Insert("newfirstkey","newfirstvalue");

List<KeyValuePair<string, string>> kvpList = new List<KeyValuePair<string, string>>()
{
new KeyValuePair<string, string>("Key1", "Value1"),
new KeyValuePair<string, string>("Key2", "Value2"),
new KeyValuePair<string, string>("Key3", "Value3"),
};
kvpList.Insert(0, new KeyValuePair<string, string>("New Key 1", "New Value 1"));
Using this code:
foreach (KeyValuePair<string, string> kvp in kvpList)
{
Console.WriteLine(string.Format("Key: {0} Value: {1}", kvp.Key, kvp.Value);
}
the expected output should be:
Key: New Key 1 Value: New Value 1
Key: Key 1 Value: Value 1
Key: Key 2 Value: Value 2
Key: Key 3 Value: Value 3
The same will work with a KeyValuePair or whatever other type you want to use..
Edit -
To lookup by the key, you can do the following:
var result = stringList.Where(s => s == "Lookup");
You could do this with a KeyValuePair by doing the following:
var result = kvpList.Where (kvp => kvp.Value == "Lookup");

Maybe the OrderedDictonary will help you out.

Do you need to look up objects by the key? If not, consider using List<Tuple<string, string>> or List<KeyValuePair<string, string>> if you're not using .NET 4.

I would use the Dictionary<TKey, TValue> (so long as each key is unique).
EDIT: Sorry, realised you wanted to add it to a specific position. My bad. You could use a SortedDictionary but this still won't let you insert.

You could use an OrderedDictionary, but I would question why you would want to do that.

Use a linked list. It was designed for this exact situation.
If you still need the dictionary O(1) lookups, use both a dictionary and a linked list.

Hashtables are not inherently sorted, your best bet is to use another structure such as a SortedList or an ArrayList