Introduction to Azure Functions Pt. 2 - Creating the Azure Function
Tags: azure, serverless, dotnet, devops
Published: 2019-11-11 17:11:07

---
title: Introduction to Azure Functions Pt. 2 - Creating the Azure Function
published: true
description: 
tags: azure, serverless, dotnet, devops
series: Introduction to Azure Functions
---

## Introduction
In this post we will be creating an Azure Function in our `HelloAzure.Functions` project. We will add an assembly reference to `HelloAzure.BusinessLogic` in order to add some contrived business logic. Finally we will run the function project locally in order to verify the function works as expected.

## Prerequisites
To create the Azure Function we will be using the azure-functions-core-tools cli. Instructions for installing the CLI can be found [here](https://github.com/Azure/azure-functions-core-tools#installing). To add an assembly reference from our BusinessLogic assembly we'll use the dotnet cli which is included in the .NET Core SDK. We will be using version 2.1 of the SDK. The SDK installer can be found [here](https://dotnet.microsoft.com/download). 

We will be using the command line in this section. Some basic knowledge of the command line will be useful. 

Shell commands will be prefixed with `$`.

This wiki assumes that you have created a repository in a source control provider such as GitHub and that you have cloned that repository locally.

## Creating the Azure Function
1. Change directories into the `Functions` project of your locally cloned repository.
    ```sh
    $ cd ~/code/HelloAzure/HelloAzure.Functions/
    ```
2. Create a new Azure Function in the project.
    ```sh
    $ func new
    ```
    1. This will start the function creation wizard.
    2. When prompted for a trigger select `Http Trigger`.
    4. Name the function `SayHello`.
    5. You should see the following output
        ```sh
        The function "SayHello" was created successfully from the "HttpTrigger" template.
        ```
3. Your `HelloAzure.Functions/` directory should now have a `SayHello.cs` file in it.
    ```
    .
    +-- HelloAzure.Functions/
    |   +-- SayHello.cs
    |   +-- ...
    ```

## Adding a reference to our BusinessLogic assembly
1. From your `HelloAzure.Functions/` directory add a reference to the BusinessLogic assembly.
    ```sh
    $ dotnet add reference ../HelloAzure.BusinessLogic/HelloAzure.BusinessLogic.csproj
    ```
    1. This command will add a project reference to your `HelloAzure_Functions.csproj` file that points to the `HelloAzure.BusinessLogic` project.


## Add "business logic" to the function
1. In a text editor modify the contents of `SayHello.cs`
    ```c#
    using System;
    using System.IO;
    using System.Threading.Tasks;
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Azure.WebJobs.Extensions.Http;
    using Microsoft.AspNetCore.Http;
    using Microsoft.Extensions.Logging;
    using Newtonsoft.Json;
    using HelloAzure.BusinessLogic;
    
    namespace HelloAzure.Functions
    {
        public static class SayHello
        {
            [FunctionName("SayHello")]
            public static async Task<IActionResult> Run(
                [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
                ILogger log)
            {
                GreetingService greetingService = new GreetingService();
                log.LogInformation("C# HTTP trigger function processed a request.");
    
                string name = req.Query["name"];
    
                string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
                dynamic data = JsonConvert.DeserializeObject(requestBody);
                name = name ?? data?.name;
    
                if (name != null) {
                    string greeting = greetingService.GetGreeting(name);
                    return (ActionResult)new OkObjectResult(greeting);
                }
    
                return new BadRequestObjectResult("Please pass a name on the query string or in the request body");
            }
        }
    }
    ```
    1. In our changes we added a using statement for `HelloAzure.BusinessLogic`.
    2. Next we instantiated an instance of the `GreetingService`.
    3. Finally we modified the return logic to generate a greeting using our `GreetingService` instead of using a hard-coded string.

## Running the function locally
1. From your `HelloAzure.Functions/` directory start the function project.
    ```sh
    $ func start --build
    ```
    1. This will build the functions project and start it.
    2. The `--build` flag is needed since this is a .NET Core functions project and it must be built.
    3. This will start an HTTP Server and point your functions to it.
    4. You should see output containing the following.
        ```sh
        Http Functions:

    	SayHello: [GET,POST] http://localhost:7071/api/SayHello
        ```
2. If you visit the URL above in a browser and add a query string parameter for `name` you should see a response with the message `Hello, <name>`. If you do then congrats! Your function is working.

## Recap
In this post we added an Azure Function to our `HelloAzure.Functions` project. We added a reference to our `HelloAzure.BusinessLogic` class library in order to add some contrived business logic to illustrate how you might add logic to a function. Finally we ran our function project locally in order to verify the function works.

This would be a good time to commit the changes you've made to source.

The next step is creating Azure Function resources.