Código de cómo instanciar una clase a partir del contenido de una cadena (C#)

Lo dicho el código completo para Visual Basic del ejemplo comentado en:

Crear un objeto a partir de una cadena con Activator.CreateInstance

(el enlace al de Visual Basic está en ese mismo artículo)

//-----------------------------------------------------------------------------
// Crear un objeto a partir de una cadena con Activator             (05/Ene/13)
//
//
// ©Guillermo 'guille' Som, 2013
//-----------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Text;

namespace ActivatorCS
{
    public sealed class CrearClase
    {

        public static void Main()
        {
            // La clase a crear
            var elNombre = "ActivatorCS.Colega";

            crearColega(elNombre);


            // Esta clase se llama igual,
            // pero no es del mismo tipo
            // y no pasaría la prueba de IsAssignableFrom,
            // aunque no daría error al hacer la conversión
            // pero no crearía una instancia,
            // por tanto Activator devolvería nulo,
            // en realidad el valor nulo lo devuelve
            // la operación de conversión de tipos
            // por eso en C# utilizo "as Colega" en lugar de "(Colega)"
            // para hacer la conversión
            elNombre = "OtroEspacio.Colega";
            crearColega(elNombre);

            // esta clase se basa en la que queremos crear
            // aunque esté en otro espacio de nombres
            elNombre = "OtroEspacio.Coleguilla";
            crearColega(elNombre);

            // este tipo no existe,
            // pero debemos usar IsAssignableFrom
            // para no provocar una excepción
            elNombre = "Activator.Colega";
            crearColega(elNombre);

            // esta se basa en la nuestra
            // pero es abstracta (no tiene constructor)
            // ya dará un error al crearla
            // aunque pasaría la prueba de IsAssignableFrom
            try
            {
                elNombre = "ActivatorCS.ColegaAbstracto";
                crearColega(elNombre);

            }
            catch (Exception ex)
            {
                Console.WriteLine("Mrw! (o Ups!) esta clase {0} da error: {1}",
                                  elNombre, ex.Message);

            }

            Console.ReadKey();

        }

        private static void crearColega(string laClase)
        {
            Type elTipo = Type.GetType(laClase);

            // el equivalente en c# de TryCast es hacer el cast con "as tipo"
            // aunque también se puede comprobar si se puede crear el objeto

            // Esto contralará las clases que no se basan en Colega
            if (!typeof(Colega).IsAssignableFrom(elTipo))
            {
                Console.WriteLine("El tipo: {0} no es del tipo adecuado.\n", 
                                  laClase);
                return;
            }

            Colega obj = Activator.CreateInstance(elTipo) as Colega;

            if (obj != null)
            {
                obj.Nombre = "Pepe";
                obj.Email = "pepe@outlook.com";

                Console.WriteLine("Objeto creado correctamente: {0}{1}{2}, {3}",
                                  obj.GetType().Name, "\r\n",
                                  obj.Nombre, obj.Email);
            }
            else
            {
                Console.WriteLine("Parece que el tipo: {0} no es del tipo adecuado.", 
                                  laClase);
            }

            Console.WriteLine();
        }

        void pruebaDirecta()
        {
            var laClase = "ActivatorCS.Colega";

            Type elTipo = Type.GetType(laClase);

            Colega obj = Activator.CreateInstance(elTipo) as Colega;

            if (obj != null)
            {
                obj.Nombre = "Pepe";
                obj.Email = "pepe@outlook.com";
            }

        }

        static void Main2()
        {
            var laClase = "ActivatorVB.unColega";

            Type elTipo = Type.GetType(laClase);

            IColega obj = ((IColega)Activator.CreateInstance(elTipo));

            if (obj != null)
            {
                obj.Nombre = "Pepe";
            }
        }  

    }

    public interface IColega
    {
        string Nombre { get; set; }
    }

    public class unColega : IColega
    {
        public string Nombre { get; set; }
    }


    public class Colega
    {
        public string Nombre { get; set; }
        public string Email { get; set; }
    }

    // Clase no instanciable
    public abstract class ColegaAbstracto : Colega
    {
        public int Edad { get; set; }
    }

}

namespace OtroEspacio
{

    public class Colega
    {
        public string Nombre { get; set; }
        public int Edad { get; set; }
    }

    public class Coleguilla : ActivatorCS.Colega
    {
        public int Edad { get; set; }
    }

    // las clase selladas (sealed / NotInheritable)
    // se pueden usar, pero siempre deben tener
    // un constructor público sin parámetros
    public sealed class Coleguilla2 : ActivatorCS.Colega
    {

        //protected Coleguilla2()
        //{ 
        //}

        //private Coleguilla2()
        //{
        //}

        public int Edad { get; set; }
    }

}

Nos vemos.

Guillermo