public void TestValidDataWithSingleParameter()
{
int i = 0;
Type[] parameterTypes = new Type[]
{
typeof(ConstructorBuilderDefineParameter)
};
for (; i < _supportedAttributes.Length; ++i)
{
ConstructorBuilder constructor = CreateConstructorBuilder("PosTest2_Type" + i,
parameterTypes);
constructor.DefineParameter(1, _supportedAttributes[i], "parameter1" + 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(1, definedParams.Length);
}
}
private static StripeHandlerFactory <T, R> GenerateStripeHandlerFactory <T, R>(Expression <Kernel <T, R> > kernel)
where T : unmanaged
where R : unmanaged
{
var ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("ExprStripeHandler"), AssemblyBuilderAccess.RunAndSave);
var tb = ab.DefineDynamicModule("ExprStripeHandler", "ExprStripeHandler.dll", true).DefineType("StripeHandler", TypeAttributes.Class | TypeAttributes.Public);
var xmin = tb.DefineField("_xmin", typeof(int), FieldAttributes.Private);
var xmax = tb.DefineField("_xmax", typeof(int), FieldAttributes.Private);
var ymin = tb.DefineField("_ymin", typeof(int), FieldAttributes.Private);
var ymax = tb.DefineField("_ymax", typeof(int), FieldAttributes.Private);
//var delta = tb.DefineField("_delta", typeof(long), @private);
//var stride = tb.DefineField("_stride", typeof(int), FieldAttributes.Private);
var source = tb.DefineField("_source", typeof(UnsafeArray2d <T>), FieldAttributes.Private);
var target = tb.DefineField("_target", UnsafeArray2d.GetTypeInstance <R>(), FieldAttributes.Private);
ConstructorBuilder cb = BuildConstructor <T, R>(tb, xmin, xmax, ymin, ymax, source, target);
MethodBuilder rm = BuildRunMethod(kernel, tb, xmin, xmax, ymin, ymax, source, target);
var t = tb.CreateType();
var constructor = t.GetConstructor((from p in cb.GetParameters() select p.ParameterType).ToArray());
var runMethod = t.GetMethod(rm.Name); // there is only one method with this name
ab.Save("ExprStripeHandler.dll");
return(PrepareFactory <T, R>(constructor, runMethod));
}
public void GetParameters_Complete2()
{
ConstructorBuilder cb = genClass.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard, null);
cb.GetILGenerator().Emit(OpCodes.Ret);
genClass.CreateType();
ParameterInfo [] parameters = cb.GetParameters();
Assert.IsNotNull(parameters, "#1");
Assert.AreEqual(0, parameters.Length, "#2");
}
public void GetParameters_Incomplete()
{
ConstructorBuilder cb = genClass.DefineConstructor(
0, 0, new Type [2] {
typeof(int), typeof(string)
});
cb.DefineParameter(1, ParameterAttributes.In, "param1");
cb.DefineParameter(2, ParameterAttributes.In, "param2");
cb.GetILGenerator().Emit(OpCodes.Ret);
try {
cb.GetParameters();
Assert.Fail("#1");
} catch (NotSupportedException ex) {
// Type has not been created
Assert.AreEqual(typeof(NotSupportedException), ex.GetType(), "#2");
Assert.IsNull(ex.InnerException, "#3");
Assert.IsNotNull(ex.Message, "#4");
}
}
internal static StripeMultiHandlerFactory GenerateStripeHandlerFactory <R>(LambdaExpression kernel, bool recurrent)
{
var ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("ExprStripeHandler"), AssemblyBuilderAccess.RunAndSave);
var tb = ab.DefineDynamicModule("ExprStripeHandler", "ExprStripeHandler.dll", true).DefineType("StripeHandler", TypeAttributes.Class | TypeAttributes.Public);
var xmin = tb.DefineField("_xmin", typeof(int), FieldAttributes.Private);
var xmax = tb.DefineField("_xmax", typeof(int), FieldAttributes.Private);
var ymin = tb.DefineField("_ymin", typeof(int), FieldAttributes.Private);
var ymax = tb.DefineField("_ymax", typeof(int), FieldAttributes.Private);
var sources = new List <FieldBuilder>();
foreach (var p in kernel.Parameters)
{
var pType = p.Type;
if (pType.IsConstructedGenericType && pType.GetGenericTypeDefinition() == typeof(ICell <>))
{
pType = pType.GetGenericArguments()[0];
}
sources.Add(tb.DefineField("_source." + p.Name, UnsafeArray2d.GetTypeInstance(pType), FieldAttributes.Private));
}
var target = tb.DefineField("_target", UnsafeArray2d.GetTypeInstance(typeof(R)), FieldAttributes.Private);
if (recurrent)
{
sources.RemoveAt(sources.Count - 1);
}
ConstructorBuilder cb = BuildConstructor <R>(tb, xmin, xmax, ymin, ymax, sources, target);
MethodBuilder rm = BuildRunMethod <R>(kernel, tb, xmin, xmax, ymin, ymax, sources, target, recurrent);
var t = tb.CreateType();
var constructor = t.GetConstructor((from p in cb.GetParameters() select p.ParameterType).ToArray());
var runMethod = t.GetMethod(rm.Name); // there is only one method with this name
ab.Save("ExprStripeHandler.dll");
return(PrepareFactory <R>(constructor, runMethod));
}
public void DefineParameter_SingleParameter_NullParameterName()
{
Type[] parameterTypes = new Type[] { typeof(ConstructorBuilderDefineParameter) };
for (int i = 0; i < s_supportedAttributes.Length; i++)
{
TypeBuilder type = Helpers.DynamicType(TypeAttributes.NotPublic);
ConstructorBuilder constructor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes);
constructor.DefineParameter(1, s_supportedAttributes[i], null);
ILGenerator ilGenerator = constructor.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0]));
ilGenerator.Emit(OpCodes.Ret);
type.CreateType();
ParameterInfo[] definedParams = constructor.GetParameters();
Assert.Equal(1, definedParams.Length);
}
}
unsafe private static StripeHandlerFactory <T> GenerateStripeHandlerFactory <T, R>(Kernel <T, R> kernel)
where T : unmanaged
where R : unmanaged
{
var ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("StripeHandler"), AssemblyBuilderAccess.RunAndCollect);
var tb = ab.DefineDynamicModule("StripeHandler").DefineType("StripeHandler", TypeAttributes.Class | TypeAttributes.Public);
var length = tb.DefineField("_length", typeof(int), FieldAttributes.Private);
var sourcePtr = tb.DefineField("_sourcePtr", typeof(T *), FieldAttributes.Private);
var delta = tb.DefineField("_delta", typeof(long), FieldAttributes.Private);
var width = tb.DefineField("_width", typeof(int), FieldAttributes.Private);
var target = tb.DefineField("_target", typeof(object), FieldAttributes.Private);
ConstructorBuilder cb = BuildConstructor <T>(tb, length, sourcePtr, delta, width, target);
MethodBuilder rm = BuildRunMethod(kernel, tb, length, sourcePtr, delta, width, target);
var t = tb.CreateType();
var constructor = t.GetConstructor((from p in cb.GetParameters() select p.ParameterType).ToArray());
var runMethod = t.GetMethod(rm.Name); // there is only one method with this name
return(PrepareFactory <T>(constructor, runMethod));
}
internal MyConstructorBuilder()
{
// <Snippet1>
// <Snippet3>
MethodBuilder myMethodBuilder = null;
AppDomain myCurrentDomain = AppDomain.CurrentDomain;
// Create assembly in current CurrentDomain.
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "TempAssembly";
// Create a dynamic assembly.
myAssemblyBuilder = myCurrentDomain.DefineDynamicAssembly
(myAssemblyName, AssemblyBuilderAccess.Run);
// Create a dynamic module in the assembly.
myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule");
// Create a type in the module.
TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("TempClass", TypeAttributes.Public);
FieldBuilder myGreetingField = myTypeBuilder.DefineField("Greeting",
typeof(String), FieldAttributes.Public);
Type[] myConstructorArgs = { typeof(String) };
// <Snippet2>
// <Snippet4>
// Define a constructor of the dynamic class.
ConstructorBuilder myConstructorBuilder = myTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs);
// Get a reference to the module that contains this constructor.
Module myModule = myConstructorBuilder.GetModule();
Console.WriteLine("Module Name : " + myModule.Name);
// Get the 'MethodToken' that represents the token for this constructor.
MethodToken myMethodToken = myConstructorBuilder.GetToken();
Console.WriteLine("Constructor Token is : " + myMethodToken.Token);
// Get the method implementation flags for this constructor.
MethodImplAttributes myMethodImplAttributes = myConstructorBuilder.GetMethodImplementationFlags();
Console.WriteLine("MethodImplAttributes : " + myMethodImplAttributes);
// </Snippet3>
// </Snippet2>
// </Snippet1>
// Generate IL for the method, call its base class constructor and store the arguments
// in the private field.
ILGenerator myILGenerator3 = myConstructorBuilder.GetILGenerator();
myILGenerator3.Emit(OpCodes.Ldarg_0);
ConstructorInfo myConstructorInfo = typeof(Object).GetConstructor(new Type[0]);
myILGenerator3.Emit(OpCodes.Call, myConstructorInfo);
myILGenerator3.Emit(OpCodes.Ldarg_0);
myILGenerator3.Emit(OpCodes.Ldarg_1);
myILGenerator3.Emit(OpCodes.Stfld, myGreetingField);
myILGenerator3.Emit(OpCodes.Ret);
// Add a method to the type.
myMethodBuilder = myTypeBuilder.DefineMethod
("HelloWorld", MethodAttributes.Public, null, null);
// Generate IL for the method.
ILGenerator myILGenerator2 = myMethodBuilder.GetILGenerator();
myILGenerator2.EmitWriteLine("Hello World from global");
myILGenerator2.Emit(OpCodes.Ret);
myModuleBuilder.CreateGlobalFunctions();
myType1 = myTypeBuilder.CreateType();
// Get the parameters of this constructor.
ParameterInfo[] myParameterInfo = myConstructorBuilder.GetParameters();
for (int i = 0; i < myParameterInfo.Length; i++)
{
Console.WriteLine("Declaration type : " + myParameterInfo[i].Member.DeclaringType);
}
// </Snippet4>
}
