Add binding attribute to converter context

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

@@ -39,7 +39,7 @@ public async ValueTask<FunctionInputBindingResult> BindFunctionInputAsync(Functi
                     // Return the cached value if BindFunctionInputAsync is called a second time during invocation.
                     return _inputBindingResult!;
                 }
-                
+
                 IFunctionBindingsFeature functionBindings = context.GetBindings();
                 var inputBindingCache = context.InstanceServices.GetService<IBindingCache<ConversionResult>>();
                 var inputConversionFeature = context.Features.Get<IInputConversionFeature>();
@@ -72,25 +72,12 @@ 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.AllowConverterFallback);
+                        AddFunctionParameterPropertyIfPresent(properties, param, PropertyBagKeys.BindingAttributeSupportedConverters);
+                        AddFunctionParameterPropertyIfPresent(properties, param, PropertyBagKeys.BindingAttribute);
+
+                        var converterContext = _converterContextFactory.Create(param.Type, source, context, properties.Count() != 0
                                              ? properties.ToImmutableDictionary()
                                              : ImmutableDictionary<string, object>.Empty);
 
@@ -129,6 +116,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/Converters/Converter/ConverterContextExtensions.cs

@@ -0,0 +1,22 @@
+// 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>
+    /// Provides extension methods to work with an <see cref="ConverterContext"/> instance.
+    /// </summary>
+    public static class ConverterContextExtensions
+    {
+        /// <summary>
+        /// Tries to retrieve the binding attribute from the <see cref="ConverterContext"/>.
+        /// </summary>
+        /// <param name="context">The converter context.</param>
+        /// <param name="bindingAttribute">When this method returns, contains the binding attribute if found; otherwise, <c>null</c>.</param>
+        /// <returns><c>true</c> if the binding attribute is found in the converter context; otherwise, <c>false</c>.</returns>
+        public static bool TryGetBindingAttribute<T>(this ConverterContext context, out object? bindingAttribute) where T : Attribute
+            => context.Properties.TryGetValue(PropertyBagKeys.BindingAttribute, out bindingAttribute);
+    }
+}

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

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

src/DotNetWorker.Grpc/Definition/GrpcFunctionDefinition.cs

@@ -111,11 +111,12 @@ public GrpcFunctionDefinition(FunctionLoadRequest loadRequest, IMethodInfoLocato
             var output = new Dictionary<string, object>();
             bool isInputConverterAttributeAdvertised = false;
 
+            output.Add(PropertyBagKeys.BindingAttribute, bindingAttribute);
+
             // ConverterTypesDictionary will be "object" part of the return value - ImmutableDictionary<string, object>
             // 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>();