Usando el nuevo tipo dynamic en C# 4.0

Una de las nuevas funcionalidades de la nueva version de C# 4.0 que viene con el framework 4.0 son los tipos “dinamicos” los cuales se declaran usando la palabra “dynamic”.

La palabra “dynamic” tiene una funcionalidad muy similar a la palabra “var”, que se incluyo a apartir de C# 3.0, ya que el tipo de la variable es inferido al momento de compilar el programa, la diferencia y gran ventaja de la palabra dynamic es que la resolucion de los metodos de cualquier variable declarada como dynamic se realiza en el momento de ejecucion, no en momento de compilacion. Por ejemplo:

Digamos que yo estoy tratando de llamar un metodo que no existe de mi clase string:

var persona=new Persona(); 
persona.Suicidarse(); //este metodo no existe, tira error al momento de compilar

El codigo anterior no compila. Ahora usando la palabra dynamic:

dynamic persona=new Persona(); 
persona.Suicidarse();

Esto si compila, sin embargo tira un error al momento en el que se ejecuta el codigo.

Ventajas

Para que nos puede servir la palabra dynamic? bueno pues la razon principal de su inclusion en este framework es gracias al DLR(Dynamic Language Runtime), el DLR es lo que nos permite ejecutar scripts de lenguajes interpretado en .NET como python y ruby, como ya sabran estos lenguajes son de tipado dinamico entonces para poder interactuar con objetos de estos dos lenguajes de script era necesario tener la palabra dynamic.

Aparte de esto, con la palabra dynamic nos evitamos tener que usar reflection en algunos casos. Por ejemplo, si estamos usando variable de tipo object, tenemos que usar reflection para acceder a sus metodos o propiedades, ahora solo podemos usar la palabra dynamic y llamamos a los metodos sin recibir errores al compilar porque el metodo no existe.

Aplicacion de ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

namespace Demostraciones.Dynamic
{
    class Program
    {
        static void Main(string[] args)
        {
            ParametroDinamico(new { Nombre="Roberto", Apellido="Yudice" });
            ParametroNoDinamico(new { Nombre="Roberto", Apellido="Yudice" });
        }
 
        static void ParametroDinamico(dynamic parametro)
        {
            Console.WriteLine("Ejecutando metodo dinamico");
            Console.WriteLine(parametro.Nombre);
            Console.WriteLine(parametro.Apellido);
        }
 
        static void ParametroNoDinamico(object parametro)
        {
            Console.WriteLine("Ejecutando metodo con Reflection");
            var propertyInfo = parametro.GetType().GetProperty("Nombre");
            var value = propertyInfo.GetValue(parametro,null);
            Console.WriteLine(value.ToString());
            propertyInfo = parametro.GetType().GetProperty("Apellido");
            value = propertyInfo.GetValue(parametro,null);
            Console.WriteLine(value.ToString());
        }
    }
}

Como podran ver me ahorro una buena parte de codigo usando la palabra dynamic.

Related posts:

1. Usando Reflection en C#
2. Funcion para palindromo en .NET y C#
3. Introduccion a las clases parciales en .NET (c#)
4. Funcion fibonacci con recursion

Tagged as: .net 4, C#