Method that returns a class

Question

I am trying to create a method that takes a string and returns an instance of the class with the name passed, example: "Calculator", will return me an instance of the class "Calculator" (If it exists), I have a problem at the time of setting which type it returns, 'Cause from what I’ve researched, I need to get the guy to the method, too. I tried to: Type Tipo = Type.GetType("NomeDaClasse"); and then passing var x = RetornaClasse<Tipo>("Calculadora"); but without success. (I can’t even set the method to try to use.

static T RetornaClasse<T>(string nome) where T : class
{
    return (T)Assembly.GetExecutingAssembly().CreateInstance(nome);
}

Use: the return of this method will be parameter for this Generic Class:

public class Generico<T> where T : class
{
    public T Objeto { get; set; }

    public string ListarAtributos()
    {
        var p = Objeto.GetType().GetProperties();
        string atributos = String.Empty;

        foreach (PropertyInfo pop in p) // Lista de atributos
            atributos += (String.Concat("[", pop.Name, "] = [", pop.GetValue(Objeto, null), "]\n"));

        return atributos;
    }

    public string[] ListarMetodos()
    {
        var m = Objeto.GetType().GetMethods();
        string[] metodos = new string[m.Length];

        for (int i = 0; i < m.Length; i++)
            metodos[i] = String.Concat(i, " [+] ", m[i].Name, "\n");
        return metodos;
    }

    // TODO: Setar atributos, usar métodos
}

Solution:

static object RetornaClasse(string nome)
{
    var classe = Assembly.GetExecutingAssembly().GetTypes().First(x => x.Name == nome);
    var instancia = Activator.CreateInstance(classe);
    return instancia;
}

Answer 1

If the type is in the same Assembly that is running, you can do so:

var t = Assembly.GetExecutingAssembly().GetTypes().First(x => x.Name == "Calculadora");

And then use the type to create a new instance:

var objectOfType = Activator.CreateInstance(t);

Example of a fully functional program, using generic argument, and LINQ to make it a little easier:

public class Program
{
    public static void Main(string[] args)
    {
        var computador = GetInstanciaDoTipo<Computador>("Calculadora");

        var usarReflexao = new UsandoReflexaoParaAcessarObjeto();
        usarReflexao.Objeto = computador;
        var resultado1 = usarReflexao.TentarSomar();
        var resultado2 = usarReflexao.SomarUsandoDynamic();
        var resultado3 = computador.Somar(1, 2);
    }

    private static T GetInstanciaDoTipo<T>(string nomeTipo)
    {
        return
            (T)Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => t.Name == nomeTipo)
                .Where(t => typeof(T).IsAssignableFrom(t))
                .Select(Activator.CreateInstance)
                .First();
    }

    abstract class Computador
    {
        public abstract int Somar(int a, int b);
    }

    class Calculadora : Computador
    {
        public override int Somar(int a, int b)
        {
            return a + b;
        }
    }

    /// <summary>
    /// Esta classe usa reflexão para acessar o objeto, seja lá qual o tipo dele.
    /// Também há um método usando dynamic, para exemplificar como é mais fácil usar dynamic do que reflection,
    /// quando queremos executar algo dinamicamente.
    /// </summary>
    public class UsandoReflexaoParaAcessarObjeto
    {
        public object Objeto { get; set; }

        public int? TentarSomar()
        {
            if (this.Objeto != null)
            {
                var type = this.Objeto.GetType();
                var methodInfo = type.GetMethod("Somar");
                var result = methodInfo.Invoke(this.Objeto, new object[] { 1, 2 });
                return (int)result;
            }

            return null;
        }

        public int? SomarUsandoDynamic()
        {
            if (this.Objeto != null)
            {
                dynamic dyn = this.Objeto;
                return dyn.Somar(1, 2);
            }

            return null;
        }
    }
}