We Keep Coding

Accessing a generic dictionary via casting at runtime

Our program has a dictionary of type:
Dictionary<TKey, TCache>();
where TKey and TCache are whatever generic types the encompassing method is given, and TCache is a CacheBase.
In another method I need to reference this object (which is stored in another dictionary where it's stored as an object) and remove a key/value pair from it. At runtime I have the TKey object boxed as an 'object' class.
How would I go about this? I can't cast to Dictionary because this method is not generic and won't know at compile time what type of cache/key it is. These are passed as parameters.
Is there a way to use reflection to cast the dictionary from Dictionary to effectively
Dictionary<CacheBase<key.GetType()>, key.GetType()>
I know this can easily fixed by not using the methods generics and instead making the Dictionary a Dictionary and making CaseBase extend an empty CacheBase, but my supervisor insisted I do it this way

Managed to fix it on my own, but for future people,
Essentially, I had to flip the perspective. I can't cast an existing dictionary to another equivalent type via reflection, however the goal was to do so so I could modify the dictionary with Types at runtime.
So instead, I made a generic method that would communicate with the dictionary in the way it wanted (if it expects a TKey, I made my method take a TKey so it would work properly).
e.g.
public void RemoveFromCache<TCache, TKey>( Type type, TKeykey ) where TCache : CacheBase<TKey> {
((Dictionary<TKey, TCache>)m_caches[type]).Remove( key );
}
After that, I simply used reflection to call my generic method at runtime with the types passed in as the appropriate generics
e.g.
var keyType = key.GetType();
var removeFromCache = GetType().GetMethod( nameof( RemoveFromCache ) ).MakeGenericMethod( type, keyType );
removeFromCache.Invoke( this, new object[] { type, key } );
And that let me communicate with a Dictionary that was boxed into an object at runtime with only types available.

Passing a "reference" to Dictionary element?

So I have:
ConcurrentDictionary<string, int> dict;
I want to pass a reference to one of its elements, suppose dict["x"] to a method, and allow that method to change/set that element. Is it possible to do exactly that, or do I have to pass the dictionary itself? Also, is it possible to do so even if the element does not exist as a key in the dictionary? Or does it already has to be a valid key contained in the dictionary?

Yes, by using a delegate. This delegate can be called from within the changing function. The delegate will then change or set the key/value inside the dictionary.
void DoChangeMyElement<T>(Action<T> changeIt)
{
changeIt(123);
}
You can call this method with:
ConcurrentDictionary<string, int> dict = new ...;
DoChangeMyElement(value => dict["X"] = value);

I want to pass a reference to one of its elements, suppose dict["x"] to a method, and allow that method to change/set that element. Is it possible to do exactly that, or I have to pass the dictionary itself ?
Just pass the dictionary, as Sam I am said it is a reference type anyway.
Also, is it possible to do so even if the element does not exist as a key in the dictionary ?
No that's not possible, you'd have to add to it, then send it to the function.

You'd have to pass the whole dictionary and key, and let the method do what it needs to. The basic reason for this is that you can only pass fields and local variables by reference, not properties (including indexer properties).
If you were really desperate to do so, you could use reflection and/or delegates to get what you want done, but it's not the best way to do it.

There's no harm in passing the whole Dictionary. It itself is a reference type after all, and passing the Dictionary would be better form than passing by reference.
but I suppose you could encapsulate you int and pass it like that
public class IntContainer
{
int value;
}

Is there a generic IDictionary implementation where IsFixedSize is True?

I wonder if there is an implementation of IDictionary interface in the standard library that has property IsFixedSize == true.
In my code, I am using a Dictionary indexed by an enum, like this:
Dictionary<EMyEnum, string> myDictionary = new Dictionary<EMyEnum, string>();
I always have values in the dictionary for all possible values of MyEnum, using a code like this:
foreach (EMyEnum myEnum in Enum.GetValues(typeof(EMyEnum)))
{
m_myDictionary.Add(myEnum, "");
}
so my dictionary actually has a fixed size. It feels kind of 'wrong' to be using Dictionary for it and I am wondering if there is perhaps a better type I am missing.
I was looking in System.Collections.Generic and System.Collections namespaces but could not find anything suitable.
In response to one of the questions, the enum is just a bunch of values, like this:
enum EMyEnum
{
meValue1,
meValue2,
meValue3
}
EDIT:
I have accepted supermem's answer as it is most to the point of the original question. To elaborate my original concern, an ordinary dictionary can have one of the keys/items deleted and then any code that relies on the fact that iterating over keys of the dictionary also iterates over all values of enum will be broken.
I understand that I can create a fixed size array but casting enums to ints is not that pretty, besides it would only work for contiguous enums (good enough in my case).
I think there is a good case for Dictionary that has enum values as keys and it is a pity that such a class does not ship with .Net.

.Net 4.5 actually introduces a new interface that sounds like it may be what you need, IReadOnlyDictionary<TKey, TValue>.
Also, IReadOnlyList<T>

No, there are no fixed size IDictionary implementations shipping with the CLR. (Except for the ReadOnly* sort, but not applicable to your problem.)
You can roll your own, but unless you have profiled this code and determined that the use of Dictionary presents a meaningful bottleneck (IMO, very rare), I'd say to keep it as is. You also have the benefit of readability as Dictionary is very well understood and easy to grok.

If you are using the simple enum declaration and not explicitly assigning values to the elements, you could use just an array:
Array values = Enum.GetValues(typeof(EMyEnum));
string[] myDictionary = new string[values.Length];
foreach (EMyEnum myEnum in values)
{
myDictionary[(int)myEnum] = "";
}
You could even wrap this approach in a custom class that treat the enum type as indexer, if you are bothered by those explicit casts to int everywhere:
class EnumDictionary<EnumType, ValueType>
{
private readonly ValueType[] array = new ValueType[Enum.GetValues(typeof(EnumType)).Length];
public ValueType this[EnumType index]
{
get { return array[Convert.ToInt32(index)]; }
set { array[Convert.ToInt32(index)] = value; }
}
}
EnumDictionary<EMyEnum, string> enumDictionary = new EnumDictionary<EMyEnum, string>();
foreach ( EMyEnum myEnum in Enum.GetValues(typeof(EnumType))
enumDictionary[myEnum] = "";
Now, if this is better than using Dictionary or not is a completely different discussion.

Traversing through an arbitrary dictionary tree structure in C#

I am trying to write a recursive C# function that will operate on generic dictionaries of the form IDictionary<string, T> where T is either another IDictionary<string, T> or a string.
My first failed attempt looked something like this:
public string HandleDict(IDictionary<string, string> dict){
// handle the leaf-node here
}
public string HandleDict<T>(IDictionary<string, IDictionary<string, T>> dict){
// loop through children
foreach(string key in dict.Keys){
HandleDict(dict[key]);
}
}
I also tried variants of HandleDict<T>(IDictionary<string, T>) where T : IDictionary<string, T> but that also doesn't quite work. I know that what I want to do could be achieved through a custom class as the parameter instead of dictionaries, and that my attempts are conceptually flawed (there's no end to the recursion in the generic function). I would still like to know if there is actually a way to do what I want here using just generic IDictionaries.

In order to store either a Dictionary<string, string> or a Dictionary<string,??> as a value in a dictionary, you'd need to declare the dictionary to be of type Dictionary<string, object>.
public string HandleDict(IDictionary<string, object> dict)
{
foreach (KeyValuePair<string, object> kvp in dict)
{
Then you'd need to check for each value if it's a string or another Dictionary<string, string> or another Dictionary<string, object> -- C# performs overload resolution at compile-time, not at run-time!
var leaf = kvp.Value as IDictionary<string, string>;
if (leaf != null)
{
HandleDict(leaf);
}
else
{
HandleDict((IDictionary<string, object>)kvp.Value);
}
}
}
Recursion would end when a leaf is reached, because the HandleDict overload for Dictionary<string, string> does not continue the recursion.
However, as you'll note, there's a lot of type checking and casting going on, and a Dictionary<string, object> smells badly -- it essentially defeats the purpose of generics.
I suggest you have a look at the Visitor Pattern instead.

The C# type system is not powerful enough to represent the sort of "higher" generic types that you need to do this in the type system proper. Consider Haskell or F# if you need a language with a richer generic type system.
It is possible to do what you want in C# 4 using the 'dynamic' feature, but I'd recommend against it. Doing that basically starts up the compiler again at runtime. Rather than resorting to runtime type analysis I'd spend some time revisiting the decision to use dictionaries in the first place. I suspect there are better data structures for your actual task at hand. Describe that task and we'll see if there are better data structures.

Convert Dictionary<MyType>.ValueCollection to IList<MyType>

I'm using a Dictionary<int, MyType> in a class. That class implements a interface that requires an IList<MyType> to be returned. Is there a simple way to to cast the one to the other (without copying the entire thing)?
My current solution follows:
private IList<MyType> ConvertToList(Dictionary<int, MyType>.ValueCollection valueCollection)
{
List<MyType> list = new List<MyType>();
list.AddRange(valueCollection);
return list;
}

You'll need to do a copy, but this is probably a good thing. In C# 2, your current code is almost the cleanest you can make. It would be improved by directly constructing your list off your values (List<MyType> list = new List<MyType>(valueCollection);), but a copy will still be required.
Using LINQ with C# 3, however, you would be able to do:
myDictionary.Values.ToList();
That being said, I would not (probably) try to avoid the copy. Returning a copy of your values tends to be safer, since it prevents the caller from causing problems if they attempt to modify your collection. By returning a copy, the caller can do list.Add(...) or list.Remove(...) without causing your class problems.
Edit: Given your comment below, if all you want is an IEnumerable<T> with a Count, you can just return ICollection<T>. This is directly implemented by ValueCollection, which means you can just return your dictionary's values directly, with no copying:
private ICollection<MyType> ConvertToList(Dictionary<int, MyType>.ValueCollection valueCollection)
{
return valueCollection;
}
(Granted, this method becomes really useless in this case - but I wanted to demonstrate it for you...)

How about
Dictionary<int, MyType> dlist = new Dictionary<int, MyType>();
IList<MyType> list = new List<MyType>(dlist.Values);

This is not possible.
A dictionary (including its Values collection) is an inherently unordered collections; its order will change based on the hashcodes of its keys. This is why ValueCollection doesn't implement IList<T> in the first place.
If you really wanted to, you could make a wrapper class that implements IList and wraps the ValueCollection, using a foreach loop in the indexer. However, it's not a good idea.

You can use the constructor:
public IList<MyType> MyValues
{
get { return new List<MyType>(myDictionary.Values); }
}
(Edited to remove an assertion I'm not 100% sure on.)

You can use ToList() method:
myDictionary.Values.ToList();
It is available importing Linq: using System.Linq;