C # Criar novo T ()

Você pode ver o que estou tentando (mas falhando) com o seguinte código:

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

Qualquer ajuda seria muito apreciada.

EDITAR:

O contexto foi o seguinte. Eu estava brincando com uma classe de controlador personalizada para a qual todos os controladores derivam, com métodos padronizados. Portanto, no contexto, eu precisava criar uma nova instância do objeto do tipo de controlador. Então, no momento da escrita, era algo como:

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

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

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

        return View(obj);
    }

E então eu decidi que a reflexão era mais fácil aqui. Concordo que, certamente, dada a afirmação inicial da pergunta, a resposta mais apropriada para marcar como correta foi a que estava usando a nova restrição (). Eu consertei isso.

Dê uma olhada no novo Constraint

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

Tpoderia ser uma classe que não possui um construtor padrão: nesse caso, new T()seria uma instrução inválida. A new()restrição diz que Tdeve ter um construtor padrão, o que torna new T()legal.

Você pode aplicar a mesma restrição a um método genérico:

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

Se você precisar passar parâmetros:

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

Por que ninguém sugeriu Activator.CreateInstance?

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

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

Outra maneira é usar a reflexão:

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

Apenas para conclusão, a melhor solução aqui é geralmente exigir um argumento de função de fábrica:

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

e chame de algo assim:

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

Você pode usar isso para exigir ou usar os parâmetros disponíveis, se necessário.

A nova restrição é boa, mas se você também precisar de um tipo de valor T, use este:

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

Como esse código está marcado como C # 4. Com a estrutura de código-fonte aberto ImpromptuIntereface, ele usará o dlr para chamar o construtor. É significativamente mais rápido que o Activator quando o construtor tem argumentos, e notavelmente mais lento quando não. No entanto, a principal vantagem é que ele manipulará os construtores com parâmetros opcionais do C # 4.0 corretamente, algo que o Activator não fará.

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

Para obter isso, tentei o seguinte código:

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