En C#: ¿Cómo declarar un diccionario genérico con un tipo como clave y un IEnumerable <> de ese tipo como valor?

Question

Quiero declarar un diccionario que almacena mecanografiadas IEnumerable 's de un tipo específico, con ese tipo exacto como la clave, así: (Editado para seguir comentario johny de g)

private IDictionary<Type, IEnumerable<T>> _dataOfType where T: BaseClass; //does not compile! 

Las clases concretas que quiero tienda, todos derivan de BaseClass, por lo tanto, la idea de usarlo como restricción. El compilador se queja de que espera un punto y coma después del nombre del miembro.

Si iba a funcionar, yo esperaría que esto haría que la posterior recuperación de la simple diccionario como:

IEnumerable<ConcreteData> concreteData; 
_sitesOfType.TryGetValue(typeof(ConcreteType), out concreteData); 

¿Cómo definir un diccionario de este tipo?

Answer 1

Es posible que ni siquiera necesita un diccionario para ser capaz de hacer esto - pero eso depende de sus necesidades. Si sólo necesita siempre 1 dicha lista según el tipo por dominio de aplicación (es decir, el "diccionario" es static), el siguiente patrón puede ser eficiente y promueve el tipo de inferencia muy bien:

interface IBase {} 

static class Container { 
    static class PerType<T> where T : IBase { 
     public static IEnumerable<T> list; 
    } 

    public static IEnumerable<T> Get<T>() where T : IBase 
     => PerType<T>.list; 

    public static void Set<T>(IEnumerable<T> newlist) where T : IBase 
     => PerType<T>.list = newlist; 

    public static IEnumerable<T> GetByExample<T>(T ignoredExample) where T : IBase 
     => Get<T>(); 
} 

Tenga en cuenta que usted debe pensar cuidadosamente antes de adoptar este enfoque acerca de la distinción entre el tipo de tiempo de compilación y el tipo de tiempo de ejecución. Este método le permitirá almacenar una variable IEnumerable<SomeType> con torsión en tiempo de ejecución bajo SomeType y -si la envía- bajo cualquiera de los tipos de base SomeType, incluido IBase, sin errores de tiempo de ejecución ni de compilación - que podría ser una función, o un error esperando a suceder, por lo que es posible que desee un if para verificarlo.

Además, este enfoque ignora el enhebrado; por lo tanto, si desea acceder a esta estructura de datos desde múltiples hilos, probablemente desee agregar algún bloqueo. Las lecturas/escrituras de referencia son atómicas, por lo que no se dañará si no se bloquea, pero los datos obsoletos y las condiciones de carrera son ciertamente posibles.

Answer 2

No restringe T en el miembro privado; lo constriñes en el nivel de clase.

class Foo<T> where T : BaseClass 
{ 
    private IDictionary<T, IEnumerable<T>> _dataOfType; 

    public Foo(IDictionary<T, IEnumerable<T>> dataOfType) 
    { 
     this._dataOfType = dataOfType; 
    } 
} 

Answer 3

hacer una clase diccionario personalizado:

public class BaseClassDictionary<T, IEnumerable<T>> : Dictionary<T, IEnumerable<T>> 
    where T : BaseClass 
{ 
} 

continuación, puede utilizar este diccionario especializado en cambio, como tipo de campo:

private BaseClassDictionary<BaseClassDerivedType, IEnumerable<BaseClassDerivedType>> myDictionary; 

Answer 4

1. no puede limitarse una variable específica. Solo funciona en clases y métodos. Realmente no tiene ningún sentido en el nivel variable, para ser honesto.
2. Lo que quiere es una clase personalizada - class WeirdDictionary : IDictionary<Type, IEnumerable>, que sobrecargará el método Agregar para tomar un tipo y un IEnumerable de ese tipo, que puede hacer usando restricciones, y convertir el IEnumerable <> a IEnumerable. Sobrecargue también el indexador y vuelva a colocarlo en el tipo correspondiente. Se necesita
   Todo este casting, ya que los genéricos son estrictos con IEnumerable<Base> ser tan bueno como IEnumerable<Derived> (Esto se llama varianza, creo?)

Esta solución es ligeramente generalizada, ya que las rocas de reutilización

Editar por 280Z28:

Al principio marqué esto porque el punto 2 era confuso y lo malinterpreté. Al utilizar la implementación explícita de métodos en IDictionary<Type, IEnumerable> y proporcionar alternativas genéricas, puede obtener una interfaz bastante limpia. Tenga en cuenta que no puede crear indizadores genéricos, por lo que siempre deberá usar TryGet<T> (que de todos modos es una buena idea). Solo incluí la implementación explícita de uno de los métodos IDictionary<> para mostrar cómo realizar las comprobaciones. No obtenga WeirdDictionary directamente de Dictionary<Type, IEnumerable> o perderá la capacidad de garantizar restricciones en los datos subyacentes.

class WeirdDictionary : IDictionary<Type, IEnumerable> 
{ 
    private readonly Dictionary<Type, IEnumerable> _data = 
     new Dictionary<Type, IEnumerable>(); 

    public void Add<T>(IEnumerable<T> value) 
    { 
     _data.Add(typeof(T), value); 
    } 

    public bool TryGet<T>(out IEnumerable<T> value) 
    { 
     IEnumerable enumerable; 
     if (_data.TryGetValue(typeof(T), out enumerable) 
     { 
      value = (IEnumerable<T>)enumerable; 
      return true; 
     } 

     value = null; 
     return false; 
    } 

    // use explicit implementation to discourage use of this method since 
    // the manual type checking is much slower that the generic version above 
    void IDictionary<Type, IEnumerable>.Add(Type key, IEnumerable value) 
    { 
     if (key == null) 
      throw new ArgumentNullException("key"); 
     if (value != null && !typeof(IEnumerable<>).MakeGenericType(key).IsAssignableFrom(value.GetType())) 
      throw new ArgumentException(string.Format("'value' does not implement IEnumerable<{0}>", key)); 

     _data.Add(key, value); 
    } 
} 

Fin 280Z28

Answer 5

Prueba esto:

public class MyCustomDictionary<T>: Dictionary<T, IEnumerable<T>> { } 

Answer 6

Use System.ComponentModel.Design.ServiceContainer que ya está disponible en .Net framework.

 ServiceContainer container = new ServiceContainer(); 

     IList<int> integers = new List<int>(); 
     IList<string> strings = new List<string>(); 
     IList<double> doubles = new List<double>(); 

     container.AddService(typeof(IEnumerable<int>), integers); 
     container.AddService(typeof(IEnumerable<string>), strings); 
     container.AddService(typeof(IEnumerable<double>), doubles);