Refactor deferred binding attributes (#1723)

sdk/Sdk.Generators/Constants.cs

@@ -39,7 +39,7 @@ internal static class Types
             internal const string FixedDelayRetryAttribute = "Microsoft.Azure.Functions.Worker.FixedDelayRetryAttribute";
             internal const string ExponentialBackoffRetryAttribute = "Microsoft.Azure.Functions.Worker.ExponentialBackoffRetryAttribute";
             internal const string InputConverterAttributeType = "Microsoft.Azure.Functions.Worker.Converters.InputConverterAttribute";
-            internal const string SupportedConverterTypeAttributeType = "Microsoft.Azure.Functions.Worker.Converters.SupportedConverterTypeAttribute";
+            internal const string SupportedTargetTypeAttributeType = "Microsoft.Azure.Functions.Worker.Converters.SupportedTargetTypeAttribute";
             internal const string SupportsDeferredBindingAttributeType = "Microsoft.Azure.Functions.Worker.Extensions.Abstractions.SupportsDeferredBindingAttribute";
 
             // System types

sdk/Sdk.Generators/FunctionMetadataProviderGenerator/FunctionMetadataProviderGenerator.Parser.cs

@@ -380,7 +380,7 @@ private bool DoesConverterSupportDeferredBinding(TypedConstant converter, string
                     if (converterAdvertisesDeferredBindingSupport)
                     {
                         bool converterAdvertisesTypes = converterAdvertisedAttributes.Any(
-                            a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, _knownFunctionMetadataTypes.SupportedConverterTypeAttributeType));
+                            a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, _knownFunctionMetadataTypes.SupportedTargetTypeAttributeType));
 
                         if (!converterAdvertisesTypes)
                         {
@@ -399,7 +399,7 @@ private bool DoesConverterSupportTargetType(List<AttributeData> converterAdverti
             {
                 foreach (AttributeData attribute in converterAdvertisedAttributes)
                 {
-                    if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, _knownFunctionMetadataTypes.SupportedConverterTypeAttributeType))
+                    if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, _knownFunctionMetadataTypes.SupportedTargetTypeAttributeType))
                     {
                         foreach (var element in attribute.ConstructorArguments)
                         {

sdk/Sdk.Generators/FunctionMetadataProviderGenerator/KnownFunctionMetadataTypes.cs

@@ -21,7 +21,7 @@ namespace Microsoft.Azure.Functions.Worker.Sdk.Generators
         private readonly Lazy<INamedTypeSymbol?> _fixedDelayRetryAttribute;
         private readonly Lazy<INamedTypeSymbol?> _exponentialBackoffRetryAttribute;
         private readonly Lazy<INamedTypeSymbol?> _inputConverterAttributeType;
-        private readonly Lazy<INamedTypeSymbol?> _supportedConverterTypeAttributeType;
+        private readonly Lazy<INamedTypeSymbol?> _supportedTargetTypeAttributeType;
         private readonly Lazy<INamedTypeSymbol?> _supportsDeferredBindingAttributeType;
 
         internal KnownFunctionMetadataTypes(Compilation compilation)
@@ -38,7 +38,7 @@ internal KnownFunctionMetadataTypes(Compilation compilation)
             _fixedDelayRetryAttribute = new Lazy<INamedTypeSymbol?>(() => compilation.GetTypeByMetadataName(Constants.Types.FixedDelayRetryAttribute));
             _exponentialBackoffRetryAttribute = new Lazy<INamedTypeSymbol?>(() => compilation.GetTypeByMetadataName(Constants.Types.ExponentialBackoffRetryAttribute));
             _inputConverterAttributeType = new Lazy<INamedTypeSymbol?>(() => compilation.GetTypeByMetadataName(Constants.Types.InputConverterAttributeType));
-            _supportedConverterTypeAttributeType = new Lazy<INamedTypeSymbol?>(() => compilation.GetTypeByMetadataName(Constants.Types.SupportedConverterTypeAttributeType));
+            _supportedTargetTypeAttributeType = new Lazy<INamedTypeSymbol?>(() => compilation.GetTypeByMetadataName(Constants.Types.SupportedTargetTypeAttributeType));
             _supportsDeferredBindingAttributeType = new Lazy<INamedTypeSymbol?>(() => compilation.GetTypeByMetadataName(Constants.Types.SupportsDeferredBindingAttributeType));
         }
 
@@ -66,7 +66,7 @@ internal KnownFunctionMetadataTypes(Compilation compilation)
 
         public INamedTypeSymbol? InputConverterAttributeType { get => _inputConverterAttributeType.Value; }
 
-        public INamedTypeSymbol? SupportedConverterTypeAttributeType { get => _supportedConverterTypeAttributeType.Value; }
+        public INamedTypeSymbol? SupportedTargetTypeAttributeType { get => _supportedTargetTypeAttributeType.Value; }
 
         public INamedTypeSymbol? SupportsDeferredBindingAttributeType { get => _supportsDeferredBindingAttributeType.Value; }
     }

sdk/Sdk/Constants.cs

@@ -17,7 +17,7 @@ internal static class Constants
         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 SupportedConverterTypeAttributeType = "Microsoft.Azure.Functions.Worker.Converters.SupportedConverterTypeAttribute";
+        internal const string SupportedTargetTypeAttributeType = "Microsoft.Azure.Functions.Worker.Converters.SupportedTargetTypeAttribute";
 
         // System types
         internal const string IEnumerableType = "System.Collections.IEnumerable";

sdk/Sdk/FunctionMetadataGenerator.cs

@@ -837,11 +837,11 @@ private static bool DoesConverterSupportDeferredBinding(CustomAttributeArgument
 
                 if (converterAdvertisesDeferredBindingSupport)
                 {
-                    bool converterAdvertisesTypes = typeReferenceCustomAttributes.Any(a => string.Equals(a.AttributeType.FullName, Constants.SupportedConverterTypeAttributeType, StringComparison.Ordinal));
+                    bool converterAdvertisesTypes = typeReferenceCustomAttributes.Any(a => string.Equals(a.AttributeType.FullName, Constants.SupportedTargetTypeAttributeType, StringComparison.Ordinal));
 
                     if (!converterAdvertisesTypes)
                     {
-                        // If a converter advertises deferred binding but does not explictly advertise any types then DeferredBinding will be supported for all the types
+                        // If a converter advertises deferred binding but does not explicitly advertise any types then DeferredBinding will be supported for all the types
                         return true;
                     }
 
@@ -857,7 +857,7 @@ private static bool DoesConverterSupportTargetType(Collection<CustomAttribute> c
             // Parse attributes advertised by converter
             foreach (CustomAttribute attribute in customAttributes)
             {
-                if (string.Equals(attribute.AttributeType.FullName, Constants.SupportedConverterTypeAttributeType, StringComparison.Ordinal))
+                if (string.Equals(attribute.AttributeType.FullName, Constants.SupportedTargetTypeAttributeType, StringComparison.Ordinal))
                 {
                     foreach (CustomAttributeArgument element in attribute.ConstructorArguments)
                     {

src/DotNetWorker.Core/CollectionModelBindingData.cs

@@ -9,8 +9,8 @@ namespace Microsoft.Azure.Functions.Worker.Core
     public abstract class CollectionModelBindingData
     {
         /// <summary>
-        /// Gets the array of ModelBindingData
+        /// Gets a ModelBindingData array
         /// </summary>
-        public abstract ModelBindingData[] ModelBindingDataArray { get; }
+        public abstract ModelBindingData[] ModelBindingData { get; }
     }
 }

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

@@ -72,25 +72,11 @@ public async ValueTask<FunctionInputBindingResult> BindFunctionInputAsync(Functi
                     {
                         var properties = new Dictionary<string, object>();
 
-                        // Pass info about specific input converter type defined for this parameter, if present.
-                        if (param.Properties.TryGetValue(PropertyBagKeys.ConverterType, out var converterTypeAssemblyFullName))
-                        {
-                            properties.Add(PropertyBagKeys.ConverterType, converterTypeAssemblyFullName);
-                        }
-
-                        // Pass info about the flag to allow fallback to default converters defined for this parameter, if present.
-                        if (param.Properties.TryGetValue(PropertyBagKeys.AllowConverterFallback, out var flag))
-                        {
-                            properties.Add(PropertyBagKeys.AllowConverterFallback, flag);
-                        }
-
-                        // Pass info about input converter types defined for this parameter, if present.
-                        if (param.Properties.TryGetValue(PropertyBagKeys.BindingAttributeSupportedConverters, out var converters))
-                        {
-                            properties.Add(PropertyBagKeys.BindingAttributeSupportedConverters, converters);
-                        }
-
-                        var converterContext = _converterContextFactory.Create(param.Type, source, context, properties.Count() != 0 
+                        AddFunctionParameterPropertyIfPresent(properties, param, PropertyBagKeys.ConverterType);
+                        AddFunctionParameterPropertyIfPresent(properties, param, PropertyBagKeys.ConverterFallbackBehavior);
+                        AddFunctionParameterPropertyIfPresent(properties, param, PropertyBagKeys.BindingAttributeSupportedConverters);
+
+                        var converterContext = _converterContextFactory.Create(param.Type, source, context, properties.Count() != 0
                                              ? properties.ToImmutableDictionary()
                                              : ImmutableDictionary<string, object>.Empty);
 
@@ -129,6 +115,14 @@ public async ValueTask<FunctionInputBindingResult> BindFunctionInputAsync(Functi
             }
         }
 
+        private void AddFunctionParameterPropertyIfPresent(IDictionary<string, object> properties, FunctionParameter param, string key)
+        {
+            if (param.Properties.TryGetValue(key, out object val))
+            {
+                properties.Add(key, val);
+            }
+        }
+
         public void Dispose()
         {
             if (_disposed)

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

@@ -191,11 +191,11 @@ private async ValueTask<ConversionResult> AwaitAndReturnConversionTaskResult(Val
         /// </summary>
         private bool IsConverterFallbackAllowed(ConverterContext context)
         {
-            if (context.Properties.TryGetValue(PropertyBagKeys.AllowConverterFallback, out var result))
+            if (context.Properties.TryGetValue(PropertyBagKeys.ConverterFallbackBehavior, out var result))
             {
-                if (result is not null && result is bool res)
+                if (result is not null && result is ConverterFallbackBehavior fallbackBehavior)
                 {
-                    return res;
+                    return fallbackBehavior != ConverterFallbackBehavior.Disallow;
                 }
             }
 

src/DotNetWorker.Core/Converters/Converter/ConverterFallbackBehavior.cs

@@ -0,0 +1,29 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Azure.Functions.Worker.Converters
+{
+    /// <summary>
+    /// Specifies the fallback behavior for a converter.
+    /// The default behavior is <see cref="ConverterFallbackBehavior.Allow"/>.
+    /// </summary>
+    public enum ConverterFallbackBehavior
+    {
+        /// <summary>
+        /// Allows fallback to built-in converters. This is the default behavior.
+        /// </summary>
+        Allow = 0,
+
+        /// <summary>
+        /// Disallows fallback to built-in converters.
+        /// </summary>
+        Disallow = 1,
+
+        /// <summary>
+        /// Specifies the default fallback behavior as <see cref="ConverterFallbackBehavior.Allow"/>
+        /// </summary>
+        Default = Allow
+    }
+}

src/DotNetWorker.Core/Converters/Converter/ConverterFallbackBehaviorAttribute.cs

@@ -0,0 +1,31 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Azure.Functions.Worker.Converters
+{
+    /// <summary>
+    /// An attribute that specifies if converter fallback is allowed or disallowed.
+    /// Converter fallback refers to the ability to use built-in converters when custom converters
+    /// cannot handle a given request.
+    /// The default converter fallback behavior is <see cref="ConverterFallbackBehavior.Allow"/>.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public sealed class ConverterFallbackBehaviorAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets the value of the converter fallback behavior.
+        /// </summary>
+        public ConverterFallbackBehavior Behavior { get; }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ConverterFallbackBehaviorAttribute"/>
+        /// </summary>
+        /// <param name="fallbackBehavior">The value to indicate if converter fallback is allowed or disallowed.</param>
+        public ConverterFallbackBehaviorAttribute(ConverterFallbackBehavior fallbackBehavior)
+        {
+            Behavior = fallbackBehavior;
+        }
+    }
+}

src/DotNetWorker.Core/Converters/Converter/PropertyBagKeys.cs

@@ -6,7 +6,7 @@ namespace Microsoft.Azure.Functions.Worker.Converters
     internal static class PropertyBagKeys
     {
         internal const string ConverterType = "converterType";
-        internal const string AllowConverterFallback = "allowConverterFallback";
+        internal const string ConverterFallbackBehavior = "converterFallbackBehavior";
         internal const string BindingAttributeSupportedConverters = "bindingAttributeSupportedConverters";
     }
 }

src/DotNetWorker.Core/Converters/Converter/SupportedTargetTypeAttribute.cs

@@ -0,0 +1,29 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Azure.Functions.Worker.Converters
+{
+    /// <summary>
+    /// An attribute that can specify a target type supported by function input conversion.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+    public sealed class SupportedTargetTypeAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets the input converter supported target type.
+        /// </summary>
+        public Type TargetType { get; }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="SupportedTargetTypeAttribute"/>
+        /// </summary>
+        /// <param name="targetType">Input converter target type.</param>
+        /// <exception cref="ArgumentNullException">Thrown when type is null</exception>
+        public SupportedTargetTypeAttribute(Type targetType)
+        {
+            TargetType = targetType ?? throw new ArgumentNullException(nameof(targetType));
+        }
+    }
+}

src/DotNetWorker.Grpc/Definition/GrpcFunctionDefinition.cs

@@ -111,7 +111,6 @@ public GrpcFunctionDefinition(FunctionLoadRequest loadRequest, IMethodInfoLocato
             // The dictionary has key of type IInputConverter and value as List of Types supported by the converter.
             var converterTypesDictionary = new Dictionary<Type, List<Type>>();
 
-
             Type type = bindingAttribute.GetType();
             var attributes = type.GetCustomAttributes<InputConverterAttribute>();
 
@@ -131,7 +130,7 @@ public GrpcFunctionDefinition(FunctionLoadRequest loadRequest, IMethodInfoLocato
 
             if (isInputConverterAttributeAdvertised)
             {
-                output[PropertyBagKeys.AllowConverterFallback] = type.GetCustomAttribute<AllowConverterFallbackAttribute>()?.AllowConverterFallback ?? true;
+                output[PropertyBagKeys.ConverterFallbackBehavior] = type.GetCustomAttribute<ConverterFallbackBehaviorAttribute>()?.Behavior ?? ConverterFallbackBehavior.Default;
             }
 
             return output.ToImmutableDictionary();
@@ -143,7 +142,7 @@ private List<Type> GetTypesSupportedByConverter(Type converter)
 
             foreach (CustomAttributeData converterAttribute in converter.CustomAttributes)
             {
-                if (converterAttribute.AttributeType == typeof(SupportedConverterTypeAttribute))
+                if (converterAttribute.AttributeType == typeof(SupportedTargetTypeAttribute))
                 {
                     foreach (CustomAttributeTypedArgument supportedType in converterAttribute.ConstructorArguments)
                     {

src/DotNetWorker.Grpc/GrpcCollectionModelBindingData.cs

@@ -8,12 +8,12 @@ namespace Microsoft.Azure.Functions.Worker.Grpc.Messages
 {
     internal partial class GrpcCollectionModelBindingData : Microsoft.Azure.Functions.Worker.Core.CollectionModelBindingData
     {
-        public GrpcCollectionModelBindingData(CollectionModelBindingData modelBindingDataArray)
+        public GrpcCollectionModelBindingData(CollectionModelBindingData collectionModelBindingData)
         {
-            ModelBindingDataArray = modelBindingDataArray.ModelBindingData
+            ModelBindingData = collectionModelBindingData.ModelBindingData
                                         .Select(p => new GrpcModelBindingData(p)).ToArray();
         }
 
-        public override Core.ModelBindingData[] ModelBindingDataArray { get; }
+        public override Core.ModelBindingData[] ModelBindingData { get; }
     }
 }