public void AddExactConverter <TSource, TDestination>(Func <TSource, TDestination> func) { FuncAsyncConverter converter = (src, attr, context) => Task.FromResult <object>(func((TSource)src)); FuncConverterBuilder builder = (srcType, destType) => converter; this.AddConverter <TSource, TDestination, System.Attribute>(builder); }
public static PatternMatcher New <TSource, TDest, TAttribute>(Func <TSource, TAttribute, TDest> func) where TAttribute : System.Attribute { FuncAsyncConverter converter = (src, attr, ctx) => Task.FromResult <object>(func((TSource)src, (TAttribute)attr)); return(new CreateFromDelegate(converter)); }
public void OpenTypeTest() { int count = 0; var cm = new ConverterManager(); // Register a converter builder. // Builder runs once; converter runs each time. // Uses open type to match. cm.AddConverter <TypeWrapperIsString, int, Attribute>( (typeSrc, typeDest) => { count++; Assert.Equal(typeof(String), typeSrc); Assert.Equal(typeof(int), typeDest); FuncAsyncConverter converter2 = (input, attr, ctx) => { string s = (string)input; return(Task.FromResult <object>(int.Parse(s))); }; return(converter2); }); var converter = cm.GetSyncConverter <string, int, Attribute>(); Assert.NotNull(converter); Assert.Equal(12, converter("12", new TestAttribute(null), null)); Assert.Equal(34, converter("34", new TestAttribute(null), null)); Assert.Equal(1, count); // converterBuilder is only called once. // 'char' as src parameter doesn't match the type predicate. Assert.Null(cm.GetSyncConverter <char, int, Attribute>()); }
/// <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 ConverterManager converterManager, FuncAsyncConverter <TSource, TDestination> converter) where TAttribute : Attribute { FuncAsyncConverter func = (src, attr, context) => Task.FromResult <object>(converter((TSource)src, attr, context)); FuncConverterBuilder builder = (srcType, destType) => func; converterManager.AddConverter <TSource, TDestination, TAttribute>(builder); }
// Add a 'global' converter for all Attributes. // Passing in the cancellationToken also helps C# overload resolution determine sync. vs. async public void AddExactConverter <TSource, TDestination>(Func <TSource, CancellationToken, Task <TDestination> > func) { FuncAsyncConverter converter = async(src, attr, context) => await func((TSource)src, CancellationToken.None); FuncConverterBuilder builder = (srcType, destType) => converter; this.AddConverter <TSource, TDestination, System.Attribute>(builder); }
/// <summary> /// Add a converter that that uses open types. /// Src type must handle object since it could be unknown. /// But it's converting to a well-known destination type. /// </summary> /// <typeparam name="TSource"></typeparam> /// <typeparam name="TDestination"></typeparam> /// <param name="func"></param> /// <returns></returns> public TThis AddOpenConverter <TSource, TDestination>(FuncAsyncConverter func) { var pm = PatternMatcher.New(func); this.AddConverterBuilder <TSource, TDestination>(pm); return((TThis)(object)this); }
/// <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>(FuncAsyncConverter <TSource, TDestination> func) { VerifyNotOpenTypes <TSource, TDestination>(); var pm = PatternMatcher.New(func); this.AddConverterBuilder <TSource, TDestination>(pm); return((TThis)(object)this); }
public static FuncConverterBuilder GetBuilder <TSource, TDestination>(FuncAsyncConverter <TSource, TDestination> func) { FuncConverterBuilder builder = (srcType, destType) => { // Cast from TDestination --> Object return(async(input, attr, ctx) => (object) await func((TSource)input, attr, ctx)); }; return(builder); }
public BlobCollectionConverter(BlobsExtensionConfigProvider parent) { IConverterManager cm = parent._converterManager; _converter = cm.GetConverter <BlobBaseClient, T, BlobAttribute>(); if (_converter == null) { throw new InvalidOperationException($"Can't convert blob to {typeof(T).FullName}."); } }
public ExactBinding( AttributeCloner <TAttribute> cloner, ParameterDescriptor param, FuncAsyncConverter buildFromAttribute, FuncAsyncConverter converter, Type parameterType) : base(cloner, param) { this._buildFromAttribute = buildFromAttribute; this._converter = converter; this._parameterType = parameterType; }
public BindToStreamBindingProvider( PatternMatcher patternMatcher, FileAccess access, INameResolver nameResolver, IConverterManager converterManager) { _builder = patternMatcher.TryGetConverterFunc <TAttribute, Stream>(); _nameResolver = nameResolver; _converterManager = converterManager; _access = access; }
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 ExactBinding( AttributeCloner <TAttribute> cloner, ParameterDescriptor param, Mode mode, FuncAsyncConverter buildFromAttribute, FuncAsyncConverter <TMessage, TType> converter) : base(cloner, param) { this._buildFromAttribute = buildFromAttribute; this._mode = mode; this._converter = converter; }
public CustomTriggerArgumentBinding( ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy, IConverterManager converterManager, FuncAsyncConverter <TMessage, TUserType> converter) : base(bindingStrategy, converterManager) { if (converter == null) { throw new ArgumentNullException("converter"); } this._converter = converter; this.ElementType = typeof(TUserType); }
public override FuncAsyncConverter Execute(object instance) { IConverter <TSrc, TDest> converter = (IConverter <TSrc, TDest>)instance; FuncAsyncConverter func = (input, attr, ctx) => { TSrc src = (TSrc)input; var result = converter.Convert(src); return(Task.FromResult <object>(result)); }; return(func); }
public PocoEntityValueBinder( TableEntityContext entityContext, ValueBindingContext context, TableEntity originalEntity, FuncAsyncConverter entityToPocoConverter, FuncAsyncConverter pocoToEntityConverter) { _entityContext = entityContext; _valueBindingContext = context; _originalEntity = originalEntity; _entityToPocoConverter = entityToPocoConverter; _pocoToEntityConverter = pocoToEntityConverter; }
public override FuncAsyncConverter Execute(object instance) { IAsyncConverter <TSrc, TDest> converter = (IAsyncConverter <TSrc, TDest>)instance; FuncAsyncConverter func = async(input, attr, ctx) => { TSrc src = (TSrc)input; var cts = ctx == null ? CancellationToken.None : ctx.CancellationToken; TDest result = await converter.ConvertAsync(src, cts); return(result); }; return(func); }
public TypedAsyncCollectorAdapter( IAsyncCollector <TDest> inner, FuncAsyncConverter <TSrc, TDest> convert, TAttribute attrResolved, ValueBindingContext context) { if (convert == null) { throw new ArgumentNullException("convert"); } _inner = inner; _convert = convert; _attrResolved = attrResolved; _context = context; }
public void UseValueBindingContext() { var cm = new ConverterManager(); // empty Guid instance = Guid.NewGuid(); var testContext = new ValueBindingContext(new FunctionBindingContext(instance, CancellationToken.None, null), CancellationToken.None); FuncAsyncConverter converter = (object obj, Attribute attr, ValueBindingContext ctx) => { Assert.Same(ctx, testContext); var result = JObject.FromObject(obj); result["$"] = ctx.FunctionInstanceId; return(Task.FromResult <object>(result)); }; cm.AddConverter <object, JObject, Attribute>(converter); cm.AddConverter <JObject, Wrapper>(str => new Wrapper { Value = str.ToString() }); // Expected: // Other --> JObject, // JObject --> string , (builtin) // string --> Wrapper var func = cm.GetSyncConverter <Other, Wrapper, Attribute>(); var value = new Other { Value2 = "abc" }; Wrapper x1 = func(value, null, testContext); // strip whitespace string val = Regex.Replace(x1.Value, @"\s", ""); string expected = String.Format("{{\"Value2\":\"abc\",\"$\":\"{0}\"}}", instance); Assert.Equal(expected, val); }
public static PatternMatcher New <TSource, TDest>(Func <TSource, CancellationToken, Task <TDest> > func) { FuncAsyncConverter converter = async(src, attr, ctx) => await func((TSource)src, ctx.CancellationToken); return(new CreateFromDelegate(converter)); }
public static PatternMatcher New <TSource, TDest>(Func <TSource, TDest> func) { FuncAsyncConverter converter = (src, attr, ctx) => Task.FromResult <object>(func((TSource)src)); return(new CreateFromDelegate(converter)); }
public static ExactBinding <TMessage> TryBuild( AsyncCollectorBindingProvider <TAttribute, TType> parent, Mode mode, BindingProviderContext context) { var patternMatcher = parent._patternMatcher; var parameter = context.Parameter; var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter); FuncAsyncConverter buildFromAttribute; FuncAsyncConverter <TMessage, 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 = OpenType.FromType <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) { context.BindingErrors.Add(String.Format(Constants.BindingAssemblyConflictMessage, typeof(TType).AssemblyQualifiedName, typeof(TMessage).AssemblyQualifiedName)); 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); return(new ExactBinding <TMessage>(cloner, param, mode, buildFromAttribute, converter)); }
public static PatternMatcher New <TSource, TDest>(FuncAsyncConverter <TSource, TDest> func) { FuncAsyncConverter converter = async(input, attr, ctx) => (object) await func((TSource)input, attr, ctx); return(new CreateFromDelegate(converter)); }
internal static FuncAsyncConverter <TSource, TDestination> AsTyped <TSource, TDestination>(this FuncAsyncConverter func) { if (func == null) { return(null); } return(async(src, attr, ctx) => { var result = await func((TSource)src, attr, ctx); return (TDestination)result; }); }
public OutArgBaseValueProvider(object converter) { _converter = (FuncAsyncConverter <ApplyConversion <TUserType, Stream>, object>)converter; }
public ValueProvider(object converter) { _converter = (FuncAsyncConverter <Stream, TUserType>)converter; }
public static ExactBinding TryBuild( BindToInputBindingProvider <TAttribute, TType> parent, BindingProviderContext context) { var cm = parent._converterManager; var patternMatcher = parent._patternMatcher; var parameter = context.Parameter; var userType = parameter.ParameterType; var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter); var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._configuration, parent._nameResolver); FuncAsyncConverter buildFromAttribute; FuncAsyncConverter 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 = OpenType.FromType <TType>(); if (checker.IsMatch(userType)) { buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), userType); } else { // Try with a converter // Find a builder for : TAttribute --> TType // and then couple with a converter: TType --> TParameterType converter = cm.GetConverter <TAttribute>(typeof(TType), userType); if (converter == null) { var targetType = typeof(TType); context.BindingErrors.Add(String.Format(Resource.BindingAssemblyConflictMessage, targetType.AssemblyQualifiedName, userType.AssemblyQualifiedName)); 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(cloner, param, buildFromAttribute, converter, userType)); }
public static PatternMatcher New(FuncAsyncConverter func) { FuncAsyncConverter converter = func; return(new CreateFromDelegate(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 ConverterManager converterManager, FuncAsyncConverter converter) where TAttribute : Attribute { FuncConverterBuilder builder = (srcType, destType) => converter; converterManager.AddConverter <TSource, TDestination, TAttribute>(builder); }
public PocoEntityArgumentBinding(FuncAsyncConverter entityToPocoConverter, FuncAsyncConverter pocoToEntityConverter) { _pocoToEntityConverter = pocoToEntityConverter; _entityToPocoConverter = entityToPocoConverter; }