public static TView Bind <TView, TSource, TDest>(this TView view, BindableProperty targetProperty, string sourcePropertyName = bindingContextPropertyName, BindingMode mode = BindingMode.Default, Func <TSource, TDest> convert = null, Func <TDest, TSource> convertBack = null, object converterParameter = null, string stringFormat = null, object source = null, object targetNullValue = null, object fallbackValue = null) where TView : Element { var converter = new FuncConverter <TSource, TDest>(convert, convertBack); if (source != null || converterParameter != null || targetNullValue != null || fallbackValue != null) { view.SetBinding(targetProperty, new Binding( path: sourcePropertyName, mode: mode, converter: converter, converterParameter: converterParameter, stringFormat: stringFormat, source: source ) { TargetNullValue = targetNullValue, FallbackValue = fallbackValue }); } else { view.SetBinding(targetProperty, sourcePropertyName, mode, converter, stringFormat); } return(view); }
/// <summary> /// Add converter that uses the control attribute. /// </summary> /// <typeparam name="TSource"></typeparam> /// <typeparam name="TDestination"></typeparam> /// <param name="func"></param> /// <returns></returns> public TThis AddConverter <TSource, TDestination>(Func <TSource, TAttribute, TDestination> func) { FuncConverter <TSource, TAttribute, TDestination> wrapper = (src, attr, context) => func(src, attr); this.Converters.AddConverter(wrapper); return((TThis)(object)this); }
// Return null if not found. private FuncConverter <TSrc, TAttribute, TDest> TryGetConverter <TSrc, TAttribute, TDest>() where TAttribute : Attribute { object obj; // First lookup specificially for TAttribute. string keySpecific = GetKey <TSrc, TDest, TAttribute>(); if (_funcsWithAttr.TryGetValue(keySpecific, out obj)) { var func = (FuncConverter <TSrc, TAttribute, TDest>)obj; return(func); } // No specific case, lookup in the general purpose case. string keyGeneral = GetKey <TSrc, TDest, Attribute>(); if (_funcsWithAttr.TryGetValue(keyGeneral, out obj)) { var func1 = (FuncConverter <TSrc, Attribute, TDest>)obj; FuncConverter <TSrc, TAttribute, TDest> func2 = (src, attr, context) => func1(src, null, context); return(func2); } return(null); }
public void AddConverter <TSrc, TDest, TAttribute>(FuncConverter <TSrc, TAttribute, TDest> converter) where TAttribute : Attribute { string key = GetKey <TSrc, TDest, TAttribute>(); _funcsWithAttr[key] = converter; }
/// <summary> /// Register a new converter function that is influenced by the attribute. /// If TSource is object, then this converter is applied to any attempt to convert to TDestination. /// </summary> /// <typeparam name="TSource">Source type.</typeparam> /// <typeparam name="TDestination">Destination type.</typeparam> /// <typeparam name="TAttribute">Attribute on the binding. </typeparam> /// <param name="converterManager"></param> /// <param name="converter">A function to convert from the source to the destination type.</param> public static void AddConverter <TSource, TDestination, TAttribute>(this IConverterManager converterManager, Func <TSource, TAttribute, TDestination> converter) where TAttribute : Attribute { FuncConverter <TSource, TAttribute, TDestination> func = (src, attr, context) => converter(src, attr); converterManager.AddConverter(func); }
public SimpleTriggerArgumentBinding(ITriggerBindingStrategy <TMessage, TTriggerValue> hooks, IConverterManager converterManager, bool isSingleDispatch = true) { this._hooks = hooks; this.Contract = Hooks.GetBindingContract(isSingleDispatch); this.ElementType = typeof(TMessage); _converterManager = converterManager; _stringConverter = _converterManager.GetConverter <TMessage, string, Attribute>(); }
public Bind <TBinding> WithConverter <TSource>( Expression <Func <TBinding, TSource> > member, Func <TSource, TProperty> converter) { var funcConverter = new FuncConverter <TSource, TProperty>(converter); return(WithConverter(member, funcConverter)); }
public ExactBinding( AttributeCloner <TAttribute> cloner, ParameterDescriptor param, Func <object, object> buildFromAttribute, FuncConverter <TType, TAttribute, TUserType> converter) : base(cloner, param) { this._buildFromAttribute = buildFromAttribute; this._converter = converter; }
public void Test___Method_Convert___Generic_2() { var testee = new FuncConverter <int, string>() { Func = (value) => value.ToString() }; Assert.AreEqual("10", testee.Convert(10)); }
public void Test___Method_Convert() { var testee = new FuncConverter() { Func = (value) => value.ToString() }; Assert.AreEqual("10", testee.ConvertToObject(10)); }
public CustomTriggerArgumentBinding( ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy, IConverterManager converterManager, FuncConverter <TMessage, Attribute, TUserType> converter) : base(bindingStrategy, converterManager) { if (converter == null) { throw new ArgumentNullException("converter"); } this._converter = converter; this.ElementType = typeof(TUserType); }
public static TView Bind <TView, TSource, TDest>(this TView view, string sourcePropertyName = bindingContextPropertyName, BindingMode mode = BindingMode.Default, Func <TSource, TDest> convert = null, Func <TDest, TSource> convertBack = null, object converterParameter = null, string stringFormat = null, object source = null) where TView : Element { var converter = new FuncConverter <TSource, TDest>(convert, convertBack); view.Bind( targetProperty: GetDefaultProperty(view), sourcePropertyName: sourcePropertyName, mode: mode, converter: converter, converterParameter: converterParameter, stringFormat: stringFormat, source: source ); return(view); }
public TypedAsyncCollectorAdapter( IAsyncCollector <TDest> inner, FuncConverter <TSrc, TAttribute, TDest> convert, TAttribute attrResolved, ValueBindingContext context) { if (convert == null) { throw new ArgumentNullException("convert"); } _inner = inner; _convert = convert; _attrResolved = attrResolved; _context = context; }
public static ExactBinding <TMessage> TryBuild( AsyncCollectorBindingProvider <TAttribute, TType> parent, Mode mode, BindingProviderContext context) { var patternMatcher = parent._patternMatcher; var parameter = context.Parameter; TAttribute attributeSource = parameter.GetCustomAttribute <TAttribute>(inherit: false); Func <TAttribute, Task <TAttribute> > hookWrapper = null; if (parent.PostResolveHook != null) { hookWrapper = (attrResolved) => parent.PostResolveHook(attrResolved, parameter, parent._nameResolver); } Func <object, object> buildFromAttribute; FuncConverter <TMessage, TAttribute, TType> converter = null; // Prefer the shortest route to creating the user type. // If TType matches the user type directly, then we should be able to directly invoke the builder in a single step. // TAttribute --> TUserType var checker = ConverterManager.GetTypeValidator <TType>(); if (checker.IsMatch(typeof(TMessage))) { buildFromAttribute = patternMatcher.TryGetConverterFunc( typeof(TAttribute), typeof(IAsyncCollector <TMessage>)); } else { var converterManager = parent._converterManager; // Try with a converter // Find a builder for : TAttribute --> TType // and then couple with a converter: TType --> TParameterType converter = converterManager.GetConverter <TMessage, TType, TAttribute>(); if (converter == null) { // Preserves legacy behavior. This means we can only have 1 async collector. // However, the collector's builder object can switch. throw NewMissingConversionError(typeof(TMessage)); } buildFromAttribute = patternMatcher.TryGetConverterFunc( typeof(TAttribute), typeof(IAsyncCollector <TType>)); } if (buildFromAttribute == null) { return(null); } ParameterDescriptor param; if (parent.BuildParameterDescriptor != null) { param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver); } else { param = new ParameterDescriptor { Name = parameter.Name, DisplayHints = new ParameterDisplayHints { Description = "output" } }; } var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._nameResolver, hookWrapper); return(new ExactBinding <TMessage>(cloner, param, mode, buildFromAttribute, converter)); }
public static ExactBinding <TUserType> TryBuild( BindToInputBindingProvider <TAttribute, TType> parent, BindingProviderContext context) { var cm = parent._converterManager; var patternMatcher = parent._patternMatcher; var parameter = context.Parameter; TAttribute attributeSource = parameter.GetCustomAttribute <TAttribute>(inherit: false); Func <TAttribute, Task <TAttribute> > hookWrapper = null; if (parent.PostResolveHook != null) { hookWrapper = (attrResolved) => parent.PostResolveHook(attrResolved, parameter, parent._nameResolver); } var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._nameResolver, hookWrapper); Func <object, object> buildFromAttribute; FuncConverter <TType, TAttribute, TUserType> converter = null; // Prefer the shortest route to creating the user type. // If TType matches the user type directly, then we should be able to directly invoke the builder in a single step. // TAttribute --> TUserType var checker = ConverterManager.GetTypeValidator <TType>(); if (checker.IsMatch(typeof(TUserType))) { buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), typeof(TUserType)); } else { // Try with a converter // Find a builder for : TAttribute --> TType // and then couple with a converter: TType --> TParameterType converter = cm.GetConverter <TType, TUserType, TAttribute>(); if (converter == null) { return(null); } buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), typeof(TType)); } if (buildFromAttribute == null) { return(null); } ParameterDescriptor param; if (parent.BuildParameterDescriptor != null) { param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver); } else { param = new ParameterDescriptor { Name = parameter.Name, DisplayHints = new ParameterDisplayHints { Description = "input" } }; } return(new ExactBinding <TUserType>(cloner, param, buildFromAttribute, converter)); }
public void AddConverter <TSource, TDestination, TAttribute1>(FuncConverter <TSource, TAttribute1, TDestination> converter) where TAttribute1 : Attribute { throw new NotImplementedException(); }