Uso de dónde especificar diferentes genéricos

Question

Estoy escribiendo un bijective dictionary class, pero quiero asegurarme de que los dos tipos genéricos no son del mismo tipo por dos razones.

En primer lugar, me gustaría que implementa la interfaz IDictionary en ambas direcciones, pero

public class BijectiveDictionary<TKey, TValue> 
    : IDictionary<TKey, TValue>, IDictionary<TValue, TKey> 

me da " 'BijectiveDictionary < TKey, TValue >' no se puede aplicar tanto 'IDictionary < TKey, TValue >' y 'IDictionary < TValue, TKey >', ya que pueden unificar para algunas sustituciones de parámetros de tipo "(que es comprensible, pero indeseable.)

segundo lugar, me gustaría escribir un opt solución imitada si ambos tipos son iguales.

public class BijectiveDictionary<TKey, TValue> 
    : IDictionary<TKey, TValue> where TValue : TKey 
{ 
    // Optimized solution 
} 

public class BijectiveDictionary<TKey, TValue> 
    : IDictionary<TKey, TValue>, IDictionary<TValue, TKey> where TValue : !TKey 
{ 
    // Standard solution 
} 

¿Esto es posible?

Si no, puedo considerar la no implementación de IDictionary, pero no puedo garantizar que TValue this[TKey key] y TKey this[TValue key] sean diferentes, lo que sería desafortunado.

---

Parece que el problema aquí es que cuando los dos tipos son iguales, surgen los casos especiales.

Mi intención original era crear un diccionario que asigna exactamente una clave a exactamente un valor, y viceversa, de modo que para cada KeyValuePair<TKey, TValue>(X, Y), existe también un KeyValuePair<TValue, TKey>(Y, X).

Cuando TKey = TValue, entonces esto se puede simplificar a un solo diccionario:

public T this[T key] 
{ 
    get { return this[key]; } 
    set 
    { 
     base.Add(key, value); 
     base.Add(value, key); 
    } 
} 

En este caso, no se puede Add(2,3); Add(3,4) porque Add(2,3) mapas 3 a 2 también, y [3] volvería 2.

Sin embargo, Jaroslav Jandek's solution propuso utilizar un segundo diccionario para hacer esto para los casos cuando TKey! = TValue. Y aunque esto funciona maravillosamente para esos casos, (y lo que decidí implementar, al final) no sigue mi intención original cuando TKey = TValue, al permitir Add(2,3); Add(3,4) asignar una sola clave 3 a dos valores (2 en una dirección, y 4 en la otra, aunque creo que estrictamente hablando sigue siendo una función biológica válida.

Answer 1

¿Qué tal esto (enfoque diferente):

public class BijectiveDictionary<TKey, TValue> : Dictionary<TKey, TValue> 
{ 
    public BijectiveDictionary<TValue, TKey> Reversed { get; protected set; } 

    public BijectiveDictionary() 
    { 
     this.Reversed = new BijectiveDictionary<TValue,TKey>(true); 
     this.Reversed.Reversed = this; 
    } 

    protected BijectiveDictionary(bool reversedWillBeSetFromTheCallingBiji) { } 

    protected void AddRaw(TKey key, TValue value) 
    { 
     base.Add(key, value); 
    } 

    // Just for demonstration - you should implement the IDictionary interface instead. 
    public new void Add(TKey key, TValue value) 
    { 
     base.Add(key, value); 
     this.Reversed.AddRaw(value, key); 
    } 

    public static explicit operator BijectiveDictionary<TValue, TKey>(BijectiveDictionary<TKey, TValue> biji) 
    { 
     return biji.Reversed; 
    } 
} 

y en el código:

BijectiveDictionary<int, bool> a = new BijectiveDictionary<int, bool>(); 

a.Add(5, true); 
a.Add(6, false); 

Console.WriteLine(a[5]);// => True 
Console.WriteLine(((BijectiveDictionary < bool, int>)a)[true]);// => 5 
//or 
Console.WriteLine(a.Reversed[true]);// => 5 

Answer 2

En resumen, no. Al optimizarlo, una opción podría ser una estrategia basada en un inicializador estático, que elija una implementación concreta apropiada para el caso del mismo tipo, pero de lo contrario; es decir,

public class BijectiveDictionary<TKey, TValue> 
    : IDictionary<TKey, TValue> 
{ 
    static readonly ISomeStrategy strategy; 
    static BijectiveDictionary() { 
     if(typeof(TKey) == typeof(TValue)) { 
      strategy = ... 
     } else { 
      strategy = ... 
     } 
    } 
} 

pero es casi seguro que se encuentre utilizando MakeGenericType y reflexión para crear la instancia (pero una vez creado debe estar bien - y sólo hacerlo una vez).

Answer 3

Incluso si pudiera, lo que sería la salida de este código?

var dict = new BijectiveDictionary<int, int>(); 

dict.Add(2,3); 
dict.Add(3,4); 

Console.WriteLine(dict[3]); // Do I get 2 or 4? 

Tal vez se puede reestructurar el código de otra forma que no sea ambigua?

Answer 4

¡Hasta cierto punto, esto se puede hacer! Utilizo un método de diferenciación, en lugar de cualificador (es) que limita los tipos.

No se unifica, de hecho podría ser mejor que si lo hiciera porque puede separar las interfaces separadas.

Vea mi publicación aquí, con un ejemplo totalmente funcional en otro contexto. https://stackoverflow.com/a/12361409/471129

Básicamente, lo que se hace es añadir otro parámetro de tipo de IIndexer, de modo que se convierta en IIndexer <TKey, TValue, TDifferentiator>.

A continuación, cuando se utiliza dos veces, se pasa "primero" a la primera utilización, y "segundo" para el segundo uso

Por lo tanto, la prueba de clase se convierte en: class Test<TKey, TValue> : IIndexer<TKey, TValue, First>, IIndexer<TValue, TKey, Second>

Por lo tanto, se puede hacer new Test<int,int>()

en primer lugar, y segundo son triviales:

interface First { } 

interface Second { }