public DefineDefaultConstructor ( System attributes ) : System.Reflection.Emit.ConstructorBuilder | ||
attributes | System | |
Результат | System.Reflection.Emit.ConstructorBuilder |
/// <summary> /// Emits constructors. /// </summary> private void EmitPageConstructors(TypeBuilder type) { ConstructorBuilder ctor; // ILGenerator il; ConstructorInfo ci; //public instance void .ctor() //{ // ldarg.0 // call instance void [PhpNetCore]PHP.Core.PhpPage::.ctor() // ret //} ctor = type.DefineDefaultConstructor(MethodAttributes.Public); ci = typeof(PhpPage).GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, // flags: instance family null, // binder new Type[] { }, // params null); // modifiers /* obsolete //public instance void .ctor(class [PhpNetCore]PHP.Core.ConfigurationRecord) //{ // ldarg.0 // ldarg.1 // call instance void [PhpNetCore]PHP.Core.PhpPage::.ctor(class [PhpNetCore]PHP.Core.ConfigurationRecord) // ret //} ctor = type.DefineConstructor( MethodAttributes.Public, // flags CallingConventions.Standard, // calling convention new Type[] {typeof(ConfigurationRecord)}); // params ci = typeof(PhpPage).GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, // flags: instance family null, // binder new Type[] {typeof(ConfigurationRecord)}, // params null); // modifiers il = ctor.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Call,ci); il.Emit(OpCodes.Ret); */ }
public static Type CompileResultType(List <FieldInfo> listOfFields, string typeName) { System.Reflection.Emit.TypeBuilder tb = GetTypeBuilder(typeName); ConstructorBuilder constructor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); // NOTE: assuming your list contains Field objects with fields FieldName(string) and FieldType(Type) foreach (var field in listOfFields) { CreateProperty(tb, field.Name, field.Type); } Type objectType = tb.CreateType(); return(objectType); }
public Type CompileResultType() { System.Reflection.Emit.TypeBuilder tb = GetTypeBuilder(); ConstructorBuilder constructor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); // NOTE: assuming your list contains Field objects with fields FieldName(string) and FieldType(Type) foreach (KeyValuePair <string, Tuple <Type, bool> > field in Fields) { CreateProperty(tb, field.Key, field.Value.Item1, field.Value.Item2); } Type objectType = tb.CreateType(); return(objectType); }
// Функция предкодогенерационного обхода синтаксического дерева // Нужен для того, чтобы выполнить некоторую подготовительную работу. Например, задекларировать классы private void BeforeCompile(Node ActiveNode) { if (ActiveNode.IsTerminal) { } else { if ( (ActiveNode.TypeNTerminal == NonTerminal.MainClass) || (ActiveNode.TypeNTerminal == NonTerminal.ClassDecl)) { if (TypeTable.ContainsKey(ActiveNode.Nodes[1].Value)) { throw new System.Exception("Переопределение класса " + ActiveNode.Nodes[1].Value); } else { Emit.TypeBuilder _TypeBuilder = ModBuilder.DefineType(ActiveNode.Nodes[1].Value); TypeTable[ActiveNode.Nodes[1].Value] = _TypeBuilder; if (ActiveNode.TypeNTerminal != NonTerminal.MainClass) { _TypeBuilder.DefineDefaultConstructor(Reflect.MethodAttributes.Public); } } } foreach (Node Child in ActiveNode.Nodes) { BeforeCompile(Child); } } }
/// <summary> /// Creates a new fluent type builder using the given name, telling if the /// generated type will be collectible (if you use the other overloads, /// this value is true) and optionally telling which interfaces should be /// implemented. /// </summary> public FluentTypeBuilder(string name, bool isCollectible, params Type[] interfaceTypes) { _delegatesExpression = () => _delegates; _creatorThreadId = Thread.CurrentThread.ManagedThreadId; _isCollectible = isCollectible; Type baseType; HashSet <Type> allInterfaces = new HashSet <Type>(); if (typeof(TBase).IsInterface) { baseType = typeof(object); allInterfaces.Add(typeof(TBase)); } else { baseType = typeof(TBase); } foreach (var interfaceType in typeof(TBase).GetInterfaces()) { allInterfaces.Add(interfaceType); } if (interfaceTypes != null) { foreach (var interfaceType in interfaceTypes) { if (interfaceType == null) { throw new ArgumentException("interfaceTypes can't contain null values.", "interfaceTypes"); } if (!interfaceType.IsInterface) { throw new ArgumentException("interfaceTypes can't contain non-interface types.", "interfaceTypes"); } if (!interfaceType.IsVisible) { throw new ArgumentException("interfaceTypes must only contain visible interfaces (public interfaces declared directly in namespaces or inside other public types).", "interfaceTypes"); } allInterfaces.Add(interfaceType); foreach (var baseInterface in interfaceType.GetInterfaces()) { allInterfaces.Add(baseInterface); } } } AssemblyBuilderAccess access = AssemblyBuilderAccess.Run; if (isCollectible) { access = AssemblyBuilderAccess.RunAndCollect; } _interfaceTypes = allInterfaces.ToArray(); var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name), access); var module = assembly.DefineDynamicModule(name); _type = module.DefineType(name, TypeAttributes.NotPublic, baseType, _interfaceTypes); _type.DefineDefaultConstructor(MethodAttributes.Public); _delegatesField = _type.DefineField(".delegates", typeof(Delegate[]), FieldAttributes.Private | FieldAttributes.Static); }
private static void GenerateConstructor(TypeBuilder dynamicType, string[] properties, List<FieldBuilder> fields) { const MethodAttributes CtorAttributes = MethodAttributes.RTSpecialName | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public; var defaultCtor = dynamicType.DefineDefaultConstructor(CtorAttributes); var ctor = dynamicType.DefineConstructor(CtorAttributes, CallingConventions.Standard, fields.Select(x => x.FieldType).ToArray()); var ctorIl = ctor.GetILGenerator(); ctorIl.Emit(OpCodes.Ldarg_0); ctorIl.Emit(OpCodes.Call, defaultCtor); for (var i = 0; i < properties.Length; i++) { var strParamName = properties[i]; var field = fields[i]; var builder3 = ctor.DefineParameter(i + 1, ParameterAttributes.None, strParamName); ctorIl.Emit(OpCodes.Ldarg_0); ctorIl.Emit(OpCodes.Ldarg, builder3.Position); ctorIl.Emit(OpCodes.Stfld, field); } ctorIl.Emit(OpCodes.Ret); AddDebuggerHiddenAttribute(ctor); }
/// <summary> /// 构造函数 /// </summary> /// <param name="type"></param> /// <returns></returns> private ConstructorBuilder BuildMethod_ctor(TypeBuilder type) { System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig; return type.DefineDefaultConstructor(methodAttributes); }
/// <summary> /// add a no arg constructor, which calls the default constructor of the supertype. /// </summary> public void AddDefaultConstructor(TypeBuilder builder, MethodAttributes attrs) { builder.DefineDefaultConstructor(attrs); }
public static ConstructorBuilder DefineDefaultConstructor (TypeBuilder typeBuilder) { ConstructorBuilder constructorBuilder = typeBuilder.DefineDefaultConstructor (EmitConstants.PUBLIC_CONSTRUCTOR); return constructorBuilder; }
public void BuildMethod_ctor1(TypeBuilder type) { // Declaring method builder // Method attributes System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig; ctor = type.DefineDefaultConstructor(methodAttributes); }
private static void GenerateWrapperConstructor(TypeBuilder newType, FieldInfo defaultValue) { ConstructorBuilder ctor = newType.DefineDefaultConstructor(MethodAttributes.Public); }
private static void GenerateConstructor(TypeBuilder type) { type.DefineDefaultConstructor (MethodAttributes.Public); }
/// <summary>adds an empty default constructor</summary> private void DefineEmptyDefaultConstr(TypeBuilder boxBuilder) { boxBuilder.DefineDefaultConstructor(MethodAttributes.Public); }