Иногда в разработке возникают задачи, требующие создания типов в рантайме. Чаще всего это необходимо при написании декларативных сервисов, высокопроизводительных мапперов или систем с динамическим проксированием.
Допустим, мы хотим сгенерировать тип с таким интерфейсом:
public interface IStudent { string Name { get; set; } int Some(string value); }
Логика метода Some (просто для примера):
public int Some(string value) { string str = Name + value; Console.WriteLine(str); return str.Length; }
Reflection.Emit
Можно использовать System.Reflection.Emit.
// 1. Создаем сборку, модуль и тип AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("StudentReflectionEmitAssembly"), AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("StudentReflectionEmitModule"); TypeBuilder typeBuilder = moduleBuilder.DefineType("Student", TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable, typeof(object), new[] { typeof(IStudent) }); // 2. Объявляем backing-поле и свойство FieldBuilder nameField = typeBuilder.DefineField("_name", typeof(string), FieldAttributes.Private); PropertyBuilder nameProperty = typeBuilder.DefineProperty("Name", PropertyAttributes.None, typeof(string), Type.EmptyTypes); // 3. Создаем сеттеры, геттеры и метод MethodBuilder getter = typeBuilder.DefineMethod("get_Name", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.NewSlot | MethodAttributes.Final, typeof(string), Type.EmptyTypes); MethodBuilder setter = typeBuilder.DefineMethod("set_Name", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.NewSlot | MethodAttributes.Final, typeof(void), new[] { typeof(string) }); MethodBuilder someMethod = typeBuilder.DefineMethod("Some", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Final, typeof(int), new[] { typeof(string) }); // 4. Пишем логику свойств ILGenerator getterIl = getter.GetILGenerator(); getterIl.Emit(OpCodes.Ldarg_0); getterIl.Emit(OpCodes.Ldfld, nameField); getterIl.Emit(OpCodes.Ret); nameProperty.SetGetMethod(getter); ILGenerator setterIl = setter.GetILGenerator(); setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Ldarg_1); setterIl.Emit(OpCodes.Stfld, nameField); setterIl.Emit(OpCodes.Ret); nameProperty.SetSetMethod(setter); // 5. Пишем логику метода Some ILGenerator someIl = someMethod.GetILGenerator(); LocalBuilder str = someIl.DeclareLocal(typeof(string)); someIl.Emit(OpCodes.Ldarg_0); someIl.Emit(OpCodes.Call, getter); someIl.Emit(OpCodes.Ldarg_1); someIl.Emit(OpCodes.Call, typeof(string).GetMethod(nameof(string.Concat), new[] { typeof(string), typeof(string) })); someIl.Emit(OpCodes.Stloc, str); someIl.Emit(OpCodes.Ldloc, str); someIl.Emit(OpCodes.Call, typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(string) })); someIl.Emit(OpCodes.Ldloc, str); someIl.Emit(OpCodes.Call, typeof(string).GetProperty(nameof(string.Length)).GetGetMethod()); someIl.Emit(OpCodes.Ret); // 6. Финализация типа typeBuilder.DefineDefaultConstructor(MethodAttributes.Public); Type studentType = typeBuilder.CreateTypeInfo().AsType();
Получился многословный код. Хотя он очень шаблонный, можно написать небольшую обертку и получить:
AssemblyFactory
Это позволит описывать типы в декларативном стиле:
Type studentType = AssemblyFactory.CreateAssembly("StudentReflectionEmitAssembly") .CreateClass("Student", typeof(object), new[] { typeof(IStudent) }) .AddProperty(typeof(string), nameof(IStudent.Name)) .AddMethod(typeof(int), nameof(IStudent.Some), new[] { typeof(string) }, (ilGenerator, typeBuilder) => { LocalBuilder str = ilGenerator.DeclareLocal(typeof(string)); ilGenerator.Emit(OpCodes.Ldarg_0); ilGenerator.Emit(OpCodes.Call, typeBuilder.GetProperty(nameof(IStudent.Name)).GetGetMethod()); ilGenerator.Emit(OpCodes.Ldarg_1); ilGenerator.Emit(OpCodes.Call, typeof(string).GetMethod(nameof(string.Concat), new[] { typeof(string), typeof(string) })); ilGenerator.Emit(OpCodes.Stloc, str); ilGenerator.Emit(OpCodes.Ldloc, str); ilGenerator.Emit(OpCodes.Call, typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(string) })); ilGenerator.Emit(OpCodes.Ldloc, str); ilGenerator.Emit(OpCodes.Call, typeof(string).GetProperty(nameof(string.Length)).GetGetMethod()); ilGenerator.Emit(OpCodes.Ret); }) .Build();
Для этого напишем фабрику:
private class AssemblyFactory { // Создает сборку public static AssemblyFactory CreateAssembly(string name) { AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(name); return new AssemblyFactory(moduleBuilder); } private readonly ModuleBuilder moduleBuilder; private AssemblyFactory(ModuleBuilder moduleBuilder) { this.moduleBuilder = moduleBuilder; } // Создает класс в сборке public DynamicTypeBuilder CreateClass(string name, Type baseType, Type[] interfaces) { TypeBuilder typeBuilder = moduleBuilder.DefineType(name, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable, baseType, interfaces); return new DynamicTypeBuilder(typeBuilder); } }
И билдер классов:
private sealed class DynamicTypeBuilder(TypeBuilder typeBuilder) { // те же атрибуты, что и раньше private const MethodAttributes DefaultMethodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Final; private const MethodAttributes PropertyMethodAttributes = DefaultMethodAttributes | MethodAttributes.SpecialName; // сохраняем поля и свойства для доступа private readonly IDictionary<string, FieldBuilder> fields = new Dictionary<string, FieldBuilder>(StringComparer.Ordinal); private readonly IDictionary<string, PropertyBuilder> properties = new Dictionary<string, PropertyBuilder>(StringComparer.Ordinal); // создание полей очень простое public DynamicTypeBuilder AddField(Type type, string name) { fields[name] = typeBuilder.DefineField(name, type, FieldAttributes.Public); return this; } // свойство чуть сложнее, но так же взято из кода выше public DynamicTypeBuilder AddProperty(Type type, string name) { FieldBuilder field = typeBuilder.DefineField($"_{name}", type, FieldAttributes.Private); fields[name] = field; PropertyBuilder property = typeBuilder.DefineProperty(name, PropertyAttributes.None, type, Type.EmptyTypes); properties[name] = property; MethodBuilder getter = typeBuilder.DefineMethod($"get_{name}", PropertyMethodAttributes, type, Type.EmptyTypes); ILGenerator getterIl = getter.GetILGenerator(); getterIl.Emit(OpCodes.Ldarg_0); getterIl.Emit(OpCodes.Ldfld, field); getterIl.Emit(OpCodes.Ret); property.SetGetMethod(getter); MethodBuilder setter = typeBuilder.DefineMethod($"set_{name}", PropertyMethodAttributes, typeof(void), new[] { type }); ILGenerator setterIl = setter.GetILGenerator(); setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Ldarg_1); setterIl.Emit(OpCodes.Stfld, field); setterIl.Emit(OpCodes.Ret); property.SetSetMethod(setter); return this; } public FieldBuilder GetField(string name) { return fields[name]; } public PropertyBuilder GetProperty(string name) { return properties[name]; } // создание методов делегируется вызывающей стороне public DynamicTypeBuilder AddMethod(Type returnType, string name, Type[] parameterTypes, Action<ILGenerator, DynamicTypeBuilder> emit) { MethodBuilder method = typeBuilder.DefineMethod(name, DefaultMethodAttributes, returnType, parameterTypes); emit(method.GetILGenerator(), this); return this; } // и само создание типа public Type Build() { typeBuilder.DefineDefaultConstructor(MethodAttributes.Public); return typeBuilder.CreateTypeInfo().AsType(); } }
Этого уже достаточно, чтобы создавать DTO и писать простые методы, но писать IL — не самое приятное занятие. На этом моменте нужно подумать: а что может генерировать логику в IL?
Expression Trees
Сначала нужно вкратце разобраться, как оно работает. Работа с ним идет через статические методы System.Linq.Expressions.Expression.
Допустим, мы хотим построить дерево для (User u) => u.Age >= 18.
Для построения дерева вызывается метод Expression.Lambda, он получает дженерик делегата Func<>, Action<>, тело и параметры. Нужно сначала создать параметры через Expression.Parameter и передать в Lambda. Если типы параметров и делегатов не совпадают — будет выброшено исключение.
// входящие параметры описываются какой тип и какое имя (имена могут повторяться или их может не быть, они нужны в основном для отладки) ParameterExpression paramUser = Expression.Parameter(typeof(User), "u"); Expression body = ...; Expression<Predicate<User>> lambda = Expression.Lambda<Predicate<User>>( body, // тело выражения paramUser // и входящие параметры передаются здесь );
Теперь нужно получить поле Age и сравнить его с 18.
// получаем поле, с которым хотим работать MemberExpression propAge = Expression.PropertyOrField(paramUser, "Age"); // создаем константу, так как можно работать только с Expression ConstantExpression const18 = Expression.Constant(18, typeof(int)); // и делаем проверку «больше или равно». Любое Expression может быть телом, в нашем случае это будет greaterOrEqual BinaryExpression greaterOrEqual = Expression.GreaterThanOrEqual(propAge, const18);
Полный код выглядит так:
ParameterExpression paramUser = Expression.Parameter(typeof(User), "u"); MemberExpression propAge = Expression.PropertyOrField(paramUser, "Age"); ConstantExpression const18 = Expression.Constant(18, typeof(int)); BinaryExpression greaterOrEqual = Expression.GreaterThanOrEqual(propAge, const18); Expression<Predicate<User>> lambda = Expression.Lambda<Predicate<User>>( greaterOrEqual, paramUser ); // и когда дерево собрано его можно скомпилировать Predicate<User> compiled = lambda.Compile(); // и использовать if (compiled(new User(name: "Anton", age: 20))) { Console.WriteLine("Hello"); }
Объеденяем
И тут приходит мысль: что если попробовать писать методы, используя Expression Tree?
Сам по себе IL не работает в ООП, и все методы по своей сути — это статические функции. А когда функция используется как метод класса, нулевым аргументом подставляется экземпляр типа. Тогда теоретически можно написать делегат с первым параметром “self” и написать метод на Expression Tree.
Легальных способов подсунуть IL нет, поэтому прибегнем к грязному свинству и черной магии — к рефлексии.
Если сильно покопаться в Expression Tree, а точнее в том, как и где компилируется IL, можно найти тип System.Linq.Expressions.Compiler.LambdaCompiler - он записывает IL. В конструктор принимает LambdaExpression и AnalyzedTree. AnalyzedTree — это проанализированное дерево, оно создает scope генерации и создается через System.Linq.Expressions.Compiler.VariableBinder.Bind. Естественно, всё это internal-классы.
Найдем типы:
Assembly expressionsAssembly = typeof(Expression).Assembly; Type variableBinderType = expressionsAssembly.GetType("System.Linq.Expressions.Compiler.VariableBinder", throwOnError: true); Type lambdaCompilerType = expressionsAssembly.GetType("System.Linq.Expressions.Compiler.LambdaCompiler", throwOnError: true);
Создадим LambdaCompiler:
object analyzedTree = variableBinderType.GetMethod("Bind", PrivateStatic).Invoke(null, new object[] { expression }); object compiler = lambdaCompilerType.GetConstructor( PrivateInstance, null, new[] { analyzedTree.GetType(), typeof(LambdaExpression) }, null).Invoke(new[] { analyzedTree, expression });
Создаем метод в билдере. Не забываем, что в делегате первым аргументом указывается объект, которому должен принадлежать метод, но в самом методе он, естественно, не виден. И подсунем ILGenerator в компилятор в поле _ilg:
MethodBuilder method = typeBuilder.DefineMethod(name, DefaultMethodAttributes, expression.ReturnType, delegateParameters.Skip(1).ToArray()); lambdaCompilerType.GetField("_ilg", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(compiler, method.GetILGenerator());
К сожалению для нас, это не всё. По умолчанию лямбда имеет первым аргументом контекст замыкания. Нужно сказать компилятору, что замыкания нет (_hasClosureArgument = false), и подменить структуру метода в _method:
DynamicMethod signatureMethod = new DynamicMethod(method.Name + "_ExpressionSignature", expression.ReturnType, delegateParameters, method.Module, skipVisibility: true); lambdaCompilerType.GetField("_hasClosureArgument", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(compiler, false); lambdaCompilerType.GetField("_method", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(compiler, signatureMethod);
Осталось вызвать метод EmitLambdaBody, который запишет IL в наш ILGenerator:
lambdaCompilerType.GetMethod("EmitLambdaBody", BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null).Invoke(compiler, null);
И вуаля! Теперь методы можно писать на Expression Tree. Но есть нюансы работы с self. Перепишем наш метод Some на Expression Tree:
Type studentType = AssemblyFactory.CreateAssembly("StudentWithoutInterfaceExpressionTreeAssembly") .CreateClass("Student", typeof(object), new[] { typeof(IStudent) }) .AddProperty(typeof(string), "Name") .AddMethod("Some", typeBuilder => { // Так как тип ещё не создан, нужно принимать object ParameterExpression self = Expression.Parameter(typeof(object), "self"); ParameterExpression value = Expression.Parameter(typeof(string), "value"); // И конвертировать в ожидаемый тип. Повезло, что TypeBuilder — наследник Type. UnaryExpression typedSelf = Expression.Convert(self, typeBuilder.Type); // Мы создавали свойство, но при попытке доступа к нему будет ошибка. Опять же из-за нескомпилированного типа. // Поэтому можно работать только с полями, зато можно работать с любыми полями. MemberExpression name = Expression.Field(typedSelf, typeBuilder.GetField("_Name")); // находим методы string.Concat и Console.WriteLine MethodInfo concatMethod = typeof(string).GetMethod(nameof(string.Concat), new[] { typeof(string), typeof(string) }); MethodInfo writeLineMethod = typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(string) }); // Описываем переменную, в которую сохраним конкатенацию ParameterExpression str = Expression.Variable(typeof(string), "str"); ParameterExpression[] variables = new[] { str }; // string.Concat(_Name, value) MethodCallExpression concatExpression = Expression.Call(concatMethod, name, value); // str = string.Concat(_Name, value) BinaryExpression assign = Expression.Assign(str, concatExpression); // Console.WriteLine(str); MethodCallExpression callWriteLine = Expression.Call(writeLineMethod, str); // str.Length MemberExpression returnValue = Expression.Property(str, nameof(string.Length)); // создаем блок, первым аргументом всегда идут переменные которые используются в этом блоке // а последним должен быть return BlockExpression body = Expression.Block( variables, assign, callWriteLine, returnValue ); return Expression.Lambda<Func<object, string, int>>( body, self, value ); }) .Build();
Полный листинг фабрики:
private class AssemblyFactory { public static AssemblyFactory CreateAssembly(string name) { AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(name); return new AssemblyFactory(moduleBuilder); } private readonly ModuleBuilder moduleBuilder; private AssemblyFactory(ModuleBuilder moduleBuilder) { this.moduleBuilder = moduleBuilder; } public DynamicTypeBuilder CreateClass(string name, Type baseType, Type[] interfaces) { TypeBuilder typeBuilder = moduleBuilder.DefineType(name, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable, baseType, interfaces); return new DynamicTypeBuilder(typeBuilder); } } private sealed class DynamicTypeBuilder(TypeBuilder typeBuilder) { private const MethodAttributes DefaultMethodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Final; private const MethodAttributes PropertyMethodAttributes = DefaultMethodAttributes | MethodAttributes.SpecialName; private readonly IDictionary<string, FieldBuilder> fields = new Dictionary<string, FieldBuilder>(StringComparer.Ordinal); private readonly IDictionary<string, PropertyBuilder> properties = new Dictionary<string, PropertyBuilder>(StringComparer.Ordinal); public Type Type => typeBuilder; public DynamicTypeBuilder AddField(Type type, string name) { fields[name] = typeBuilder.DefineField(name, type, FieldAttributes.Public); return this; } public DynamicTypeBuilder AddProperty(Type type, string name) { FieldBuilder field = typeBuilder.DefineField($"_{name}", type, FieldAttributes.Private); fields[field.Name] = field; PropertyBuilder property = typeBuilder.DefineProperty(name, PropertyAttributes.None, type, Type.EmptyTypes); properties[name] = property; MethodBuilder getter = typeBuilder.DefineMethod($"get_{name}", PropertyMethodAttributes, type, Type.EmptyTypes); ILGenerator getterIl = getter.GetILGenerator(); getterIl.Emit(OpCodes.Ldarg_0); getterIl.Emit(OpCodes.Ldfld, field); getterIl.Emit(OpCodes.Ret); property.SetGetMethod(getter); MethodBuilder setter = typeBuilder.DefineMethod($"set_{name}", PropertyMethodAttributes, typeof(void), new[] { type }); ILGenerator setterIl = setter.GetILGenerator(); setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Ldarg_1); setterIl.Emit(OpCodes.Stfld, field); setterIl.Emit(OpCodes.Ret); property.SetSetMethod(setter); return this; } public FieldBuilder GetField(string name) { return fields[name]; } public PropertyBuilder GetProperty(string name) { return properties[name]; } public DynamicTypeBuilder AddMethod(Type returnType, string name, Type[] parameterTypes, Action<ILGenerator, DynamicTypeBuilder> emit) { MethodBuilder method = typeBuilder.DefineMethod(name, DefaultMethodAttributes, returnType, parameterTypes); emit(method.GetILGenerator(), this); return this; } public DynamicTypeBuilder AddMethod<TDelegate>(string name, Func<DynamicTypeBuilder, Expression<TDelegate>> expressionFactory) where TDelegate : Delegate { Expression<TDelegate> expression = expressionFactory(this); Type[] delegateParameters = expression.Parameters.Select(x => x.Type).ToArray(); if (delegateParameters.Length == 0) { throw new ArgumentException("Expression must have the instance as its first parameter.", nameof(expression)); } Assembly expressionsAssembly = typeof(Expression).Assembly; Type variableBinderType = expressionsAssembly.GetType("System.Linq.Expressions.Compiler.VariableBinder", throwOnError: true); Type lambdaCompilerType = expressionsAssembly.GetType("System.Linq.Expressions.Compiler.LambdaCompiler", throwOnError: true); object analyzedTree = variableBinderType.GetMethod("Bind", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, new object[] { expression }); object compiler = lambdaCompilerType.GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { analyzedTree.GetType(), typeof(LambdaExpression) }, null).Invoke(new[] { analyzedTree, expression }); MethodBuilder method = typeBuilder.DefineMethod(name, DefaultMethodAttributes, expression.ReturnType, delegateParameters.Skip(1).ToArray()); DynamicMethod signatureMethod = new DynamicMethod(method.Name + "_ExpressionSignature", expression.ReturnType, delegateParameters, method.Module, skipVisibility: true); lambdaCompilerType.GetField("_ilg", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(compiler, method.GetILGenerator()); lambdaCompilerType.GetField("_hasClosureArgument", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(compiler, false); lambdaCompilerType.GetField("_method", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(compiler, signatureMethod); lambdaCompilerType.GetMethod("EmitLambdaBody", BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null).Invoke(compiler, null); return this; } public Type Build() { typeBuilder.DefineDefaultConstructor(MethodAttributes.Public); return typeBuilder.CreateTypeInfo().AsType(); } }
Заключение
Мы прошли путь от низкоуровневых IL до высокоуровневых Expression Trees. Такой подход позволяет создавать динамические типы, не жертвуя при этом читаемостью.
Статья и так получилась большой, может позже разберу Roslyn как альтернативный способ.
