Sorry for the double post….

I suppose it was my fault for not posting the profiling code…but the profiling here was specifically a tight loop around only the reflection calls, not any of the AutoMapper API. I have done more profiling around the whole of AutoMapper, and the bottlenecks just aren’t the reflection stuff.

The issue I run into is that many decisions on what to do are runtime and value (and not type) specific. Some of these I’m just stuck with.

In my ORM I’ve created a cache to store the needed information about PropertyInfo and FieldInfo of each business class of my application.
When I need to set or get a value I simply used the stored PropertyInfo or FieldInfo retrieved from the cache to access or set the value. So it seems that the costs of the Reflection is not the SetValue or GetValue operation but only the GetPropertyInfo or GetFieldInfo.
When I query the cache to get the business class information, if the information are not in the cache, ones are retrieved using Reflection and stored in the cache.
In this way the Reflection are used only one time per business class.
If you want I can post my example test project.

Ciao

In my ORM I’ve created a cache to store the needed information about PropertyInfo and FieldInfo of each business class of my application.
When I need to set or get a value I simply used the stored PropertyInfo or FieldInfo retrieved from the cache to access or set the value. So it seems that the costs of the Reflection is not the SetValue or GetValue operation but only the GetPropertyInfo or GetFieldInfo.
When I query the cache to get the business class information, if the information are not in the cache, ones are retrieved using Reflection and stored in the cache.
In this way the Reflection are used only one time per business class.
If you want I can post my example test project.

Ciao

I have done some testing: your solution is ~2 times faster on value types, very insignificantly faster on reference types.

On the other hand, in my solution creation of LateBoundPropertySet is ~7 times faster comparing to yours.

I guess for Automapper scenarios LateBoundPropertySet delegate usage performance is much more important than creation performance, so your solution is better for Automapper. Anyway, I suggested my alternative not so much from performance perspective, but just as an example how the same thing could be solved without IL generation (thus much simpler, easier to support and less error prone – though once written this piece of code doesn’t really need much support).

Yeah, I tried Delegate.CreateDelegate, but found it to be slower. Have you run any numbers on it?

@Mikael

The problem is that AutoMapper doesn’t know about these types at compile time, only runtime. All I have to work with is MemberInfo objects. To AutoMapper, everything is an object.

@Michael

Thanks! I think I still need to use unbox.any, as I have to cast the incoming type to the type of the setter. Unbox.any either unboxes to the value type, or does castclass if it’s a reference type, so it’s a two-for-one deal.

where UnboxIfNeeded is
private static void UnboxIfNeeded(Type type, ILGenerator generator)
{
if (type.IsValueType)
{
generator.Emit(OpCodes.Unbox_Any, type);
}
}

one “if” more but no unboxing if not needed

FYI:
I ran into some issue using some IL generation with DynamicMethod in the past when dealing with private field.
So I tried to use your CreateSet(FieldInfo field) method this morning with a purely private field (type int, no setter/getter) to see how it would behave. I got following error
“operation could destabilize the runtime”…. scary

class DelegateFactory
…
DelegateFactory.LateBoundPropertySet callback = DelegateFactory.CreateSet(property);

It might be easier to generate those using CodeDomProvider instead as you don’t have to type IL.

I had a similar task and here is how I solved it without IL:

public delegate void LateBoundPropertySet(object target, object value);

public static LateBoundPropertySet CreateSet(PropertyInfo property)
{
var setterType = typeof(Action< ,>).MakeGenericType(property.DeclaringType, property.PropertyType);
var propertyWriter = typeof(PropertyWriter< ,>).MakeGenericType(property.DeclaringType, property.PropertyType);
var setterDelegate = Delegate.CreateDelegate(setterType, property.GetSetMethod());
var writer = (IPropertyWriter)Activator.CreateInstance(propertyWriter, setterDelegate);
return writer.SetValue;
}

private interface IPropertyWriter
{
void SetValue(object instance, object value);
}

private class PropertyWriter : IPropertyWriter
{
private readonly Action _setValueDelegate;

public PropertyWriter(Action setValueDelegate)
{
_setValueDelegate = setValueDelegate;
}

public void SetValue(object instance, object value)
{
_setValueDelegate((TInstance)instance, (TProperty)value);
}
}