Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to generate the .NET class of C# at run time". In the daily operation, I believe that many people have doubts about how to generate the .NET class of C# at run time. I have consulted all kinds of materials and sorted out the simple and easy-to-use operation methods. I hope it will be helpful to answer the doubt of "how to generate the .NET class of C# at run time"! Next, please follow the editor to study!

Why do I need to generate classes at run time?

The requirement to produce a new type at run time is usually due to the runtime knowing the class properties, meeting performance requirements, and the need to add functionality to the new type. When you try to do this, the first thing you should consider is whether this is really a sensible solution. Before you think deeply, there are many other things you can try and ask yourself questions like this:

Can I use a normal class?

Can I use Dictionary, Tuple, or object array (Array)?

Can I use the extension object

Am I sure I can't use a normal class?

If you think this is still necessary, please continue to read the following.

Example use case

As a developer, I bind large amounts of data to various WPF Grids. Most of the time, the properties are fixed, and I can use predefined classes. Sometimes I have to build the grid dynamically and be able to change the data while the application is running. Take the following classes that display ID and some financial data (FTSE and CAC are indices whose attributes represent index prices):

Public class PriceHolderViewModel: ViewModelBase {public long Id {get; set;} public decimal FTSE100 {get; set;} public decimal CAC40 {get; set;}}

This class is well defined if we are only interested in the properties. However, if you want to extend this class with more properties, you need to add it to your code, recompile it, and deploy it in the new version.

Instead, what we can do is track the properties required by the object and build the class at run time. This will allow us to constantly add and remove attributes as needed, and use reflection to update their values.

/ / Keep track of my propertiesvar _ properties = new Dictionary (new [] {new KeyValuePair ("FTSE100", typeof (Decimal)), new KeyValuePair ("CAC40", typeof (Decimal))}; create your type

The following example shows you how to build a new type at run time. You need to use the * * System.Reflection.Emit** library to construct a new dynamic assembly in which your classes will be created, followed by modules and types. Unlike the old * * .NET Framework** Framework, where you need to create an assembly in the AppDomain of the current program, AppDomain is no longer available in the * * .NET Core**. You will see that I have created a new type name using GUID to make it easier to track the version of the type. In the past, you couldn't create two types with the same name, but now that doesn't seem to be the case.

Public Type GeneratedType {private set; get;} private void Initialise () {var newTypeName = Guid.NewGuid () .ToString (); var assemblyName = new AssemblyName (newTypeName); var dynamicAssembly = AssemblyBuilder.DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Run); var dynamicModule = dynamicAssembly.DefineDynamicModule ("Main") Var dynamicType = dynamicModule.DefineType (newTypeName, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, typeof (T)); / / This is the typeof class to derive from. Use null if there isn't one dynamicType.DefineDefaultConstructor (MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); foreach (var property in Properties) AddProperty (dynamicType, property.Key, property.Value); GeneratedType = dynamicType.CreateType ();}

When defining a type, you can provide a type from which a new type can be derived. This is useful if your base class has some features or attributes to include in the new type. I have previously used it to extend ViewModel and Serializable types at run time.

After you have created the TypeBuilder, you can start adding properties using the code provided below. It creates supporting fields and the required intermediate languages to access them through Getter and Setter. After this is done for each property, you can use CreateType () to create an instance of the type.

Private static void AddProperty (TypeBuilder typeBuilder, string propertyName, Type propertyType) {var fieldBuilder = typeBuilder.DefineField ("_" + propertyName, propertyType, FieldAttributes.Private); var propertyBuilder = typeBuilder.DefineProperty (propertyName, PropertyAttributes.HasDefault, propertyType, null); var getMethod = typeBuilder.DefineMethod ("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); var getMethodIL = getMethod.GetILGenerator (); getMethodIL.Emit (OpCodes.Ldarg_0) GetMethodIL.Emit (OpCodes.Ldfld, fieldBuilder); getMethodIL.Emit (OpCodes.Ret); var setMethod = typeBuilder.DefineMethod ("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new [] {propertyType}); var setMethodIL = setMethod.GetILGenerator (); Label modifyProperty = setMethodIL.DefineLabel (); Label exitSet = setMethodIL.DefineLabel (); setMethodIL.MarkLabel (modifyProperty) SetMethodIL.Emit (OpCodes.Ldarg_0); setMethodIL.Emit (OpCodes.Ldarg_1); setMethodIL.Emit (OpCodes.Stfld, fieldBuilder); setMethodIL.Emit (OpCodes.Nop); setMethodIL.MarkLabel (exitSet); setMethodIL.Emit (OpCodes.Ret); propertyBuilder.SetGetMethod (getMethod); propertyBuilder.SetSetMethod (setMethod);}

Once you have a type, it's easy to create an instance of it by using Activator.CreateInstance (). However, you want to be able to change the value of the property you have created, and to do this, you can use reflection again to get the propertyInfos and extract the Set method. Once you have these properties, it is relatively easy for movie classes to set property values.

Foreach (var property in Properties) {var propertyInfo = GeneratedType.GetProperty (property.Key); var setMethod = propertyInfo.GetSetMethod (); setMethod.Invoke (objectInstance, new [] {propertyValue});}

Now you can use custom properties to create your own types at run time, with the ability to update their values, and everything is in place. The only obstacle I found was to create a list that could store instances of new types. DataGrid in WPF tends to read only the properties of the general parameter type of List. This means that even if you extend the base class with the new attributes, you can only see the properties in the base class with AutoGenerateProperties. The solution is to explicitly create a new List using the generated type. I provide an example of how to do this below:

Var listGenericType = typeof (List); var list = listGenericType.MakeGenericType (GeneratedType); var constructor = list.GetConstructor (new Type [] {}); var newList = (IList) constructor.Invoke (new object [] {}); foreach (var value in values) newList.Add (value); at this point, the study on "how to generate .NET classes of C # at runtime" is over, hoping to solve everyone's doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.