El tipo dinámico

En C# versión 4.0, Microsoft introdujo un nuevo tipo: el dinámico. En realidad, es un tipo estático, pero a diferencia de otros tipos estáticos, el compilador no verifica los miembros (potenciales) de un objeto dinámico. Esto le dará algunas de las ventajas de los lenguajes de tipo dinámico / débil, mientras mantiene las ventajas de un lenguaje fuertemente tipado en todos los demás casos.

Declarar uno dinámico es como declarar cualquier otro tipo: simplemente use la palabra clave dynamic en lugar del tipo de datos:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;

Ahora tiene tres objetos diferentes: el primero realmente no es nada hasta este punto (null), mientras que el segundo es una cadena (string) y el tercero un número entero(integer). El intérprete lo decidirá automáticamente en tiempo de ejecución, en función de lo que asigne a las variables. Eso también significa que el compilador no verificará lo que haces con estas variables, como se ilustra en el siguiente ejemplo:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;
Console.WriteLine(d2.Length);
Console.WriteLine(d3.Length);

Las cadenas tienen una propiedad de longitud, para decidir qué tan larga es la cadena, pero un número entero no. En este caso, trato de usar esta propiedad en ambas variables, y el compilador no se quejará; si estas variables se hubieran declarado como una cadena y un entero, el compilador las habría interceptado. Pero como los tipos son dinámicos, solo se compila y se ejecuta. Sin embargo, tan pronto como el intérprete llegue a la última línea, una excepción sera arrojada, porque obviamente no puedes acceder a una propiedad que no existe.

Esto también muestra el peligro de los tipos dinámicos: debe ser consciente de lo que está haciendo y asegurarse de escribir correctamente todas las propiedades y llamadas a métodos, ya que el compilador no volverá a verificar tu trabajo, básicamente le permitirá publicar código que falla en todo momento.

Un objeto dinámico

La palabra clave dinámica puede, por supuesto, usarse para tipos más complejos que enteros y cadenas. Un gran ejemplo de esto es cuando se usa para contener un objeto anónimo, como este:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.Name + " is " + user.Age + " years old");

Esto le permite crear un objeto sin definir primero una clase para él. La palabra clave dynamic se puede utilizar para contenerla, pero también la palabra clave var , que podría ser más adecuada en muchas situaciones.

Puede pensar que, desde que el tipo es dinámico, puedes agregarle propiedades más adelante, de esta manera:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
user.HomeTown = "New York";

Como no se realiza ninguna comprobación en tiempo de compilación en un tipo dinámico, este código realmente se ejecuta, porque el compilador no valida la existencia de la propiedad HomeTown, pero tan pronto como se alcanza la última línea, te lanzará una excepción. Mientras un tipo dinámico ES muy dinámico, no le permite agregar dinámicamente nuevas propiedades. Para eso, puede usar un ExpandoObject, que discutiremos en el próximo artículo.

Cambiando tipo

Una variable declarada como dinámica no tiene ningún tipo. Hasta que, C# lo tratara internamente como cualquier tipo de objeto que le haya asignado. En nuestro primer ejemplo, verá cómo podemos declarar una variable como dinámica, asignarle una cadena o un entero y luego comenzar a usar propiedades que pertenezcan a estos tipos. Sin embargo, puede cambiar fácilmente el tipo de una variable dinámica, simplemente asígnele un nuevo valor. Aquí hay un ejemplo:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.GetType() + ": " + user.Name + " is " + user.Age + " years old");
user = "Jane Doe";
Console.WriteLine(user.GetType() + ": String.Length = " + user.Length);

Observe cómo usamos la variable dinámica user: primero contiene un objeto anónimo y luego le asignamos una cadena simple. Lo validamos usando el método GetType () que se encuentra en todos los objetos de C#, y en ambos casos, accedemos a las propiedades que se encuentran en el tipo que tenemos actualmente (Nombre / Edad) propiedades del objeto anónimo, luego la propiedad longitud que se encuentra en los objetos de cadena.

Resumen

La palabra clave dynamic le permite usar variables que no tienen un tipo específico; en cambio, actúan como el tipo de datos que contienen. Puede asignar fácilmente un nuevo valor a una variable dinámica, y si el tipo de valor que está asignando no es el mismo que tiene actualmente, la variable dinámica simplemente cambiará el tipo automáticamente.

El compilador no verifica las variables dinámicas, permitiéndote acceder a propiedades que pueden o no estar presentes. Esto las hace muy flexibles, pero también hace que tus aplicaciones sean mucho más vulnerables a los errores. Especialmente por esta razón, es posible que desee restringir el uso de la palabra clave dynamic a situaciones en las que no puede lograr lo que desea sin usarlo. Ejemplos de cuándo tiene sentido usar la palabra clave dynamic son para COM interop y al interactuar con formatos de datos como JSON y XML.