¿Puedo tener una propiedad genérica this []?

Question

Tengo un diccionario DICOM que contiene un conjunto de objetos derivados de DataElement. El diccionario tiene un int como clave y DataElement como propiedad. Mi diccionario DICOM contiene una esta propiedad [] donde puedo acceder al DataElement, así:

public class DicomDictionary 
{ 
    Dictionary<int, DataElement> myElements = new Dictionary<int, DataElement>(); 
    . 
    . 
    public DataElement this[int DataElementTag] 
    { 
    get 
    { 
     return myElements[int]; 
    } 
    } 
} 

Un problema ahora es que tengo diferentes tipos DataElement todos los derivados de DataElement, como DataElementSQ, DataElementOB y así sucesivamente. Lo que quería hacer ahora es lo siguiente para hacer la escritura en C# un poco más fácil:

public T this<T>[int DataElementTag] where T : DataElement 
{ 
    get 
    { 
     return myElements[int]; 
    } 
} 

Pero esto no es realmente posible. ¿Hay algo que me he perdido? Por supuesto que podría hacerlo con el método Getter, pero sería mucho mejor tenerlo de esta manera.

Answer 1

¿Por qué no utilizar un método genérico real GetDataElement<T> where T : DataElement en su lugar? Los indexadores genéricos no son compatibles con C#. ¿Por qué crees que en este caso un indexador es mejor que un método?

Answer 2

Las mejores opciones son utilizar un método genérico (en lugar de un indexador) o hacer que su clase sea genérica (en cuyo caso, el indexador estaría vinculado al tipo genérico de clase). Un indexador genérico como usted ha descrito no está permitido en C#.

Answer 3

¿Es un caso para usted?

public class DicomDictionary<TElement> 
{ 
     Dictionary<int, TElement> myElements = new Dictionary<int, TElement>(); 
     public TElement this[int DataElementTag] 
     {  
       get  
       {  
       return myElements[int];  
       } 
     } 
} 

Answer 4

agregación en respuesta SLL es:

public class Acessor<TKey, TValue> 
    where TKey : IComparable 
    where TValue : class 
{ 
    Dictionary<TKey, TValue> myElements = new Dictionary<TKey, TValue>(); 

    public TValue this[TKey key] 
    { 
     get 
     { 
      return myElements[key]; 
     } 
     set 
     { 
      myElements.Add(key, value); 
     } 
    } 
} 

o sin cambiar la firma de clase:

public class Acessor 
{ 
    Dictionary<string, object> myElements = new Dictionary<string, object>(); 

    public object this[string key] 
    { 
     get 
     { 
      return myElements[key]; 
     } 
     set 
     { 
      myElements.Add(key, value); 
     } 
    } 
} 

y crear un método para analizar el tipo genérico:

public T Get<T>(string key) 
     where T : class 
    { 
     return (T)Convert.ChangeType(acessor[key], typeof(T)); 
    }