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

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

  C#

  class ExampleClass
  {
      // A dynamic field.
      static dynamic field;
  
      // A dynamic property.
      dynamic prop { get; set; }
  
      // A dynamic return type and a dynamic paramater 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 conversions, as the target type of a conversion.

  C#

  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 types serve as values, such as on the right side of an is operator or an as operator, or as the argument to typeof as part of a constructed type. For example, dynamic can be used in the following expressions.

  C#

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

The following example uses dynamic in several declarations. The Main method also contrasts compile-time type checking with run-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

For more information and examples, see Using Type dynamic (C# Programming Guide).

Tasks

Reference

Other Resources