LateNew source


The following code is for the post "Activator.CreateInstance and beyond"


**All source code is provided as is, with no warranties intended or implied. Use at your own risk.**

Instruction
perl sample.pl > sample.cs
csc /t:library sample.cs
csc /o+ latenew.cs
To run: latenew sample.dll 1000 1000

sample.pl
for $i (1..2000)
{
$name = "C$i";
print "public class $name { public $name() {} public $name(int i) {} public $name(string s) {} }\n";
}

latenew.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;

class LateNew
{
static int LOOP;
static int TYPENUM;
static Type[] types;

delegate void Approach(out DateTime prepareStart, out DateTime executeStart, out DateTime finish);

static void Measure(Approach d)
{
DateTime prepareStart, executeStart, finish;
d(out prepareStart, out executeStart, out finish);
Console.WriteLine("{0} - {1}", executeStart - prepareStart, finish - executeStart);
GC.Collect(2);
GC.WaitForPendingFinalizers();
}

static void Main(string[] args)
{
types = Assembly.LoadFrom(args[0]).GetTypes();
LOOP = Int32.Parse(args[1]);
TYPENUM = Int32.Parse(args[2]);
if (TYPENUM > types.Length) TYPENUM = types.Length;

Console.WriteLine("Total Type #: {0}", types.Length);
Console.WriteLine("Used Type #: {0}", TYPENUM);
Console.WriteLine("Loop: {0}", LOOP);

Measure(ParameterAndActivator);
Measure(ParameterAndEmit);
Measure(ParameterAndEmitAndDelegate);
Measure(ParameterAndDynamicMethod);
Measure(ParameterAndDynamicMethodAndDelegate);
Measure(ParameterAndCtorInfo);

Measure(ParameterlessAndActivator);
Measure(ParameterlessAndEmit);
Measure(ParameterlessAndEmitAndDelegate);
Measure(ParameterlessAndDynamicMethod);
Measure(ParameterlessAndDynamicMethodAndDelegate);
Measure(ParameterlessAndCtorInfo);
}
public delegate object CtorInt32Delegate(int arg);
public delegate object CtorDelegate();

private static void ParameterAndActivator(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
executeStart = prepareStart;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
Activator.CreateInstance(types[j++], 100);
finish = DateTime.Now;
}
private static void ParameterAndCtorInfo(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
Dictionary<Type, ConstructorInfo> ctors = new Dictionary<Type, ConstructorInfo>();
foreach (Type t in types)
ctors.Add(t, t.GetConstructor(new Type[] { typeof(int) }));
executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]].Invoke(new object[] { 100 });
finish = DateTime.Now;
}
private static void ParameterAndDynamicMethod(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
Dictionary<Type, DynamicMethod> ctors = new Dictionary<Type, DynamicMethod>();
foreach (Type type in types)
{
DynamicMethod dm = new DynamicMethod("MyCtor", type, new Type[] { typeof(int) }, typeof(LateNew).Module, true);
ILGenerator ilgen = dm.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(new Type[] { typeof(int) }));
ilgen.Emit(OpCodes.Ret);

ctors.Add(type, dm);
}
executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]].Invoke(null, new object[] { 100 });
finish = DateTime.Now;
}
private static void ParameterAndDynamicMethodAndDelegate(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
Dictionary<Type, CtorInt32Delegate> ctors = new Dictionary<Type, CtorInt32Delegate>();
foreach (Type type in types)
{
DynamicMethod dm = new DynamicMethod("MyCtor", type, new Type[] { typeof(int) }, typeof(LateNew).Module, true);
ILGenerator ilgen = dm.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(new Type[] { typeof(int) }));
ilgen.Emit(OpCodes.Ret);

ctors.Add(type, (CtorInt32Delegate)dm.CreateDelegate(typeof(CtorInt32Delegate)));
}
executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]](100);
finish = DateTime.Now;
}
private static void ParameterAndEmit(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
AssemblyBuilder asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("inmemory"), AssemblyBuilderAccess.Run);
ModuleBuilder modBldr = asmBldr.DefineDynamicModule("helper");
TypeBuilder typeBldr = modBldr.DefineType("ClassFactory");
foreach (Type type in types)
{
MethodBuilder methBldr = typeBldr.DefineMethod(type.Name, MethodAttributes.Public | MethodAttributes.Static, type, new Type[] { typeof(int) });
ILGenerator ilgen = methBldr.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(new Type[] { typeof(int) }));
ilgen.Emit(OpCodes.Ret);

}
Type baked = typeBldr.CreateType();
Dictionary<Type, MethodInfo> ctors = new Dictionary<Type, MethodInfo>();
foreach (Type type in types)
ctors.Add(type, baked.GetMethod(type.Name));

executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]].Invoke(null, new object[] { 100 });
finish = DateTime.Now;
}
private static void ParameterAndEmitAndDelegate(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
AssemblyBuilder asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("inmemory"), AssemblyBuilderAccess.Run);
ModuleBuilder modBldr = asmBldr.DefineDynamicModule("helper");
TypeBuilder typeBldr = modBldr.DefineType("ClassFactory");
foreach (Type type in types)
{
MethodBuilder methBldr = typeBldr.DefineMethod(type.Name, MethodAttributes.Public | MethodAttributes.Static, type, new Type[] { typeof(int) });
ILGenerator ilgen = methBldr.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(new Type[] { typeof(int) }));
ilgen.Emit(OpCodes.Ret);

}
Type baked = typeBldr.CreateType();
Dictionary<Type, CtorInt32Delegate> ctors = new Dictionary<Type, CtorInt32Delegate>();
foreach (Type type in types)
ctors.Add(type, (CtorInt32Delegate)Delegate.CreateDelegate(typeof(CtorInt32Delegate), baked.GetMethod(type.Name)));
executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]](100);
finish = DateTime.Now;
}

private static void ParameterlessAndActivator(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
executeStart = prepareStart;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
Activator.CreateInstance(types[j++]);
finish = DateTime.Now;
}
private static void ParameterlessAndCtorInfo(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
Dictionary<Type, ConstructorInfo> ctors = new Dictionary<Type, ConstructorInfo>();
foreach (Type t in types)
ctors.Add(t, t.GetConstructor(Type.EmptyTypes));

executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]].Invoke(null);
finish = DateTime.Now;
}
private static void ParameterlessAndDynamicMethod(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
Dictionary<Type, DynamicMethod> ctors = new Dictionary<Type, DynamicMethod>();
foreach (Type type in types)
{
DynamicMethod dm = new DynamicMethod("MyCtor", type, Type.EmptyTypes, typeof(LateNew).Module, true);
ILGenerator ilgen = dm.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
ilgen.Emit(OpCodes.Ret);

ctors.Add(type, dm);
}

executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]].Invoke(null, null);
finish = DateTime.Now;
}
private static void ParameterlessAndDynamicMethodAndDelegate(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
Dictionary<Type, CtorDelegate> ctors = new Dictionary<Type, CtorDelegate>();
foreach (Type type in types)
{
DynamicMethod dm = new DynamicMethod("MyCtor", type, Type.EmptyTypes, typeof(LateNew).Module, true);
ILGenerator ilgen = dm.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
ilgen.Emit(OpCodes.Ret);

ctors.Add(type, (CtorDelegate)dm.CreateDelegate(typeof(CtorDelegate)));
}

executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]]();
finish = DateTime.Now;
}
private static void ParameterlessAndEmit(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
AssemblyBuilder asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("inmemory"), AssemblyBuilderAccess.Run);
ModuleBuilder modBldr = asmBldr.DefineDynamicModule("helper");
TypeBuilder typeBldr = modBldr.DefineType("ClassFactory");

foreach (Type type in types)
{
MethodBuilder methBldr = typeBldr.DefineMethod(type.Name, MethodAttributes.Public | MethodAttributes.Static, type, Type.EmptyTypes);
ILGenerator ilgen = methBldr.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
ilgen.Emit(OpCodes.Ret);

}
Type baked = typeBldr.CreateType();

Dictionary<Type, MethodInfo> ctors = new Dictionary<Type, MethodInfo>();
foreach (Type type in types)
ctors.Add(type, baked.GetMethod(type.Name));

executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]].Invoke(null, null);
finish = DateTime.Now;
}
private static void ParameterlessAndEmitAndDelegate(out DateTime prepareStart, out DateTime executeStart, out DateTime finish)
{
prepareStart = DateTime.Now;
AssemblyBuilder asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("inmemory"), AssemblyBuilderAccess.Run);
ModuleBuilder modBldr = asmBldr.DefineDynamicModule("helper");
TypeBuilder typeBldr = modBldr.DefineType("ClassFactory");

foreach (Type type in types)
{
MethodBuilder methBldr = typeBldr.DefineMethod(type.Name, MethodAttributes.Public | MethodAttributes.Static, type, Type.EmptyTypes);
ILGenerator ilgen = methBldr.GetILGenerator();
ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
ilgen.Emit(OpCodes.Ret);

}
Type baked = typeBldr.CreateType();

Dictionary<Type, CtorDelegate> ctors = new Dictionary<Type, CtorDelegate>();
foreach (Type type in types)
ctors.Add(type, (CtorDelegate)Delegate.CreateDelegate(typeof(CtorDelegate), baked.GetMethod(type.Name)));

executeStart = DateTime.Now;
for (int i = 0; i < LOOP; i++)
for (int j = 0; j < TYPENUM; )
ctors[types[j++]]();
finish = DateTime.Now;
}
}

Comments (0)

Skip to main content