Dynamic Type in C#

Dynamic Type in C# with Examples

In this article, I am going to discuss Dynamic Type in C# with Examples. Please read our previous article where we discussed Reflection in C# with Examples. As part of C# 4.0, a new type was introduced called dynamic that avoids compile-time type checking. A dynamic type escapes type checking at compile-time; instead, it resolves type at run time.

Types of Programming Languages:

Before understanding dynamic keyword in C#, let us first understand the different types of programming languages that exist in the market. Broadly Programming Languages are categorized into two sections i.e. Dynamic Programming Language and Strongly Typed Programming Language (Static). For a better understanding, please have a look at the below image.

Types of Programming Languages

The Strongly Typed Programming Languages are those programming languages where data type checking actually happens at compile time and Dynamically Typed Programming Languages are those languages where data type checking happens at runtime. For example, if I declared an integer variable and if I try to store some string value in it, then I will get a compile time error as shown in the below image.

Dynamic Type in C# with Examples

As you can see in the above image, it is saying that you Cannot implicitly convert type ‘string’ to ‘int’ type. So, strongly typed programming languages are those languages where type checking happened during the compilation time.

But sometimes what happens is that you don’t know the object data type until the application runs. That means at the time of compilation, you don’t know the data type. In other words, you confirm the object data type during the runtime only. So, in that scenario, what you need to do is, you need to bypass this compile time type checking logic and during runtime, you would like to go and invoke the methods and properties of the object.

But as a developer, you need to take the advantage of both approaches. Because type checking is a good thing, it minimizes the defects of your application, it allows you to choose the right data type for your application, etc.

So, yes, during compilation time, you need to bypass the type checking. But once the type is confirmed during runtime, you need to ensure that type checking is happening. In other words, you would have something like dynamically statically typed benefits. And that is what dynamic keyword gives you C# programming language. It will bypass the compile-time type checking. But once the data type is confirmed during runtime, then it will ensure that type checking is happening at runtime.

For example, if you want to declare a variable dynamically, you need to use the dynamic keyword. Here, you can see in the below image, I have created a simple object called str using the dynamic keyword. Now, you can see when we type str.(dot) it is not showing any intelligence. This thing will resolve during runtime using the concept called Reflection. So, during runtime, it will figure out exactly the data type of this str object.

Strongly Typed Programming Languages

This is good. During compile time it will not do any kind of checking. But during runtime, once it figures out the data type, it will do the type checking. For example, you can see in the below code. On a string value, we are trying to perform a mathematical operation i.e. increment.

Strongly Typed Programming Languages

You can see that here we are not getting any compile time error. So, if you build the application, you will not get any error, Build will be successful. This is because, during compile time, it is not doing any kind of checking. But during runtime, we need to ensure that this str++ operation should not work. It should be throw exception. For a better understanding, please have a look at the below example. Here, first, we are declaring one object using the dynamic keyword. Then we are using the GetType method to get the type of the str variable and then we are performing an increment mathematical operation on the str object. The GetType method will return the type of object.

using System;
namespace DynamicVSReflectionDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic str = "Hello";
            Console.WriteLine(str.GetType());
            str++;
        }
    }
}
Output:

First, it will print the type of the str on the console window as follows.

Dynamic Type in C#

And then immediately it will throw the following exception when the str++ statement is executed.

Dynamic Type in C#

As you can see in the above image, it is clearly saying that ‘Operator ‘++’ cannot be applied to operand of type ‘string”. This is because during runtime, now it becomes strongly type. Please understand that during compile time, it will bypass the logic for type checking i.e. it will not check whether the increment operation is allowed or not on the str object. But runtime, it figures out the data type is a string and now if I go and invoke the mathematical increment operation on it, it should an exception, and that is what you can see in the above image.

So, with dynamic in C#, at compile time, we are bypassing the type checking logic. But at runtime, we preserved the type-checking logic. Dynamic keyword uses Reflection internally. Now, I hope you understand the need and use of Dynamic Keyword in C#. Let us proceed and explore the dynamic keyword in more detail.

Dynamic Type in C#:

In C# we have several built-in data types such as string, int, bool, double, DateTime, etc. All these are static data types, meaning type checking and type safety are enforced at compile time. For a better understanding, please have a look at the below example.

In the below example, first, we have declared and initialized an integer variable called i with the value 50. Then we created a long variable called l and initialize it with the value of int variable i. The following code will compile fine and runs without any issues. This is because int data type can be converted to a long data type without any data loss. Why because the long data type has a bigger range than the int data type. The C# compiler CSC allows this implicit type conversion. Then we simply print the i and l value on the console.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 50;
            long l = i;
            Console.WriteLine($"int i = {i} & long l = {l}");
            Console.ReadKey();
        }
    }
}

Output: int i = 50 & long l = 50

Now, let us reverse the data type. Let us try to assign the long data type to the int data type as shown in the below example.

Dynamic Type in C#

As you can see in the above image, here we are getting compile-time error i.e. Cannot implicitly convert type ‘long’ to ‘int’. This is because an implicit conversion is not allowed in this case. The reason is long data type has a much bigger range than the int data type and there is a chance for data loss, hence the C# compiler does not allow this conversion and gives a compile-time error.

If you look at the compiler error message, the second message says that An explicit conversion exists (are you missing a cast?). That means we can use an explicit cast if we want to covert a long data type to an int data as shown in the below example. The compiler allows this because we are doing the conversion explicitly i.e we are making the decision consciously, we know converting long data type value to int data type value can result in data loss, but in this case, the long variable has a value of 50 which can be safely converted to int data type without losing any data.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            long l = 50;
            int i =(int) l; //Explicit Type Conversion
            Console.WriteLine($"int i = {i} & long l = {l}");
            Console.ReadKey();
        }
    }
}

Output: int i = 50 & long l = 50

Example to Understand Dynamic Type in C#:

Let us see another example. Please have a look at the following code. The following code compiles fine and runs without any error. This is because the C# compiler knows the variable str is of type string and it has the ToUpper() instance method.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "Dynamic Keyword in C#";
            Console.WriteLine(str.ToUpper());
            Console.ReadKey();
        }
    }
}

Output: DYNAMIC KEYWORD IN C#

The following code on the other hand will not compile. This is because the compiler knows that string type does not have an instance method called SomeMethod() and hence it will give you a compile-time error as shown in the below code.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "Dynamic Keyword in C#";
            str.SomeMethod(); //Compile Time Error

            Console.ReadKey();
        }
    }
}

So, when you try to run the above code, you will get the following compile-time error.

Example to Understand Dynamic Type in C#

This compile-time checking of the code is called static binding or early binding and it’s a good thing because we are able to catch errors at compile-time instead of runtime.

Dynamic Type in C#

This new type i.e. dynamic is introduced as part of C# 4 and as the name implies, we can use this dynamic type to write dynamic code in C#. For a better understanding, please have a look at the below example, The following code will compile fine and runs without any error.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic str = "Dynamic Keyword in C#";
            Console.WriteLine(str.ToUpper());

            Console.ReadKey();
        }
    }
}

Output: DYNAMIC KEYWORD IN C#

The following code will compile fine but we will get an exception at runtime. This is because the string type does not have SomeMethod() which will check at run time only.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic str = "Dynamic Keyword in C#";
            str.SomeMethod();
            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following exception at runtime.

Dynamic Type in C#

So, the most important point that you need to keep in mind is that even with C# dynamic data type, type checking and type safety are also enforced. The only difference is that type checking and type safety is enforced at runtime instead of compile-time.

With static C# code, type checking and type safety are enforced at compile-time, and with dynamic, C# code type checking and type safety are enforced at runtime. For a better understanding, please have a look at the below image.

Example to Understand dynamic type in C#

Example to Understand Dynamic Type in C#:

So, based on the assigned value it will decide the type at runtime and then enforce type checking and type safety at runtime. In the below example, at runtime, it will decide the type of str as string and type of i as int.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Based on the value, at runtime it will decide the type of str as string
            dynamic str = "Dynamic Keyword in C#";
            Console.WriteLine($"Type is {str.GetType()} & value = {str}");

            //Based on the value, at runtime it will decide the type of i as int
            dynamic i = 50;
            Console.WriteLine($"Type is {i.GetType()} & value = {i}");
            
            Console.ReadKey();
        }
    }
}
Output:

Example to Understand Dynamic Type in C#

Conversion from Static Types to Dynamic and Vice Versa in C#

Conversion from Static Types to Dynamic and Vice Versa in C#

In C#, conversion from static data types like int, double, float, etc, to dynamic types and vice versa does not require an explicit cast. These conversions are done implicitly. For a better understanding, please have a look at the below example. Here, we are converting int type to dynamic type as well as dynamic type to int type without using any explicit cast operator. The following code will compile fine and run without any error.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Convert from int to dynamic
            int int1 = 50;
            dynamic dynamic1 = int1; //Explicit cast not required
            Console.WriteLine($"int1 = {int1} & dynamic1 = {dynamic1}");

            //Convert from dynamic to int
            dynamic dynamic2 = 100;
            int int2 = dynamic2; //Explicit cast not required
            Console.WriteLine($"int2 = {int2} & d2 = {dynamic2}");

            Console.ReadKey();
        }
    }
}
Output:

Conversion from Static Types to Dynamic and Vice Versa in C#

This is true even with complex types like Customer, Employee, etc. So, we convert a complex type to a dynamic type as well as a dynamic type to a complex type without any error.

Convert Complex Type to Dynamic Type in C#:

In the below example, we are converting student type to dynamic type.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Student student1 = new Student()
            {
                Name = "Anurag",
                Barnch = "CSE",
                Roll = 1001
            };

            // Student type to dynamic conversion
            dynamic dynamicStudent = student1;

            Console.WriteLine($"Name = {dynamicStudent.Name}");
            Console.WriteLine($"Barnch = {dynamicStudent.Barnch}");
            Console.WriteLine($"Roll = {dynamicStudent.Roll}");
            
            Console.ReadKey();
        }
    }
    public class Student
    {
        public string Name { get; set; }
        public string Barnch { get; set; }
        public long Roll { get; set; }
    }
}
Output:

Convert Complex Type to Dynamic Type in C#

Convert Dynamic Type to Complex Type in C#:

In the below example, we are converting dynamic type to student type.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic dynamicStudent = new Student()
            {
                Name = "Anurag",
                Barnch = "CSE",
                Roll = 1001
            };

            // dynamic to Student type conversion
            Student student1 = dynamicStudent;

            Console.WriteLine($"Name = {student1.Name}");
            Console.WriteLine($"Barnch = {student1.Barnch}");
            Console.WriteLine($"Roll = {student1.Roll}");
            
            Console.ReadKey();
        }
    }
    public class Student
    {
        public string Name { get; set; }
        public string Barnch { get; set; }
        public long Roll { get; set; }
    }
}
Output:

Convert Dynamic Type to Complex Type in C#

Dynamic Type Implicit Conversions in C#:

C# allows certain data type conversions implicitly When there is no chance for data loss. For example, converting from int to double, converting from int to long, etc. Double and long have a much bigger range than int, so converting from int to long or double will not result in data loss, hence the conversion happens implicitly. This is true with both static and dynamic type C#. For a better understanding, please have a look at the below example.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //C# Static Type Implicit Conversion

            // int to double - implicit conversion
            int int1 = 500;
            double double1 = int1;
            Console.WriteLine($"int1 = {int1} & double1 = {double1}");

            // int to long - implicit conversion
            int int2 = 200;
            long long1 = int2;
            Console.WriteLine($"int2 = {int2} & long1 = {long1}");

            //C# Dynamic Type Implicit Conversion

            // int to dynamic to double - implicit conversion
            int int3 = 100;
            dynamic dynamic1 = int3;
            double double2 = dynamic1;
            Console.WriteLine($"int3 = {int3} & dynamic1 = {dynamic1} & double2 = {double2}");

            // int to dynamic to long - implicit conversion
            int int4 = 200;
            dynamic dynamic2 = int4;
            long long2 = dynamic2;
            Console.WriteLine($"int4 = {int4} & dynamic2 = {dynamic2} & long2 = {long2}");

            Console.ReadKey();
        }
    }
}
Output:

Dynamic Type Implicit Conversions in C#

Dynamic Type Explicit Conversions in C#

In C#, converting large data types to smaller data types is not allowed implicitly by the Compiler. This is because there is a chance of data loss. In this case, we can use an explicit cast operator to do the conversion. Again, this is true for both static and dynamic data types in C#. For a better understanding, please have a look at the below example. The following code is self-explained, so please go through the comment lines.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Convert double to int. Fails to compile, an explicit cast is required
            // Error : Cannot implicitly convert type double to int
            double double1 = 4000;
            // int int1 = double1;

            // Explicit cast from double to int
            int int1 = (int)double1;
            Console.WriteLine($"double1 = {double1} & int1 = {int1}");

            // Even with dynamic c# an explicit cast is required when 
            // converting larger data types like double to int
            double double2 = 4000;
            dynamic dynamicDouble = double2;
            int int2 = (int)dynamicDouble;
            Console.WriteLine($"double2 = {double2} & dynamicDouble = {dynamicDouble} && int2 = {int2}");

            Console.ReadKey();
        }
    }
}
Output:

Dynamic Type Explicit Conversions in C#

Dynamic Type as a Parameter in C#:

In C#, it is also possible to use dynamic type as a method parameter so that it can accept any type of value at run time. For a better understanding, please have a look at the following example. Here, the DisplayValue method parameter type is dynamic and hence you can see that we are passing a string, bool, double, int, etc values to the DisplayValue method from inside the Main method. The following example will compile fine and run without any error.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Calling DisplayValue Function with different types of values
            DisplayValue("Dynamic in C#"); //String
            DisplayValue(true); //Boolean
            DisplayValue(5000); //Integer
            DisplayValue(111.50); //Double
            DisplayValue(DateTime.Now); //Date

            Console.ReadKey();
        }

        public static void DisplayValue(dynamic val)
        {
            Console.WriteLine(val);
        }
    }
}
Output:

Dynamic Type as a Parameter in C#

Why do we need Dynamic Type in C#?

By looking at the examples we have discussed so far, you might be thinking, why do we need dynamic type in C#, what benefits it provides? The dynamic type C# has provided several benefits. They are as follows:

  1. Simplifies Processing of JSON API Data: In general, when an API returns JSON data, we normally create another strongly type class in our application and map the JSON data to that strongly typed class. However, in some scenarios where we do not want to create yet another strongly type class but still want to be able to consume and process the JSON data, we can make use of dynamic type in C#. In our upcoming article, we will see this with a real-time example.
  2. Interoperate with other languages like IronRuby or IronPython: Dynamic in C# Language makes it possible to interoperate with other programming languages like IronRuby or IronPython. If you are wondering, why do we need to interoperate with other programming languages? Well, to use features of other languages that C# doesn’t support.
Dynamic Type Real-time Example in C#:

With dynamic in C#, it is very easy to write reflection code which in turn makes the code more readable and maintainable. Let us see an example for a better understanding. We want to invoke an instance method using reflection in C#. Please read our previous article where we discussed Reflection in Detail. Here, I am not going to explain anything related to Reflection, rather I am simply going to use Reflection. Please have a look at the following Calculator class.

public class Calculator
{
    public int Add(int number1, int number2)
    {
        return number1 + number2;
    }
}

The above class is very straightforward. This class had one method i.e. Add which takes two integer parameters and the Add method returns the sum of the two input numbers. Now, we want to invoke the above Add method using Reflection. To invoke the above Add method using Reflection we need to write the following code.

Dynamic Type Real-time Example in C#

The complete example code is given below.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();

            //Using Reflection to Invoke the Add method
            var result = calculator.GetType().InvokeMember("Add",
                System.Reflection.BindingFlags.InvokeMethod,
                null,
                calculator,
                new object[] { 10, 20 });

            Console.WriteLine($"Sum = {result}");

            Console.ReadKey();
        }
    }

    public class Calculator
    {
        public int Add(int number1, int number2)
        {
            return number1 + number2;
        }
    }
}

Output: Sum = 30

Here, as you can see, we have written a lot of code just to call the Add method using C# Reflection. The code size not only big but also it is complex and difficult to understand. The above reflection code can be rewritten using dynamic. And using dynamic, the code will be simpler, cleaner, and easier to understand. The following example uses dynamic to invoke the Add method.

using System;
namespace DynamicDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic calculator = new Calculator();
            var result = calculator.Add(10, 20);
            Console.WriteLine($"Sum = {result}");

            Console.ReadKey();
        }
    }

    public class Calculator
    {
        public int Add(int number1, int number2)
        {
            return number1 + number2;
        }
    }
}

Output: Sum = 30

Limitations of Dynamic Type in C#:

In most situations, it is not advisable to use the dynamic type unless you are integrating with a dynamic language or another framework where types are not known at compile time. Because the compiler does not know what type the dynamic variable will eventually become, it’s unable to offer method or property code hints in Visual Studio.

In the next article, I am going to discuss Var Keyword in C# with Examples. Here, in this article, I try to explain Dynamic Type in C# with Examples. I hope you enjoy this Dynamic Type in C# with Examples article. I would like to have your feedback. Please post your feedback, question, or comments about this article.

1 thought on “Dynamic Type in C#”

  1. blank

    Guys,
    Please give your valuable feedback. And also, give your suggestions about this Dynamic Type in C# concept. If you have any better examples, you can also put them in the comment section. If you have any key points related to Dynamic Type in C#, you can also share the same.

Leave a Reply

Your email address will not be published.