Detailed explanation and practical demonstration of 5 methods for dynamically generating entity classes in C#

Abstract: This article introduces five practical methods for dynamically generating entity classes in C#, covering technologies such as T4 templates, CodeDOM, Roslyn, reflection and Emit, and helps developers to meet different scenario needs through real code examples.

1. Application scenario analysis

Dynamically generated entity classes are commonly used for:

Automatic synchronization when the database table structure changes

Dynamically parse heterogeneous data sources such as JSON/XML

Reduce duplicate coding efforts

Runtime dynamic type creation

2. Comparison of implementation plans

method	Ease of use	flexibility	performance	Applicable stage
T4 template	★★★★	★★	high	When designing
CodeDOM	★★★	★★★	middle	Design/runtime
Roslyn API	★★★	★★★★	middle	Runtime
	★★	★★★★	high	Runtime
Third-party library	★★★★	★★★	middle	Runtime

3. Specific implementation methods

Method 1: Use T4 template to generate (design-time)

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#
    var className = "DynamicEntity";
    var properties = new Dictionary<string, string> 
    {
        {"Id", "int"},
        {"Name", "string"}
    };
#>
// Auto-generated class
public class <#= className #>
{
<# foreach(var prop in properties) { #>
    public <#=  #> <#=  #> { get; set; }
<# } #>
}

Advantages: Visual Studio native support

Disadvantages: Pre-generated files are required

Method 2: Use CodeDOM (runtime)

var compileUnit = new CodeCompileUnit();
var @namespace = new CodeNamespace("DynamicEntities");
var @class = new CodeTypeDeclaration("Person") { IsClass = true };
 
@(new CodeMemberField(typeof(int), "_age"));
var property = new CodeMemberProperty()
{
    Name = "Age",
    Type = new CodeTypeReference(typeof(int)),
    Attributes = 
};
(new CodeMethodReturnStatement(
    new CodeFieldReferenceExpression(null, "_age")));
(new CodeAssignStatement(
    new CodeFieldReferenceExpression(null, "_age"),
    new CodePropertySetValueReferenceExpression()));
    
@(property);
var provider = new CSharpCodeProvider();
using var writer = new StringWriter();
(compileUnit, writer, null);
("", ());

Applicable scenario: When a complete class file is needed

Method 3: Use the Roslyn API (runtime)

var syntaxTree = (@"
using System;
namespace DynamicEntities
{
    public class Employee
    {
        public string FirstName { get; set; }
        public decimal Salary { get; set; }
    }
}");
 
var compilation = ("DynamicAssembly")
    .AddReferences((typeof(object).))
    .AddSyntaxTrees(syntaxTree);
 
using var ms = new MemoryStream();
var result = (ms);
if ()
{
    var assembly = (());
    dynamic obj = ((""));
     = "John";
}

Advantages: Supports a complete compilation process

Note: Installation package is required

Method 4: Use (High Performance)

var assemblyName = new AssemblyName("DynamicAssembly");
var assemblyBuilder = (assemblyName, );
var moduleBuilder = ("MainModule");
var typeBuilder = ("Product", );
 
// Add propertiesvar fieldBuilder = ("_price", typeof(decimal), );
var propertyBuilder = ("Price", , typeof(decimal), null);
 
// Generate get/set methodvar getSetAttr =  | ;
var getMethod = ("get_Price", getSetAttr, typeof(decimal), );
var getIL = ();
(OpCodes.Ldarg_0);
(, fieldBuilder);
();
 
var setMethod = ("set_Price", getSetAttr, null, new[] { typeof(decimal) });
var setIL = ();
(OpCodes.Ldarg_0);
(OpCodes.Ldarg_1);
(, fieldBuilder);
();
 
(getMethod);
(setMethod);
 
var dynamicType = ();
dynamic obj = (dynamicType);
 = 99.99m;

Features: The highest performance, suitable for high-frequency usage scenarios

4. Things to note

Dynamic assembly cannot be uninstalled

Type conflict handling

Debugging difficulties suggests adding exception handling

Consider using caching mechanism to improve performance

5. Plan selection suggestions

Simple scene: Select T4 template

Need dynamic compilation: Use Roslyn

High performance requirements: Priority Emit

Quick development: Select a third-party library

Conclusion:Choose the right plan according to the project needs. It is recommended to start familiarizing yourself with the T4 template and gradually master advanced skills such as Emit. Welcome to exchange practical application scenarios in the comment area!

Recommended tools:

LINQPad: Quickly test dynamic code

ILSpy: View generated IL code

: Roslyn Core Library

This is the article about the detailed explanation and practical demonstration of 5 methods of dynamically generating entity classes in C#. For more related content on dynamically generating entity classes, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!