dynamic (C# reference)

For the latest documentation for Visual Studio 2017 RC, see Visual Studio 2017 RC Documentation.

In operations implemented through the dynamic type, the role of this type is to bypass compile-time type checking and instead resolve these operations at runtime. The dynamic type simplifies access to COM APIs (such as the Office Automation API), dynamic APIs (such as the IronPython library), and the HTML Document Object Model (DOM).

In most cases, dynamic types behave the same as object types. However, operations containing expressions of type dynamic are not parsed or type-checked by the compiler. The compiler packages together information about this operation, and this information is later used to calculate the runtime operation. During this process, variables of type dynamic are compiled into variables of type object . Therefore, the type dynamic only exists at compile time and not at runtime.

The following example compares a variable of type dynamic with a variable of type object. To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statement. IntelliSense shows the "dynamic" of dyn and the "object" of 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());
        }
    }

WriteLine statement displays the runtime type of dyn and obj . At this point, both have the same integer type. The following output will be generated:

System.Int32

System.Int32

To see the difference between dyn and obj , add the following two lines between the declaration and the WriteLine statement in the previous example.

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

Report compiler errors for attempts to add integers and objects in the expression obj + 3 . However, dyn + 3 errors are not reported. Expressions containing dyn are not checked at compile time because dyn is of type dynamic.

Context

dynamic keyword can appear directly or as a component of a constructed type in the following situations:

In a declaration, as a property, field, indexer, parameter, return value, or type constraint type. The following class definition uses dynamic in several different declarations.

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;
            }
        }
    }

In explicit type conversion, as the target type of the conversion.

 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

In any context where a type serves as a value (such as the is operator or the right-hand side of the as operator) or is part of a constructed type as an argument to typeof . For example, you can use dynamic in the following expressions.

        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));

Example

The following example uses dynamic with multiple declarations. Main also uses runtime type checking versus compile time type checking.

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