/// <summary>
/// Sets the property value.
/// </summary>
/// <param name="object">The object.</param>
/// <param name="propertyInfo">The property information.</param>
/// <param name="value">The value.</param>
public static void SetPropertyValue(object @object, PropertyInfo propertyInfo, object value)
{
if (@object == null)
{
throw new ArgumentNullException("object");
}
if (propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
Type type = @object.GetType();
if (!propertyInfo.CanWrite)
{
throw new ReflectionHelperException(string.Format(CultureInfo.CurrentCulture, Strings.ReflectionHelper_SetPropertyValue_the_property_has_no_set_method, propertyInfo.Name, type.AssemblyQualifiedName));
}
ReflectionHelper.PropertyAccessItem propertyAccessItem = GetPropertyAccessItem(type, propertyInfo);
//if (!TypeUtils.IsImplicitlyConvertible(valueType, propertyInfo.PropertyType))
//{
// throw new ReflectionHelperException(string.Format(CultureInfo.CurrentCulture, Strings.ReflectionHelper_SetPropertyValue_type_is_not_implicitly_convertable, valueType, propertyInfo.PropertyType));
//}
ReflectionHelper.CheckAreAssignable(propertyInfo, value, propertyInfo.PropertyType);
propertyAccessItem.Setter(@object, value);
}
public void CreatePropertyAccessItemReadonlyProperty()
{
ReflectionHelper.PropertyAccessItem propertyAccessItem = ReflectionHelper.CreatePropertyAccessItem(typeof(PropertyTestClass), typeof(PropertyTestClass).GetProperty("ReadOnlyProperty"));
Assert.AreEqual(true, propertyAccessItem.CanRead);
Assert.AreEqual(false, propertyAccessItem.CanWrite);
Assert.NotNull(propertyAccessItem.Getter);
Assert.IsNull(propertyAccessItem.Setter);
Assert.AreEqual(1, propertyAccessItem.Getter(new PropertyTestClass()));
}
internal static ReflectionHelper.PropertyAccessItem CreatePropertyAccessItem(Type objectType, PropertyInfo propertyInfo)
{
if (objectType == null)
{
throw new ArgumentNullException("objectType");
}
if (propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
bool canRead = propertyInfo.CanRead;
bool canWrite = propertyInfo.CanWrite;
ReflectionHelper.PropertyAccessItem propertyAccessItem = new ReflectionHelper.PropertyAccessItem
{
CanRead = canRead,
CanWrite = canWrite
};
if (canRead)
{
MethodInfo getMethodInfo = propertyInfo.GetGetMethod(true);
ParameterExpression thisParameterExpression = Expression.Parameter(typeof(object), "this");
MethodCallExpression methodCallExpression = Expression.Call(Expression.Convert(thisParameterExpression, objectType), getMethodInfo);
Expression callExpr = Expression.Convert(methodCallExpression, typeof(object));
propertyAccessItem.Getter = Expression.Lambda <MemberGetter>(callExpr, thisParameterExpression).Compile();
}
if (canWrite)
{
MethodInfo setMethodInfo = propertyInfo.GetSetMethod(true);
ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "value");
ParameterExpression thisParameterExpression = Expression.Parameter(typeof(object), "this");
MethodCallExpression methodCallExpression =
Expression.Call(
Expression.Convert(thisParameterExpression, objectType),
setMethodInfo,
new Expression[]
{
Expression.Convert(parameterExpression, setMethodInfo.GetParameters()[0].ParameterType)
});
propertyAccessItem.Setter = Expression.Lambda <MemberSetter>(methodCallExpression, thisParameterExpression, parameterExpression).Compile();
}
return(propertyAccessItem);
}
public void CreatePropertyAccessItemWriteOnlyProperty()
{
ReflectionHelper.PropertyAccessItem propertyAccessItem = ReflectionHelper.CreatePropertyAccessItem(typeof(PropertyTestClass), typeof(PropertyTestClass).GetProperty("WriteOnlyProperty"));
Assert.AreEqual(false, propertyAccessItem.CanRead);
Assert.AreEqual(true, propertyAccessItem.CanWrite);
Assert.IsNull(propertyAccessItem.Getter);
Assert.NotNull(propertyAccessItem.Setter);
PropertyTestClass propertyTestClass = new PropertyTestClass();
propertyAccessItem.Setter(propertyTestClass, 2);
Assert.AreEqual(2, propertyTestClass.ReadWriteProperty);
}
/// <summary>
/// Gets the property value.
/// </summary>
/// <param name="object">The object.</param>
/// <param name="propertyInfo">The property information.</param>
/// <returns>The property value</returns>
/// <exception cref="System.ArgumentNullException">
/// object
/// or
/// propertyInfo
/// </exception>
public static object GetPropertyValue(object @object, PropertyInfo propertyInfo)
{
if (@object == null)
{
throw new ArgumentNullException("object");
}
if (propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
Type type = @object.GetType();
if (!propertyInfo.CanRead)
{
throw new ReflectionHelperException(string.Format(CultureInfo.CurrentCulture, Strings.ReflectionHelper_GetPropertyValue_property_has_no_get_method, propertyInfo.Name, type.AssemblyQualifiedName));
}
ReflectionHelper.PropertyAccessItem propertyAccessItem = GetPropertyAccessItem(type, propertyInfo);
return(propertyAccessItem.Getter(@object));
}
