C # Neues T erstellen ()

Sie können sehen, was ich mit dem folgenden Code versuche (aber nicht schaffe):

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

Jede Hilfe wäre sehr dankbar.

BEARBEITEN:

Der Kontext war wie folgt. Ich habe mit einer benutzerdefinierten Controller-Klasse herumgespielt, von der alle Controller mit standardisierten Methoden abgeleitet werden können. Im Kontext musste ich also eine neue Instanz des Objekts vom Controllertyp erstellen. Zum Zeitpunkt des Schreibens war es so etwas wie:

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

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

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

        return View(obj);
    }

Und so entschied ich, dass Reflexion hier am einfachsten ist. Ich bin damit einverstanden, dass angesichts der ursprünglichen Aussage der Frage die am besten geeignete Antwort, um sie als richtig zu markieren, diejenige war, die die neue () - Einschränkung verwendet. Ich habe das behoben.

Schauen Sie sich die neue Einschränkung an

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

Tkönnte eine Klasse sein, die keinen Standardkonstruktor hat: In diesem Fall new T()wäre dies eine ungültige Anweisung. Die new()Einschränkung besagt, Tdass ein Standardkonstruktor vorhanden sein muss, der new T()legal ist.

Sie können dieselbe Einschränkung auf eine generische Methode anwenden:

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

Wenn Sie Parameter übergeben müssen:

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

Warum hat niemand vorgeschlagen Activator.CreateInstance?

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

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

Eine andere Möglichkeit ist die Verwendung von Reflexion:

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

Nur zur Vervollständigung besteht die beste Lösung häufig darin, ein Factory-Funktionsargument zu benötigen:

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

und nenne es so etwas:

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

Sie können dies verwenden, um verfügbare Parameter bei Bedarf zu benötigen oder zu nutzen.

Die neue Einschränkung ist in Ordnung, aber wenn Sie T auch als Werttyp benötigen, verwenden Sie Folgendes:

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

Da dies mit C # 4 gekennzeichnet ist, wird mit dem Open-Sourece-Framework ImpromptuIntereface der Konstruktor mithilfe der DLR aufgerufen. Es ist erheblich schneller als Activator, wenn Ihr Konstruktor Argumente hat, und vernachlässigbar langsamer, wenn dies nicht der Fall ist. Der Hauptvorteil besteht jedoch darin, dass Konstruktoren mit optionalen C # 4.0-Parametern korrekt behandelt werden, was Activator nicht kann.

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

Um dies zu bekommen, habe ich folgenden Code versucht:

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