C # Utwórz nowe T ()

Możesz zobaczyć, co próbuję (ale bezskutecznie) zrobić z następującym kodem:

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

Każda pomoc byłaby bardzo mile widziana.

EDYTOWAĆ:

Kontekst był następujący. Bawiłem się niestandardową klasą kontrolera, z której miały pochodzić wszystkie kontrolery, przy użyciu standardowych metod. W kontekście musiałem więc stworzyć nową instancję obiektu typu kontroler. Więc w czasie pisania było to coś takiego:

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

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

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

        return View(obj);
    }

Postanowiłem więc, że tu najłatwiej będzie nam zadbać o refleksję. Zgadzam się, że z pewnością biorąc pod uwagę początkowe stwierdzenie pytania, najwłaściwszą odpowiedzią do oznaczenia jako poprawną była ta, w której zastosowano nowe () ograniczenie. Naprawiłem to.

Spójrz na nowe ograniczenie

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

Tmogłaby być klasą, która nie ma domyślnego konstruktora: w tym przypadku new T()byłaby to nieprawidłowa instrukcja. new()Ograniczenie mówi, że Tmusi mieć konstruktora domyślnego, co czyni new T()prawa.

Możesz zastosować to samo ograniczenie do metody ogólnej:

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

Jeśli potrzebujesz przekazać parametry:

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

Dlaczego nikt nie zasugerował Activator.CreateInstance?

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

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

Innym sposobem jest użycie refleksji:

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

Aby zakończyć, najlepszym rozwiązaniem jest często wymaganie argumentu funkcji fabrycznej:

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

i nazwij to mniej więcej tak:

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

W razie potrzeby można tego użyć, aby wymagać lub skorzystać z dostępnych parametrów.

Nowy ograniczeniem jest w porządku, ale jeśli trzeba T jest typ wartości też użyć tego:

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

Ponieważ jest oznaczony jako C # 4. Z otwartym środowiskiem źródłowym ImpromptuIntereface użyje dlr do wywołania konstruktora, jest to znacznie szybsze niż Activator, gdy konstruktor ma argumenty, i pomijalnie wolniejsze, gdy ich nie ma. Jednak główną zaletą jest to, że poprawnie obsłuży konstruktory z opcjonalnymi parametrami C # 4.0, czego nie zrobi Activator.

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

Aby to uzyskać, wypróbowałem następujący kod:

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