protected virtual Action <object, TType> GetMemberSetterInternal <TType>(MemberInfo member) { var key = new MemberInfoDelegateCacheKey(member, typeof(TType)); lock (MemberSetterCache) { Delegate action; if (!MemberSetterCache.TryGetValue(key, out action)) { var declaringType = member.DeclaringType; var fieldInfo = member as FieldInfo; #if NET_STANDARD if (declaringType.GetTypeInfo().IsValueType) #else if (declaringType.IsValueType) #endif { Action <object, TType> result; if (fieldInfo == null) { var propertyInfo = (PropertyInfo)member; result = propertyInfo.SetValue <TType>; } else { result = fieldInfo.SetValue <TType>; } MemberSetterCache[key] = result; return(result); } Expression expression; var targetParameter = Expression.Parameter(typeof(object), "instance"); var valueParameter = Expression.Parameter(typeof(TType), "value"); var target = ConvertIfNeed(targetParameter, declaringType, false); if (fieldInfo == null) { var propertyInfo = member as PropertyInfo; MethodInfo setMethod = null; if (propertyInfo != null) { setMethod = propertyInfo.GetSetMethod(true); } Should.MethodBeSupported(propertyInfo != null && setMethod != null, "supports only properties (non-readonly) and fields"); var valueExpression = ConvertIfNeed(valueParameter, propertyInfo.PropertyType, false); expression = Expression.Call(setMethod.IsStatic ? null : ConvertIfNeed(target, declaringType, false), setMethod, valueExpression); GenerateSetterCode(member, typeof(TType), propertyInfo.PropertyType); } else { expression = Expression.Field(fieldInfo.IsStatic ? null : ConvertIfNeed(target, declaringType, false), fieldInfo); expression = Expression.Assign(expression, ConvertIfNeed(valueParameter, fieldInfo.FieldType, false)); GenerateSetterCode(member, typeof(TType), fieldInfo.FieldType); } action = Expression .Lambda <Action <object, TType> >(expression, targetParameter, valueParameter) .Compile(); MemberSetterCache[key] = action; } return((Action <object, TType>)action); } }
public object ConvertBack(object value, Type targetType, object parameter, string language) { Should.MethodBeSupported(false, "ConvertBack()"); return(null); }
/// <summary> /// Gets a delegate to set specified value in the specified <see cref="MemberInfo" /> in a value type target, can be /// used with reference type. /// </summary> /// <typeparam name="TType">Type of the value.</typeparam> /// <param name="member"> /// The specified <see cref="MemberInfo" />. /// </param> /// <returns> /// An instance of <see cref="Action{TOwner,TType}" /> /// </returns> public virtual Action <object, TType> GetMemberSetter <TType>(MemberInfo member) { Should.NotBeNull(member, "member"); lock (MemberSetterCache) { Delegate action; if (!MemberAccessCache.TryGetValue(member, out action) || !(action is Action <object, TType>)) { var declaringType = GetDeclaringType(member); var fieldInfo = member as FieldInfo; #if PCL_WINRT if (declaringType.GetTypeInfo().IsValueType) #else if (declaringType.IsValueType) #endif { Action <object, TType> result; if (fieldInfo == null) { var propertyInfo = (PropertyInfo)member; result = propertyInfo.SetValue <TType>; } else { result = fieldInfo.SetValue <TType>; } MemberAccessCache[member] = result; return(result); } Expression expression; var targetParameter = Expression.Parameter(typeof(object), "instance"); var valueParameter = Expression.Parameter(typeof(TType), "value"); var target = ConvertIfNeed(targetParameter, declaringType, false); if (fieldInfo == null) { var propertyInfo = member as PropertyInfo; MethodInfo setMethod = null; if (propertyInfo != null) { setMethod = propertyInfo.GetSetMethod(true); } Should.MethodBeSupported(propertyInfo != null && setMethod != null, "supports only properties(non-readonly) and fields"); var valueExpression = ConvertIfNeed(valueParameter, propertyInfo.PropertyType, false); expression = Expression.Call(setMethod.IsStatic ? null : ConvertIfNeed(target, declaringType, false), setMethod, valueExpression); } else { expression = Expression.Field(fieldInfo.IsStatic ? null : ConvertIfNeed(target, declaringType, false), fieldInfo); expression = Assign(expression, ConvertIfNeed(valueParameter, fieldInfo.FieldType, false)); } action = Expression .Lambda <Action <object, TType> >(expression, targetParameter, valueParameter) .Compile(); MemberAccessCache[member] = action; } return((Action <object, TType>)action); } }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { Should.MethodBeSupported(false, "ConvertBack()"); return(null); }
/// <summary> /// Navigates forward. /// </summary> public virtual void GoForward() { Should.MethodBeSupported(false, "GoForward()"); }
public object ConvertBack(object value, Type targetType, object parameter, string language) { Should.MethodBeSupported(_convertBack != null, "ConvertBack"); return(_convertBack(value, targetType, parameter, language)); }
/// <summary> /// Converts a value. /// </summary> /// <returns> /// A converted value. If the method returns null, the valid null value is used. /// </returns> /// <param name="value">The value that is produced by the binding target.</param> /// <param name="targetType">The type to convert to.</param> /// <param name="parameter">The converter parameter to use.</param> /// <param name="culture">The culture to use in the converter.</param> /// <param name="context">The current context to use in the converter.</param> public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture, IDataContext context) { Should.MethodBeSupported(_convertBack != null, "ConvertBack"); return(_convertBack(value, targetType, parameter, culture.Name)); }