.NET developer moving into Azure Functions and Durable Functions

 For a .NET developer moving into Azure Functions, I’d prioritize learning in this order:

1. HTTP Trigger
2. Timer Trigger
3. Queue Trigger
4. Dependency Injection
5. Configuration & app settings
6. Blob Trigger
7. Service Bus
8. Logging + monitoring
9. Durable Functions
10. Deployment to Azure

After this, the next major topic is Durable Functions (fan-out/fan-in, chaining, orchestration), which is frequently asked in interviews and used in enterprise projects.

This pattern is very common in production systems.

Example: E-commerce order processing

HTTP Trigger

      ↓

Queue Output

      ↓

Queue Trigger

      ↓

Process order

      ↓

Blob Storage

      ↓

Send Email

https://chatgpt.com/share/6a151bf1-e124-8322-96f5-84b133b2a0b1

Since you're already a .NET developer, the fastest path is: understand what Azure Functions are, create one locally, run/debug it, then deploy it. Here's a practical step-by-step roadmap.

Step 1: Understand the core idea

Azure Function = small, event-driven code that runs when something happens.

Common triggers:

• HTTP Trigger → API endpoint (GET, POST)
• Timer Trigger → runs on schedule (cron)
• Queue Trigger → processes queue messages
• Blob Trigger → reacts to file uploads
• Service Bus Trigger → messaging/events

Basic flow:

Trigger → Function executes → Output/Binding

Example:

HTTP request
      ↓
Azure Function
      ↓
JSON response

---

Step 2: Install required tools

Install:

1. .NET SDK (prefer .NET 8 LTS)
2. Azure Functions Core Tools
3. Visual Studio 2022 or VS Code
4. Azure account

Useful links:

• .NET SDK
• Azure Functions Core Tools documentation
• Visual Studio
• Azure Portal

Verify installation:

dotnet --version

func --version

Expected example:

8.0.xxx
4.x.x

---

Step 3: Create your first Function App

Open terminal:

mkdir MyFunctionApp

cd MyFunctionApp

Create project:

func init --worker-runtime dotnet-isolated

Create HTTP function:

func new

Select:

HTTP Trigger
Function Name: HelloFunction
Authorization level: Anonymous

Folder structure:

MyFunctionApp
 ├── HelloFunction.cs
 ├── host.json
 ├── local.settings.json
 ├── Program.cs
 └── MyFunctionApp.csproj

---

Step 4: Understand generated code

Example:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;

namespace MyFunctionApp;

public class HelloFunction
{
    private readonly ILogger<HelloFunction> _logger;

    public HelloFunction(
        ILogger<HelloFunction> logger)
    {
        _logger = logger;
    }

    [Function("HelloFunction")]
    public HttpResponseData Run(
        [HttpTrigger(AuthorizationLevel.Anonymous,
        "get","post")] HttpRequestData req)
    {
        _logger.LogInformation("Function executed.");

        var response = req.CreateResponse(
            HttpStatusCode.OK);

        response.WriteString(
            "Hello Azure Function");

        return response;
    }
}

Important parts:

Code	Purpose
[Function()]	Function name
[HttpTrigger()]	Defines trigger
ILogger	Logging
HttpRequestData	Request object
HttpResponseData	Response object

---

Step 5: Run locally

Start application:

func start

You should see:

Functions:

HelloFunction:
http://localhost:7071/api/HelloFunction

Open browser:

http://localhost:7071/api/HelloFunction

Output:

Hello Azure Function

---

Step 6: Debug in Visual Studio

1. Open project
2. Press F5
3. Put breakpoint:

_logger.LogInformation("Function executed.");

4. Call API

Visual Studio stops at breakpoint.

---

Step 7: Learn configuration

local.settings.json

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "MyConnection":"ABC"
  }
}

Read value:

public class HelloFunction
{
    private readonly IConfiguration _config;

    public HelloFunction(
        IConfiguration config)
    {
        _config=config;
    }

    [Function("HelloFunction")]
    public void Run()
    {
        string value =
          _config["MyConnection"];
    }
}

---

Step 8: Learn Dependency Injection

You already know .NET DI, and Azure Functions use a similar pattern.

Program.cs

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        services.AddScoped<IMyService,
                            MyService>();
    })
    .Build();

host.Run();

Service:

public interface IMyService
{
    string GetMessage();
}

public class MyService : IMyService
{
    public string GetMessage()
    {
        return "From service";
    }
}

Inject:

public class HelloFunction
{
    private readonly IMyService _service;

    public HelloFunction(IMyService service)
    {
        _service=service;
    }
}

---

Step 9: Learn the most important triggers

Start with this order:

1. HTTP Trigger
2. Timer Trigger
3. Queue Trigger
4. Blob Trigger
5. Service Bus Trigger

Timer example:

[Function("TimerDemo")]
public void Run(
[TimerTrigger("0 */5 * * * *")]
TimerInfo timer)
{
   _logger.LogInformation(
      "Runs every 5 mins");
}

Cron:

0 */5 * * * *

Meaning:

Second Minute Hour Day Month DayOfWeek

---

Step 10: Deploy to Azure

Login:

az login

Create Function App and deploy:

func azure functionapp publish MyFunctionApp

---

Learning path for the next 7 days

Day 1

• HTTP Trigger
• Local debugging

Day 2

• Dependency Injection
• Configuration

Day 3

• Timer Trigger

Day 4

• Queue Trigger

Day 5

• Blob Trigger

Day 6

• Service Bus Trigger

Day 7

• Deploy to Azure

After that learn:

• Durable Functions
• Application Insights
• Managed Identity
• Azure Storage
• CI/CD with GitHub Actions or Azure DevOps

As a .NET developer, think of Azure Functions as: ASP.NET Core + Dependency Injection + event triggers + serverless hosting.

Great. Since you're new to Azure Functions but already know .NET, Day 1 should focus on **understanding HTTP Trigger + local debugging**. Keep it hands-on.

# Day 1: Azure Functions Fundamentals + HTTP Trigger

Duration: ~60–90 minutes

## Session Goal

By the end of Day 1 you should be able to:

✅ Understand what Azure Functions are

✅ Create a Function App

✅ Create an HTTP-trigger function

✅ Run locally

✅ Debug with breakpoints

✅ Pass query parameters

---

# Part 1 — What is Azure Function? (10 mins)

Think in .NET terms:

| ASP.NET Core Web API    |       Azure Function |

| ----------------------- | -------------------: |

| Controller              |             Function |

| Action method           |      Function method |

| Route                   |              Trigger |

| Dependency Injection    | Dependency Injection |

| App hosted continuously |  Runs when triggered |

Example:

User calls:

```text

http://localhost:7071/api/HelloFunction

```

Execution flow:

```text

Request

   ↓

HTTP Trigger

   ↓

Function runs

   ↓

Response

```

---

# Part 2 — Create your first Function App (15 mins)

Open terminal:

```bash

mkdir AzureDay1

cd AzureDay1

```

Create Function project:

```bash

func init --worker-runtime dotnet-isolated

```

Expected files:

```text

AzureDay1

│

├── host.json

├── Program.cs

├── local.settings.json

└── AzureDay1.csproj

```

Now create function:

```bash

func new

```

Select:

```text

Template: HTTP Trigger

Function Name:

HelloFunction

Authorization:

Anonymous

```

---

# Part 3 — Understand generated code (15 mins)

You will get something similar:

```csharp

using Microsoft.Azure.Functions.Worker;

using Microsoft.Azure.Functions.Worker.Http;

using Microsoft.Extensions.Logging;

using System.Net;

namespace AzureDay1;

public class HelloFunction

{

    private readonly ILogger<HelloFunction> _logger;

    public HelloFunction(

        ILogger<HelloFunction> logger)

    {

        _logger = logger;

    }

    [Function("HelloFunction")]

    public HttpResponseData Run(

        [HttpTrigger(

            AuthorizationLevel.Anonymous,

            "get",

            "post")]

        HttpRequestData req)

    {

        _logger.LogInformation(

            "Function executed");

        var response =

            req.CreateResponse(

                HttpStatusCode.OK);

        response.WriteString(

            "Welcome to Azure Function");

        return response;

    }

}

```

Understand line by line:

### Function Name

```csharp

[Function("HelloFunction")]

```

This becomes:

```text

/api/HelloFunction

```

---

### Trigger

```csharp

[HttpTrigger(

AuthorizationLevel.Anonymous,

"get",

"post")]

```

Means:

* Anonymous → no login needed

* GET allowed

* POST allowed

---

### Logger

```csharp

_logger.LogInformation(

"Function executed");

```

Similar to ASP.NET Core logging.

---

# Part 4 — Run locally (10 mins)

Run:

```bash

func start

```

Expected output:

```text

Functions:

HelloFunction:

http://localhost:7071/api/HelloFunction

```

Open browser:

```text

http://localhost:7071/api/HelloFunction

```

Output:

```text

Welcome to Azure Function

```

---

# Part 5 — Add query parameter (20 mins)

Modify code:

```csharp

using Microsoft.Azure.Functions.Worker;

using Microsoft.Azure.Functions.Worker.Http;

using Microsoft.Extensions.Logging;

using System.Net;

using System.Web;

namespace AzureDay1;

public class HelloFunction

{

    private readonly ILogger<HelloFunction> _logger;

    public HelloFunction(

        ILogger<HelloFunction> logger)

    {

        _logger = logger;

    }

    [Function("HelloFunction")]

    public HttpResponseData Run(

        [HttpTrigger(

            AuthorizationLevel.Anonymous,

            "get")]

        HttpRequestData req)

    {

        var query =

            HttpUtility.ParseQueryString(

                req.Url.Query);

        var name =

            query["name"];

        var response =

            req.CreateResponse(

                HttpStatusCode.OK);

        response.WriteString(

            $"Hello {name}");

        return response;

    }

}

```

Run:

```bash

func start

```

Test:

```text

http://localhost:7071/api/HelloFunction?name=Selva

```

Output:

```text

Hello Selva

```

---

# Part 6 — Debugging (10 mins)

Open project in Visual Studio:

1. Open solution

2. Put breakpoint:

```csharp

var name=query["name"];

```

3. Press:

```text

F5

```

4. Call:

```text

http://localhost:7071/api/HelloFunction?name=Selva

```

Visual Studio stops at breakpoint.

Check:

* name value

* request values

* logger output

---

# Small Exercise

Create a new function:

```bash

func new

```

Choose:

```text

Function Name:

Calculator

```

Write:

```csharp

[Function("Calculator")]

public HttpResponseData Run(

[HttpTrigger(

AuthorizationLevel.Anonymous,

"get")]

HttpRequestData req)

{

    var query =

      HttpUtility.ParseQueryString(

      req.Url.Query);

    int n1 =

      Convert.ToInt32(query["n1"]);

    int n2 =

      Convert.ToInt32(query["n2"]);

    var response =

       req.CreateResponse(

       HttpStatusCode.OK);

    response.WriteString(

        $"Sum={n1+n2}");

    return response;

}

```

Test:

```text

http://localhost:7071/api/Calculator?n1=10&n2=20

```

Expected:

```text

Sum=30

```

---

Day 1 homework:

1. Create **MultiplyFunction**

2. Create **AgeCalculator**

3. Add logging

4. Debug all functions locally

Day 2 will cover **Dependency Injection + Configuration + local.settings.json**, which connects directly to your existing .NET experience.