The dynamic
type is a feature introduced in C# 4.0 that allows for dynamic programming. It enables us to resolve types and members at runtime instead of at compile time.
The dynamic
type is a data type that skips static type checking at compile time and delegates the resolution of types and members to runtime.
This means that operations on dynamic
type variables are not validated until the program is running, allowing for greater flexibility in certain programming scenarios.
Using dynamic
provides flexibility to work with types that may not be known until the program is executed.
Basic Syntax
The dynamic
type is declared similarly to other types in C#, using the dynamic
keyword.
dynamic variable = 10;
variable = "Hello, World!";
variable = new List<int> { 1, 2, 3 };
In this example, variable
can hold different types of values, and the actual type of the variable is resolved at runtime.
Operations with dynamic
When performing operations with a dynamic
type variable, the compiler does not perform any type checking. Instead, operations are resolved at runtime.
dynamic value = 10;
Console.WriteLine(value + 5); // Valid operation, output: 15
value = "Hello";
Console.WriteLine(value + " World!"); // Valid operation, output: Hello World!
In the first case, value
is treated as an integer, while in the second case, it is treated as a string.
Exception Handling
Since dynamic
operations are resolved at runtime, it is especially important to be aware of exceptions that may occur due to type errors.
try
{
dynamic value = "text";
int number = value; // Will cause a runtime exception
}
catch (RuntimeBinderException ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
Advantages and Disadvantages of Using dynamic
Advantages
Flexibility: Allows working with data types that are not known at compile time, which is useful when interacting with COM libraries, reflection libraries, dynamic APIs, or data coming from external sources like JSON or XML.
Code Simplification: Avoids the need for explicit conversions and casting, making it easier to write code that interacts uniformly with different data types.
Disadvantages
- Performance:
dynamic
operations can be slower due to the need to resolve types at runtime. - Loss of Type Safety: Using
dynamic
skips type checks at compile time, which can lead to runtime errors that would be avoidable with statically defined types. - Less Clarity: Code with
dynamic
can be harder to understand and maintain due to the lack of type information at compile time.
Practical Examples
Interaction with COM Types
Using dynamic
is especially useful when working with COM libraries where types are not known at compile time:
dynamic excel = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
excel.Visible = true;
excel.Workbooks.Add();
excel.Cells[1, 1].Value = "Hello World";
Implicit and Explicit Conversion
dynamic
variables can be converted implicitly or explicitly to other types:
dynamic value = "123";
int number = int.Parse(value); // Explicit conversion
value = 456;
int anotherNumber = value; // Implicit conversion
Practical Example: JSON Data Processing
A common practical case for dynamic
is processing JSON data:
using System;
using System.Dynamic;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;
class Program
{
static async Task Main(string[] args)
{
string url = "https://api.example.com/data";
using HttpClient client = new HttpClient();
string jsonData = await client.GetStringAsync(url);
dynamic data = JsonConvert.DeserializeObject<ExpandoObject>(jsonData);
Console.WriteLine(data.Name);
Console.WriteLine(data.Age);
}
}
In this example, dynamic
is used to deserialize JSON data into a dynamic object, allowing direct access to properties without needing to define a data class beforehand.