Linq Fusioni <T> con System.Type

Question

LinQ contiene il metodo Fusioni che getta ogni voce nell'elenco di digitare T. Consente di dire che abbiamo una lista che si presenta come il seguente:

List<Object> obj = new List<Object>(); 
obj.Add("A"); 
obj.Add("B"); 

Un cast di lavoro potrebbe essere

var list = obj.Cast<string>(); 

Quello che mi piacerebbe lavorare

Type t = typeof(String); 
Object list = obj.Cast(t); 

Una soluzione potrebbe essere quella di utilizzare riflessione e genericamente creare un elenco e popolarlo, ma mi chiedevo se esiste una soluzione migliore? Ho sentito che .NET 4.0 dovrebbe supportare qualche co/contro-varianza che potrebbe essere un modo per farlo.

---

informazione e di riflessione supplementare Soulution

L'errore che ottengo è la seguente The model item passed into the dictionary is of type System.Collections.Generic.List1[IStatisticEntry], but this dictionary requires a model item of type System.Collections.Generic.List1[CrashStatistic+CrashEntry]. Nota che CrashEntry implementa IStaticEntry ma non può essere castato perché è un tipo generico della lista.

ho costruito la seguente soluzione attraverso lo farei stille come qualcosa senza riflettere:

public static object Cast(this IEnumerable list, Type type) 
    { 
     var newList = Activator.CreateInstance(typeof(List<>).MakeGenericType(type)); 

     foreach (var item in list) 
      newList.GetType().GetMethod("Add").Invoke(newList, new object[] { item }); 

     return newList; 
    } 

Answer 1

Non è possibile eseguire questa operazione staticamente, non più di quanto non si possa fare con un singolo oggetto.

Type t = typeof(string); 
var x = (t)obj; // invalid 

Tuttavia, è possibile trattare gli elementi in modo dinamico in modo che un cast al tipo di fondo non è necessaria:

static void Main(string[] args) 
{ 
    List<Object> obj = new List<Object>(); 
    obj.Add("A"); 
    obj.Add("B"); 

    var list = obj.Cast<dynamic>(); 
    foreach (var item in list) 
    { 
     Console.WriteLine(item[0]); 
    } 

    Console.ReadKey(); 
} 

Answer 2

Non è necessario gettare qualcosa sul tipo che si sa solo in fase di esecuzione. Il tipo dell'oggetto non cambierà perché eseguirai cast, se fosse una stringa sarà una stringa successiva e non importa se la assegnerai alla variabile stringa o oggetto.

Non è necessario preoccuparsi della trasmissione a un tipo di oggetto reale mentre si sta utilizzando i metodi di riflessione. Può rimanere come variabile di un oggetto, perché mentre si usa il reflection è possibile accedere a tutti i membri del tipo reale in ogni caso, senza alcun cast.

Answer 3

Io non capisco perché ci si vuole fare questo, ma si potrebbe invocare Enumerable.Cast<T> attraverso la riflessione:

List<object> objectList = new List<object> { "Foo", "Bar" }; 
object stringSequence = typeof(Enumerable) 
    .GetMethod("Cast", BindingFlags.Public | BindingFlags.Static) 
    .MakeGenericMethod(typeof(string)) 
    .Invoke(null, new[] { objectList }); 

In questo caso il tipo di runtime di stringSequence attuerebbe IEnumerable<string>.