C # Crear nuevo T ()

Puedes ver lo que bash (pero no) hacer con el siguiente código:

protected T GetObject() { return new T(); } 

Cualquier ayuda sería muy apreciada.

EDITAR:

El contexto fue el siguiente. Estaba jugando con una clase de controlador personalizado para todos los controladores a partir de, con métodos estandarizados. Entonces, en contexto, necesitaba crear una nueva instancia del objeto del tipo de controlador. Entonces, al momento de escribir, era algo así como:

 public class GenericController : Controller { ... protected T GetObject() { return (T)Activator.CreateInstance(ObjectType); } public ActionResult Create() { var obj = GetObject() return View(obj); } 

Y entonces decidí que la reflexión era más fácil aquí. Estoy de acuerdo en que, ciertamente dado el enunciado inicial de la pregunta, la respuesta más adecuada para marcar como correcta fue la que usa la nueva restricción (). Lo he arreglado.

Echa un vistazo a la nueva Restricción

 public class MyClass where T : new() { protected T GetObject() { return new T(); } } 

T podría ser una clase que no tiene un constructor predeterminado: en este caso, una new T() sería una statement inválida. La new() restricción new() dice que T debe tener un constructor predeterminado, lo que hace que la new T() legal.

Puede aplicar la misma restricción a un método genérico:

 public static T GetObject() where T : new() { return new T(); } 

Si necesita pasar parámetros:

 protected T GetObject(params object[] args) { return (T)Activator.CreateInstance(typeof(T), args); } 

¿Por qué nadie sugirió Activator.CreateInstance ?

http://msdn.microsoft.com/en-us/library/wccyzw83.aspx

 T obj = Activator.CreateInstance(typeof(T)); 

Otra forma es usar la reflexión:

 protected T GetObject(Type[] signature, object[] args) { return (T)typeof(T).GetConstructor(signature).Invoke(args); } 

Solo para completar, la mejor solución aquí es a menudo requerir un argumento de función de fábrica:

 T GetObject(Func factory) { return factory(); } 

y llámalo algo como esto:

 string s = GetObject(() => "result"); 

Puede usar eso para requerir o hacer uso de los parámetros disponibles, si es necesario.

La nueva restricción está bien, pero si necesita que T sea también un tipo de valor, use esto:

 protected T GetObject() { if (typeof(T).IsValueType || typeof(T) == typeof(string)) { return default(T); } else { return (T)Activator.CreateInstance(typeof(T)); } } 

Dado que esto está etiquetado como C # 4. Con el marco abierto de sourece ImpromptuIntereface usará el dlr para llamar al constructor, es significativamente más rápido que Activator cuando su constructor tiene argumentos, y es insignificantemente más lento cuando no lo hace. Sin embargo, la principal ventaja es que manejará correctamente los constructores con parámetros opcionales C # 4.0, algo que Activator no hará.

 protected T GetObject(params object[] args) { return (T)Impromptu.InvokeConstructor(typeof(T), args); } 

Para obtener esto probé el siguiente código:

  protected T GetObject() { T obj = default(T); obj =Activator.CreateInstance(); return obj ; }