Implement bypass deferred binding

extensions/Worker.Extensions.Storage.Blobs/src/BlobInputAttribute.cs

@@ -1,11 +1,12 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using Microsoft.Azure.Functions.Worker.Converters;
 using Microsoft.Azure.Functions.Worker.Extensions.Abstractions;
 
 namespace Microsoft.Azure.Functions.Worker
 {
-    [SupportsDeferredBinding]
+    [InputConverter(disableConverterFallback: false, typeof(BlobStorageConverter))]
     public sealed class BlobInputAttribute : InputBindingAttribute
     {
         private readonly string _blobPath;

extensions/Worker.Extensions.Storage.Blobs/src/BlobStorageConverter.cs

@@ -14,12 +14,25 @@
 using Microsoft.Azure.Functions.Worker.Core;
 using Microsoft.Extensions.Options;
 using Microsoft.Extensions.Logging;
+using Microsoft.Azure.Functions.Worker.Extensions.Abstractions;
 
 namespace Microsoft.Azure.Functions.Worker
 {
     /// <summary>
     /// Converter to bind Blob Storage type parameters.
     /// </summary>
+    [SupportsDeferredBinding]
+    [SupportedConverterTypes(
+        typeof(string), typeof(IEnumerable<string>), typeof(string[]),
+        typeof(Stream), typeof(IEnumerable<Stream>), typeof(Stream[]),
+        typeof(Byte[]), typeof(IEnumerable<Byte[]>), typeof(Byte[][]),
+        typeof(BlobBaseClient), typeof(IEnumerable<BlobBaseClient>), typeof(BlobBaseClient[]),
+        typeof(BlobClient), typeof(IEnumerable<BlobClient>), typeof(BlobClient[]),
+        typeof(BlockBlobClient), typeof(IEnumerable<BlockBlobClient>), typeof(BlockBlobClient[]),
+        typeof(PageBlobClient), typeof(IEnumerable<PageBlobClient>), typeof(PageBlobClient[]),
+        typeof(AppendBlobClient), typeof(IEnumerable<AppendBlobClient>), typeof(AppendBlobClient[]),
+        typeof(BlobContainerClient), typeof(IEnumerable<BlobContainerClient>), typeof(BlobContainerClient[]),
+        typeof(object), typeof(IEnumerable<object>), typeof(object[]))]
     internal class BlobStorageConverter : IInputConverter
     {
         private readonly IOptions<WorkerOptions> _workerOptions;

extensions/Worker.Extensions.Storage.Blobs/src/BlobTriggerAttribute.cs

@@ -1,11 +1,12 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using Microsoft.Azure.Functions.Worker.Converters;
 using Microsoft.Azure.Functions.Worker.Extensions.Abstractions;
 
 namespace Microsoft.Azure.Functions.Worker
 {
-    [SupportsDeferredBinding]
+    [InputConverter(disableConverterFallback: false , typeof(BlobStorageConverter))]
     public sealed class BlobTriggerAttribute : TriggerBindingAttribute
     {
         private readonly string _blobPath;

sdk/Sdk/Constants.cs

@@ -16,6 +16,8 @@ internal static class Constants
         internal const string ExponentialBackoffRetryAttributeType = "Microsoft.Azure.Functions.Worker.ExponentialBackoffRetryAttribute";
         internal const string BindingPropertyNameAttributeType = "Microsoft.Azure.Functions.Worker.Extensions.Abstractions.BindingPropertyNameAttribute";
         internal const string SupportsDeferredBindingAttributeType = "Microsoft.Azure.Functions.Worker.Extensions.Abstractions.SupportsDeferredBindingAttribute";
+        internal const string InputConverterAttributeType = "Microsoft.Azure.Functions.Worker.Converters.InputConverterAttribute";
+        internal const string SupportedConverterTypesAttributeType = "Microsoft.Azure.Functions.Worker.Converters.SupportedConverterTypesAttribute";
 
         // System types
         internal const string IEnumerableType = "System.Collections.IEnumerable";

sdk/Sdk/FunctionMetadataGenerator.cs

@@ -487,7 +487,7 @@ private static ExpandoObject BuildBindingMetadataFromAttribute(CustomAttribute a
 
             // For extensions that support deferred binding, set the supportsDeferredBinding property so parameters are bound by the worker
             // Only use deferred binding for input and trigger bindings, output is out not currently supported
-            if (SupportsDeferredBinding(attribute) && direction != Constants.OutputBindingDirection)
+            if (SupportsDeferredBinding(attribute, parameterType.FullName) && direction != Constants.OutputBindingDirection)
             {
                 bindingProperties.Add(Constants.SupportsDeferredBindingProperty, Boolean.TrueString);
             }
@@ -795,7 +795,7 @@ private static string GetBindingDirection(CustomAttribute attribute)
             return Constants.InputBindingDirection;
         }
 
-        private static bool SupportsDeferredBinding(CustomAttribute attribute)
+        private static bool SupportsDeferredBinding(CustomAttribute attribute, string bindingType)
         {
             var typeDefinition = attribute?.AttributeType?.Resolve();
 
@@ -804,10 +804,95 @@ private static bool SupportsDeferredBinding(CustomAttribute attribute)
                 return false;
             }
 
-            return typeDefinition.CustomAttributes
-                                 .Any(a => string.Equals(a.AttributeType.FullName, Constants.SupportsDeferredBindingAttributeType, StringComparison.Ordinal));
+            foreach (var bindingAttribute in typeDefinition.CustomAttributes)
+            {
+                if (string.Equals(bindingAttribute.AttributeType.FullName, Constants.InputConverterAttributeType, StringComparison.Ordinal))
+                {
+                    return CheckBindingAttributeForInputConverters(bindingAttribute, bindingType);
+                }
+            }
+
+            return false;
+        }
+
+        private static bool CheckBindingAttributeForInputConverters(CustomAttribute bindingAttribute, string bindingType)
+        {
+            // InputConverterAttribute has list of supported converter types
+            foreach (var customAttribute in bindingAttribute.ConstructorArguments)
+            {
+                if (string.Equals(customAttribute.Type.GetElementType().FullName, typeof(Type).FullName) &&
+                    customAttribute.Value.GetType() == typeof(CustomAttributeArgument[]))
+                {
+                    return CheckSupportedConverters(customAttribute, bindingType);
+                }
+            }
+
+            return false;
         }
 
+        private static bool CheckSupportedConverters(CustomAttributeArgument customAttribute, string bindingType)
+        {
+            // Check if converter supports deferred binding for the binding type
+
+            CustomAttributeArgument[] customAttributeArguments = (CustomAttributeArgument[])customAttribute.Value;
+
+            if (customAttributeArguments is null)
+            {
+                return false;
+            }
+
+            foreach (var element in customAttributeArguments)
+            {
+                bool isSupportsDeferredBindingAttribute = false;
+
+                var typeReferenceValue = (TypeReference)element.Value;
+                var typeReferenceCustomAttributes = typeReferenceValue.Resolve().CustomAttributes;
+
+                foreach (var attribute in typeReferenceCustomAttributes)
+                {
+                    if (string.Equals(attribute.AttributeType.FullName, Constants.SupportsDeferredBindingAttributeType, StringComparison.Ordinal))
+                    {
+                        isSupportsDeferredBindingAttribute = true;
+                        break;
+                    }
+                }
+
+                if (isSupportsDeferredBindingAttribute)
+                {
+                    foreach (var attribute in typeReferenceCustomAttributes)
+                    {
+                        if (string.Equals(attribute.AttributeType.FullName, Constants.SupportedConverterTypesAttributeType, StringComparison.Ordinal))
+                        {
+                            return CheckConverterTypes(attribute, bindingType);
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static bool CheckConverterTypes(CustomAttribute attribute, string bindingType)
+        {
+            foreach (var bindingTypes in attribute.ConstructorArguments)
+            {
+                var bindingTypeElements = (CustomAttributeArgument[])bindingTypes.Value;
+
+                foreach (var bindingTypeElement in bindingTypeElements)
+                {
+                    var bindingTypeValue = (TypeReference)bindingTypeElement.Value;
+
+                    if (string.Equals(bindingTypeValue.FullName, bindingType, StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+
         private static bool IsOutputBindingType(CustomAttribute attribute)
         {
             return TryGetBaseAttributeType(attribute, Constants.OutputBindingType, out _);

src/DotNetWorker.Core/Context/Features/DefaultFunctionInputBindingFeature.cs

@@ -69,18 +69,26 @@ public async ValueTask<FunctionInputBindingResult> BindFunctionInputAsync(Functi
                     }
                     else
                     {
-                        IReadOnlyDictionary<string, object> properties = ImmutableDictionary<string, object>.Empty;
+                        Dictionary<string, object>? properties = null;
 
                         // Pass info about specific input converter type defined for this parameter, if present.
                         if (param.Properties.TryGetValue(PropertyBagKeys.ConverterType, out var converterTypeAssemblyFullName))
                         {
-                            properties = new Dictionary<string, object>()
+                            properties ??= new Dictionary<string, object>();
+                            properties.Add(PropertyBagKeys.ConverterType, converterTypeAssemblyFullName);
+                        }
+                        if (param.Properties.TryGetValue(PropertyBagKeys.DisableConverterFallback, out var flag))
+                        {
+                            properties ??= new Dictionary<string, object>();
+                            properties.Add(PropertyBagKeys.DisableConverterFallback, flag);
+                        }
+                        if (param.Properties.TryGetValue(PropertyBagKeys.BindingAttributeConverters, out var input))
                         {
-                            { PropertyBagKeys.ConverterType, converterTypeAssemblyFullName }
-                        };
+                            properties ??= new Dictionary<string, object>();
+                            properties.Add(PropertyBagKeys.BindingAttributeConverters, input);
                         }
 
-                        var converterContext = _converterContextFactory.Create(param.Type, source, context, properties);
+                        var converterContext = _converterContextFactory.Create(param.Type, source, context, properties != null ? properties.ToImmutableDictionary() : ImmutableDictionary<string, object>.Empty);
 
                         bindingResult = await inputConversionFeature.ConvertAsync(converterContext);
                         inputBindingCache[cacheKey] = bindingResult;

src/DotNetWorker.Core/Context/Features/DefaultInputConversionFeature.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Azure.Functions.Worker.Converters;
@@ -47,17 +48,41 @@ public async ValueTask<ConversionResult> ConvertAsync(ConverterContext converter
                 }
             }
 
-            // Use the registered converters. The first converter which can handle the conversion wins.
-            foreach (var converter in _inputConverterProvider.RegisteredInputConverters)
-            {
-                var conversionResult = await ConvertAsyncUsingConverter(converter, converterContext);
+            // Get list of converters advertised by the Binding Attribute
+            Dictionary<IInputConverter, List<Type>>? advertisedConverterTypes = GetExplicitConverterTypes(converterContext);
 
-                if (conversionResult.Status != ConversionStatus.Unhandled)
+            if (advertisedConverterTypes is not null)
+            {
+                foreach (var converterType in advertisedConverterTypes)
                 {
-                    return conversionResult;
+                    bool res = converterType.Value.Any(a => a == converterContext.TargetType);
+
+                    if (res)
+                    {
+                        var conversionResult = await ConvertAsyncUsingConverter(converterType.Key, converterContext);
+
+                        if (conversionResult.Status != ConversionStatus.Unhandled)
+                        {
+                            return conversionResult;
+                        }
+                    }
                 }
+            }
+
+            if (!IsConvertersFallbackDisabled(converterContext))
+            {
+                // Use the registered converters. The first converter which can handle the conversion wins.
+                foreach (var converter in _inputConverterProvider.RegisteredInputConverters)
+                {
+                    var conversionResult = await ConvertAsyncUsingConverter(converter, converterContext);
 
-                // If "Status" is Unhandled, we move on to the next converter and try to convert with that.
+                    if (conversionResult.Status != ConversionStatus.Unhandled)
+                    {
+                        return conversionResult;
+                    }
+
+                    // If "Status" is Unhandled, we move on to the next converter and try to convert with that.
+                }
             }
 
             return ConversionResult.Unhandled();
@@ -111,6 +136,65 @@ private async ValueTask<ConversionResult> AwaitAndReturnConversionTaskResult(Val
             return null;
         }
 
+
+        private Dictionary<IInputConverter, List<Type>>? GetExplicitConverterTypes(ConverterContext context)
+        {
+            if (context.Properties.TryGetValue(PropertyBagKeys.BindingAttributeConverters, out var converterTypes))
+            {
+                if (converterTypes is not null && converterTypes.GetType() == typeof(Dictionary<Type, List<Type>>))
+                {
+                    var converters = (Dictionary<Type, List<Type>>)converterTypes;
+                    var result = new Dictionary<IInputConverter, List<Type>>();
+                    var interfaceType = typeof(IInputConverter);
+
+                    foreach (var converterTypesPair in converters)
+                    {
+                        var converter = converterTypesPair.Key;
+                        /*
+                        var types = new List<Type>();
+
+                        foreach (var type in converterTypesPair.Value)
+                        {
+                            try
+                            {
+                                Type t = (Type)type;
+                                types.Add(t);
+                            }
+                            catch { }
+                        }
+                        */
+
+                        if (interfaceType.IsAssignableFrom(converter))
+                        {
+                            string? converterTypeFullName = converter.AssemblyQualifiedName;
+                            if (converterTypeFullName is not null)
+                            {
+                                result.Add(_inputConverterProvider.GetOrCreateConverterInstance(converterTypeFullName), converterTypesPair.Value);
+                            }
+                        }
+                    }
+
+                    return result;
+                }
+            }
+
+            return null;
+        }
+
+        private bool IsConvertersFallbackDisabled(ConverterContext context)
+        {
+            if (context.Properties.TryGetValue(PropertyBagKeys.DisableConverterFallback, out var res))
+            {
+                if (res is not null && res.GetType() == typeof(bool))
+                {
+                    return (bool)res;
+                }
+            }
+
+            return false;
+        }
+
+
         /// <summary>
         /// Checks a type has an "InputConverter" attribute decoration present
         /// and if present, return the assembly qualified name of the "ConverterType" property.
@@ -128,7 +212,7 @@ private async ValueTask<ConversionResult> AwaitAndReturnConversionTaskResult(Val
                     return null;
                 }
 
-                Type converterType = ((InputConverterAttribute)converterAttribute).ConverterType;
+                Type converterType = ((InputConverterAttribute)converterAttribute).ConverterTypes.FirstOrDefault();
                 return converterType.AssemblyQualifiedName!;
 
             }, targetType);