/// <summary>
/// Uses reflection to dynamically invoke a method,
/// throwing an exception if it is not
/// implemented on the target object.
/// </summary>
/// <param name="obj">
/// Object containing method.
/// </param>
/// <param name="info">
/// MethodInfo for the method.
/// </param>
/// <param name="parameters">
/// Parameters to pass to method.
/// </param>
public static object CallMethod(object obj, MethodInfo info, params object[] parameters)
{
DynamicMethodHandle cachedMethod = MethodCaller.GetCachedMethod(obj, info, parameters);
if (cachedMethod == null || cachedMethod.DynamicMethod == null)
{
throw new NotImplementedException(info.Name + " not implemented.");
}
return(MethodCaller.CallMethod(obj, cachedMethod, parameters));
}
/// <summary>
/// Uses reflection to create an object using its
/// default constructor.
/// </summary>
/// <param name="objectType">Type of object to create.</param>
public static object CreateInstance(Type objectType)
{
DynamicConstructor cachedConstructor = MethodCaller.GetCachedConstructor(objectType);
if (cachedConstructor == null)
{
throw new NotImplementedException("Default Constructor not implemented.");
}
return(cachedConstructor());
}
/// <summary>
/// Uses reflection to dynamically invoke a method
/// if that method is implemented on the target object.
/// </summary>
/// <param name="obj">
/// Object containing method.
/// </param>
/// <param name="method">
/// Name of the method.
/// </param>
/// <param name="parameters">
/// Parameters to pass to method.
/// </param>
public static object CallMethodIfImplemented(object obj, string method, params object[] parameters)
{
DynamicMethodHandle cachedMethod = MethodCaller.GetCachedMethod(obj, method, parameters);
if (cachedMethod == null || cachedMethod.DynamicMethod == null)
{
return(null);
}
return(MethodCaller.CallMethod(obj, cachedMethod, parameters));
}
/// <summary>
/// Gets an object's property value by name.
/// </summary>
/// <param name="target">Object containing the property to get.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="useCache">if set to <c>true</c> use dynamic cache.</param>
/// <returns>The value of the property.</returns>
public static object GetPropertyValue(object target, string propertyName, bool useCache)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (string.IsNullOrEmpty(propertyName))
{
throw new ArgumentNullException("propertyName");
}
if (useCache)
{
return(MethodCaller.GetCachedProperty(target.GetType(), propertyName).DynamicMemberGet(target));
}
return(MethodCaller.FindProperty(target.GetType(), propertyName).GetValue(target, null));
}
internal static string[] GetCachedPropertyNames(Type objectType)
{
string[] propertyNames;
if (MethodCaller._propertyNameCache.TryGetValue(objectType, out propertyNames))
{
return(propertyNames);
}
lock (MethodCaller._propertyNameCache)
{
if (!MethodCaller._propertyNameCache.TryGetValue(objectType, out propertyNames))
{
propertyNames = MethodCaller.GetPropertyNames(objectType);
MethodCaller._propertyNameCache.Add(objectType, propertyNames);
}
}
return(propertyNames);
}
/// <summary>
/// Copies values from the source into the target <see cref="T:System.Collections.IDictionary" />.
/// </summary>
/// <param name="source">The source object.</param>
/// <param name="target">The target <see cref="T:System.Collections.IDictionary" />.</param>
/// <param name="settings">The settings to use when copying properties.</param>
public static void Copy(object source, IDictionary <string, object> target, ObjectCopierSettings settings)
{
string[] cachedPropertyNames;
if (source == null)
{
throw new ArgumentNullException("source", "Source object can not be Null.");
}
if (target == null)
{
throw new ArgumentNullException("target", "Target object can not be Null.");
}
if (settings == null)
{
settings = new ObjectCopierSettings();
}
if (settings.UseDynamicCache)
{
cachedPropertyNames = MethodCaller.GetCachedPropertyNames(source.GetType());
}
else
{
cachedPropertyNames = MethodCaller.GetPropertyNames(source.GetType());
}
foreach (string str in cachedPropertyNames)
{
if (!settings.IgnoreList.Contains(str))
{
try
{
object obj2 = GetPropertyValue(source, str, settings.UseDynamicCache);
target.Add(str, obj2);
}
catch (Exception exception)
{
if (!settings.SuppressExceptions)
{
throw new ArgumentException(string.Format("Property '{0}' copy failed.", str), exception);
}
}
}
}
}
private static DynamicMethodHandle GetCachedMethod(object obj, string method, params object[] parameters)
{
MethodCacheKey key = new MethodCacheKey(obj.GetType().FullName, method, MethodCaller.GetParameterTypes(parameters));
DynamicMethodHandle dynamicMethodHandle = null;
if (MethodCaller._methodCache.TryGetValue(key, out dynamicMethodHandle))
{
return(dynamicMethodHandle);
}
lock (MethodCaller._methodCache)
{
if (!MethodCaller._methodCache.TryGetValue(key, out dynamicMethodHandle))
{
MethodInfo method2 = MethodCaller.GetMethod(obj.GetType(), method, parameters);
dynamicMethodHandle = new DynamicMethodHandle(method2, parameters);
MethodCaller._methodCache.Add(key, dynamicMethodHandle);
}
}
return(dynamicMethodHandle);
}
/// <summary>
/// Uses reflection to dynamically invoke a method,
/// throwing an exception if it is not implemented
/// on the target object.
/// </summary>
/// <param name="obj">
/// Object containing method.
/// </param>
/// <param name="methodHandle">
/// MethodHandle for the method.
/// </param>
/// <param name="parameters">
/// Parameters to pass to method.
/// </param>
private static object CallMethod(object obj, DynamicMethodHandle methodHandle, params object[] parameters)
{
object result = null;
DynamicMemberMethod arg_08_0 = methodHandle.DynamicMethod;
object[] array2;
if (parameters == null)
{
object[] array = new object[1];
array2 = array;
}
else
{
array2 = parameters;
}
if (methodHandle.HasFinalArrayParam)
{
int methodParamsLength = methodHandle.MethodParamsLength;
int num = array2.Length - (methodParamsLength - 1);
object[] extrasArray = MethodCaller.GetExtrasArray(num, methodHandle.FinalArrayElementType);
Array.Copy(array2, extrasArray, num);
object[] array3 = new object[methodParamsLength];
for (int i = 0; i <= methodParamsLength - 2; i++)
{
array3[i] = parameters[i];
}
array3[array3.Length - 1] = extrasArray;
array2 = array3;
}
try
{
result = methodHandle.DynamicMethod(obj, array2);
}
catch (Exception ex)
{
throw new CallMethodException(methodHandle.MethodName + " method call failed.", ex);
}
return(result);
}
/// <summary>
/// Sets an object's property with the specified value,
/// converting that value to the appropriate type if possible.
/// </summary>
/// <param name="target">Object containing the property to set.</param>
/// <param name="propertyName">Name of the property to set.</param>
/// <param name="value">Value to set into the property.</param>
/// <param name="useCache">if set to <c>true</c> use dynamic cache.</param>
public static void SetPropertyValue(object target, string propertyName, object value, bool useCache)
{
if (target == null)
{
throw new ArgumentNullException("target", "Target object can not be Null.");
}
if (useCache)
{
DynamicMemberHandle cachedProperty = MethodCaller.GetCachedProperty(target.GetType(), propertyName);
if (cachedProperty != null)
{
SetValueWithCoercion(target, cachedProperty, value);
}
}
else
{
PropertyInfo handle = MethodCaller.FindProperty(target.GetType(), propertyName);
if (handle != null)
{
SetValueWithCoercion(target, handle, value);
}
}
}
internal static DynamicMemberHandle GetCachedProperty(Type objectType, string propertyName)
{
MethodCacheKey key = new MethodCacheKey(objectType.FullName, propertyName, MethodCaller.GetParameterTypes(null));
DynamicMemberHandle dynamicMemberHandle = null;
if (MethodCaller._memberCache.TryGetValue(key, out dynamicMemberHandle))
{
return(dynamicMemberHandle);
}
lock (MethodCaller._memberCache)
{
if (!MethodCaller._memberCache.TryGetValue(key, out dynamicMemberHandle))
{
PropertyInfo propertyInfo = MethodCaller.FindProperty(objectType, propertyName);
if (propertyInfo != null)
{
dynamicMemberHandle = new DynamicMemberHandle(propertyInfo);
}
MethodCaller._memberCache.Add(key, dynamicMemberHandle);
}
}
return(dynamicMemberHandle);
}
/// <summary>
/// Finds a <see cref="T:System.Reflection.PropertyInfo" /> by name ignoring case.
/// </summary>
/// <param name="type">The type to search.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns>A <see cref="T:System.Reflection.PropertyInfo" /> matching the property name.</returns>
/// <remarks>
/// FindProperty will first try to get a property matching the name and case of the
/// property name specified. If a property cannot be found, all the properties will
/// be searched ignoring the case of the name.
/// </remarks>
public static PropertyInfo FindProperty(Type type, string propertyName)
{
return(MethodCaller.FindProperty(type, propertyName));
}
/// <summary>
/// Invokes a property setter using dynamic
/// method invocation.
/// </summary>
/// <param name="obj">Target object.</param>
/// <param name="property">Property to invoke.</param>
/// <param name="value">New value for property.</param>
public static void CallPropertySetter(object obj, string property, object value)
{
DynamicMemberHandle cachedProperty = MethodCaller.GetCachedProperty(obj.GetType(), property);
cachedProperty.DynamicMemberSet(obj, value);
}
/// <summary>
/// Invokes a property getter using dynamic
/// method invocation.
/// </summary>
/// <param name="obj">Target object.</param>
/// <param name="property">Property to invoke.</param>
/// <returns></returns>
public static object CallPropertyGetter(object obj, string property)
{
DynamicMemberHandle cachedProperty = MethodCaller.GetCachedProperty(obj.GetType(), property);
return(cachedProperty.DynamicMemberGet(obj));
}
internal static DynamicMemberHandle GetCachedField(Type objectType, string fieldName)
{
MethodCacheKey key = new MethodCacheKey(objectType.FullName, fieldName, MethodCaller.GetParameterTypes(null));
DynamicMemberHandle dynamicMemberHandle = null;
if (MethodCaller._memberCache.TryGetValue(key, out dynamicMemberHandle))
{
return(dynamicMemberHandle);
}
lock (MethodCaller._memberCache)
{
if (!MethodCaller._memberCache.TryGetValue(key, out dynamicMemberHandle))
{
FieldInfo field = objectType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
dynamicMemberHandle = new DynamicMemberHandle(field);
}
MethodCaller._memberCache.Add(key, dynamicMemberHandle);
}
}
return(dynamicMemberHandle);
}