{"id":73515,"date":"2022-08-23T08:00:49","date_gmt":"2022-08-23T06:00:49","guid":{"rendered":"https:\/\/drafts.code-maze.com\/?p=73515"},"modified":"2022-08-23T08:30:48","modified_gmt":"2022-08-23T06:30:48","slug":"create-class-dynamically-csharp","status":"publish","type":"post","link":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/","title":{"rendered":"How to Create a Class Dynamically in C#?"},"content":{"rendered":"

In this article, we are going to learn how to create a class dynamically in C#. Thanks to the introduction of the dynamic type<\/a> in C# 4, working with dynamic classes has become easier, but we shouldn’t abuse it. Dynamic classes are very powerful, but they bring a substantial overhead as well.<\/p>\n

To download the source code for this article, you can visit our GitHub repository<\/a>.<\/div>\n

Let’s start.<\/p>\n

Why Do We Need Dynamic Classes?<\/h2>\n

Before looking at the code, let’s imagine a scenario where using a dynamic class is a reasonable choice. We need to aggregate data coming from several weather stations. The problem is that each station returns this data as JSON, each with a different schema. This means that the first weather station could return the temperature as “Temperature1”, the second one as “Temperature2”, and so on.<\/p>\n

We might not want to create a data class for each weather station response, so what is it that we can do in this case?\u00a0<\/p>\n

How to Create a Class Dynamically With ExpandoObject<\/h2>\n

ExpandoObject<\/code> is part of the System.Dynamic<\/code> namespace and allows us to add\/remove properties to it at runtime. Creating an instance of the ExpandoObject<\/code> is as simple as:<\/p>\n

dynamic expando = new ExpandoObject();<\/code><\/p>\n

Then, if we need to add a new property to this instance, it is sufficient to initialize it using the dot-notation:<\/p>\n

expando.MyNewProperty = \"dynamic property\"<\/code><\/p>\n

In our example, we have one of the weather stations that returns this JSON object:<\/p>\n

{ \r\n    \"Temperature1\": 10.5, \r\n    \"Humidity1\": 50\r\n}<\/pre>\n
How can we create an ExpandoObject<\/code> from this JSON string? We have 2 options: Newtonsoft.Json<\/code> or System.Text.Json<\/code>. While the second one should guarantee better performances, it does not yet provide full support for dynamic objects. With System.Text.Json<\/code>, even if we specify ExpandoObject<\/code> to be the deserialization type, each property is wrapped in a JsonElement<\/code>:<\/p>\n
dynamic expando = JsonSerializer.Deserialize<ExpandoObject>(jsonWeather);<\/code><\/p>\n
If we try to access expando.Temperature1<\/code> we get a JsonElement<\/code> representing the value 10.5<\/code>. On the other hand, with Newtonsoft.Json<\/code>, properties are deserialized as expected:\u00a0<\/p>\n
var expandoConverter = new ExpandoObjectConverter();\r\ndynamic expando = JsonConvert.DeserializeObject<ExpandoObject>(\r\n    json, expandoConverter);<\/pre>\n
expando.Temperature1<\/code> and expando.Humidity1<\/code> return 10.5 and 50, respectively.<\/p>\n
We can also simulate a method call by assigning a lambda to a new property:<\/p>\n
var toCsvFormatter = (dynamic thisObj) => \r\n    () => \r\n    {\r\n        StringBuilder sb = new StringBuilder();\r\n\r\n        foreach (var prop in (IDictionary<String, Object>)thisObj)\r\n            if (prop.Key != \"Format\")\r\n                sb.Append($\"{prop.Value},\");\r\n\r\n        sb.Remove(sb.Length - 1, 1);\r\n\r\n        return sb.ToString();\r\n    };\r\n\r\nexpando.Format = toCsvFormatter(expando);<\/pre>\n
toCsvFormatter(expando)<\/code> is a partial application of the toCsvFormatter<\/code> lambda. This is convenient because we cannot access this<\/code>, which is expando<\/code>, directly from inside the lambda. The only way to access it is to pass it as an argument to the lambda itself. Instead of passing expando<\/code> every time we need to call Format()<\/code>, we do it at initialization time.<\/p>\n
We call Format()<\/code> the same way we call a method from a statically compiled class. Starting from the previous expando initialization:<\/p>\n
var formattedExpando = expando.Format();\r\nAssert.AreEqual(\"10.5,50\", formattedExpando);<\/pre>\n
In the lambda body, we are looping over each property of expando<\/code>. The ExpandoObject<\/code> implements the IDictionary<\/span><string<\/span>, object<\/span>><\/code> interface, which allows us to enumerate properties as key-value pairs or to remove one with:<\/p>\n
((IDictionary<string, Object>)expando).Remove(\"Temperature1\");<\/code><\/p>\n
Another interesting feature of the ExpandoObject<\/code> is the possibility to attach an event handler when any dynamic property changes. Let’s create a class that aggregates data coming from weather stations:<\/p>\n
public class WeatherAggregator\r\n{\r\n    public WeatherAggregator(dynamic weatherExpando1, dynamic weatherExpando2, dynamic weatherExpando3)\r\n    {\r\n        foreach (var weatherExp in new dynamic[] { weatherExpando1, weatherExpando2, weatherExpando3 })\r\n        {\r\n            ((INotifyPropertyChanged)weatherExp).PropertyChanged += new PropertyChangedEventHandler(\r\n                (sender, e) => \r\n                {\r\n                    ComputeAggregatedWeather();\r\n                }\r\n            );\r\n        }\r\n\r\n        ComputeAggregatedWeather();\r\n    }\r\n\r\n    private void ComputeAggregatedWeather()\r\n    {\r\n        \/\/ ...\r\n    }\r\n}<\/pre>\n
Each time we change a property (like temperature or humidity) of any expando, we should also recompute the aggregation operations. We can do it by leveraging the INotifyPropertyChanged<\/code> interface implemented by ExpandoObject<\/code>.<\/p>\n
This works by adding an event handler of type PropertyChangedEventHandler<\/code> to the PropertyChanged<\/code> member of all the expando objects. In this event handler, we recompute the aggregated data by calling ComputeAggregatedWeather()<\/code>.<\/p>\n
Advantages and Disadvantages of ExpandoObject<\/h3>\n
ExpandoObject<\/code> is very simple to use and it is probably the best way to bypass static type checking<\/strong>. This is a huge advantage, that should usually make it our favorite way to work with dynamic classes. However, we might need a custom dynamic binding logic, which is different from the one implemented in the ExpandoObject<\/code>.<\/p>\n
Let’s find out how to customize the dynamic binding behavior.<\/p>\n
How to Create a Class Dynamically With DynamicObject<\/h2>\n
DynamicObject<\/code> is a class in the System.Dynamic<\/code> namespace, but we have to inherit it because of the constructor protection level (protected). Let’s see how we can do that by solving the weather stations problem again. We are going to wrap the dynamic object created by the JSON deserialization with a DynamicWeatherData<\/code> object:<\/p>\n
dynamic weatherObj = new DynamicWeatherData(\r\n    JsonSerializer.Deserialize<JsonObject>(json)\r\n);<\/pre>\n
In this case, we have used System.Text.Json<\/code>, but it is possible with the Json.NET library as well. With Json.NET, instead of deserializing into a JsonObject<\/code>, we could have used a JObject<\/code>, which supports DLR. We will not cover the details of the serialization of dynamic objects, but we have written an article on how to deserialize JSON into a dynamic object<\/a>. This is how we can implement a basic version of DynamicWeatherData<\/code>:<\/p>\n
public class DynamicWeatherData : DynamicObject\r\n{\r\n    JsonObject _weatherData;\r\n\r\n    public DynamicWeatherData(JsonObject weatherData)\r\n    {\r\n        _weatherData = weatherData;\r\n    }\r\n\r\n    public override bool TrySetMember(SetMemberBinder binder, object? value)\r\n    {\r\n        if (!_weatherData.ContainsKey(binder.Name))\r\n            return false;\r\n\r\n        _weatherData[binder.Name] = value == null ? null : JsonValue.Create(value);\r\n\r\n        return true;\r\n    }\r\n\r\n    public override bool TryGetMember(GetMemberBinder binder, out object? result)\r\n    {\r\n        if (!_weatherData.ContainsKey(binder.Name))\r\n        {\r\n            result = null;\r\n            return false;\r\n        }\r\n\r\n        result = _weatherData[binder.Name]?.AsValue();\r\n        return true;\r\n    }\r\n}<\/pre>\n
The first thing we see is that we completely lost the simplicity of ExpandoObject<\/code>. Now we have to implement the class behavior, starting with where and how to store the members of the class itself.\u00a0We have chosen JsonObject<\/code> as data storage, but properties are dynamically accessed through TryGetMember()<\/code> and TrySetMember()<\/code>:<\/p>\n
weatherObj.Temperature1 = 10;\r\nAssert.IsTrue(weatherObj.Temperature1.GetType().IsAssignableTo(typeof(JsonValue)));\r\nAssert.AreEqual(10, (int)weatherObj.Temperature1);<\/pre>\n
When we assign 10 to weatherObj.Temperature1<\/code>, TrySetMember()<\/code> is called. In this case, binder.Name<\/code> is equal to \"Temperature1\"<\/code> and value<\/code> is 10. If the property name already exists in _weatherData<\/code>, then we store the new value as a JsonValue<\/code> and return true<\/code>.<\/p>\n
When we try to get weatherObj.Temperature1<\/code> in the assertions, TryGetMember()<\/code> is called. binder.Name<\/code> is equal to \"Temperature1\"<\/code>, but we must initialize result<\/code> before returning. If the property name already exists in _weatherData<\/code>, then we return the stored value as a JsonValue<\/code> and return true<\/code>. The explicit cast to int<\/code> is necessary because the result<\/code> type is JsonValue<\/code>.<\/p>\n
Both TryGetMember()<\/code> and TrySetMember()<\/code> return a boolean value, which represents the success or failure of the method execution. In case of failure (false<\/code>), the runtime binder usually throws an exception.<\/p>\n
So far, there is no reason to wrap a JsonObject<\/code> with a DynamicObject<\/code> because we are just overcomplicating the design. After all, what have we gained over the solution with ExpandoObject<\/code>? We should probably not adopt this approach when we can achieve the same result with ExpandoObject<\/code>.<\/p>\n
The beauty of DynamicObject<\/code> is that we can customize many other aspects of our class. The first one we are going to see is TryInvokeMember()<\/code>:<\/p>\n
public override bool TryInvokeMember(InvokeMemberBinder binder, object?[]? args, out object? result)\r\n{\r\n    if (binder.Name == \"Format\" && args?.Length == 0)\r\n    {\r\n        var (temperature, humidity) = GetProperties();\r\n\r\n        result = $\"{temperature},{humidity}\";\r\n        return true;\r\n    }\r\n    else\r\n    {\r\n        result = null;\r\n        return false;\r\n    }\r\n}\r\n\r\nprivate (double, int) GetProperties()\r\n{\r\n    var temperatureAttr = _weatherData\r\n        .First(kv => kv.Key.StartsWith(\"Temperature\"))\r\n        .Value!.GetValue<double>();\r\n    var humidityAttr = _weatherData\r\n        .First(kv => kv.Key.StartsWith(\"Humidity\"))\r\n        .Value!.GetValue<int>();\r\n\r\n    return (temperatureAttr, humidityAttr);\r\n}<\/pre>\n
binder.Name<\/code> contains the method name we are trying to call, args<\/code> are the arguments provided to the method. The advantage we have here over the ExpandoObject<\/code> solution is that we have direct access to the class methods. The only supported method in the example is Format()<\/code>, which we can call with:<\/p>\n
var formattedWeather = weatherObj.Format();\r\nAssert.AreEqual(\"10.5,50\", formattedWeather);<\/pre>\n
What if we wanted to cast our dynamic<\/code> object to a data class, like WeatherData<\/code>:<\/p>\n
public class WeatherData \r\n{\r\n    public WeatherData(double temperature, int humidity) \r\n    {\r\n        this.Temperature = temperature;\r\n        this.Humidity = humidity;\r\n    }\r\n\r\n    public double Temperature { get; init; }\r\n    public int Humidity { get; init; }\r\n}<\/pre>\n
With an ExpandoObject<\/code>, we would need to create a method that cast the dynamic object to the data class involved. This is not a real problem, but we would lose the possibility to use explicit\/implicit casting. Instead, to support the casting operator in DynamicWeatherData<\/code>, we just need to override TryConvert()<\/code>:\u00a0<\/p>\n
public override bool TryConvert(ConvertBinder binder, out object? result)\r\n{\r\n    if (binder.Type.Equals(typeof(WeatherData)))\r\n    {\r\n        var (temperature, humidity) = GetProperties();\r\n\r\n        result = new WeatherData(temperature, humidity);\r\n        return true;\r\n    }\r\n    else \r\n    {\r\n        result = null;\r\n        return false;\r\n    }\r\n}<\/pre>\n
binder<\/code> contains the target type, which can come from implicit or explicit casting. This means that this is perfectly valid:<\/p>\n
WeatherData castObj = weatherObj;<\/code><\/p>\n
Where the type of weatherObj<\/code> is DynamicWeatherData<\/code>.<\/p>\n
We have seen just a few possible methods we can override to customize the dynamic behavior of our class. Was this the right way to solve the initial problem?<\/p>\n
Advantages and Disadvantages of DynamicObject<\/h3>\n
ExpandoObject<\/code> and <\/strong>DynamicObject<\/code> have one thing in common: they both implement <\/strong>IDynamicMetaObjectProvider<\/code>. This interface is responsible for DLR support<\/strong>. The difference is that DynamicObject<\/code> is much more flexible than ExpandoObject<\/code>, which is limited to what we have shown previously. In the examples we proposed, DynamicObject<\/code> was unnecessary and the benefits we obtained didn’t pay off the implementation costs.<\/p>\n
For these reasons, before opting for DynamicObject<\/code>, we should try to solve the problem with ExpandoObject<\/code>.<\/p>\n
And what if DynamicObject<\/code> isn’t good enough?<\/p>\n
Create a Class Dynamically in C# With Roslyn<\/h2>\n
Roslyn, the .NET compiler, has some public APIs that we can use to compile source code at runtime. Finding a reasonable use case for them is probably more difficult than using them. It might be convenient if we wanted to execute a piece of code on a remote device.<\/p>\n
We are not going to cover this topic extensively here because it is very complex. We have added a simple example in the GitHub repository<\/strong> (see CSharpRuntimeCompilerUnitTest.cs<\/code>), but it is just the tip of the iceberg. If we don’t have a choice and we are left with this solution, our advice is to start from this article<\/a>.<\/p>\n
Conclusion<\/h2>\n
Creating a class dynamically in C# isn’t cheap at all in terms of performance<\/strong>. Moreover, we lose static type-checking and the risk of introducing a bug is higher<\/strong>. Typically, we should give priority to ExpandoObject because easier to use. We have also seen the approach based on DynamicObject, which is harder to maintain but more flexible than ExpandoObject.<\/p>\n","protected":false},"excerpt":{"rendered":"
In this article, we are going to learn how to create a class dynamically in C#. Thanks to the introduction of the dynamic type in C# 4, working with dynamic classes has become easier, but we shouldn’t abuse it. Dynamic classes are very powerful, but they bring a substantial overhead as well. Let’s start. Why […]<\/p>\n","protected":false},"author":6,"featured_media":62189,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[12],"tags":[10,324,471,1405,1404,1406],"class_list":["post-73515","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-csharp","tag-net","tag-classes","tag-dynamic","tag-dynamicobject","tag-expandoobject","tag-roslyn","et-has-post-format-content","et_post_format-et-post-format-standard"],"yoast_head":"\nHow to Create a Class Dynamically in C#? - Code Maze<\/title>\n<meta name=\"description\" content=\"Creating a class dynamically in C# isn't cheap in terms of performance. We lose static type-checking and the risk of having bugs is higher.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Create a Class Dynamically in C#? - Code Maze\" \/>\n<meta property=\"og:description\" content=\"Creating a class dynamically in C# isn't cheap in terms of performance. We lose static type-checking and the risk of having bugs is higher.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\" \/>\n<meta property=\"og:site_name\" content=\"Code Maze\" \/>\n<meta property=\"article:published_time\" content=\"2022-08-23T06:00:49+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-08-23T06:30:48+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1100\" \/>\n\t<meta property=\"og:image:height\" content=\"620\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Code Maze\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@https:\/\/twitter.com\/CodeMazeBlog\" \/>\n<meta name=\"twitter:site\" content=\"@CodeMazeBlog\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Code Maze\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":[\"Article\",\"BlogPosting\"],\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\"},\"author\":{\"name\":\"Code Maze\",\"@id\":\"https:\/\/code-maze.com\/#\/schema\/person\/09d29b223012c8e94a68ba62861d0b04\"},\"headline\":\"How to Create a Class Dynamically in C#?\",\"datePublished\":\"2022-08-23T06:00:49+00:00\",\"dateModified\":\"2022-08-23T06:30:48+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\"},\"wordCount\":1348,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/code-maze.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png\",\"keywords\":[\".NET\",\"Classes\",\"Dynamic\",\"DynamicObject\",\"ExpandoObject\",\"Roslyn\"],\"articleSection\":[\"C#\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\",\"url\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\",\"name\":\"How to Create a Class Dynamically in C#? - Code Maze\",\"isPartOf\":{\"@id\":\"https:\/\/code-maze.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png\",\"datePublished\":\"2022-08-23T06:00:49+00:00\",\"dateModified\":\"2022-08-23T06:30:48+00:00\",\"description\":\"Creating a class dynamically in C# isn't cheap in terms of performance. We lose static type-checking and the risk of having bugs is higher.\",\"breadcrumb\":{\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage\",\"url\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png\",\"contentUrl\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png\",\"width\":1100,\"height\":620,\"caption\":\"C# Development\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/code-maze.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"How to Create a Class Dynamically in C#?\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/code-maze.com\/#website\",\"url\":\"https:\/\/code-maze.com\/\",\"name\":\"Code Maze\",\"description\":\"Learn. Code. Succeed.\",\"publisher\":{\"@id\":\"https:\/\/code-maze.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/code-maze.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/code-maze.com\/#organization\",\"name\":\"Code Maze\",\"url\":\"https:\/\/code-maze.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/code-maze.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez.png\",\"contentUrl\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez.png\",\"width\":3511,\"height\":3510,\"caption\":\"Code Maze\"},\"image\":{\"@id\":\"https:\/\/code-maze.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/x.com\/CodeMazeBlog\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/code-maze.com\/#\/schema\/person\/09d29b223012c8e94a68ba62861d0b04\",\"name\":\"Code Maze\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/code-maze.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez-150x150.png\",\"contentUrl\":\"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez-150x150.png\",\"caption\":\"Code Maze\"},\"description\":\"This is the standard author on the site. Most articles are published by individual authors, with their profiles, but when several authors have contributed, we publish collectively as a part of this profile.\",\"sameAs\":[\"https:\/\/www.linkedin.com\/company\/codemaze\/\",\"https:\/\/x.com\/https:\/\/twitter.com\/CodeMazeBlog\"],\"url\":\"https:\/\/code-maze.com\/author\/codemazecontributor\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Create a Class Dynamically in C#? - Code Maze","description":"Creating a class dynamically in C# isn't cheap in terms of performance. We lose static type-checking and the risk of having bugs is higher.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/","og_locale":"en_US","og_type":"article","og_title":"How to Create a Class Dynamically in C#? - Code Maze","og_description":"Creating a class dynamically in C# isn't cheap in terms of performance. We lose static type-checking and the risk of having bugs is higher.","og_url":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/","og_site_name":"Code Maze","article_published_time":"2022-08-23T06:00:49+00:00","article_modified_time":"2022-08-23T06:30:48+00:00","og_image":[{"width":1100,"height":620,"url":"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png","type":"image\/png"}],"author":"Code Maze","twitter_card":"summary_large_image","twitter_creator":"@https:\/\/twitter.com\/CodeMazeBlog","twitter_site":"@CodeMazeBlog","twitter_misc":{"Written by":"Code Maze","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":["Article","BlogPosting"],"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#article","isPartOf":{"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/"},"author":{"name":"Code Maze","@id":"https:\/\/code-maze.com\/#\/schema\/person\/09d29b223012c8e94a68ba62861d0b04"},"headline":"How to Create a Class Dynamically in C#?","datePublished":"2022-08-23T06:00:49+00:00","dateModified":"2022-08-23T06:30:48+00:00","mainEntityOfPage":{"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/"},"wordCount":1348,"commentCount":0,"publisher":{"@id":"https:\/\/code-maze.com\/#organization"},"image":{"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage"},"thumbnailUrl":"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png","keywords":[".NET","Classes","Dynamic","DynamicObject","ExpandoObject","Roslyn"],"articleSection":["C#"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/code-maze.com\/create-class-dynamically-csharp\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/","url":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/","name":"How to Create a Class Dynamically in C#? - Code Maze","isPartOf":{"@id":"https:\/\/code-maze.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage"},"image":{"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage"},"thumbnailUrl":"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png","datePublished":"2022-08-23T06:00:49+00:00","dateModified":"2022-08-23T06:30:48+00:00","description":"Creating a class dynamically in C# isn't cheap in terms of performance. We lose static type-checking and the risk of having bugs is higher.","breadcrumb":{"@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/code-maze.com\/create-class-dynamically-csharp\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#primaryimage","url":"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png","contentUrl":"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/social-csharp.png","width":1100,"height":620,"caption":"C# Development"},{"@type":"BreadcrumbList","@id":"https:\/\/code-maze.com\/create-class-dynamically-csharp\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/code-maze.com\/"},{"@type":"ListItem","position":2,"name":"How to Create a Class Dynamically in C#?"}]},{"@type":"WebSite","@id":"https:\/\/code-maze.com\/#website","url":"https:\/\/code-maze.com\/","name":"Code Maze","description":"Learn. Code. Succeed.","publisher":{"@id":"https:\/\/code-maze.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/code-maze.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/code-maze.com\/#organization","name":"Code Maze","url":"https:\/\/code-maze.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/code-maze.com\/#\/schema\/logo\/image\/","url":"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez.png","contentUrl":"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez.png","width":3511,"height":3510,"caption":"Code Maze"},"image":{"@id":"https:\/\/code-maze.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/CodeMazeBlog"]},{"@type":"Person","@id":"https:\/\/code-maze.com\/#\/schema\/person\/09d29b223012c8e94a68ba62861d0b04","name":"Code Maze","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/code-maze.com\/#\/schema\/person\/image\/","url":"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez-150x150.png","contentUrl":"https:\/\/code-maze.com\/wp-content\/uploads\/2020\/01\/Code-Maze-Only-Logo-Transparent-HRez-150x150.png","caption":"Code Maze"},"description":"This is the standard author on the site. Most articles are published by individual authors, with their profiles, but when several authors have contributed, we publish collectively as a part of this profile.","sameAs":["https:\/\/www.linkedin.com\/company\/codemaze\/","https:\/\/x.com\/https:\/\/twitter.com\/CodeMazeBlog"],"url":"https:\/\/code-maze.com\/author\/codemazecontributor\/"}]}},"_links":{"self":[{"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/posts\/73515","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/comments?post=73515"}],"version-history":[{"count":6,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/posts\/73515\/revisions"}],"predecessor-version":[{"id":74123,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/posts\/73515\/revisions\/74123"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/media\/62189"}],"wp:attachment":[{"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/media?parent=73515"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/categories?post=73515"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/code-maze.com\/wp-json\/wp\/v2\/tags?post=73515"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}