C # Créer un nouveau T ()

Vous pouvez voir ce que j'essaye (mais échoue) de faire avec le code suivant:

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

Toute aide serait grandement appréciée.

ÉDITER:

Le contexte était le suivant. Je jouais avec une classe de contrôleur personnalisée pour tous les contrôleurs à dériver, avec des méthodes standardisées. Donc, en contexte, j'avais besoin de créer une nouvelle instance de l'objet du type contrôleur. Donc, au moment de la rédaction de cet article, c'était quelque chose comme:

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

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

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

        return View(obj);
    }

Et j'ai donc décidé que la réflexion était la plus facile ici. Je conviens que, compte tenu de l'énoncé initial de la question, la réponse la plus appropriée pour marquer comme correcte était celle utilisant la contrainte new (). J'ai arrangé ça.

Jetez un œil à la nouvelle contrainte

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

Tpourrait être une classe qui n'a pas de constructeur par défaut: dans ce cas new T()serait une instruction invalide. La new()contrainte dit que Tdoit avoir un constructeur par défaut, ce qui rend new T()légal.

Vous pouvez appliquer la même contrainte à une méthode générique:

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

Si vous devez passer des paramètres:

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

Pourquoi personne n'a suggéré Activator.CreateInstance?

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

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

Une autre façon est d'utiliser la réflexion:

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

Juste pour compléter, la meilleure solution ici est souvent d'exiger un argument de fonction d'usine:

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

et appelez-le quelque chose comme ceci:

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

Vous pouvez l'utiliser pour exiger ou utiliser les paramètres disponibles, si nécessaire.

La nouvelle contrainte est correcte, mais si vous avez besoin que T soit également un type valeur, utilisez ceci:

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

Puisqu'il est étiqueté C # 4. Avec le framework open source ImpromptuIntereface, il utilisera le dlr pour appeler le constructeur, il est significativement plus rapide que Activator lorsque votre constructeur a des arguments, et négligeable quand il ne le fait pas. Cependant, le principal avantage est qu'il gérera correctement les constructeurs avec des paramètres optionnels C # 4.0, ce qu'Activator ne fera pas.

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

Pour obtenir cela, j'ai essayé le code suivant:

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