Inizializzazione di una serie di raccolte generiche con ciascuna un argomento generico diverso

Question

Durante lo sviluppo di uno dei miei progetti, ho riscontrato un problema relativo ai tipi generici.

Il progetto richiede che scriva una classe che funga da sorgente di oggetti elenco. Supponiamo che ho avuto la seguente classe:

public class TablesProvider 
{ 
    private readonly List[] _tables; 

    public TablesProvider() 
    { 
     // initialize the tables var here.... 
    } 

    public List<TItem> GetTable<TItem>() 
    { 
     return (List<TItem>)_tables.Single(x => x is List<TItem>); 
    } 
} 

Questa classe, ovviamente, non funziona, perché il tipo List è un tipo generico e, pertanto, deve essere specificato gli argomenti generici.

così ho fatto un tipo astratto chiamato MyList, che sarebbe derivato da una più specifica di tipo MyList<TItem> al fine di sfuggire a questa esigenza, e curato il TablesProvider un po '.

public class TablesProvider 
{ 
    private readonly MyList[] _tables; 

    public TablesProvider() 
    { 
     // initialize the tables var here.... 
    } 

    public MyList<TItem> GetTable<TItem>() 
    { 
     return (MyList<TItem>)_tables.Single(x => x is MyList<TItem>); 
    } 
} 

public abstract class MyList 
{ 
    // ... 
} 

public class MyList<TItem> : MyList, IList<TItem> 
{ 
    private readonly List<TItem> _elements = new List<TItem>(); 

    public TItem this[int index] 
    { 
     get { return _elements[index]; } 
     set { _elements[index] = value; } 
    } 

    // ... 
} 

Questo funziona abbastanza bene. C'è rimasto solo un problema. Supponiamo di avere 45 collezioni diverse, ciascuna definita con un argomento generico diverso. Quale sarebbe il modo migliore per inizializzare tutte queste raccolte? Non posso usare un ciclo for qui, dal momento che i parametri generici sono specificati al momento della compilazione e non in fase di esecuzione, e quindi una costruzione del genere non sarebbe possibile:

for (int i = 0; i < 45; i++) 
     _tables[i] = new MyList<GenericParameters[i]>(); 

Il mio obiettivo finale è quello di avere il lusso di solo fare qualcosa di simile ...

var table = _tablesProvider.GetTable<SomeClass>(); 
var element = table[3]; 
var propertyValue = element.SomeProperty; 

... senza la necessità di lanciare la variabile element al fine di accedere ai suoi membri tipiche specifiche.

È probabilmente opportuno menzionare che la quantità di oggetti elenco diversi è fissa a 45. Ciò non cambierà. In teoria, potevo inizializzare l'array riga per riga, o avere invece 45 proprietà o variabili. Entrambe queste opzioni, tuttavia, mi sembrano una soluzione piuttosto economica, ma accetterò una di queste se non c'è altro modo.

Qualcuno di voi ha qualche idea? Sto sbagliando tutto questo? Dovrei prendere in considerazione un'altra struttura?

Grazie in anticipo.

Answer 1

questa implementazione funziona

public class TablesProvider 
{ 
    private readonly List<object> _tables; 

    public TablesProvider() 
    { 
     _tables = new List<object>(); 
    } 

    public IList<TItem> GetTable<TItem>() 
    { 
     var lst = (List<TItem>)_tables.SingleOrDefault(x => x is List<TItem>); 
     if (lst == null) 
     { 
      lst = new List<TItem>(); 
      _tables.Add(lst); 
     } 
     return lst; 
    } 
} 

crea Elenco dei TItem quando necessario; la volta successiva restituisce lo stesso elenco per TItem. è l'inizializzazione pigra

modo da poter fare richiamare

var table = _tablesProvider.GetTable<SomeClass>(); 

senza alcun codice come questo:

for (int i = 0; i < 45; i++) 
    _tables[i] = new MyList<GenericParameters[i]>(); 

non è ThreadSafe

Answer 2

Sì, è possibile fare ciò che si stanno descrivendo se usi la riflessione.

Supponendo che la vostra ipotetica GenericParameters matrice è una matrice di Type s (dal momento che non si può avere una matrice di tipo identificatori), è possibile definire questa funzione di supporto:

private MyList MakeList(Type t) 
{ 
    return (MyList)Activator.CreateInstance(typeof(MyList<>).MakeGenericType(t)); 
} 

E che permetterà di fare questo:

public TablesProvider() 
{ 
    var GenericParameters = new[] { typeof(string), typeof(int), typeof(DateTime) }; 

    _tables = new MyList[GenericParameters.Length]; 

    for (int i = 0; i < GenericParameters.Length; i++) 
    { 
     _tables[i] = MakeList(GenericParameters[i]); 
    } 
} 

È anche possibile utilizzare LINQ se si vuole:

public TablesProvider() 
{ 
    var GenericParameters = new[] { typeof(string), typeof(int), typeof(DateTime) }; 

    _tables = GenericParameters.Select(MakeList).ToArray(); 
} 

---

risposta precedente:

Beh, la realtà è che si sta andando ad avere un elenco di 45 diversi tipi qualche parte, il che significa più o meno si sta andando ad avere 45 diverse linee di simile codice. Quindi si potrebbe dire che l'obiettivo è rendere quelle linee il più concise possibile.

Un modo per farlo sarebbe quello di aggiungere una funzione di supporto:

private void AddTable<T>() 
{ 
    _tables.Add(new MyTable<T>()); 
} 

(questo presuppone che cambia _tables ad un List<MyTable>)

Poi si può solo fare:

AddTable<Type1>(); 
AddTable<Type2>(); 
AddTable<Type3>(); 
AddTable<Type4>();