C # Crear nueva T ()

Puedes ver lo que intento (pero no puedo) 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, 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<T> : Controller
{
    ...

    protected T GetObject()
    {
        return (T)Activator.CreateInstance(ObjectType);
    }        

    public ActionResult Create()
    {
        var obj = GetObject()

        return View(obj);
    }

Entonces decidí que la reflexión era más fácil aquí. Estoy de acuerdo en que, ciertamente dada la declaración inicial de la pregunta, la respuesta más apropiada para marcar como correcta fue la que usa la restricción new (). He arreglado eso.

Echa un vistazo a la nueva restricción

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

Tpodría ser una clase que no tiene un constructor predeterminado: en este caso new T()sería una declaración no válida. La new()restricción dice que Tdebe tener un constructor predeterminado, lo que lo hace new T()legal.

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

public static T GetObject<T>() 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 ha sugerido Activator.CreateInstance?

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

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

Otra forma es usar la reflexión:

protected T GetObject<T>(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<T>(Func<T> factory)
{  return factory(); }

y llámalo así:

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 de referencia abierto ImpromptuIntereface , usará el dlr para llamar al constructor, es significativamente más rápido que Activator cuando su constructor tiene argumentos, y mucho más lento cuando no lo tiene. Sin embargo, la principal ventaja es que manejará los constructores con parámetros opcionales de C # 4.0 correctamente, 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>()
    {
        T obj = default(T);
        obj =Activator.CreateInstance<T>();
        return obj ;
    }