public void TestValidDataWithMultipleParameters()
{
int i = 0;
Type[] parameterTypes = new Type[]
{
typeof(int),
typeof(string)
};
for (i = 1; i < _supportedAttributes.Length; ++i)
{
ConstructorBuilder constructor = CreateConstructorBuilder("PosTest1_Type" + i,
parameterTypes);
constructor.DefineParameter(1, _supportedAttributes[i - 1], "parameter1" + i);
constructor.DefineParameter(2, _supportedAttributes[i], "parameter2" + i);
ILGenerator ilg = constructor.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[] { }));
ilg.Emit(OpCodes.Ret);
_typeBuilder.CreateTypeInfo().AsType();
ParameterInfo[] definedParams = constructor.GetParameters();
Assert.Equal(2, definedParams.Length);
}
}
/// <summary>
/// Generates the (<see cref="ScriptContext"/>, <see cref="DTypeDesc"/>) constructor.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="shortConstructor">This type's short constructor.</param>
/// <returns>The constructor builder.</returns>
/// <remarks>
/// The entire constructor is generated. See <see cref="PHP.Core.PhpObject(PHP.Core.ScriptContext,DTypeDesc)"/>.
/// </remarks>
public static ConstructorBuilder GenerateLongConstructor(TypeBuilder typeBuilder, ConstructorInfo shortConstructor)
{
ConstructorBuilder ctor_builder = typeBuilder.DefineConstructor(LongConstructorAttributes,
CallingConventions.Standard, LongConstructorParamTypes);
// annotate with EditorBrowsable attribute
#if !SILVERLIGHT // Not available on Silverlight
ctor_builder.SetCustomAttribute(AttributeBuilders.EditorBrowsableNever);
#endif
// define parameter names
ctor_builder.DefineParameter(1, ParameterAttributes.None, "context");
ctor_builder.DefineParameter(2, ParameterAttributes.None, "caller");
// call this type's short constructor
ILEmitter il = new ILEmitter(ctor_builder);
il.Ldarg(FunctionBuilder.ArgThis);
il.Ldarg(FunctionBuilder.ArgContextInstance);
il.LdcI4(1);
il.Emit(OpCodes.Call, shortConstructor);
// call PhpObject.InvokeConstructor
il.Ldarg(FunctionBuilder.ArgThis);
il.Ldarg(1);
il.Ldarg(2);
il.Emit(OpCodes.Call, Methods.DObject_InvokeConstructor);
il.Emit(OpCodes.Ret);
return(ctor_builder);
}
private void AddConstructor()
{
Type[] paramTypes = Sequence.Collect(typeToIntercept, typeof(Type)).ToArray();
ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.HasThis,
paramTypes);
ctorBuilder.DefineParameter(1, ParameterAttributes.None, "target");
ctorBuilder.DefineParameter(2, ParameterAttributes.None, "typeToProxy");
ILGenerator il = ctorBuilder.GetILGenerator();
// Call base class constructor
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, ObjectMethods.Constructor);
// Initialize pipeline field
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Newobj, InterceptionBehaviorPipelineMethods.Constructor);
il.Emit(OpCodes.Stfld, proxyInterceptionPipelineField);
// Initialize the target field
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, targetField);
// Initialize the typeToProxy field
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Stfld, typeToProxyField);
il.Emit(OpCodes.Ret);
}
public void DefineParameter_NoParameters_InvalidSequence_ThrowsArgumentOutOfRangeException()
{
TypeBuilder type = Helpers.DynamicType(TypeAttributes.NotPublic);
ConstructorBuilder constructor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[0]);
Assert.Throws <ArgumentOutOfRangeException>(() => constructor.DefineParameter(-1, ParameterAttributes.None, "p"));
Assert.Throws <ArgumentOutOfRangeException>(() => constructor.DefineParameter(1, ParameterAttributes.None, "p"));
}
void DefineParameterNames(string[] parameterNames)
{
for (var i = 0; i < parameterNames.Length; i++)
{
_constructor.DefineParameter(i + 1, ParameterAttributes.None, parameterNames[i]);
}
}
// generates this constructor:
// public NewType(param0, param1, ...) : base(param0, param1, ...) { }
private static void ImplementConstructor(TypeBuilder newType, ConstructorInfo baseCtor)
{
ParameterInfo[] parameters = baseCtor.GetParameters();
Type[] parameterTypes = (from p in parameters select p.ParameterType).ToArray();
ConstructorBuilder newCtor = newType.DefineConstructor(
(baseCtor.Attributes & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Public /* force public constructor */,
baseCtor.CallingConvention, parameterTypes);
// parameter 0 is 'this', so we start at index 1
for (int i = 0; i < parameters.Length; i++)
{
newCtor.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
}
// load all arguments (including 'this') in proper order, then call and return
ILGenerator ilGen = newCtor.GetILGenerator();
for (int i = 0; i <= parameterTypes.Length; i++)
{
ilGen.Emit(OpCodes.Ldarg_S, (byte)i);
}
ilGen.Emit(OpCodes.Call, baseCtor);
ilGen.Emit(OpCodes.Ret);
}
private static void GenerateCustomConstructor(TypeBuilder tb, Type funcType, ParameterInfo parameterInfo, FieldBuilder fb)
{
Type objType = typeof(object);
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
Type[] ctorParams = new Type[] { funcType };
ConstructorBuilder customCtor = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ctorParams);
var paramBuilder = customCtor.DefineParameter(1, parameterInfo.Attributes, "func");
var paramAttributes = parameterInfo.CustomAttributes;
foreach (var attr in paramAttributes)
{
var targetAttrBuilder = GetAttributeBuilder(attr.AttributeType);
paramBuilder.SetCustomAttribute(targetAttrBuilder);
}
ILGenerator ctorIlg = customCtor.GetILGenerator();
ctorIlg.Emit(OpCodes.Ldarg_0);
ctorIlg.Emit(OpCodes.Call, objCtor);
ctorIlg.Emit(OpCodes.Ldarg_0);
ctorIlg.Emit(OpCodes.Ldarg_1);
// store the ctor arg in the _func field
ctorIlg.Emit(OpCodes.Stfld, fb);
ctorIlg.Emit(OpCodes.Ret);
}
protected static ConstructorBuilder CreateConstructor(TypeBuilder typeBuilder, List <FieldBuilder> fieldBuilders)
{
List <Type> types = fieldBuilders.Select(s => s.FieldType).ToList();
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
fieldBuilders.Select(s => s.FieldType).ToArray());
for (int i = 0; i < fieldBuilders.Count; i++)
{
constructorBuilder.DefineParameter(i + 1, ParameterAttributes.None, fieldBuilders[i].Name);
}
ILGenerator constructorIlGenerator = constructorBuilder.GetILGenerator();
constructorIlGenerator.CallBaseTypeDefaultConstructor(typeBuilder.BaseType);
constructorIlGenerator.Emit(OpCodes.Nop);
if (fieldBuilders.Count > 0)
{
for (int i = 0; i < fieldBuilders.Count; i++)
{
constructorIlGenerator.Emit(OpCodes.Ldarg_0);
constructorIlGenerator.Emit(OpCodes.Ldarg_S, (i + 1));
constructorIlGenerator.Emit(OpCodes.Stfld, fieldBuilders[i]);
}
}
constructorIlGenerator.Emit(OpCodes.Ret);
return(constructorBuilder);
}
private static void DefineParameters(this ConstructorBuilder constructorBuilder, ConstructorInfo constructorInfo, IEnumerable <string> additionalParameterNames)
{
var position = 1;
foreach (var additionalParameterName in additionalParameterNames)
{
constructorBuilder.DefineParameter(position++, ParameterAttributes.None, additionalParameterName);
}
var parameterInfos = constructorInfo.GetParameters();
foreach (var parameterInfo in parameterInfos)
{
constructorBuilder.DefineParameter(parameterInfo.Position + position, parameterInfo.Attributes, parameterInfo.Name);
}
}
private void AddConstructor(ConstructorInfo ctor)
{
if (!ctor.IsPublic && !ctor.IsFamily && !ctor.IsFamilyOrAssembly)
{
return;
}
MethodAttributes attributes = (ctor.Attributes & ~(MethodAttributes.RTSpecialName | MethodAttributes.HasSecurity | MethodAttributes.RequireSecObject) & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Public;
ParameterInfo[] parameters = ctor.GetParameters();
Type[] paramTypes = (from item in parameters
select item.ParameterType).ToArray();
ConstructorBuilder ctorBuilder = _typeBuilder.DefineConstructor(attributes, ctor.CallingConvention, paramTypes);
for (int j = 0; j < parameters.Length; j++)
{
ctorBuilder.DefineParameter(j + 1, parameters[j].Attributes, parameters[j].Name);
}
ILGenerator il = ctorBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
for (int i = 0; i < paramTypes.Length; i++)
{
il.Emit(OpCodes.Ldarg, i + 1);
}
il.Emit(OpCodes.Call, ctor);
il.Emit(OpCodes.Ret);
}
private static void DefineParameters(this ConstructorBuilder constructorBuilder, params ParameterInfo[] parameters)
{
foreach (var parameterInfo in parameters)
{
constructorBuilder.DefineParameter(parameterInfo.Position + 1, parameterInfo.Attributes, parameterInfo.Name);
}
}
/// <summary>
/// Defines the special IgnoresAccessChecksToAttribute type in the <see cref="moduleBuilder"/>.
/// </summary>
/// <returns>The generated attribute type.</returns>
private TypeInfo EmitMagicAttribute()
{
TypeBuilder tb = this.moduleBuilder.DefineType(
"System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute",
TypeAttributes.NotPublic,
typeof(Attribute));
var attributeUsage = new CustomAttributeBuilder(
AttributeUsageCtor,
new object[] { AttributeTargets.Assembly },
new PropertyInfo[] { AttributeUsageAllowMultipleProperty },
new object[] { false });
tb.SetCustomAttribute(attributeUsage);
ConstructorBuilder cb = tb.DefineConstructor(
MethodAttributes.Public |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName,
CallingConventions.Standard,
new Type[] { typeof(string) });
cb.DefineParameter(1, ParameterAttributes.None, "assemblyName");
ILGenerator il = cb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, AttributeBaseClassCtor);
il.Emit(OpCodes.Ret);
return(tb.CreateTypeInfo());
}
/// <summary>
/// 发行。
/// </summary>
public void Emit(ConstructorBuilder builder)
{
#if NET40
var attributes = builder.GetMethodImplementationFlags();
#else
var attributes = builder.MethodImplementationFlags;
#endif
if ((attributes & MethodImplAttributes.Runtime) != MethodImplAttributes.IL)
{
return;
}
if (IsEmpty)
{
InvokeBaseConstructor();
}
foreach (var item in parameters)
{
item.Emit(builder.DefineParameter(item.Position, item.Attributes, item.ParameterName));
}
var ilg = builder.GetILGenerator();
base.Load(ilg);
ilg.Emit(OpCodes.Ret);
}
private static FieldInfo MakeConstructor(TypeBuilder typeBuilder, Type baseType)
{
FieldBuilder fieldBuilder = typeBuilder.DefineField("proxiedObj", baseType, FieldAttributes.Private | FieldAttributes.InitOnly);
ConstructorInfo constructor = baseType.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
throw new Exception("Proxed object don't have constructor with no parameter");
}
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { baseType });
constructorBuilder.DefineParameter(1, ParameterAttributes.None, "proxiedObj");
ILGenerator lGenerator = constructorBuilder.GetILGenerator();
Label label = lGenerator.DefineLabel();
lGenerator.Emit(OpCodes.Ldarg_0);
lGenerator.Emit(OpCodes.Call, constructor);
lGenerator.Emit(OpCodes.Ldarg_1);
lGenerator.Emit(OpCodes.Brtrue_S, label);
lGenerator.Emit(OpCodes.Ldstr, "proxiedObj");
ConstructorInfo constructorInfo = typeof(ArgumentNullException).GetConstructor(new Type[] { typeof(string) });
if (constructorInfo != null)
{
lGenerator.Emit(OpCodes.Newobj, constructorInfo);
lGenerator.Emit(OpCodes.Throw);
}
lGenerator.MarkLabel(label);
lGenerator.Emit(OpCodes.Ldarg_0);
lGenerator.Emit(OpCodes.Ldarg_1);
lGenerator.Emit(OpCodes.Stfld, fieldBuilder);
lGenerator.Emit(OpCodes.Ret);
return(fieldBuilder);
}
// TODO: use in Python's OverrideConstructor:
public static ParameterBuilder DefineParameterCopy(ConstructorBuilder builder, int paramIndex, ParameterInfo info)
{
var result = builder.DefineParameter(1 + paramIndex, info.Attributes, info.Name);
CopyParameterAttributes(info, result);
return(result);
}
private static void ImplementConstructor(TypeBuilder newType, ConstructorInfo baseCtor)
{
ParameterInfo[] parameters = baseCtor.GetParameters();
Type[] parameterTypes = new Type[parameters.Length];
for (int idx = 0; idx < parameters.Length; idx++)
{
parameterTypes[idx] = parameters[idx].ParameterType;
}
ConstructorBuilder newCtor = newType.DefineConstructor(
(baseCtor.Attributes & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Public /* force public constructor */,
baseCtor.CallingConvention, parameterTypes);
for (int i = 0; i < parameters.Length; i++)
{
newCtor.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
}
ILGenerator ilGen = newCtor.GetILGenerator();
for (int i = 0; i <= parameterTypes.Length; i++)
{
ilGen.Emit(OpCodes.Ldarg_S, (byte)i);
}
ilGen.Emit(OpCodes.Call, baseCtor);
ilGen.Emit(OpCodes.Ret);
}
public void GenerateName(bool isStatic)
{
MethodAttributes attr = getMethodAttributes(isStatic);
if (FnName.IsConstructor(this.ClassName) != -1)
{
List <Type> argTypes = FnName.ProcDesc.GetArgTypes(1);
var ClassSymbol = MethodContext.ClassContext.ClassSymbol;
ConstructorBuilder constructorBuilder = ClassSymbol.ClassBuilder.DefineConstructor(attr, CallingConventions.Standard, argTypes.ToArray());
MethodContext.EmitContext.SetBuilder(constructorBuilder);
MethodContext.EmitContext.ClassContext = this.ClassContext.EmitContext;
if (FnName.IsMinConstructor())
{
MethodContext.ClassContext.ZeroConstructor = constructorBuilder;
}
else
{
List <TKTProcArg> normalArgs = this.MethodContext.ProcDesc.GetSpecialArgs(1);
int start_i = isStatic ? 0 : 1;
for (var i = 0; i < normalArgs.Count; i++)
{
constructorBuilder.DefineParameter(i + start_i, ParameterAttributes.None, normalArgs[i].ArgName);
}
}
MethodContext.ClassContext.ConstructorBuilderList.Add(constructorBuilder);
}
else
{
List <Type> argTypes = FnName.ProcDesc.GetArgTypes(1);
var ClassSymbol = MethodContext.ClassContext.ClassSymbol;
MethodName = getMethodName(isStatic);
MethodBuilder methodBuilder = ClassSymbol.ClassBuilder.DefineMethod(MethodName, attr, MethodContext.RetType, argTypes.ToArray());
if (MethodName == "启动")
{
Type myType = typeof(STAThreadAttribute);
ConstructorInfo infoConstructor = myType.GetConstructor(new Type[] { });
CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(infoConstructor, new object[] { });
methodBuilder.SetCustomAttribute(attributeBuilder);
}
else
{
setAttrMappingCode(methodBuilder);
}
MethodContext.EmitContext.SetBuilder(methodBuilder);
MethodContext.EmitContext.ClassContext = this.ClassContext.EmitContext;
List <TKTProcArg> genericArgs = this.MethodContext.ProcDesc.GetSpecialArgs(2);
if (genericArgs.Count > 0)
{
string[] names = genericArgs.Select(p => p.ArgName).ToArray();
methodBuilder.DefineGenericParameters(names);
}
List <TKTProcArg> normalArgs = this.MethodContext.ProcDesc.GetSpecialArgs(1);
int start_i = isStatic ? 0 : 1;
for (var i = 0; i < normalArgs.Count; i++)
{
methodBuilder.DefineParameter(i + start_i, ParameterAttributes.None, normalArgs[i].ArgName);
}
}
}
public void EmitName()
{
var classBuilder = this.ProcContext.ClassContext.EmitContext.ClassBuilder;
MethodAttributes methodAttributes;
CallingConventions callingConventions;
bool isSstatic = (this.ProcContext.IsStatic);
if (isSstatic)
{
methodAttributes = MethodAttributes.Private | MethodAttributes.Static;
callingConventions = CallingConventions.Standard;
}
else
{
methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual;
callingConventions = CallingConventions.HasThis;
}
var argTypes = this.constructorDesc.GetArgTypes();
ConstructorBuilder constructorBuilder = classBuilder.DefineConstructor(methodAttributes, callingConventions, argTypes);
ProcContext.EmitContext.SetBuilder(constructorBuilder);
ProcContext.EmitContext.ILout = constructorBuilder.GetILGenerator();
List <ZMethodNormalArg> normalArgs = this.constructorDesc.Args;
int start_i = isSstatic ? 0 : 1;
for (var i = 0; i < normalArgs.Count; i++)
{
constructorBuilder.DefineParameter(i + start_i, ParameterAttributes.None, normalArgs[i].ArgName);
}
}
public override void EmitName()
{
var classBuilder = this.ConstructorContext.ClassContext.GetTypeBuilder();
bool isStatic = this.ConstructorContext.IsStatic();
MethodAttributes methodAttributes;
CallingConventions callingConventions;
if (isStatic)
{
methodAttributes = MethodAttributes.Private | MethodAttributes.Static;
callingConventions = CallingConventions.Standard;
}
else
{
methodAttributes = MethodAttributes.Public;
callingConventions = CallingConventions.HasThis;
}
var argTypes = this.ConstructorContext.ZConstructorInfo.GetParameterTypes();// this.constructorDesc.GetParamTypes();
ConstructorBuilder constructorBuilder = classBuilder.DefineConstructor(methodAttributes, callingConventions, argTypes);
ConstructorContext.SetBuilder(constructorBuilder);
var normalArgs = this.ConstructorContext.ZConstructorInfo.GetNormalParameters();
int start_i = isStatic ? 0 : 1;
for (var i = 0; i < normalArgs.Length; i++)
{
constructorBuilder.DefineParameter(i + start_i, ParameterAttributes.None, normalArgs[i].GetZParamName());
}
}
private static void CreateConstructor <T>(TypeBuilder typeBuilder)
{
ConstructorInfo parentCtor = (typeof(T)).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).SingleOrDefault();
if (parentCtor != null)
{
ParameterInfo[] parentCtorParms = parentCtor.GetParameters();
ConstructorBuilder ctor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parentCtorParms.Select(p => p.ParameterType).ToArray());
for (int idx = 0; idx < parentCtorParms.Length; idx++)
{
ctor.DefineParameter(idx + 1, ParameterAttributes.None, parentCtorParms[idx].Name);
}
ILGenerator ilGenerator = ctor.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
for (int i = 1; i <= parentCtorParms.Count(); i++)
{
ilGenerator.Emit(OpCodes.Ldarg, i);
}
ilGenerator.Emit(OpCodes.Call, parentCtor);
ilGenerator.Emit(OpCodes.Ret);
}
}
/// <summary>adds a constructor to a type, setting the attributes on the parameters</summary>
/// <remarks>forgeign method: should be better on TypeBuilder, but not possible</remarks>
/// <returns>the ConstructorBuilder for the method created</returns>
public ConstructorBuilder AddConstructor(TypeBuilder builder, ParameterSpec[] parameters,
MethodAttributes attrs)
{
Type[] paramTypes = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
paramTypes[i] = parameters[i].GetParamTypeMergedDirection();
}
ConstructorBuilder constrBuild =
builder.DefineConstructor(attrs, CallingConventions.Standard,
paramTypes);
// define the paramter-names / attributes
for (int i = 0; i < parameters.Length; i++)
{
ParameterAttributes paramAttr = ParameterAttributes.None;
ParameterBuilder paramBuild =
constrBuild.DefineParameter(i + 1, paramAttr,
parameters[i].GetPramName());
// custom attribute spec
TypeContainer specType = parameters[i].GetParamType();
for (int j = 0; j < specType.GetSeparatedAttrs().Length; j++)
{
paramBuild.SetCustomAttribute(specType.GetSeparatedAttrs()[j]);
}
}
return(constrBuild);
}
public void DefineParameter_ZeroSequence_SingleParameter()
{
TypeBuilder type = Helpers.DynamicType(TypeAttributes.NotPublic);
ConstructorBuilder constructor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Any, new Type[0]);
Assert.NotNull(constructor.DefineParameter(0, ParameterAttributes.None, "p"));
}
private static ILGenerator CreateConstructorIlGenerator(TypeBuilder typeBuilder)
{
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { typeof(ICustomTypeBiserializerRegistry) });
constructorBuilder.DefineParameter(1, ParameterAttributes.None, "biserializerRegistry");
return(constructorBuilder.GetILGenerator());
}
public IParameterBuilder DefineParameter(int iSequence, ParameterAttributes attributes, string strParamName)
{
// Parameter name may be null.
var parameterBuilder = _constructorBuilder.DefineParameter(iSequence, attributes, strParamName);
return(new ParameterBuilderAdapter(parameterBuilder));
}
private void InitConstuctor()
{
ConstructorBuilder ctor = _typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig, CallingConventions.HasThis, new Type[] { _modelParam.Type, _formatProviderParam.Type });
ParameterBuilder modelArg = ctor.DefineParameter(1, ParameterAttributes.None, "model");
ParameterBuilder formatProviderArg = ctor.DefineParameter(2, ParameterAttributes.None, "formatProvider");
ILGenerator il = ctor.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, CTOR_Object);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, _modelParam.Field);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Stfld, _formatProviderParam.Field);
il.Emit(OpCodes.Ret);
}
static Type createDelegate(TypeBuilder tbDelegates, MethodInfo method)
{
// Initially based on this: https://blogs.msdn.microsoft.com/joelpob/2004/02/15/creating-delegate-types-via-reflection-emit/
// Create the delegate type
TypeAttributes ta = TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed | TypeAttributes.NestedPublic;
TypeBuilder tb = tbDelegates.DefineNestedType(method.Name, ta, typeof(MulticastDelegate));
// Apply [UnmanagedFunctionPointer] using the value from RuntimeClass.defaultCallingConvention
CustomAttributeBuilder cab = new CustomAttributeBuilder(ciFPAttribute, new object[1] {
RuntimeClass.defaultCallingConvention
});
tb.SetCustomAttribute(cab);
// Create constructor for the delegate
MethodAttributes ma = MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public;
ConstructorBuilder cb = tb.DefineConstructor(ma, CallingConventions.Standard, new Type[] { typeof(object), typeof(IntPtr) });
cb.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
cb.DefineParameter(1, ParameterAttributes.In, "object");
cb.DefineParameter(2, ParameterAttributes.In, "method");
// Create Invoke method for the delegate. Appending one more parameter to the start, `[in] IntPtr pThis`
ParameterInfo[] methodParams = method.GetParameters();
Type[] paramTypes = new Type[methodParams.Length + 1];
paramTypes[0] = typeof(IntPtr);
for (int i = 0; i < methodParams.Length; i++)
{
ParameterInfo pi = methodParams[i];
Type tp = pi.ParameterType;
iCustomMarshal cm = pi.customMarshaller();
if (null != cm)
{
tp = cm.getNativeType(pi);
}
paramTypes[i + 1] = tp;
}
var mb = tb.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual, typeof(int), paramTypes);
mb.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
defineDelegateParameters(mb, methodParams);
// The method has no code, it's pure virtual.
return(tb.CreateType());
}
public static void Main()
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "Utilities";
assemblyName.Version = new Version("1.0.1.0");
AssemblyBuilder assembly = Thread.GetDomain().
DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder module;
module = assembly.DefineDynamicModule("MainModule", "Utilities.dll");
TypeBuilder utilsTypeBldr = module.DefineType("Apress.ExpertDotNet.EmitClass.Utilities",
TypeAttributes.Class | TypeAttributes.Public, typeof(System.Object));
FieldBuilder nameFld = utilsTypeBldr.DefineField("a", typeof(string),
FieldAttributes.PrivateScope);
MethodBuilder toStringMethod = utilsTypeBldr.DefineMethod("ToString",
MethodAttributes.Public | MethodAttributes.Virtual, typeof(string),
null);
ILGenerator toStringIL = toStringMethod.GetILGenerator();
toStringIL.Emit(OpCodes.Ldarg_0);
toStringIL.Emit(OpCodes.Ldfld, nameFld);
toStringIL.Emit(OpCodes.Ret);
Type[] constructorParamList = { typeof(string) };
ConstructorInfo objectConstructor = (typeof(System.Object)).
GetConstructor(new Type[0]);
ConstructorBuilder constructor = utilsTypeBldr.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard,
constructorParamList);
constructor.DefineParameter(1, ParameterAttributes.None, "name");
ILGenerator constructorIL = constructor.GetILGenerator();
constructorIL.Emit(OpCodes.Ldarg_0);
constructorIL.Emit(OpCodes.Call, objectConstructor);
constructorIL.Emit(OpCodes.Ldarg_0);
constructorIL.Emit(OpCodes.Ldarg_1);
constructorIL.Emit(OpCodes.Stfld, nameFld);
constructorIL.Emit(OpCodes.Ret);
Type utilsType = utilsTypeBldr.CreateType();
object utils = Activator.CreateInstance(utilsType, new object[] {
"New Object!"
});
object name = utilsType.InvokeMember("ToString",
BindingFlags.InvokeMethod, null, utils, null);
Console.WriteLine("ToString() returned: " + (string)name);
assembly.Save("Utilities.dll");
}
private static void AddNameParameters(IEnumerable <string> parameterNames, ConstructorBuilder constructor)
{
var i = 1;
foreach (var parameterName in parameterNames)
{
constructor.DefineParameter(i++, ParameterAttributes.None, parameterName);
}
}
private void NegTestCaseVerificationHelper(
ConstructorBuilder constructor,
int sequence,
ParameterAttributes attribute,
string paramName,
Type desiredException)
{
Assert.Throws(desiredException, () => { constructor.DefineParameter(sequence, attribute, paramName); });
}
private static void DefineParameters(this ConstructorBuilder constructorBuilder, IEnumerable <string> parameterNames)
{
var position = 1;
foreach (var parameterName in parameterNames)
{
constructorBuilder.DefineParameter(position++, ParameterAttributes.None, parameterName);
}
}
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index, PredefinedAttributes pa)
{
if (builder != null)
throw new InternalErrorException ("builder already exists");
var pattrs = ParametersCompiled.GetParameterAttribute (modFlags);
if (HasOptionalExpression)
pattrs |= ParameterAttributes.Optional;
if (mb == null)
builder = cb.DefineParameter (index, pattrs, Name);
else
builder = mb.DefineParameter (index, pattrs, Name);
if (OptAttributes != null)
OptAttributes.Emit ();
if (HasDefaultValue) {
//
// Emit constant values for true constants only, the other
// constant-like expressions will rely on default value expression
//
var def_value = DefaultValue;
Constant c = def_value != null ? def_value.Child as Constant : default_expr as Constant;
if (c != null) {
if (c.Type.BuiltinType == BuiltinTypeSpec.Type.Decimal) {
pa.DecimalConstant.EmitAttribute (builder, (decimal) c.GetValue (), c.Location);
} else {
builder.SetConstant (c.GetValue ());
}
} else if (default_expr.Type.IsStruct) {
//
// Handles special case where default expression is used with value-type
//
// void Foo (S s = default (S)) {}
//
builder.SetConstant (null);
}
}
if (parameter_type != null) {
if (parameter_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
pa.Dynamic.EmitAttribute (builder);
} else if (parameter_type.HasDynamicElement) {
pa.Dynamic.EmitAttribute (builder, parameter_type, Location);
}
}
}