public NestedClassEmitter(AbstractTypeEmitter maintype, String name, Type baseType, Type[] interfaces) : this( maintype, CreateTypeBuilder(maintype, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class, baseType, interfaces)) { }
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes, Type returnType, params Type[] argumentTypes) : this(owner, name, attributes) { SetParameters(argumentTypes); SetReturnType(returnType); }
private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType, Type[] interfaces) { return(maintype.TypeBuilder.DefineNestedType( name, attributes, baseType, interfaces)); }
internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments) { this.maintype = maintype; var args = ArgumentsUtil.InitializeAndConvert(arguments); builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args); }
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes, Type propertyType, Type[] arguments) { this.parentTypeEmitter = parentTypeEmitter; builder = parentTypeEmitter.TypeBuilder.DefineProperty( name, attributes, CallingConventions.HasThis, propertyType, null, null, arguments, null, null); }
public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type) { if (name == null) { throw new ArgumentNullException("name"); } this.typeEmitter = typeEmitter; this.type = type ?? throw new ArgumentNullException("type"); eventBuilder = typeEmitter.TypeBuilder.DefineEvent(name, attributes, type); }
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes, MethodInfo methodToUseAsATemplate) : this(owner, name, attributes) { var name2GenericType = GenericUtil.GetGenericArgumentsMap(owner); var returnType = GenericUtil.ExtractCorrectType(methodToUseAsATemplate.ReturnType, name2GenericType); var baseMethodParameters = methodToUseAsATemplate.GetParameters(); var parameters = GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType); genericTypeParams = GenericUtil.CopyGenericArguments(methodToUseAsATemplate, builder, name2GenericType); SetParameters(parameters); SetReturnType(returnType); SetSignature(returnType, methodToUseAsATemplate.ReturnParameter, parameters, baseMethodParameters); DefineParameters(baseMethodParameters); }
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes) : this(owner.TypeBuilder.DefineMethod(name, attributes)) { }
internal TypeConstructorEmitter(AbstractTypeEmitter maintype) : base(maintype, maintype.TypeBuilder.DefineTypeInitializer()) { }
public static Dictionary <string, GenericTypeParameterBuilder> GetGenericArgumentsMap(AbstractTypeEmitter parentEmitter) { if (parentEmitter.GenericTypeParams == null || parentEmitter.GenericTypeParams.Length == 0) { return(new Dictionary <string, GenericTypeParameterBuilder>(0)); } var name2GenericType = new Dictionary <string, GenericTypeParameterBuilder>(parentEmitter.GenericTypeParams.Length); foreach (var genType in parentEmitter.GenericTypeParams) { name2GenericType.Add(genType.Name, genType); } return(name2GenericType); }
public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder) : base(typeBuilder) { maintype.Nested.Add(this); }
protected internal ConstructorEmitter(AbstractTypeEmitter maintype, ConstructorBuilder builder) { this.maintype = maintype; this.builder = builder; }