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();
}
