public void TestNotThrowsExceptionOnNull() { string methodName = null; methodName = _generator.GetString(false, false, true, MinStringLength, MaxStringLength); Type returnType = typeof(void); TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder = typeBuilder.DefineMethod(methodName, TestMethodAttributes); Type[] typeParameters = builder.DefineGenericParameters(new string[] { "T" }).Select(a => a.AsType()).ToArray(); builder.SetParameters(typeParameters); builder.SetReturnType(returnType); MethodInfo methodInfo = builder.MakeGenericMethod(null); }
public void TestForEqualObjects2() { string methodName = null; methodName = _generator.GetString(false, false, true, MinStringLength, MaxStringLength); TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder1 = typeBuilder.DefineMethod(methodName, MethodAttributes.Public); string[] typeParamNames = { "T", "U" }; GenericTypeParameterBuilder[] Parameters = builder1.DefineGenericParameters(typeParamNames); MethodBuilder builder2 = typeBuilder.DefineMethod(methodName, MethodAttributes.Public); Parameters = builder2.DefineGenericParameters(typeParamNames); Assert.Equal(builder1.GetHashCode(), builder2.GetHashCode()); }
public void TestGenericMethodWithReturnTypeRequiredModifiersSet() { string methodName = null; methodName = TestLibrary.Generator.GetString(false, false, true, MinStringLength, MaxStringLength); TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder = typeBuilder.DefineMethod(methodName, TestMethodAttributes); string[] typeParamNames = { "T" }; GenericTypeParameterBuilder[] typeParameters = builder.DefineGenericParameters(typeParamNames); GenericTypeParameterBuilder desiredReturnType = typeParameters[0]; builder.SetSignature(desiredReturnType.AsType(), null, null, null, null, null); VerifyMethodSignature(typeBuilder, builder, desiredReturnType.AsType()); }
public void DefineGenericParameters_TwoTypeParameters(string[] names) { TypeBuilder type = Helpers.DynamicType(TypeAttributes.NotPublic); MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public); GenericTypeParameterBuilder[] parameters = method.DefineGenericParameters(names); Assert.True(method.IsGenericMethod); Assert.True(method.IsGenericMethodDefinition); Assert.Equal(names.Length, parameters.Length); for (int i = 0; i < names.Length; i++) { GenericTypeParameterBuilder parameter = parameters[i]; Assert.Equal(method, parameter.DeclaringMethod); Assert.Equal(names[i], parameters[i].Name); Assert.Equal(i, parameters[i].GenericParameterPosition); } }
/// <summary> /// Defines the generic method parameters based on the specified method. /// </summary> /// <param name="methodBuilder">The method builder.</param> /// <param name="methodBase">The method base.</param> /// <returns>The generic parameter types.</returns> /// <remarks> /// Custom attributes are not considered by this method. /// </remarks> public static Type[] DefineGenericParameters(this MethodBuilder methodBuilder, MethodBase methodBase) { if (methodBuilder == null) { throw new ArgumentNullException("methodBuilder"); } if (methodBase == null) { throw new ArgumentNullException("methodBase"); } if (!methodBase.IsGenericMethodDefinition) { return(Type.EmptyTypes); } var genericParameterTypes = methodBase.GetGenericArguments(); var genericParameterNames = Array.ConvertAll(genericParameterTypes, t => t.Name); var genericParameterBuilders = methodBuilder.DefineGenericParameters(genericParameterNames); foreach (var genericParameterBuilder in genericParameterBuilders) { var genericParameterType = genericParameterTypes[genericParameterBuilder.GenericParameterPosition]; // Set generic parameter attributes. genericParameterBuilder.SetGenericParameterAttributes(genericParameterType.GenericParameterAttributes); // Set generic parameter constraints. var genericParameterConstraints = genericParameterType.GetGenericParameterConstraints(); var baseTypeConstraint = genericParameterConstraints.FirstOrDefault(t => t.IsClass); if (baseTypeConstraint != null) { genericParameterBuilder.SetBaseTypeConstraint(baseTypeConstraint); } var interfaceConstraints = genericParameterConstraints.Where(t => t.IsInterface).ToArray(); genericParameterBuilder.SetInterfaceConstraints(interfaceConstraints); } return(Array.ConvertAll(genericParameterBuilders, b => (Type)b)); }
private Dictionary <Type, Type> DefineMethodGenericParameters(MethodBuilder methodBuilder, MethodInfo methodInfo) { var genericParameters = methodInfo.GetGenericArguments(); var genericParameterNames = Enumerable.Range(1, genericParameters.Length).Select(it => $"T{it}").ToArray(); var builders = methodBuilder.DefineGenericParameters(genericParameterNames); for (int index = 0; index < genericParameters.Length; index++) { var builder = builders[index]; var genericParameter = genericParameters[index]; if (!genericParameter.IsGenericParameter) { continue; } builder.SetGenericParameterAttributes(genericParameter.GenericParameterAttributes); var interfaceConstraints = new List <Type>(); foreach (Type constraint in genericParameter.GetGenericParameterConstraints()) { if (constraint.IsClass) { builder.SetBaseTypeConstraint(constraint); } else { interfaceConstraints.Add(constraint); } } if (interfaceConstraints.Count > 0) { builder.SetInterfaceConstraints(interfaceConstraints.ToArray()); } } var map = new Dictionary <Type, Type>(); var genericParameters2 = methodBuilder.GetGenericArguments(); for (int index = 0; index < genericParameters.Length; index++) { map.Add(genericParameters[index], genericParameters2[index]); } return(map); }
private static MethodBuilder GenerateMethodSignature(string name, MethodInfo method, TypeBuilder typeBuilder) { const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; ParameterInfo[] parameters = method.GetParameters(); MethodBuilder methodBuilder = typeBuilder.DefineMethod(name, methodAttributes, CallingConventions.HasThis, method.ReturnType, parameters.Select(param => param.ParameterType).ToArray()); System.Type[] typeArgs = method.GetGenericArguments(); if (typeArgs.Length > 0) { var typeNames = new List <string>(); for (int index = 0; index < typeArgs.Length; index++) { typeNames.Add(string.Format("T{0}", index)); } var typeArgsBuilder = methodBuilder.DefineGenericParameters(typeNames.ToArray()); for (int index = 0; index < typeArgs.Length; index++) { // Copy generic parameter attributes (Covariant, Contravariant, ReferenceTypeConstraint, // NotNullableValueTypeConstraint, DefaultConstructorConstraint). typeArgsBuilder[index].SetGenericParameterAttributes(typeArgs[index].GenericParameterAttributes); // Copy generic parameter constraints (class and interfaces). var typeConstraints = typeArgs[index].GetGenericParameterConstraints(); var baseTypeConstraint = typeConstraints.SingleOrDefault(x => x.IsClass); typeArgsBuilder[index].SetBaseTypeConstraint(baseTypeConstraint); var interfaceTypeConstraints = typeConstraints.Where(x => !x.IsClass).ToArray(); typeArgsBuilder[index].SetInterfaceConstraints(interfaceTypeConstraints); } } return(methodBuilder); }
public void TestWithGenericReturnType() { string methodName = null; methodName = _generator.GetString(false, false, true, MinStringLength, MaxStringLength); TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder = typeBuilder.DefineMethod( methodName, MethodAttributes.Public); string[] typeParamNames = { "T", "U" }; GenericTypeParameterBuilder[] desiredParameters = builder.DefineGenericParameters(typeParamNames); builder.SetReturnType(desiredParameters[0].AsType()); Type[] actualParameters = builder.GetGenericArguments(); VerificationHelper(desiredParameters, actualParameters); }
public void TestThrowsExceptionForEmptyArray() { string name = "Assembly1"; AssemblyName asmname = new AssemblyName(); asmname.Name = name; AssemblyBuilder asmbuild = AssemblyBuilder.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run); ModuleBuilder modbuild = TestLibrary.Utilities.GetModuleBuilder(asmbuild, "Module1"); TypeBuilder tpbuild = modbuild.DefineType("C1", TypeAttributes.Public); MethodBuilder methbuild = tpbuild.DefineMethod("method1", MethodAttributes.Public | MethodAttributes.Static); string[] typeParamNames = { }; Assert.Throws <ArgumentException>(() => { GenericTypeParameterBuilder[] typeParameters = methbuild.DefineGenericParameters(typeParamNames); }); }
public void Bug354757() { TypeBuilder gtb = module.DefineType(genTypeName(), TypeAttributes.Public); gtb.DefineGenericParameters("T"); MethodBuilder mb = gtb.DefineMethod("foo", MethodAttributes.Public); mb.DefineGenericParameters("S"); Assert.IsTrue(mb.IsGenericMethodDefinition); Type gt = gtb.MakeGenericType(typeof(object)); MethodInfo m = TypeBuilder.GetMethod(gt, mb); Assert.IsTrue(m.IsGenericMethodDefinition); MethodInfo mopen = m.MakeGenericMethod(m.GetGenericArguments()); Assert.IsFalse(mopen.IsGenericMethodDefinition); }
public void DefineGenericParameter_MultipleParameters() { TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public); MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public, typeof(int), new Type[0]); method.DefineGenericParameters(new string[] { "T", "U", "V" }); ILGenerator ilGenerator = method.GetILGenerator(); ilGenerator.Emit(OpCodes.Ldc_I4, 100); ilGenerator.Emit(OpCodes.Ret); Type resultType = type.CreateType(); Type[] typeArguments = { typeof(int), typeof(string), typeof(object) }; MethodInfo constructedMethod = resultType.GetMethod("TestMethod").MakeGenericMethod(typeArguments); Assert.Equal(typeArguments, constructedMethod.GetGenericArguments()); }
public void TestWithMultipleGenericParameters() { var methodName = _generator.GetString(false, false, true, MinStringLength, MaxStringLength); TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder = typeBuilder.DefineMethod(methodName, TestMethodAttributes); string[] typeParamNames = { "T", "U" }; GenericTypeParameterBuilder[] typeParameters = builder.DefineGenericParameters(typeParamNames); Type desiredReturnType = typeParameters[1].AsType(); builder.SetReturnType(desiredReturnType); typeBuilder.CreateTypeInfo().AsType(); VerifyReturnType(builder, desiredReturnType); }
public void SetSignature_NullReturnType_RequiredCustomModifiers_OptionalCustomModifiers() { TypeBuilder type = Helpers.DynamicType(TypeAttributes.Abstract); MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual); GenericTypeParameterBuilder[] typeParameters = method.DefineGenericParameters("T"); GenericTypeParameterBuilder desiredReturnType = typeParameters[0]; Type[] desiredParamType = new Type[] { typeof(void) }; Type[][] parameterTypeRequiredCustomModifiers = new Type[desiredParamType.Length][]; Type[][] parameterTypeOptionalCustomModifiers = new Type[desiredParamType.Length][]; for (int i = 0; i < desiredParamType.Length; ++i) { parameterTypeRequiredCustomModifiers[i] = null; parameterTypeOptionalCustomModifiers[i] = null; } method.SetSignature(desiredReturnType.AsType(), null, null, desiredParamType, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers); }
public void PosTest5() { ModuleBuilder module = Helpers.DynamicModule(); TypeBuilder type1 = module.DefineType("C1", TypeAttributes.Public); type1.DefineGenericParameters("T"); MethodBuilder method1 = type1.DefineMethod("meth1", MethodAttributes.Public, typeof(int), new Type[0]); method1.DefineGenericParameters("U"); int expectedRet = 1; // Generate code for the method that we are going to use as MethodInfo in ILGenerator.Emit() ILGenerator ilGenerator1 = method1.GetILGenerator(); ilGenerator1.Emit(OpCodes.Ldc_I4, expectedRet); ilGenerator1.Emit(OpCodes.Ret); // create the type where this method is in Type createdType1 = type1.CreateTypeInfo().AsType(); Type genericType = createdType1.MakeGenericType(typeof(int)); MethodInfo createdMethod1 = genericType.GetMethod("meth1"); MethodInfo genericMethod = createdMethod1.MakeGenericMethod(typeof(string)); TypeBuilder type2 = module.DefineType("C2", TypeAttributes.Public); MethodBuilder method2 = type2.DefineMethod("meth2", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[0]); // Generate code for the method which will be invoking the first method ILGenerator ilGenerator2 = method2.GetILGenerator(); ilGenerator2.Emit(OpCodes.Newobj, genericType.GetConstructor(new Type[0])); ilGenerator2.Emit(OpCodes.Callvirt, genericMethod); ilGenerator2.Emit(OpCodes.Ret); // Create the type whose method will be invoking the MethodInfo method Type createdType2 = type2.CreateTypeInfo().AsType(); MethodInfo createdMethod2 = createdType2.GetMethod("meth2"); // meth2 should invoke meth1 which should return value 'methodRet' Assert.Equal(expectedRet, createdMethod2.Invoke(null, null)); }
public void SetSignature_NullOnReturnType_CustomModifiersSetCorrectly() { int arraySize = 10; TypeBuilder type = Helpers.DynamicType(TypeAttributes.Abstract); MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual); GenericTypeParameterBuilder[] typeParameters = method.DefineGenericParameters("T"); GenericTypeParameterBuilder desiredReturnType = typeParameters[0]; Type[] desiredParamType = null; Type[][] parameterTypeRequiredCustomModifiers = new Type[arraySize][]; Type[][] parameterTypeOptionalCustomModifiers = new Type[arraySize][]; for (int i = 0; i < arraySize; ++i) { parameterTypeRequiredCustomModifiers[i] = null; parameterTypeOptionalCustomModifiers[i] = null; } method.SetSignature(desiredReturnType.AsType(), null, null, desiredParamType, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers); }
/// <summary> /// DefineDerivedMethodSignature 定义动态类中方法的签名,支持泛型方法。 /// </summary> public static MethodBuilder DefineDerivedMethodSignature(TypeBuilder typeBuilder, MethodInfo baseMethod) { Type[] argTypes = EmitHelper.GetParametersType(baseMethod); MethodBuilder methodBuilder = typeBuilder.DefineMethod(baseMethod.Name, baseMethod.Attributes & ~MethodAttributes.Abstract, baseMethod.ReturnType, argTypes); #region GenericMethod if (baseMethod.IsGenericMethod) { Type[] genericParaTypes = baseMethod.GetGenericArguments(); string[] genericParaNames = EmitHelper.GetGenericParameterNames(baseMethod); GenericTypeParameterBuilder[] genericTypeParameterBuilders = methodBuilder.DefineGenericParameters(genericParaNames); for (int i = 0; i < genericTypeParameterBuilders.Length; i++) { genericTypeParameterBuilders[i].SetInterfaceConstraints(genericParaTypes[i].GetGenericParameterConstraints()); } } #endregion return(methodBuilder); }
public void ILGen_GenericTypeParameterBuilder() { TypeBuilder tb = module.DefineType(genTypeName(), TypeAttributes.Public); MethodBuilder mb = tb.DefineMethod("box_int", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type [] { typeof(int) }); GenericTypeParameterBuilder[] pars = mb.DefineGenericParameters(new string [] { "foo" }); ILGenerator ilgen = mb.GetILGenerator(); ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Box, pars [0]); ilgen.Emit(OpCodes.Ret); Type t = tb.CreateType(); MethodInfo mi = t.GetMethod("box_int"); MethodInfo mi2 = mi.MakeGenericMethod(new Type [] { typeof(int) }); Assert.AreEqual(1, mi2.Invoke(null, new object [] { 1 })); }
private void SetupGenericParameters(MethodBuilder methodBuilder) { if (methodToOverride.IsGenericMethod) { Type[] genericArguments = methodToOverride.GetGenericArguments(); string[] names = Seq.Make(genericArguments) .Map <string>(delegate(Type t) { return(t.Name); }) .ToArray(); GenericTypeParameterBuilder[] builders = methodBuilder.DefineGenericParameters(names); for (int i = 0; i < genericArguments.Length; ++i) { builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes); foreach (Type type in genericArguments[i].GetGenericParameterConstraints()) { builders[i].SetBaseTypeConstraint(type); } } } }
protected internal override void GeneratingGenericParameter(MethodBuilder declaringMethod) { var genericArguments = method.GetGenericArguments().ToArray(); var genericArgumentsBuilders = declaringMethod.DefineGenericParameters(genericArguments.Select(a => a.Name).ToArray()); for (var index = 0; index < genericArguments.Length; index++) { genericArgumentsBuilders[index].SetGenericParameterAttributes(genericArguments[index].GenericParameterAttributes); foreach (var constraint in genericArguments[index].GetGenericParameterConstraints()) { if (constraint.IsClass) { genericArgumentsBuilders[index].SetBaseTypeConstraint(constraint); } if (constraint.IsInterface) { genericArgumentsBuilders[index].SetInterfaceConstraints(constraint); } } } }
private static MethodInfo Create_ConvertByrefToPtr() { // We dont use AssemblyGen.DefineMethod since that can create a anonymously-hosted DynamicMethod which cannot contain unverifiable code. var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("ComSnippets"), AssemblyBuilderAccess.Run); var moduleBuilder = assemblyBuilder.DefineDynamicModule("ComSnippets"); var type = moduleBuilder.DefineType("Type$ConvertByrefToPtr", TypeAttributes.Public); Type[] paramTypes = new Type[] { typeof(Variant).MakeByRefType() }; MethodBuilder mb = type.DefineMethod("ConvertByrefToPtr", MethodAttributes.Public | MethodAttributes.Static, typeof(IntPtr), paramTypes); GenericTypeParameterBuilder[] typeParams = mb.DefineGenericParameters("T"); typeParams[0].SetGenericParameterAttributes(GenericParameterAttributes.NotNullableValueTypeConstraint); mb.SetSignature(typeof(IntPtr), null, null, new Type[] { typeParams[0].MakeByRefType() }, null, null); ILGenerator method = mb.GetILGenerator(); method.Emit(OpCodes.Ldarg_0); method.Emit(OpCodes.Conv_I); method.Emit(OpCodes.Ret); return type.CreateType().GetMethod("ConvertByrefToPtr"); }
public void SetParameters_NullParameter_ThrowsArgumentNullException() { TypeBuilder type = Helpers.DynamicType(TypeAttributes.Abstract); MethodBuilder builder = type.DefineMethod("TestMethod", MethodAttributes.Public, typeof(void), new Type[] { typeof(int) }); Type[] typeParameters = builder.DefineGenericParameters("T").Select(a => a.AsType()).ToArray(); Type[] parameterTypes = new Type[typeParameters.Length + 1]; for (int i = 0; i < typeParameters.Length; ++i) { parameterTypes[i] = typeParameters[i]; } parameterTypes[typeParameters.Length] = null; builder.SetParameters(parameterTypes); ILGenerator ilGenerator = builder.GetILGenerator(); ilGenerator.Emit(OpCodes.Ret); AssertExtensions.Throws <ArgumentNullException>("argument", () => type.CreateTypeInfo().AsType()); }
private static void DefineGenericMethodParameters(MethodInfo method, MethodBuilder methodBuilder) { var typeParameters = method.GetGenericArguments(); var typeParameterBuilders = methodBuilder .DefineGenericParameters(typeParameters.Select(tp => tp.Name).ToArray()) .ToDictionary(b => b.Name); SetGenericTypeConstraints(typeParameterBuilders, typeParameters); var returnType = method.ReturnType; methodBuilder.SetReturnType( returnType.IsGenericMethodParameter ? typeParameterBuilders[returnType.Name] : returnType); var parameters = method.GetParameters(); methodBuilder.SetParameters( parameters .Select(p => p.ParameterType) .Select(t => t.IsGenericMethodParameter ? typeParameterBuilders[t.Name] : t) .ToArray()); }
public void SetSignature_GenericMethod_ParameterType_RequiredCustomModifiers() { TypeBuilder type = Helpers.DynamicType(TypeAttributes.Abstract); MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual); string[] typeParamNames = new string[] { "T" }; GenericTypeParameterBuilder[] typeParameters = method.DefineGenericParameters(typeParamNames); GenericTypeParameterBuilder desiredReturnType = typeParameters[0]; Type[] desiredParamType = new Type[] { typeof(int) }; Type[][] parameterTypeRequiredCustomModifiers = new Type[desiredParamType.Length][]; for (int i = 0; i < desiredParamType.Length; ++i) { parameterTypeRequiredCustomModifiers[i] = null; } method.SetSignature(desiredReturnType.AsType(), null, null, desiredParamType, parameterTypeRequiredCustomModifiers, null); VerifyMethodSignature(type, method, desiredReturnType.AsType()); }
/// <summary> /// 返回具体类型的对象存储实例 /// </summary> /// <typeparam name="T">处理的类型</typeparam> /// <returns>返回一个动态实例</returns> public static PropertyValueStored <T> BuildMethod <T>() { AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Assembly"), AssemblyBuilderAccess.Run); ModuleBuilder defineDynamicModule = assemblyBuilder.DefineDynamicModule("Module"); TypeBuilder typeBuilder = defineDynamicModule.DefineType("KJFramework.DynamicModule.ValueStored", TypeAttributes.Public | TypeAttributes.Class, typeof(PropertyValueStored <T>), new Type[] {}); MethodBuilder methodBuilder = typeBuilder.DefineMethod("Get", MethodAttributes.Public | MethodAttributes.Virtual); GenericTypeParameterBuilder[] gpas = methodBuilder.DefineGenericParameters("K"); methodBuilder.SetParameters(typeof(T)); methodBuilder.SetReturnType(gpas[0].AsType()); methodBuilder.DefineParameter(1, ParameterAttributes.None, "value"); ILGenerator ilGenerator = methodBuilder.GetILGenerator(); ilGenerator.Emit(OpCodes.Ldarg_1); //(T)value //ilGenerator.Emit(OpCodes.Castclass, typeof(T)); ilGenerator.Emit(OpCodes.Ret); return((PropertyValueStored <T>)typeBuilder.Assembly.CreateInstance(typeBuilder.CreateTypeInfo().FullName)); }
public static GenericTypeParameterBuilder[] CreateGenericParametersFrom( MethodBuilder methodBuilder, MethodInfo methodInfo) { if (methodBuilder == null) { throw new ArgumentNullException(nameof(methodBuilder)); } if (methodInfo == null) { throw new ArgumentNullException(nameof(methodInfo)); } var arguments = methodInfo.GetGenericArguments(); var parameters = methodBuilder.DefineGenericParameters(arguments.Select(i => i.Name).ToArray()).ToArray(); CopyGenericParametersInformation(parameters, arguments); return(parameters); }
public void TestAfterTypeCreated() { string methodName = null; methodName = _generator.GetString(false, false, true, MinStringLength, MaxStringLength); Type[] parameterTypes = new Type[] { typeof(int) }; TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder = typeBuilder.DefineMethod(methodName, TestMethodAttributes, typeof(int), parameterTypes); string[] typeParamNames = { "T", "U" }; GenericTypeParameterBuilder[] typeParameters = builder.DefineGenericParameters(typeParamNames); Type desiredReturnType = typeParameters[0].AsType(); typeBuilder.CreateTypeInfo().AsType(); builder.SetReturnType(desiredReturnType); }
public void TestOverwriteGenericReturnTypeWithGenericType() { string methodName = null; methodName = TestLibrary.Generator.GetString(false, false, true, MinStringLength, MaxStringLength); TypeBuilder typeBuilder = GetTestTypeBuilder(); MethodBuilder builder = typeBuilder.DefineMethod(methodName, TestMethodAttributes); string[] typeParamNames = { "T", "U" }; GenericTypeParameterBuilder[] typeParameters = builder.DefineGenericParameters(typeParamNames); Type desiredReturnType = typeParameters[1].AsType(); builder.SetReturnType(typeParameters[0].AsType()); builder.SetReturnType(desiredReturnType); typeBuilder.CreateTypeInfo().AsType(); VerifyReturnType(builder, desiredReturnType); }
private static MethodBuilder DefineGeneric(this MethodBuilder methodBuilder, MethodInfo method) { var genericArguments = method.GetGenericArguments(); var genericArgumentsBuilders = methodBuilder.DefineGenericParameters(genericArguments.Select(a => a.Name).ToArray()); genericArguments.ForEach((arg, index) => { genericArgumentsBuilders[index].SetGenericParameterAttributes(arg.GenericParameterAttributes); arg.GetGenericParameterConstraints().ForEach(constraint => { if (constraint.IsClass) { genericArgumentsBuilders[index].SetBaseTypeConstraint(constraint); } if (constraint.IsInterface) { genericArgumentsBuilders[index].SetInterfaceConstraints(constraint); } }); }); return(methodBuilder); }
public void CreateProxyMethod( MethodInfo methodInfo, TypeBuilder typeBuilder) { ParameterInfo[] paramInfos = methodInfo.GetParameters(); Type[] paramTypes = new Type[paramInfos.Length]; for (int i = 0; i < paramInfos.Length; i++) { paramTypes[i] = paramInfos[i].ParameterType; } MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig; MethodBuilder methodBuilder = typeBuilder.DefineMethod( methodInfo.Name, methodAttributes, CallingConventions.HasThis, methodInfo.ReturnType, paramTypes); Type[] genericArgs = methodInfo.GetGenericArguments(); if (genericArgs != null && genericArgs.Length > 0) { string[] typeNames = new string[genericArgs.Length]; for (int i = 0; i < genericArgs.Length; i++) { typeNames[i] = "T" + i; } methodBuilder.DefineGenericParameters(typeNames); } ILGenerator ilGenerator = methodBuilder.GetILGenerator(); BuildProxyMethodBody(methodInfo, ilGenerator); }
public void ILGen_InstantiatedGenericType() { TypeBuilder tb = module.DefineType(genTypeName(), TypeAttributes.Public); MethodBuilder mb = tb.DefineMethod("return_type", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type [] { }); GenericTypeParameterBuilder[] pars = mb.DefineGenericParameters(new string [] { "foo" }); ILGenerator ilgen = mb.GetILGenerator(); Type genericFoo = typeof(GenericFoo <int>).GetGenericTypeDefinition().MakeGenericType(new Type [] { pars [0] }); ilgen.Emit(OpCodes.Ldtoken, genericFoo); ilgen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle")); ilgen.Emit(OpCodes.Ret); Type t = tb.CreateType(); MethodInfo mi = t.GetMethod("box_int"); MethodInfo mi2 = mi.MakeGenericMethod(new Type [] { typeof(int) }); Assert.AreEqual(typeof(GenericFoo <int>), mi2.Invoke(null, new object [] { 1 })); }