¿Cómo puedo crear un tipo dinámico? Lista <T>

Question

No quiero que mi lista sea del tipo fijo. Más bien, quiero que la creación de List dependa del tipo de variable. Este código no funciona:

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(); 

     } 
    } 
} 

¿Puede alguien decirme qué cambios tengo que hacer con el fin de hacer que funcione la derecha? Deseo que la creación de list dependa del tipo de variable something

Answer 1

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

Así es como se crea una lista de tipo estáticamente desconocido. Pero tenga en cuenta que no puede mencionar el tipo de tiempo de ejecución de la lista estáticamente. Tienes que usar un tipo no genérico o incluso un objeto.

Sin saber más acerca de lo que quiere lograr, esto es lo mejor que puede hacer.

Answer 2

El compilador debe conocer el tipo genérico T en el momento de la compilación. Entonces no, realmente no puedes hacer esto.

Answer 3

Quiero tipo de seguridad pero necesito seguridad de tipo dinámico.

Si quiere decir que desea el tiempo de ejecución seguridad de tipos, puede crear List<T> utilizando la reflexión (véase la respuesta de usr) o dynamic y luego tratarla como la no genérico IList.

Usando dynamic, se vería algo como esto:

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 dinámica y la reflexión todos funcionan bien - pero con un lado negativo en el rendimiento - y perder la tipificación fuerte, código de diseño/claridad, etc.
, es decir, siempre se debe tratar de resolver las cosas w/o que - si es posible, su código lo permite ...
Así, y (nota) en función (mucho) en su código específico, necesidades,
También es posible usar un 'truco' a 'inferir' el tipo y hacer que sea genérica ...

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(); 
    } 
} 

... es decir. si tiene un valor para una variable y antes de 'ingresar' al contexto genérico,
puede usar extensiones (que son muy útiles con esto), y permita inferir el tipo y tipo de lista para usted
NOTA: este 'trabajo alrededor' desafortunadamente no siempre funciona y cuando su código es 'demasiado dinámico' (sé que esto no es demasiado 'exacto' pero fuera del alcance para esto) y si depende de los tipos de reflexión inducida, etc.
es decir, no hay una solución clara, esto es solo un ejemplo, necesitarás poner un poco de sudor :) para que te funcione, por ejemplo Es posible que necesite un tipo de envoltorio aquí y allá y, obviamente, crear una lista de esta manera puede no ser lo que desea, etc.