private static Func <TAttribute, IValueProvider> BuildICollectorArgument <TAttribute, TMessage, TMessageSrc>(
            IConverterManager cm,
            Func <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute,
            AttributeCloner <TAttribute> cloner)
            where TAttribute : Attribute
        {
            // Other
            Func <TMessageSrc, TAttribute, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage, TAttribute>();

            if (convert == null)
            {
                ThrowMissingConversionError(typeof(TMessageSrc));
            }
            Func <TAttribute, IValueProvider> argumentBuilder = (attrResolved) =>
            {
                IAsyncCollector <TMessage>    raw = buildFromAttribute(attrResolved);
                IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage, TAttribute>(
                    raw, convert, attrResolved);
                ICollector <TMessageSrc> obj2 = new SyncAsyncCollectorAdapter <TMessageSrc>(obj);
                string invokeString           = cloner.GetInvokeString(attrResolved);
                return(new AsyncCollectorValueProvider <ICollector <TMessageSrc>, TMessage>(obj2, raw, invokeString));
            };

            return(argumentBuilder);
        }
Beispiel #2
0
            protected override Task <IValueProvider> BuildAsync(
                TAttribute attrResolved,
                ValueBindingContext context)
            {
                string invokeString = Cloner.GetInvokeString(attrResolved);

                object obj = _buildFromAttribute(attrResolved);

                IAsyncCollector <TMessage> collector;

                if (_converter != null)
                {
                    // Apply a converter
                    var innerCollector = (IAsyncCollector <TType>)obj;

                    collector = new TypedAsyncCollectorAdapter <TMessage, TType, TAttribute>(
                        innerCollector, _converter, attrResolved, context);
                }
                else
                {
                    collector = (IAsyncCollector <TMessage>)obj;
                }

                var vp = CoerceValueProvider(_mode, invokeString, collector);

                return(Task.FromResult(vp));
            }
        // Helper to build an argument binder for IAsyncCollector<TMessageSrc>
        private static Func <TContext, ValueBindingContext, IValueProvider> BuildIAsyncCollectorArgument <TContext, TMessageSrc, TMessage>(
            IConverterManager cm,
            Func <TContext, ValueBindingContext, IAsyncCollector <TMessage> > builder,
            string invokeString)
        {
            Func <TMessageSrc, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage>();
            Func <TContext, ValueBindingContext, IValueProvider> argumentBuilder = (context, valueBindingContext) =>
            {
                IAsyncCollector <TMessage>    raw = builder(context, valueBindingContext);
                IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage>(raw, convert);
                return(new AsyncCollectorValueProvider <IAsyncCollector <TMessageSrc>, TMessage>(obj, raw, invokeString));
            };

            return(argumentBuilder);
        }
        private static Func <TAttribute, IValueProvider> BuildOutArrayArgument <TAttribute, TMessage, TMessageSrc>(
            IConverterManager cm,
            Func <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute,
            AttributeCloner <TAttribute> cloner)
            where TAttribute : Attribute
        {
            // Other
            Func <TMessageSrc, TAttribute, TMessage> convert         = cm.GetConverter <TMessageSrc, TMessage, TAttribute>();
            Func <TAttribute, IValueProvider>        argumentBuilder = (attrResolved) =>
            {
                IAsyncCollector <TMessage>    raw = buildFromAttribute(attrResolved);
                IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage, TAttribute>(
                    raw, convert, attrResolved);
                string invokeString = cloner.GetInvokeString(attrResolved);
                return(new OutArrayValueProvider <TMessageSrc>(obj, invokeString));
            };

            return(argumentBuilder);
        }