| public AddInterfaceImplementation ( System interfaceType ) : void | ||
| interfaceType | System | |
| return | void | |
public void ImplementProxy(TypeBuilder typeBuilder)
{
// Implement the IProxy interface
typeBuilder.AddInterfaceImplementation(typeof (IProxy));
field = typeBuilder.DefineField("__interceptor", typeof (IInterceptor), FieldAttributes.Private);
// Implement the getter
MethodBuilder getterMethod = typeBuilder.DefineMethod("get_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof(IInterceptor), new System.Type[0]);
getterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
ILGenerator IL = getterMethod.GetILGenerator();
// This is equivalent to:
// get { return __interceptor;
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Ldfld, field);
IL.Emit(OpCodes.Ret);
// Implement the setter
MethodBuilder setterMethod = typeBuilder.DefineMethod("set_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (void), new[] {typeof (IInterceptor)});
setterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
IL = setterMethod.GetILGenerator();
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Ldarg_1);
IL.Emit(OpCodes.Stfld, field);
IL.Emit(OpCodes.Ret);
MethodInfo originalSetter = typeof (IProxy).GetMethod("set_Interceptor");
MethodInfo originalGetter = typeof (IProxy).GetMethod("get_Interceptor");
typeBuilder.DefineMethodOverride(setterMethod, originalSetter);
typeBuilder.DefineMethodOverride(getterMethod, originalGetter);
}
public void ImplementProxy(TypeBuilder typeBuilder)
{
typeBuilder.AddInterfaceImplementation(typeof (IProxy));
InterceptorField = typeBuilder
.DefineField("__interceptor",
typeof (Proxy.DynamicProxy.IInterceptor),
FieldAttributes.Private);
var getterMethod = typeBuilder
.DefineMethod("get_Interceptor",
InterceptorMethodsAttributes,
CallingConventions.HasThis,
typeof (Proxy.DynamicProxy.IInterceptor),
new System.Type[0]);
getterMethod.SetImplementationFlags(MethodImplAttributes.IL);
var il = getterMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, InterceptorField);
il.Emit(OpCodes.Ret);
var setterMethod = typeBuilder
.DefineMethod("set_Interceptor",
InterceptorMethodsAttributes,
CallingConventions.HasThis,
typeof (void),
new[] {typeof (Proxy.DynamicProxy.IInterceptor)});
setterMethod.SetImplementationFlags(MethodImplAttributes.IL);
il = setterMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, InterceptorField);
il.Emit(OpCodes.Ret);
var originalSetter = typeof (IProxy).GetMethod("set_Interceptor");
var originalGetter = typeof (IProxy).GetMethod("get_Interceptor");
typeBuilder.DefineMethodOverride(setterMethod, originalSetter);
typeBuilder.DefineMethodOverride(getterMethod, originalGetter);
}
/// <summary>
/// Generates the type.
/// </summary>
/// <returns></returns>
public Type GenerateType()
{
if (_generatedType == null)
{
// Setup the assembly and type builder
AssemblyName assemblyName = new AssemblyName("Mock.Generated-" + _interfaceToImplement.Name);
AssemblyBuilder assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name);
_typeBuilder = moduleBuilder.DefineType("Mock.Generated.Mock" + _interfaceToImplement.Name, TypeAttributes.Public);
_typeBuilder.AddInterfaceImplementation(_interfaceToImplement);
// Generate the body of the type
this.CreateFields();
this.CreateConstructor();
foreach (MethodInfo method in _interfaceToImplement.GetMethods(BindingFlags.Public | BindingFlags.Instance).Where(m => !m.Name.StartsWith("get_")))
{
this.ImplementMethod(method);
}
foreach (PropertyInfo property in _interfaceToImplement.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
this.ImplementProperty(property);
}
// Store the generated type for use again
_generatedType = _typeBuilder.CreateType();
}
return _generatedType;
}
private void ImplementInterfaceProperties(Type interfaceOfTypeToCreate, System.Reflection.Emit.TypeBuilder typeBuilder)
{
typeBuilder.AddInterfaceImplementation(interfaceOfTypeToCreate);
foreach (var implementedInterfaceType in interfaceOfTypeToCreate.GetInterfaces())
{
ImplementInterfaceProperties(implementedInterfaceType, typeBuilder);
}
foreach (var pi in interfaceOfTypeToCreate.GetProperties())
{
var backingFieldBuilder = typeBuilder.DefineField($"{interfaceOfTypeToCreate.Name}._{ToCamelCase(pi.Name)}", pi.PropertyType, FieldAttributes.Private);
var accessorAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Virtual | MethodAttributes.HideBySig;
var mbGetAccessor = typeBuilder.DefineMethod($"get_{pi.Name}", accessorAttributes, pi.PropertyType, Type.EmptyTypes);
var mbGetIL = mbGetAccessor.GetILGenerator();
mbGetIL.Emit(OpCodes.Ldarg_0);
mbGetIL.Emit(OpCodes.Ldfld, backingFieldBuilder);
mbGetIL.Emit(OpCodes.Ret);
var mbSetAccessor = typeBuilder.DefineMethod($"set_{pi.Name}", accessorAttributes, null, new[] { pi.PropertyType });
var mbSetIL = mbSetAccessor.GetILGenerator();
mbSetIL.Emit(OpCodes.Ldarg_0);
mbSetIL.Emit(OpCodes.Ldarg_1);
mbSetIL.Emit(OpCodes.Stfld, backingFieldBuilder);
mbSetIL.Emit(OpCodes.Ret);
var propertyBuilder = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, pi.PropertyType, null);
propertyBuilder.SetGetMethod(mbGetAccessor);
propertyBuilder.SetSetMethod(mbSetAccessor);
}
}
// 构造类型
void BuildType()
{
_typeBuilder = _moduleBuilder.DefineType(string.Format(TypeNameFormat, _realProxyType.Name),
TypeAttributes.Public | TypeAttributes.Sealed);
_typeBuilder.AddInterfaceImplementation(_interfaceType);
//if ( _baseType!=null)
// _typeBuilder.SetParent(_baseType);
}
internal static FieldBuilder ImplementIInterceptingProxy(TypeBuilder typeBuilder)
{
typeBuilder.AddInterfaceImplementation(typeof(IInterceptingProxy));
FieldBuilder proxyInterceptorPipelineField =
typeBuilder.DefineField(
"pipeline",
typeof(InterceptionBehaviorPipeline),
FieldAttributes.Private | FieldAttributes.InitOnly);
ImplementAddInterceptionBehavior(typeBuilder, proxyInterceptorPipelineField);
return proxyInterceptorPipelineField;
}
public Type CreateType(String typeName, Type parent)
{
_typeBuilder = _moduleBuilder.DefineType(typeName,
TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass |
TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout,
parent, new[] { typeof(IProxy) });
_typeBuilder.AddInterfaceImplementation(typeof(IProxy));
ImplementProxyInterface(parent);
var propHandlerDic = OverrideProperties(parent);
GenerateConstructor(propHandlerDic);
return _typeBuilder.CreateType();
}
public void Build(TypeBuilder builder, Type contractType)
{
builder.AddInterfaceImplementation(typeof(IAutoNotifyPropertyChanged));
FieldBuilder addPropertyChangedField = builder.DefineField("PropertyChanged", typeof (PropertyChangingEventHandler), FieldAttributes.Private);
MethodBuilder addMethod = DefineAddOnMethod(builder, addPropertyChangedField);
MethodBuilder removeMethod = DefineRemoveOnMethod(builder, addPropertyChangedField);
MethodBuilder notifyPropertyChangedMethod = DefineRaiseMethod(builder, addPropertyChangedField);
EventBuilder pcevent = builder.DefineEvent("PropertyChanged", EventAttributes.None, typeof(PropertyChangedEventHandler));
pcevent.SetRaiseMethod(notifyPropertyChangedMethod);
pcevent.SetAddOnMethod(addMethod);
pcevent.SetRemoveOnMethod(removeMethod);
}
public void ImplementProxy(TypeBuilder b)
{
var dynamicProxyType = typeof(IDynamicProxy);
b.AddInterfaceImplementation(dynamicProxyType);
_fieldBuilder = b.DefineField("__interceptor", typeof(IMethodInterceptor), FieldAttributes.Private);
const MethodAttributes attributes = MethodAttributes.SpecialName | MethodAttributes.VtableLayoutMask | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public;
var getMethodBuilder = b.DefineMethod("get_Interceptor", attributes, CallingConventions.HasThis, typeof(IMethodInterceptor), new Type[0]);
getMethodBuilder.SetImplementationFlags(MethodImplAttributes.IL);
var w = getMethodBuilder.GetILGenerator();
w.Emit(OpCodes.Ldarg_0);
w.Emit(OpCodes.Ldfld, _fieldBuilder);
w.Emit(OpCodes.Ret);
var setMethodBuilder = b.DefineMethod("set_Interceptor", attributes, CallingConventions.HasThis, typeof(void), new Type[] { typeof(IMethodInterceptor) });
setMethodBuilder.SetImplementationFlags(MethodImplAttributes.IL);
w = setMethodBuilder.GetILGenerator();
w.Emit(OpCodes.Ldarg_0);
w.Emit(OpCodes.Ldarg_1);
w.Emit(OpCodes.Stfld, _fieldBuilder);
w.Emit(OpCodes.Ret);
b.DefineMethodOverride(setMethodBuilder, dynamicProxyType.GetMethod("set_Interceptor"));
b.DefineMethodOverride(getMethodBuilder, dynamicProxyType.GetMethod("get_Interceptor"));
}
public static void Implement (TypeBuilder typeB, Type iface)
{
typeB.AddInterfaceImplementation (iface);
foreach (MethodInfo declMethod in iface.GetMethods ()) {
MethodBuilder method_builder = typeB.DefineMethod (declMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, declMethod.ReturnType, Mapper.GetTypes (ArgDirection.In, declMethod.GetParameters ()));
ILGenerator ilg = method_builder.GetILGenerator ();
//Mapper.GetTypes (ArgDirection.In, declMethod.GetParameters ())
ParameterInfo[] delegateParms = declMethod.GetParameters ();
Type[] hookupParms = new Type[delegateParms.Length+1];
hookupParms[0] = typeof (BusObject);
for (int i = 0; i < delegateParms.Length ; i++)
hookupParms[i+1] = delegateParms[i].ParameterType;
GenHookupMethod (ilg, declMethod, sendMethodCallMethod, Mapper.GetInterfaceName (iface), declMethod.Name, hookupParms);
typeB.DefineMethodOverride (method_builder, declMethod);
}
}
private void DefineMethodWithInterfaces(TypeBuilder typeBuilder)
{
var interfaceList = new List <Type>(interfaceTypes);
if (interfaceList.Any())
{
var i = 0;
for (var interfaceType = interfaceList[0]; i < interfaceList.Count; ++i)
{
interfaceType = interfaceList[i];
typeBuilder.AddInterfaceImplementation(interfaceType);
foreach (var interfaceMethod in interfaceType.GetMethods())
{
if (methodMappingMap.TryGetValue(interfaceMethod.Name, out var methodMapping) == false)
{
methodMappingMap[interfaceMethod.Name] = methodMapping = DefineMethod(typeBuilder, interfaceMethod);
}
methodMapping.Insert(methodMapping.Count, interfaceMethod);
typeBuilder.DefineMethodOverride(methodMapping.MethodBuilder, interfaceMethod);
}
foreach (var nestedInterfaceType in interfaceType.GetInterfaces())
{
if (interfaceList.Contains(nestedInterfaceType))
{
continue;
}
interfaceList.Insert(interfaceList.Count, nestedInterfaceType);
}
}
}
}
public static void Implement (TypeBuilder typeB, Type iface)
{
typeB.AddInterfaceImplementation (iface);
foreach (MethodInfo declMethod in iface.GetMethods ()) {
ParameterInfo[] parms = declMethod.GetParameters ();
Type[] parmTypes = new Type[parms.Length];
for (int i = 0 ; i < parms.Length ; i++)
parmTypes[i] = parms[i].ParameterType;
MethodAttributes attrs = declMethod.Attributes ^ MethodAttributes.Abstract;
MethodBuilder method_builder = typeB.DefineMethod (declMethod.Name, attrs, declMethod.ReturnType, parmTypes);
typeB.DefineMethodOverride (method_builder, declMethod);
//define in/out/ref/name for each of the parameters
for (int i = 0; i < parms.Length ; i++)
method_builder.DefineParameter (i, parms[i].Attributes, parms[i].Name);
ILGenerator ilg = method_builder.GetILGenerator ();
GenHookupMethod (ilg, declMethod, sendMethodCallMethod, Mapper.GetInterfaceName (iface), declMethod.Name);
}
}
/// <summary>
/// Implements an interface.
/// </summary>
/// <remarks>
/// Generates proxy methods that belongs to the interface
/// using the specified <paramref name="proxyMethodBuilder"/>.
/// </remarks>
/// <param name="typeBuilder">The type builder to use.</param>
/// <param name="proxyMethodBuilder">
/// The <see cref="IProxyMethodBuilder"/> implementation to use
/// </param>
/// <param name="intf">The interface to implement.</param>
/// <param name="targetType">
/// The <see cref="System.Type"/> of the target object.
/// </param>
/// <param name="proxyVirtualMethods">
/// <see langword="false"/> if target virtual methods should not be proxied;
/// otherwise <see langword="true"/>.
/// </param>
protected virtual void ImplementInterface(TypeBuilder typeBuilder,
IProxyMethodBuilder proxyMethodBuilder, Type intf,
Type targetType, bool proxyVirtualMethods)
{
Dictionary<string, MethodBuilder> methodMap = new Dictionary<string, MethodBuilder>();
InterfaceMapping mapping = GetInterfaceMapping(targetType, intf);
typeBuilder.AddInterfaceImplementation(intf);
for (int i = 0; i < mapping.InterfaceMethods.Length; i++)
{
if (!proxyVirtualMethods &&
!mapping.TargetMethods[i].DeclaringType.IsInterface &&
mapping.TargetMethods[i].IsVirtual &&
!mapping.TargetMethods[i].IsFinal)
continue;
MethodBuilder methodBuilder = proxyMethodBuilder.BuildProxyMethod(
mapping.TargetMethods[i], mapping.InterfaceMethods[i]);
ApplyMethodAttributes(methodBuilder, mapping.TargetMethods[i]);
methodMap[mapping.InterfaceMethods[i].Name] = methodBuilder;
}
foreach (PropertyInfo property in intf.GetProperties())
{
ImplementProperty(typeBuilder, intf, property, methodMap);
}
foreach (EventInfo evt in intf.GetEvents())
{
ImplementEvent(typeBuilder, intf, evt, methodMap);
}
}
public Type Compile(Type superType, Type stubType, IPersistentVector interfaces, bool onetimeUse, GenContext context)
{
if (_compiledType != null)
return _compiledType;
string publicTypeName = IsDefType || (_isStatic && Compiler.IsCompiling) ? InternalName : InternalName + "__" + RT.nextID();
_typeBuilder = context.AssemblyGen.DefinePublicType(publicTypeName, superType, true);
context = context.WithNewDynInitHelper().WithTypeBuilder(_typeBuilder);
Var.pushThreadBindings(RT.map(Compiler.CompilerContextVar, context));
try
{
if (interfaces != null)
{
for (int i = 0; i < interfaces.count(); i++)
_typeBuilder.AddInterfaceImplementation((Type)interfaces.nth(i));
}
ObjExpr.MarkAsSerializable(_typeBuilder);
GenInterface.SetCustomAttributes(_typeBuilder, _classMeta);
try
{
if (IsDefType)
{
Compiler.RegisterDuplicateType(_typeBuilder);
Var.pushThreadBindings(RT.map(
Compiler.CompileStubOrigClassVar, stubType
));
//,
//Compiler.COMPILE_STUB_CLASS, _baseType));
}
EmitConstantFieldDefs(_typeBuilder);
EmitKeywordCallsiteDefs(_typeBuilder);
DefineStaticConstructor(_typeBuilder);
if (SupportsMeta)
_metaField = _typeBuilder.DefineField("__meta", typeof(IPersistentMap), FieldAttributes.Public | FieldAttributes.InitOnly);
// If this IsDefType, then it has already emitted the closed-over fields on the base class.
if ( ! IsDefType )
EmitClosedOverFields(_typeBuilder);
EmitProtocolCallsites(_typeBuilder);
_ctorInfo = EmitConstructor(_typeBuilder, superType);
if (_altCtorDrops > 0)
EmitFieldOnlyConstructor(_typeBuilder, superType);
if (SupportsMeta)
{
EmitNonMetaConstructor(_typeBuilder, superType);
EmitMetaFunctions(_typeBuilder);
}
EmitStatics(_typeBuilder);
EmitMethods(_typeBuilder);
//if (KeywordCallsites.count() > 0)
// EmitSwapThunk(_typeBuilder);
_compiledType = _typeBuilder.CreateType();
if (context.DynInitHelper != null)
context.DynInitHelper.FinalizeType();
_ctorInfo = GetConstructorWithArgCount(_compiledType, CtorTypes().Length);
return _compiledType;
}
finally
{
if (IsDefType)
Var.popThreadBindings();
}
}
finally
{
Var.popThreadBindings();
}
}
private void GenerateFnClass(IPersistentVector interfaces, GenContext context)
{
string publicTypeName = IsDefType || (IsStatic && Compiler.IsCompiling) ? _internalName : _internalName + "__" + RT.nextID();
//Console.WriteLine("DefFn {0}, {1}", publicTypeName, context.AssemblyBuilder.GetName().Name);
_typeBuilder = context.AssemblyGen.DefinePublicType(publicTypeName, _baseType, true);
for (int i = 0; i < interfaces.count(); i++)
_typeBuilder.AddInterfaceImplementation((Type)interfaces.nth(i));
MarkAsSerializable(_typeBuilder);
GenInterface.SetCustomAttributes(_typeBuilder, _classMeta);
GenerateStaticConstructor(_typeBuilder, _baseType, context.IsDebuggable);
_ctorInfo = GenerateConstructor(_typeBuilder, _baseType);
if (_altCtorDrops > 0)
GenerateFieldOnlyConstructor(_typeBuilder, _baseType);
if (SupportsMeta)
{
_nonmetaCtorInfo = GenerateNonMetaConstructor(_typeBuilder, _baseType);
}
GenerateMetaFunctions(_typeBuilder);
//GenerateReloadVarsMethod(_typeBuilder, context);
// The incoming context holds info on the containing function.
// That is the one that holds the closed-over variable values.
//GenContext newContext = CreateContext(context, _typeBuilder, _baseType);
//GenerateMethods(newContext);
GenerateStatics(context);
GenerateMethods(context);
}
/// <summary>
/// Implements the proxy interceptor fields.
/// </summary>
/// <param name="typeBuilder">
/// The <see cref="TypeBuilder"/> for the current proxy type.
/// </param>
/// <returns>
/// The <see cref="FieldBuilder"/> for the interceptor.
/// </returns>
public static FieldBuilder Emit(TypeBuilder typeBuilder)
{
// Implement the IProxy interface
typeBuilder.AddInterfaceImplementation(typeof(IProxy));
// Define the private "interceptor" filed.
FieldBuilder fieldBuilder = typeBuilder.DefineField("interceptor", typeof(IInterceptor), FieldAttributes.Private);
// Define the correct attributes fot the property. This makes it public virtual.
const MethodAttributes Attributes = MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.SpecialName | MethodAttributes.NewSlot |
MethodAttributes.Virtual;
// Implement the getter
MethodBuilder getterMethod = typeBuilder.DefineMethod(
"get_Interceptor",
Attributes,
CallingConventions.HasThis,
typeof(IInterceptor),
new Type[0]);
// Set the correct flags to signal the property is managed and implemented in intermediate language.
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
getterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
ILGenerator il = getterMethod.GetILGenerator();
// This is equivalent to:
// get { return this.interceptor; }
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, fieldBuilder);
il.Emit(OpCodes.Ret);
// Implement the setter
MethodBuilder setterMethod = typeBuilder.DefineMethod(
"set_Interceptor",
Attributes,
CallingConventions.HasThis,
typeof(void),
new[] { typeof(IInterceptor) });
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
setterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
il = setterMethod.GetILGenerator();
// This is equivalent to:
// set { this.interceptor = value; }
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, fieldBuilder);
il.Emit(OpCodes.Ret);
// Implement the properties on the IProxy interface
MethodInfo originalSetter = typeof(IProxy).GetMethod("set_Interceptor");
MethodInfo originalGetter = typeof(IProxy).GetMethod("get_Interceptor");
typeBuilder.DefineMethodOverride(setterMethod, originalSetter);
typeBuilder.DefineMethodOverride(getterMethod, originalGetter);
return fieldBuilder;
}
private void FinishType(TypeBuilder typeBuilder, Cci.ITypeDefinition typeDef)
{
// implemented interfaces
foreach (var iface in typeDef.Interfaces(_context))
{
// an implemented interface must be loaded before the type that implements it:
typeBuilder.AddInterfaceImplementation(ResolveType(iface, dependentType: typeBuilder, valueTypeDependency: false));
}
// method implementations
foreach (Cci.MethodImplementation impl in typeDef.GetExplicitImplementationOverrides(_context))
{
typeBuilder.DefineMethodOverride(ResolveMethod(impl.ImplementingMethod), ResolveMethod(impl.ImplementedMethod));
}
// properties (don't need to be defined prior custom attributes - we don't use CustomAttributeBuilders):
foreach (Cci.IPropertyDefinition propertyDef in typeDef.GetProperties(_context))
{
EmitCustomAttributes(DefineProperty(typeBuilder, propertyDef), propertyDef.GetAttributes(_context));
}
// events
foreach (Cci.IEventDefinition eventDef in typeDef.Events)
{
EmitCustomAttributes(DefineEvent(typeBuilder, eventDef), eventDef.GetAttributes(_context));
}
// custom attributes
EmitCustomAttributes(typeBuilder, typeDef.GetAttributes(_context));
// TODO:
// decl security
}
// Makes sure the surrogate type implements ICloneable. We use ICloneable during deserialization
// to get the real exposed object from a surrogate object.
// Note that ideally we'd use an internal "IWrapper" interface, but the interface needs to be public
// because the surrogates live in their own assembly. Instead of defining a public interface, we decided
// to reuse ICloneable.
private static FieldInfo EmitICloneableImplementation(TypeBuilder typeBuilder, Type type, Type parentSurrogateType)
{
if (parentSurrogateType == typeof(object))
{
// protected Entity _wrapper
FieldInfo wrapperField = typeBuilder.DefineField("_$wrapper", type, FieldAttributes.Family);
// Implement ICloneable.
typeBuilder.AddInterfaceImplementation(typeof(ICloneable));
// public object GetUnderlyingObject() {
// return _$wrapper;
// }
MethodBuilder getUnderlyingObjectMethodBuilder = typeBuilder.DefineMethod("Clone", MethodAttributes.Public | MethodAttributes.Virtual, typeof(object), Type.EmptyTypes);
// The surrogate assembly is SecurityCritical, but ICloneable is Transparent, so make sure our Clone method
// is marked as SecuritySafeCritical.
getUnderlyingObjectMethodBuilder.SetCustomAttribute(
new CustomAttributeBuilder(
typeof(SecuritySafeCriticalAttribute).GetConstructor(Type.EmptyTypes),
new object[0]));
ILGenerator getUnderlyingObjectMethodGenerator = getUnderlyingObjectMethodBuilder.GetILGenerator();
getUnderlyingObjectMethodGenerator.Emit(OpCodes.Ldarg_0);
getUnderlyingObjectMethodGenerator.Emit(OpCodes.Ldfld, wrapperField);
getUnderlyingObjectMethodGenerator.Emit(OpCodes.Ret);
return wrapperField;
}
else
{
return parentSurrogateType.GetField("_$wrapper", BindingFlags.Instance | BindingFlags.NonPublic);
}
}
private void CompileAnaClass()
{
AnaClass = utilityClass.DefineNestedType(Constants.AnaClassName,
TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.NestedPublic,
null, TypeBuilder.EmptyTypes);
var anaClassGenericParameters = AnaClass.DefineGenericParameters(new[] { Constants.AnaClassGenericParameterName }.Concat(declaration.TypeParameters).ToArray());
if (declaration.TypeParameters.Any())
{
AnaClass.AddInterfaceImplementation(TypeBuilder.MakeGenericType(anaClassGenericParameters.Skip(1).ToArray()));
}
else
{
AnaClass.AddInterfaceImplementation(TypeBuilder);
}
var anaClassGeneratorType = typeof(IFunction<,>).MakeGenericType(anaClassGenericParameters[0],
FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, anaClassGenericParameters[0], anaClassGenericParameters.Skip(1).ToArray(), runtimeContainer));
var seedField = AnaClass.DefineField(Constants.AnaClassSeedFieldName, anaClassGenericParameters[0], FieldAttributes.Private);
var generatorField = AnaClass.DefineField(Constants.AnaClassGeneratorFieldName, anaClassGeneratorType, FieldAttributes.Private);
AnaClassConstructor = AnaClass.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { anaClassGenericParameters[0], anaClassGeneratorType });
var ctorBody = AnaClassConstructor.GetILGenerator();
ctorBody.Emit(OpCodes.Ldarg_0);
ctorBody.Emit(OpCodes.Call, typeof(object).GetConstructors()[0]);
ctorBody.Emit(OpCodes.Ldarg_0);
ctorBody.Emit(OpCodes.Ldarg_1);
ctorBody.Emit(OpCodes.Stfld, seedField);
ctorBody.Emit(OpCodes.Ldarg_0);
ctorBody.Emit(OpCodes.Ldarg_2);
ctorBody.Emit(OpCodes.Stfld, generatorField);
ctorBody.Emit(OpCodes.Ret);
var apply = AnaClass.DefineMethod(Constants.ApplyMethodName, MethodAttributes.Public | MethodAttributes.Virtual);
var resultType = apply.DefineGenericParameters(Constants.GFixFunctionClassGenericParameterName)[0];
var applyFunctionGenericParameters = new[] { resultType }.Concat(anaClassGenericParameters.Skip(1)).ToArray();
apply.SetParameters(GreatestFixedPointFunction.MakeGenericType(applyFunctionGenericParameters));
apply.SetReturnType(resultType);
var applyMethodGenericClass = TypeBuilder.GetMethod(
GreatestFixedPointFunction.MakeGenericType(applyFunctionGenericParameters),
GreatestFixedPointFunctionApplyMethod);
var applyMethodGenericMethod = applyMethodGenericClass.MakeGenericMethod(anaClassGenericParameters[0]);
var applyBody = apply.GetILGenerator();
applyBody.Emit(OpCodes.Ldarg_1);
applyBody.Emit(OpCodes.Ldarg_0);
applyBody.Emit(OpCodes.Ldfld, seedField);
applyBody.Emit(OpCodes.Ldarg_0);
applyBody.Emit(OpCodes.Ldfld, generatorField);
applyBody.Emit(OpCodes.Callvirt, applyMethodGenericMethod);
applyBody.Emit(OpCodes.Ret);
}
private void CompileAnaFunction()
{
AnaFunction = utilityClass.DefineNestedType(Constants.AnaFunctionClassName,
TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.NestedPublic,
null, TypeBuilder.EmptyTypes);
var anaClassGenericParameters = AnaFunction.DefineGenericParameters(new[] { Constants.AnaFunctionClassGenericParameterName }.Concat(declaration.TypeParameters).ToArray());
var resultType = declaration.TypeParameters.Any()
? TypeBuilder.MakeGenericType(anaClassGenericParameters.Skip(1).ToArray())
: TypeBuilder;
AnaFunction.AddInterfaceImplementation(typeof(IFunction<,>).MakeGenericType(anaClassGenericParameters[0],
resultType));
var seedType = typeof(IFunction<,>).MakeGenericType(anaClassGenericParameters[0],
FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, anaClassGenericParameters[0], anaClassGenericParameters.Skip(1).ToArray(), runtimeContainer));
var seedField = AnaFunction.DefineField(Constants.AnaFunctionClassSeedFieldName, seedType, FieldAttributes.Private);
AnaFunctionConstructor = AnaFunction.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { seedType });
var anaCtorBody = AnaFunctionConstructor.GetILGenerator();
anaCtorBody.Emit(OpCodes.Ldarg_0);
anaCtorBody.Emit(OpCodes.Call, typeof(object).GetConstructors()[0]);
anaCtorBody.Emit(OpCodes.Ldarg_0);
anaCtorBody.Emit(OpCodes.Ldarg_1);
anaCtorBody.Emit(OpCodes.Stfld, seedField);
anaCtorBody.Emit(OpCodes.Ret);
var call = AnaFunction.DefineMethod(Constants.CallMethodName, MethodAttributes.Public | MethodAttributes.Virtual,
resultType, new[] { anaClassGenericParameters[0] });
var callBody = call.GetILGenerator();
callBody.Emit(OpCodes.Ldarg_1);
callBody.Emit(OpCodes.Ldarg_0);
callBody.Emit(OpCodes.Ldfld, seedField);
callBody.Emit(OpCodes.Call, Ana.MakeGenericMethod(anaClassGenericParameters));
callBody.Emit(OpCodes.Ret);
}
/// <summary>
/// Actually implements the <see cref="ISupportsWebDependencyInjection"/> interface.
/// </summary>
private void ImplementIDependencyInjectionAware(TypeBuilder typeBuilder, Type targetType, FieldInfo appContextField)
{
Type intf = typeof (ISupportsWebDependencyInjection);
// Add interface declaration to type
typeBuilder.AddInterfaceImplementation(intf);
// get interface property
PropertyInfo piApplicationContext = intf.GetProperty("DefaultApplicationContext");
// define property
string fullPropertyName = typeof (ISupportsWebDependencyInjection).FullName + "." + piApplicationContext.Name;
PropertyBuilder appContextProperty =
typeBuilder.DefineProperty(fullPropertyName, PropertyAttributes.None, typeof (IApplicationContext), null);
MethodAttributes methodAtts = MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.SpecialName |
MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final;
// implement getter
MethodInfo getApplicationContextMethod = piApplicationContext.GetGetMethod();
string getterMethodName = typeof (ISupportsWebDependencyInjection).FullName + "." + getApplicationContextMethod.Name;
MethodBuilder mbGet =
typeBuilder.DefineMethod(getterMethodName,
methodAtts,
getApplicationContextMethod.CallingConvention, getApplicationContextMethod.ReturnType,
Type.EmptyTypes);
ILGenerator ilGet = mbGet.GetILGenerator();
ilGet.Emit(OpCodes.Ldarg_0);
ilGet.Emit(OpCodes.Ldfld, appContextField);
ilGet.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(mbGet, getApplicationContextMethod);
appContextProperty.SetGetMethod(mbGet);
// implement setter
MethodInfo setApplicationContextMethod = piApplicationContext.GetSetMethod();
string setterMethodName = typeof (ISupportsWebDependencyInjection).FullName + "." + setApplicationContextMethod.Name;
MethodBuilder mbSet = typeBuilder.DefineMethod(setterMethodName, methodAtts,
setApplicationContextMethod.CallingConvention,
setApplicationContextMethod.ReturnType,
new Type[] {typeof (IApplicationContext)});
ILGenerator ilSet = mbSet.GetILGenerator();
ilSet.Emit(OpCodes.Ldarg_0);
ilSet.Emit(OpCodes.Ldarg_1);
ilSet.Emit(OpCodes.Stfld, appContextField);
ilSet.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(mbSet, setApplicationContextMethod);
appContextProperty.SetSetMethod(mbSet);
}
private void CompileAnaFunction1()
{
AnaFunction1 = utilityClass.DefineNestedType(Constants.AnaFunction1ClassName,
TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.NestedPublic,
null, TypeBuilder.EmptyTypes);
var anaClassGenericParameters = AnaFunction1.DefineGenericParameters(new[] { Constants.AnaFunction1ClassGenericParameterName }.Concat(declaration.TypeParameters).ToArray());
var resultType = declaration.TypeParameters.Any()
? TypeBuilder.MakeGenericType(anaClassGenericParameters.Skip(1).ToArray())
: TypeBuilder;
var fAnaClassGenericParameter = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, anaClassGenericParameters[0], anaClassGenericParameters.Skip(1).ToArray(), runtimeContainer);
var coalgebraType = typeof(IFunction<,>).MakeGenericType(anaClassGenericParameters[0], fAnaClassGenericParameter);
var terminalMorphismType = typeof(IFunction<,>).MakeGenericType(anaClassGenericParameters[0], resultType);
AnaFunction1.AddInterfaceImplementation(typeof(IFunction<,>).MakeGenericType(coalgebraType,
terminalMorphismType));
AnaFunction1Constructor = AnaFunction1.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard, TypeBuilder.EmptyTypes);
var anaCtorBody = AnaFunction1Constructor.GetILGenerator();
anaCtorBody.Emit(OpCodes.Ldarg_0);
anaCtorBody.Emit(OpCodes.Call, typeof(object).GetConstructors()[0]);
anaCtorBody.Emit(OpCodes.Ret);
var call = AnaFunction1.DefineMethod(Constants.CallMethodName, MethodAttributes.Public | MethodAttributes.Virtual,
terminalMorphismType, new Type[] { coalgebraType });
var callBody = call.GetILGenerator();
callBody.Emit(OpCodes.Ldarg_1);
callBody.Emit(OpCodes.Newobj, TypeBuilder.GetConstructor(
AnaFunction.MakeGenericType(anaClassGenericParameters),
AnaFunctionConstructor));
callBody.Emit(OpCodes.Ret);
}
private void CompileInGeneratingFunction()
{
InClass = utilityClass.DefineNestedType(Constants.InGeneratingFunctionClassName,
TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.NestedPublic);
var genericParameters = declaration.TypeParameters.Any() ? InClass.DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
var greatestFixedPoint = declaration.TypeParameters.Any()
? TypeBuilder.MakeGenericType(genericParameters)
: TypeBuilder;
var fGreatestFixedPoint = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, greatestFixedPoint, genericParameters, runtimeContainer);
InClass.AddInterfaceImplementation(GreatestFixedPointFunction.MakeGenericType(new[] { fGreatestFixedPoint }.Concat(genericParameters).ToArray()));
InGeneratingFunctionConstructor = InClass.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, TypeBuilder.EmptyTypes);
var inCtorBody = InGeneratingFunctionConstructor.GetILGenerator();
inCtorBody.Emit(OpCodes.Ldarg_0);
inCtorBody.Emit(OpCodes.Call, typeof(object).GetConstructors()[0]);
inCtorBody.Emit(OpCodes.Ret);
var apply = InClass.DefineMethod(Constants.ApplyMethodName, MethodAttributes.Public | MethodAttributes.Virtual,
fGreatestFixedPoint, TypeBuilder.EmptyTypes);
var genericParameter = apply.DefineGenericParameters(Constants.ApplyMethodGenericParameterName)[0];
var fGenericParameter = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, genericParameter, genericParameters, runtimeContainer);
apply.SetParameters(genericParameter, typeof(IFunction<,>).MakeGenericType(genericParameter, fGenericParameter));
var applyBody = apply.GetILGenerator();
applyBody.Emit(OpCodes.Ldarg_2);
applyBody.Emit(OpCodes.Newobj, TypeBuilder.GetConstructor(
AnaFunction.MakeGenericType(new[] { genericParameter }.Concat(genericParameters).ToArray()),
AnaFunctionConstructor));
applyBody.Emit(OpCodes.Call, fmap.MakeGenericMethod(new Type[] { genericParameter, greatestFixedPoint }.Concat(genericParameters).ToArray()));
applyBody.Emit(OpCodes.Ldarg_2);
applyBody.Emit(OpCodes.Ldarg_1);
applyBody.Emit(OpCodes.Callvirt, TypeBuilder.GetMethod(
typeof(IFunction<,>).MakeGenericType(genericParameter, fGenericParameter),
typeof(IFunction<,>).GetMethod(Constants.CallMethodName)));
applyBody.Emit(OpCodes.Callvirt, TypeBuilder.GetMethod(
typeof(IFunction<,>).MakeGenericType(fGenericParameter, fGreatestFixedPoint),
typeof(IFunction<,>).GetMethod(Constants.CallMethodName)));
applyBody.Emit(OpCodes.Ret);
}
/// <summary>
/// creates the union in the module represented by modBuilder.
/// </summary>
/// <param name="visibility">specifies the visiblity of resulting type</param>
public UnionGenerationHelper(ModuleBuilder modBuilder, string fullName,
TypeAttributes visibility) {
TypeAttributes typeAttrs = TypeAttributes.Class | TypeAttributes.Serializable |
TypeAttributes.BeforeFieldInit | /* TypeAttributes.SequentialLayout | */
TypeAttributes.Sealed | visibility;
m_builder = modBuilder.DefineType(fullName, typeAttrs, ReflectionHelper.ValueTypeType,
new System.Type[] { ReflectionHelper.IIdlEntityType });
m_builder.AddInterfaceImplementation(ReflectionHelper.ISerializableType); // optimization for inter .NET communication
BeginType();
}
private void CompileOutFunction()
{
OutFunction = utilityClass.DefineNestedType(Constants.OutFunctionClassName,
TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.NestedPublic);
var genericParameters = declaration.TypeParameters.Any() ? OutFunction.DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
var fGreatestFixedPoint = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, TypeBuilder, genericParameters, runtimeContainer);
OutFunction.AddInterfaceImplementation(typeof(IFunction<,>).MakeGenericType(fGreatestFixedPoint, TypeBuilder));
OutFunctionConstructor = OutFunction.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, TypeBuilder.EmptyTypes);
var outCtorBody = OutFunctionConstructor.GetILGenerator();
outCtorBody.Emit(OpCodes.Ldarg_0);
outCtorBody.Emit(OpCodes.Call, typeof(object).GetConstructors()[0]);
outCtorBody.Emit(OpCodes.Ret);
var call = OutFunction.DefineMethod(Constants.CallMethodName, MethodAttributes.Public | MethodAttributes.Virtual,
TypeBuilder, new Type[] { fGreatestFixedPoint });
var callBody = call.GetILGenerator();
callBody.Emit(OpCodes.Ldarg_1);
callBody.Emit(OpCodes.Call, declaration.TypeParameters.Any()
? Out.MakeGenericMethod(genericParameters)
: Out);
callBody.Emit(OpCodes.Ret);
}
/// <summary>
/// Adds an implementation to the created type.
/// </summary>
/// <param name="tb">Type builder object.</param>
/// <param name="typeToWrap">Created class.</param>
private static void AddTypeImplementation(TypeBuilder tb, Type typeToWrap)
{
// add implementation for the interface
if(IsInterface(typeToWrap))
{
tb.AddInterfaceImplementation(typeToWrap);
}
// create implementation for each type abstract method
MethodInfo[] parentMethodInfo = typeToWrap.GetMethods(BindingFlags.Public | BindingFlags.NonPublic |BindingFlags.Instance /* | BindingFlags.DeclaredOnly */);
for(int i = 0; i < parentMethodInfo.Length; ++i)
{
if(IsAbstractMethod(parentMethodInfo[i]))
{
AddMethodImplementation(parentMethodInfo[i], tb);
}
}
}
void Generate(ref TypeBuilder tBuilder, Class c)
{
// parent and interfaces
foreach (Class baseType in c.BaseTypes) {
Type t = GetType(baseType);
if (t == null) {
// parent, or interface is not
// public namespace, or inner
Console.WriteLine("WARNING: skipped base type {0} for {1}",
baseType, tBuilder.FullName);
continue;
}
if (baseType.IsInterface) {
tBuilder.AddInterfaceImplementation(t);
} else {
tBuilder.SetParent(t);
}
}
}
/// <summary>
/// Implements serialization method.
/// </summary>
/// <param name="typeBuilder"></param>
private void ImplementGetObjectDataMethod(TypeBuilder typeBuilder)
{
typeBuilder.AddInterfaceImplementation(typeof(ISerializable));
MethodBuilder mb =
typeBuilder.DefineMethod("GetObjectData",
MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.NewSlot | MethodAttributes.Virtual,
typeof (void),
new Type[] {typeof (SerializationInfo), typeof (StreamingContext)});
ILGenerator il = mb.GetILGenerator();
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldstr, "advisedProxy");
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, advisedProxyField);
il.EmitCall(OpCodes.Callvirt, References.AddSerializationValue, null);
il.Emit(OpCodes.Ret);
//typeBuilder.DefineMethodOverride(mb, typeof(ISerializable).GetMethod("GetObjectData"));
}
void EmitBaseTypesAndAttributes(TypeDefinition typeDefinition, TypeBuilder typeBuilder)
{
foreach (TypeReference baseType in typeDefinition.BaseTypes)
{
Type type = GetSystemType(baseType);
// For some reason you can't call IsClass on constructed types created at compile time,
// so we'll ask the generic definition instead
if ((type.IsGenericType && type.GetGenericTypeDefinition().IsClass) || (type.IsClass))
{
typeBuilder.SetParent(type);
}
else
{
typeBuilder.AddInterfaceImplementation(type);
}
}
}
/// <summary>
/// Implements <see cref="Spring.Aop.Framework.IAopProxy"/> interface.
/// </summary>
/// <param name="typeBuilder">The type builder to use.</param>
protected virtual void ImplementIAopProxy(TypeBuilder typeBuilder)
{
Type intf = typeof(IAopProxy);
MethodInfo getProxyMethod = intf.GetMethod("GetProxy", Type.EmptyTypes);
typeBuilder.AddInterfaceImplementation(intf);
MethodBuilder mb = typeBuilder.DefineMethod(typeof(IAdvised).FullName + "." + getProxyMethod.Name,
MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final,
getProxyMethod.CallingConvention, getProxyMethod.ReturnType, Type.EmptyTypes);
ILGenerator il = mb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(mb, getProxyMethod);
}
public Type Compile(Type superType, Type stubType, IPersistentVector interfaces, bool onetimeUse, GenContext context)
{
if (_compiledType != null)
return _compiledType;
string publicTypeName = IsDefType || (_isStatic && Compiler.IsCompiling) ? InternalName : InternalName + "__" + RT.nextID();
//Console.WriteLine("DefFn {0}, {1}", publicTypeName, context.AssemblyBuilder.GetName().Name);
_typeBuilder = context.AssemblyGen.DefinePublicType(publicTypeName, superType, true);
context = context.WithNewDynInitHelper().WithTypeBuilder(_typeBuilder);
Var.pushThreadBindings(RT.map(Compiler.CompilerContextVar, context));
try
{
if (interfaces != null)
{
for (int i = 0; i < interfaces.count(); i++)
_typeBuilder.AddInterfaceImplementation((Type)interfaces.nth(i));
}
ObjExpr.MarkAsSerializable(_typeBuilder);
GenInterface.SetCustomAttributes(_typeBuilder, _classMeta);
try
{
if (IsDefType)
{
Compiler.RegisterDuplicateType(_typeBuilder);
Var.pushThreadBindings(RT.map(
Compiler.CompileStubOrigClassVar, stubType
));
//,
//Compiler.COMPILE_STUB_CLASS, _baseType));
}
EmitConstantFieldDefs(_typeBuilder);
EmitKeywordCallsiteDefs(_typeBuilder);
DefineStaticConstructor(_typeBuilder);
if (SupportsMeta)
_metaField = _typeBuilder.DefineField("__meta", typeof(IPersistentMap), FieldAttributes.Public | FieldAttributes.InitOnly);
EmitClosedOverFields(_typeBuilder);
EmitProtocolCallsites(_typeBuilder);
_ctorInfo = EmitConstructor(_typeBuilder, superType);
if (_altCtorDrops > 0)
EmitFieldOnlyConstructor(_typeBuilder, superType);
if (SupportsMeta)
{
EmitNonMetaConstructor(_typeBuilder, superType);
EmitMetaFunctions(_typeBuilder);
}
EmitStatics(_typeBuilder);
EmitMethods(_typeBuilder);
//if (KeywordCallsites.count() > 0)
// EmitSwapThunk(_typeBuilder);
_compiledType = _typeBuilder.CreateType();
if (context.DynInitHelper != null)
context.DynInitHelper.FinalizeType();
// If we don't pick up the ctor after we finalize the type,
// we sometimes get a ctor which is not a RuntimeConstructorInfo
// This causes System.DynamicILGenerator.Emit(opcode,ContructorInfo) to blow up.
// The error says the ConstructorInfo is null, but there is a second case in the code.
// Thank heavens one can run Reflector on mscorlib.
ConstructorInfo[] cis = _compiledType.GetConstructors();
foreach (ConstructorInfo ci in cis)
{
if (ci.GetParameters().Length == CtorTypes().Length)
{
_ctorInfo = ci;
break;
}
}
return _compiledType;
}
finally
{
if (IsDefType)
Var.popThreadBindings();
}
}
finally
{
Var.popThreadBindings();
}
}
private static void InnerCreateType(TypeBuilder typeBuilder, Type interfaceType, IMethodEmit methodEmitter)
{
typeBuilder.AddInterfaceImplementation(interfaceType);
foreach (MemberInfo member in interfaceType.GetMembers(BindingFlags.Instance | BindingFlags.Public))
{
//约定-成员必须是方法，不能有属性，事件之类的
if (member.MemberType != MemberTypes.Method)
{
throw (new ApplicationException("Could not emit " + member.MemberType + " automatically!"));
}
CreateMethod(typeBuilder, (MethodInfo)member, methodEmitter);
}
//获取派生自的父接口
Type[] typeList = interfaceType.GetInterfaces();
if (typeList == null || typeList.Length <= 0)
{
return;
}
//为父接口实现方法
for (int i = 0; i < typeList.Length; i++)
{
InnerCreateType(typeBuilder, typeList[i], methodEmitter);
}
}
