{"id":89877,"date":"2021-02-15T17:03:28","date_gmt":"2021-02-15T17:03:28","guid":{"rendered":"https:\/\/www.red-gate.com\/simple-talk\/?p=89877"},"modified":"2021-02-14T12:58:33","modified_gmt":"2021-02-14T12:58:33","slug":"custom-binding-azure-functions","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/blogs\/custom-binding-azure-functions\/","title":{"rendered":"Custom Binding for Azure Functions"},"content":{"rendered":"

Azure Functions are a great development tool, allowing us to create serverless software. However, one detail was bothering me when I create a function: The HTTP Trigger receives a\u00a0HTTPRequest<\/strong> object and we need to extract the parameters from the request. This becomes kind of a low-level code mixed with our business code. It’s like going back in time some years.<\/p>\n

The solution is simple: we can create a custom binding to extract objects from the HTTPreques<\/strong>t. I’m surprised I haven’t found many references to this online. The most complete reference I found was a reply on stackoverflow: https:\/\/stackoverflow.com\/questions\/45183820\/how-to-pass-parameters-by-post-to-an-azure-function<\/a>\u00a0. However, we can still improve the code.<\/p>\n

Let’s see how we can implement this custom binding and how it can improve the development of Azure Functions. We will analyze the classes needed to build the custom binding.<\/p>\n

BindingExtensionProvider<\/strong><\/h3>\n

This class is responsible for adding a binding rule to the azure function configuration. While adding the binding rule, a link is stablished between a custom attribute for the binding rule (FromBodyAttribute<\/strong> in our example) and the binding rule factory (FromBodyBindingProvider<\/strong>). This is the only purpose of the attribute, stablish this link.<\/p>\n

<\/p>\n

\n
    public<\/span> class<\/span> BindingExtensionProvider<\/span> : IExtensionConfigProvider\r\n    {\r\n        private<\/span> readonly<\/span> ILogger logger;\r\n        public<\/span> BindingExtensionProvider<\/span>(ILogger<Startup> logger)\r\n        {\r\n            this<\/span>.logger = logger;\r\n        }\r\n\r\n        public<\/span> void<\/span> Initialize<\/span>(ExtensionConfigContext context)\r\n        {\r\n            \/\/ Creates a rule that links the attribute to the binding<\/span>\r\n            context.AddBindingRule<FromBodyAttribute>().Bind(new<\/span> FromBodyBindingProvider(this<\/span>.logger));\r\n        }\r\n    }\r\n<\/pre>\n<\/div>\n

\nFromBodyAttribute<\/strong><\/h3>\n
It’s a simple attribute with no special code, but it’s used by BindingExtensionProvider<\/strong> to link a parameter in the Azure Function with this binding provider. We can apply the attribute to a parameter and the link will be stablished.<\/p>\n
 <\/p>\n
<\/p>\n
\n
    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.ReturnValue)]<\/span>\r\n    [Binding]<\/span>\r\n    public<\/span> sealed<\/span> class<\/span> FromBodyAttribute<\/span> : Attribute\r\n    {\r\n    }\r\n<\/pre>\n<\/div>\n
 <\/p>\n
FromBodyBindingProvider<\/strong><\/h3>\n
This class implements the interface IBindingProvider<\/strong> and works like a factory for our custom binding rule. The BindingExtensionProvider<\/strong> inserts an instance of this class in the Azure Function configuration.<\/p>\n
This class creates the next one, the binding rule. and here I included one small touch of wisdom: The binding rule is generic, the code captures the data type of the parameter in the context and dynamically creates the binding rule using this data type. By doing so, the data type will be identified from the parameter declaration, no additional clutter in the middle.<\/p>\n
 <\/p>\n
<\/p>\n
\n
    public<\/span> class<\/span> FromBodyBindingProvider<\/span> : IBindingProvider\r\n    {\r\n        private<\/span> readonly<\/span> ILogger logger;\r\n        public<\/span> FromBodyBindingProvider<\/span>(ILogger logger)\r\n        {\r\n            this<\/span>.logger = logger;\r\n        }\r\n\r\n        public<\/span> Task<IBinding> TryCreateAsync(BindingProviderContext context)\r\n        {\r\n            IBinding binding = CreateBodyBinding(logger, context.Parameter.ParameterType);\r\n            return<\/span> Task.FromResult(binding);\r\n        }\r\n\r\n        private<\/span> IBinding CreateBodyBinding<\/span>(ILogger log,Type T)\r\n        {\r\n            var<\/span> type = typeof<\/span>(FromBodyBinding<>).MakeGenericType(T);\r\n            var<\/span> a_Context = Activator.CreateInstance(type, new<\/span> object<\/span>[] { log });\r\n            return<\/span> (IBinding)a_Context;\r\n        }\r\n    }\r\n<\/pre>\n<\/div>\n
 <\/p>\n
FromBodyBinding<\/strong><\/h3>\n
This class implements the IBinding<\/strong> interface. This is the class injected inside Azure Function configuration. It provides an instance of IValueProvider<\/strong>, responsible to extract the value from the HTTPRequest<\/strong>.<\/p>\n
 <\/p>\n
<\/p>\n
\n
    public<\/span> class<\/span> FromBodyBinding<\/span><T> : IBinding\r\n    {\r\n        private<\/span> readonly<\/span> ILogger logger;\r\n        public<\/span> FromBodyBinding<\/span>(ILogger logger)\r\n        {\r\n            this<\/span>.logger = logger;\r\n        }\r\n        public<\/span> Task<IValueProvider> BindAsync(BindingContext context)\r\n        {\r\n            \/\/ Get the HTTP request<\/span>\r\n            var<\/span> request = context.BindingData[\"req\"<\/span>] as<\/span> HttpRequest;\r\n            return<\/span> Task.FromResult<IValueProvider>(new<\/span> FromBodyValueProvider<T>(request, logger));\r\n        }\r\n\r\n        public<\/span> bool<\/span> FromAttribute => true<\/span>;\r\n\r\n\r\n        public<\/span> Task<IValueProvider> BindAsync(object<\/span> value<\/span>, ValueBindingContext context)\r\n        {\r\n            return<\/span> null<\/span>;\r\n        }\r\n\r\n        public<\/span> ParameterDescriptor ToParameterDescriptor<\/span>() => new<\/span> ParameterDescriptor();\r\n    }\r\n<\/pre>\n<\/div>\n
 <\/p>\n
FromBodyValueProvider<\/strong><\/h3>\n
This class implements the IValueProvider<\/strong> interface and is the responsible for extracting the object from the HTTPRequest<\/strong>. This is where we will use the type we got from the original parameter and used as a generic type for the FromBodyBinding<\/strong> class.<\/p>\n
 <\/p>\n
<\/p>\n
\n
    public<\/span> class<\/span> FromBodyValueProvider<\/span><T> : IValueProvider\r\n    {\r\n        private<\/span> HttpRequest request;\r\n        private<\/span> ILogger logger;\r\n\r\n        public<\/span> FromBodyValueProvider<\/span>(HttpRequest request, ILogger logger)\r\n        {\r\n            this<\/span>.request = request;\r\n            this<\/span>.logger = logger;\r\n        }\r\n\r\n        public<\/span> async<\/span> Task<object<\/span>> GetValueAsync()\r\n        {\r\n            try<\/span>\r\n            {\r\n                string<\/span> requestBody = await<\/span> new<\/span> StreamReader(this<\/span>.request.Body).ReadToEndAsync();\r\n                T result = JsonConvert.DeserializeObject<T>(requestBody);\r\n                return<\/span> result;\r\n            }\r\n            catch<\/span> (System.Exception ex)\r\n            {\r\n                this<\/span>.logger.LogCritical(ex, \"Error deserializing object from body\"<\/span>);\r\n\r\n                throw<\/span> ex;\r\n            }\r\n        }\r\n\r\n        public<\/span> Type Type => typeof<\/span>(object<\/span>);\r\n        public<\/span> string<\/span> ToInvokeString<\/span>() => string<\/span>.Empty;\r\n    }\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Linking Everything<\/strong><\/h3>\n
The Azure Functions have evolved along the time. Some time ago, Azure functions used the interface IWebJobsHostBuilder<\/strong> on their startup function. Nowadays this interface was replaced by IFunctionsHostBuilder<\/strong>.<\/p>\n
The old IWebJobsHostBuilder<\/strong> interface had a direct method to add the binding extension. On the other hand, the IFunctionsHostBuilder<\/strong> doesn’t. In order to solve this problem we need to use a strange workaround.<\/p>\n
Once again, stackoverflow comes to the rescue. This link explains the workaround: https:\/\/stackoverflow.com\/questions\/57564396\/how-do-i-mix-custom-parameter-binding-with-dependency-injection-in-azure-functio<\/a><\/p>\n
 <\/p>\n
<\/p>\n
\n
        public<\/span> override<\/span> void<\/span> Configure<\/span>(IFunctionsHostBuilder builder)\r\n        {\r\n            string<\/span> SqlConnection = Environment.GetEnvironmentVariable(\"SqlConnectionString\"<\/span>);\r\n            builder.Services.AddDbContext<VotingContext>(x => x.UseSqlServer(SqlConnection));\r\n\r\n\r\n            \/\/ IWebJobsBuilders instance<\/span>\r\n            var<\/span> wbBuilder = builder.Services.AddWebJobs(x => { return<\/span>; });\r\n\r\n            \/\/ And now you can use AddExtension<\/span>\r\n            wbBuilder.AddExtension<BindingExtensionProvider>();\r\n        }\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Using the Binding in a Function<\/strong><\/h3>\n
The code below is an example of how to use the binding we created in a function.<\/p>\n
 <\/p>\n
<\/p>\n
\n
        [FunctionName(\"Voting\")]<\/span>\r\n        public<\/span> async<\/span> Task<IActionResult> RegisterVote(\r\n            [HttpTrigger(AuthorizationLevel.Function, \"post\", Route = \"Sessions\/Vote\")]<\/span>\r\n            HttpRequest req,\r\n            ILogger log, [libTools.Bindings.FromBody] VotesRecord votes)\r\n        {\r\n\r\n        }\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Conclusion<\/strong><\/h3>\n
It’s always a good practice to create and re-use tools to make our code more high-level, I hope this will help to improve your code.\u00a0I published this custom binding on GitHub, feel free to improve it: https:\/\/github.com\/DennesTorres\/HttpBinding<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Azure Functions are a great development tool, allowing us to create serverless software. However, one detail was bothering me when I create a function: The HTTP Trigger receives a\u00a0HTTPRequest object and we need to extract the parameters from the request. This becomes kind of a low-level code mixed with our business code. It’s like going……<\/p>\n","protected":false},"author":50808,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2],"tags":[5364,4658,136367,4162,136298],"coauthors":[6810],"class_list":["post-89877","post","type-post","status-publish","format-standard","hentry","category-blogs","tag-azure","tag-functions","tag-httptrigger","tag-microsoft","tag-serverless"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/89877","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/50808"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=89877"}],"version-history":[{"count":30,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/89877\/revisions"}],"predecessor-version":[{"id":89924,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/89877\/revisions\/89924"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=89877"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=89877"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=89877"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=89877"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}