Come creare un elenco di tipi dinamici <T>

Question

Non voglio che il mio elenco sia di tipo fisso. Piuttosto voglio che la creazione di List dipenda dal tipo di variabile. Questo codice non funziona:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Collections.Generic; 
namespace ConsoleApplication3 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 

      string something = "Apple"; 

      Type type = something.GetType(); 

      List<type> list = null; 

      Console.ReadKey(); 

     } 
    } 
} 

Qualcuno può dirmi quali modifiche devo apportare per farlo funzionare correttamente? Voglio che la creazione di list dipenda dal tipo di variabile something

Answer 1

string something = "Apple"; 
Type type = something.GetType(); 
Type listType = typeof(List<>).MakeGenericType(new [] { type }); 
IList list = (IList)Activator.CreateInstance(listType); 

Ecco come si crea un elenco di tipo staticamente sconosciuto. Ma notate che non siete in grado di menzionare staticamente il tipo di runtime dell'elenco. Devi usare un tipo non generico o anche un oggetto.

Senza saperne di più su ciò che si desidera ottenere, questo è il meglio che si possa fare.

Answer 2

Il compilatore deve conoscere il tipo generico T al momento della compilazione. Quindi no, non puoi davvero farlo.

Answer 3

Voglio sicurezza di tipo ma ho bisogno di sicurezza di tipo dinamico.

Se vuoi dire che si desidera runtime tipo di sicurezza, è possibile creare List<T> utilizzando la riflessione (vedi risposta del usr) o dynamic e poi trattarlo come il non generico IList.

Utilizzando dynamic, sarebbe simile a questa:

static List<T> CreateListByExample<T>(T obj) 
{ 
    return new List<T>(); 
} 

… 

object something = "Apple"; 

IList list = CreateListByExample((dynamic)something); 

list.Add(something); // OK 

list.Add(42);  // throws ArgumentException 

Answer 4

La dinamica e la riflessione tutti funzionano bene - ma con un aspetto negativo sulle prestazioni - e perdendo tipizzazione forte, codice di progettazione/chiarezza ecc
per esempio, si dovrebbe sempre cercare di risolvere le cose w/o lo - se è possibile, il codice lo permette ...
Quindi, e (nota) seconda (molto) sul codice specifico, bisogni,
si potrebbe anche usare un 'trucco' a 'dedurre' il tipo e renderla generica ...

class Program 
{ 
    static void Main(string[] args) 
    { 
     string something = "Apple"; 
     int test = 5; 
     var list = something.GetList(); 
     var listint = test.GetList(); 
     Console.WriteLine(list.GetType()); 
    } 
} 
static class Extension 
{ 
    public static List<T> GetList<T>(this T value) 
    { 
     return new[] { value }.ToList(); 
    } 
} 

... cioè. se hai un valore per una variabile e prima di "inserire" il contesto generico,
potresti usare estensioni (che sono molto utili con questo argomento), e dedurre il tipo e un tipo di lista per te
NOTA: questo "aggiramento" sfortunatamente non viene sempre visualizzato e quando il tuo codice è "troppo dinamico" (so che questo non è troppo "esatto" ma fuori dallo scopo) e se dipende dai tipi indotti da riflessione ecc.
es. Non c'è una soluzione pulita, questo è solo un esempio, dovresti mettere del sudore :) per farlo funzionare per te - es. potrebbe essere necessario un tipo di wrapper qua e là e ovviamente la creazione di un elenco in questo modo potrebbe non essere ciò che si desidera, ecc.