//create an instance:
Created instance = createdActivator (123, “Roger”);

createdActivator doesn’t allow null values. How to make this method to accept null values too?

When used the following line of code
Created instance = createdActivator(null, “Jegan”);
It is throwing object reference error.

Can you please help me to resolve this?

With 1000000 iterations I get this:
constructor.Invoke() -> 01.7241s
lambda expression -> 00.0186s
dynamicmethod il -> 00.0154s

What’s curious is that if you lower that number to 10000, the lambda expression is faster
constructor.Invoke() -> 00.01738s
lambda expression -> 00.00026s
dynamicmethod il -> 00.00044s

Here’s the code:

using System;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;

public interface IXPTO {
}

public class XPTO : IXPTO {
public XPTO() {}
}

public class BenchMark {

public static void Main() {

ConstructorInfo constructor = typeof(XPTO).MakeGenericType(typeof(int)).GetConstructor(Type.EmptyTypes);
Func<IXPTO> f1 = () => (IXPTO)constructor.Invoke(new object[0]);
Func<IXPTO> f2 = (Func<IXPTO>)Expression.Lambda(Expression.Convert(Expression.New(constructor), typeof(IXPTO))).Compile();
DynamicMethod method = new DynamicMethod(“CreateIntance”, typeof(IXPTO), Type.EmptyTypes);
ILGenerator gen = method.GetILGenerator();
gen.Emit(OpCodes.Newobj, constructor);
gen.Emit(OpCodes.Ret);
Func<IXPTO> f3 = (Func<IXPTO>)method.CreateDelegate(typeof(Func<IXPTO>));

int iterations = 1000000;

Stopwatch watch = Stopwatch.StartNew();
for (int i = 0; i < iterations; ++i) {
f1();
}
Console.WriteLine(watch.Elapsed);
watch = Stopwatch.StartNew();
for (int i = 0; i < iterations; ++i) {
f2();
}
Console.WriteLine(watch.Elapsed);
watch = Stopwatch.StartNew();
for (int i = 0; i < iterations; ++i) {
f3();
}
Console.WriteLine(watch.Elapsed);
Console.ReadLine();
}
}

I had to use reflector and dissassemble code all the time to get my emits right.
Especially the pain with types that need boxing etc.
“Should I box now or is it already boxed?”

That kind of stuff was a real PITA.

Not sure if that was a suggestion or a plug; if the former, we simply didn’t need them (besides, I’m not a big fan of too much knowledge of fields outside the declaring class).

Re setters… obviously Expression doesn’t support this; but if you *need* fast “set” access to fields, you might consider some variant of HyperDescriptor:
http://www.codeproject.com/KB/cs/HyperPropertyDescriptor.aspx
This also has the advantage of working on 2.0; at the moment it targets properties, but as the metrics show, it doesn’t exactly suffer for this…

And atleast this code wasnt _that_ similair.
The generic operator code was more scary :-)

Btw. you forgot to add field readers in your lib ;-)
http://rogeralsing.com/2008/02/26/linq-expressions-access-private-fields/

But good to see that I’m not the only person crazy enough to be using Expressions in this way!