dynamic (Referencia de C#)

Artículo
06/10/2015

El tipo dynamic permite que las operaciones en las que se produce omitan la comprobación de tipo en tiempo de compilación. En su lugar, se resuelven estas operaciones en tiempo de ejecución. El tipo dynamic simplifica el acceso a API de COM tales como las API de automatización de Office y también a API dinámicas como las bibliotecas de IronPython, y al Modelo de objetos documentos (DOM) HTML.

El tipo dynamic se comporta como el tipo object en la mayoría de las circunstancias. Sin embargo, el compilador no resuelve o no comprueba el tipo de las operaciones que contienen expresiones de tipo dynamic. El compilador empaqueta información sobre la operación y esa información se utiliza después para evaluar la operación en tiempo de ejecución. Como parte del proceso, las variables de tipo dynamic están compiladas en las variables de tipo object. Por consiguiente, el tipo dynamic sólo existe en tiempo de compilación, no en tiempo de ejecución.

El siguiente ejemplo contrasta una variable de tipo dynamic con una variable de tipo object. Para comprobar el tipo de cada variable en tiempo de compilación, coloque el puntero del mouse sobre dyn u obj en las instrucciones WriteLine. IntelliSense muestra dynamic para dyn y object para obj.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their 
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

Las instrucciones WriteLine muestran los tipos en tiempo de ejecución de dyn y obj. En ese punto, ambos tiene el mismo tipo, entero. Se produce el siguiente resultado:

System.Int32

Para ver la diferencia entre dyn y obj en tiempo de compilación, agregue las dos líneas siguientes entre las declaraciones y las instrucciones WriteLine en el ejemplo anterior.

dyn = dyn + 3;
obj = obj + 3;

Un error del compilador se notifica para el intento de suma de un entero y un objeto en la expresión obj + 3. Sin embargo, no se notifica ningún error para dyn + 3. En tiempo de compilación no se comprueba la expresión que contiene dyn porque el tipo de dyn es dynamic.

Contexto

La palabra clave dynamic puede aparecer directamente o como un componente de un tipo construido en las siguientes situaciones:

En declaraciones, como el tipo de una propiedad, un campo, un indizador, un parámetro, un valor devuelto, una variable local o una restricción de tipo. La siguiente definición de clase utiliza dynamic en varias declaraciones diferentes.

class ExampleClass
{
    // A dynamic field. 
    static dynamic field;

    // A dynamic property.
    dynamic prop { get; set; }

    // A dynamic return type and a dynamic parameter type. 
    public dynamic exampleMethod(dynamic d)
    {
        // A dynamic local variable.
        dynamic local = "Local variable";
        int two = 2;

        if (d is int)
        {
            return local;
        }
        else
        {
            return two;
        }
    }
}

En conversiones de tipos explícitas, como tipo de destino de una conversión.

static void convertToDynamic()
{
    dynamic d;
    int i = 20;
    d = (dynamic)i;
    Console.WriteLine(d);

    string s = "Example string.";
    d = (dynamic)s;
    Console.WriteLine(d);

    DateTime dt = DateTime.Today;
    d = (dynamic)dt;
    Console.WriteLine(d);

}
// Results: 
// 20 
// Example string. 
// 2/17/2009 9:12:00 AM

En cualquier contexto donde los tipos actúen como valores, por ejemplo, en el lado derecho de un operador is o un operador as, o como argumento de typeof como parte de un tipo construido. Por ejemplo, se puede usar dynamic en las siguientes expresiones.

int i = 8;
dynamic d;
// With the is operator. 
// The dynamic type behaves like object. The following 
// expression returns true unless someVar has the value null. 
if (someVar is dynamic) { }

// With the as operator.
d = i as dynamic;

// With typeof, as part of a constructed type.
Console.WriteLine(typeof(List<dynamic>));

// The following statement causes a compiler error. 
//Console.WriteLine(typeof(dynamic));

Ejemplo

El ejemplo siguiente usa dynamic en varias declaraciones. El método Main también contrasta la comprobación de tipo en tiempo de compilación con la comprobación de tipo en tiempo de ejecución.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.exampleMethod(10));
            Console.WriteLine(ec.exampleMethod("value"));

            // The following line causes a compiler error because exampleMethod 
            // takes only one argument. 
            //Console.WriteLine(ec.exampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.exampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to exampleMethod 
            // with two arguments does not produce an error at compile time. 
            // However, itdoes cause a run-time error.  
            //Console.WriteLine(dynamic_ec.exampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic field;
        dynamic prop { get; set; }

        public dynamic exampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results: 
// Local variable 
// 2 
// Local variable

Para obtener más información y ejemplos, vea Uso de tipo dinámico (Guía de programación de C#).

Vea también

Share via

dynamic (Referencia de C#)

Contexto

Ejemplo

Vea también

Tareas

Referencia

Otros recursos

Recursos adicionales