SHARE
TWEET

Crear un objeto a partir de una cadena

elGuille Jan 4th, 2013 221 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //-----------------------------------------------------------------------------
  2. // Crear un objeto a partir de una cadena con Activator             (05/Ene/13)
  3. //
  4. // El artículo explicativo está en:
  5. // http://www.elguillemola.com/index.php/2013/01/crear-un-objeto-a-partir-de-una-cadena-con-activator-createinstance/
  6. //
  7. // ©Guillermo 'guille' Som, 2013
  8. //-----------------------------------------------------------------------------
  9.  
  10. using System;
  11. using System.Collections.Generic;
  12. using System.Text;
  13.  
  14. namespace ActivatorCS
  15. {
  16.     public sealed class CrearClase
  17.     {
  18.  
  19.         public static void Main()
  20.         {
  21.             // La clase a crear
  22.             var elNombre = "ActivatorCS.Colega";
  23.  
  24.             crearColega(elNombre);
  25.  
  26.  
  27.             // Esta clase se llama igual,
  28.             // pero no es del mismo tipo
  29.             // y no pasaría la prueba de IsAssignableFrom,
  30.             // aunque no daría error al hacer la conversión
  31.             // pero no crearía una instancia,
  32.             // por tanto Activator devolvería nulo,
  33.             // en realidad el valor nulo lo devuelve
  34.             // la operación de conversión de tipos
  35.             // por eso en C# utilizo "as Colega" en lugar de "(Colega)"
  36.             // para hacer la conversión
  37.             elNombre = "OtroEspacio.Colega";
  38.             crearColega(elNombre);
  39.  
  40.             // esta clase se basa en la que queremos crear
  41.             // aunque esté en otro espacio de nombres
  42.             elNombre = "OtroEspacio.Coleguilla";
  43.             crearColega(elNombre);
  44.  
  45.             // este tipo no existe,
  46.             // pero debemos usar IsAssignableFrom
  47.             // para no provocar una excepción
  48.             elNombre = "Activator.Colega";
  49.             crearColega(elNombre);
  50.  
  51.             // esta se basa en la nuestra
  52.             // pero es abstracta (no tiene constructor)
  53.             // ya dará un error al crearla
  54.             // aunque pasaría la prueba de IsAssignableFrom
  55.             try
  56.             {
  57.                 elNombre = "ActivatorCS.ColegaAbstracto";
  58.                 crearColega(elNombre);
  59.  
  60.             }
  61.             catch (Exception ex)
  62.             {
  63.                 Console.WriteLine("Mrw! (o Ups!) esta clase {0} da error: {1}",
  64.                                   elNombre, ex.Message);
  65.  
  66.             }
  67.  
  68.             Console.ReadKey();
  69.  
  70.         }
  71.  
  72.         private static void crearColega(string laClase)
  73.         {
  74.             Type elTipo = Type.GetType(laClase);
  75.  
  76.             // el equivalente en c# de TryCast es hacer el cast con "as tipo"
  77.             // aunque también se puede comprobar si se puede crear el objeto
  78.  
  79.             // Esto contralará las clases que no se basan en Colega
  80.             if (!typeof(Colega).IsAssignableFrom(elTipo))
  81.             {
  82.                 Console.WriteLine("El tipo: {0} no es del tipo adecuado.\n",
  83.                                   laClase);
  84.                 return;
  85.             }
  86.  
  87.             Colega obj = Activator.CreateInstance(elTipo) as Colega;
  88.  
  89.             if (obj != null)
  90.             {
  91.                 obj.Nombre = "Pepe";
  92.                 obj.Email = "pepe@outlook.com";
  93.  
  94.                 Console.WriteLine("Objeto creado correctamente: {0}{1}{2}, {3}",
  95.                                   obj.GetType().Name, "\r\n",
  96.                                   obj.Nombre, obj.Email);
  97.             }
  98.             else
  99.             {
  100.                 Console.WriteLine("Parece que el tipo: {0} no es del tipo adecuado.",
  101.                                   laClase);
  102.             }
  103.  
  104.             Console.WriteLine();
  105.         }
  106.  
  107.         void pruebaDirecta()
  108.         {
  109.             var laClase = "ActivatorCS.Colega";
  110.  
  111.             Type elTipo = Type.GetType(laClase);
  112.  
  113.             Colega obj = Activator.CreateInstance(elTipo) as Colega;
  114.  
  115.             if (obj != null)
  116.             {
  117.                 obj.Nombre = "Pepe";
  118.                 obj.Email = "pepe@outlook.com";
  119.             }
  120.  
  121.         }
  122.  
  123.         static void Main2()
  124.         {
  125.             var laClase = "ActivatorVB.unColega";
  126.  
  127.             Type elTipo = Type.GetType(laClase);
  128.  
  129.             IColega obj = ((IColega)Activator.CreateInstance(elTipo));
  130.  
  131.             if (obj != null)
  132.             {
  133.                 obj.Nombre = "Pepe";
  134.             }
  135.         }  
  136.  
  137.     }
  138.  
  139.     public interface IColega
  140.     {
  141.         string Nombre { get; set; }
  142.     }
  143.  
  144.     public class unColega : IColega
  145.     {
  146.         public string Nombre { get; set; }
  147.     }
  148.  
  149.  
  150.     public class Colega
  151.     {
  152.         public string Nombre { get; set; }
  153.         public string Email { get; set; }
  154.     }
  155.  
  156.     // Clase no instanciable
  157.     public abstract class ColegaAbstracto : Colega
  158.     {
  159.         public int Edad { get; set; }
  160.     }
  161.  
  162. }
  163.  
  164. namespace OtroEspacio
  165. {
  166.  
  167.     public class Colega
  168.     {
  169.         public string Nombre { get; set; }
  170.         public int Edad { get; set; }
  171.     }
  172.  
  173.     public class Coleguilla : ActivatorCS.Colega
  174.     {
  175.         public int Edad { get; set; }
  176.     }
  177.  
  178.     // las clase selladas (sealed / NotInheritable)
  179.     // se pueden usar, pero siempre deben tener
  180.     // un constructor público sin parámetros
  181.     public sealed class Coleguilla2 : ActivatorCS.Colega
  182.     {
  183.  
  184.         //protected Coleguilla2()
  185.         //{
  186.         //}
  187.  
  188.         //private Coleguilla2()
  189.         //{
  190.         //}
  191.  
  192.         public int Edad { get; set; }
  193.     }
  194.  
  195. }
RAW Paste Data
Top