Question

I’ve read that i should create and reuse delegates to get the value of a property of an object.

I use this code to create the Delegate

    var objParm = Expression.Parameter(property.DeclaringType, "o");

    Type delegateType = typeof(Func<,>).MakeGenericType(property.DeclaringType, property.PropertyType);

    var lambda = Expression.Lambda(delegateType, Expression.Property(objParm, property.Name), objParm);

    return lambda.Compile()

Now i only find the way to use the delegate in the call of “DynamicInvoke”.

Now i want to change the call to “invoke” cause of performance reasons.

I tried

Delegate.Method.Invoke(invokedObject, null);

But after the call i get the exception

MethodInfo must be a RuntimeMethodInfo.

I have an cache class for each property where i can store the dynamically created delegate.

What should i do so i am able to use “normal” Invokes?

Thanks a lot.

Answer 1

I’ve created a class that I use when I need to access properties by using their name as text. The class caches all properties for an class.

Usage:

PropertyWrapper<User> wrapper = new PropertyWrapper<User>();
wrapper.SetValue("FirstName", "arne");
int age = (int)wrapper.GetValue("Age");

The class

public class PropertyWrapper<T>
{
    private Dictionary<string, Methods> _properties = new Dictionary<string, Methods>();
    private class Methods
    {
        public MethodBase Get { get; set; }
        public MethodBase Set { get; set; }
    }

    public PropertyWrapper()
    {
        foreach (var item in typeof(T).GetProperties())
        {
            if (!item.CanRead && !item.CanWrite)
                continue;

            var mappings = new Methods();
            if (item.CanRead)
                mappings.Get = item.GetGetMethod();
            if (item.CanWrite)
                mappings.Set = item.GetSetMethod();

            _properties.Add(item.Name, mappings);
        }
    }

    public object GetValue(T instance, string name)
    {
        Methods mappings;
        if (_properties.TryGetValue(name, out mappings) && mappings.Get != null)
            return mappings.Get.Invoke(instance, null);

        throw new MappingException("Specified property cannot be read", typeof(T), name);
    }

    public void SetValue(T instance, string name, object value)
    {
        Methods mappings;
        if (_properties.TryGetValue(name, out mappings) && mappings.Set != null)
        {
            mappings.Set.Invoke(instance, new[] { value });
            return;
        }

        throw new MappingException("Specified property cannot be written.", typeof(T), name);
    }
}

public class MappingException : Exception
{
    public MappingException(string errMsg, Type type, string propertyName) 
        : base(errMsg)
    {
        ReflectedType = type;
        PropertyName = propertyName;
    }

    public Type ReflectedType { get; private set; }
    public string PropertyName { get; private set; } 
}