C # Crea nuovo T ()

Puoi vedere cosa sto cercando (ma non riesco) di fare con il seguente codice:

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

Qualsiasi aiuto sarebbe molto apprezzato.

MODIFICARE:

Il contesto era il seguente. Stavo giocando con una classe di controller personalizzati da cui derivano tutti i controller, con metodi standardizzati. Quindi, nel contesto, dovevo creare una nuova istanza dell'oggetto del tipo di controller. Quindi al momento della scrittura, era qualcosa del tipo:

public class GenericController<T> : Controller
{
    ...

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

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

        return View(obj);
    }

E così ho deciso che la riflessione era più semplice qui. Concordo sul fatto che, certamente data la dichiarazione iniziale della domanda, la risposta più appropriata da contrassegnare come corretta era quella che utilizzava il vincolo new (). L'ho risolto.

Dai un'occhiata al nuovo Vincolo

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

Tpotrebbe essere una classe che non ha un costruttore predefinito: in questo caso new T()sarebbe un'istruzione non valida. Il new()vincolo dice che Tdeve avere un costruttore predefinito, che rende new T()legale.

È possibile applicare lo stesso vincolo a un metodo generico:

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

Se è necessario passare i parametri:

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

Perché nessuno ha suggerito Activator.CreateInstance?

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

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

Un altro modo è usare la riflessione:

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

Solo per il completamento, la soluzione migliore qui è spesso richiedere un argomento di funzione di fabbrica:

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

e chiamalo in questo modo:

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

Puoi usarlo per richiedere o utilizzare i parametri disponibili, se necessario.

Il nuovo vincolo va bene, ma se hai bisogno che anche T sia un tipo di valore, usa questo:

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

Dato che questo è etichettato C # 4. Con il framework open source ImpromptuIntereface utilizzerà il dlr per chiamare il costruttore, è significativamente più veloce di Activator quando il costruttore ha argomenti, e trascurabilmente più lento quando non lo è. Tuttavia, il vantaggio principale è che gestirà correttamente i costruttori con parametri opzionali C # 4.0, cosa che Activator non farà.

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

Per ottenere questo ho provato il seguente codice:

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