Forem: Ellie

The Two Halves of Program.cs in .NET

Ellie — Mon, 10 Nov 2025 09:28:37 +0000

If you've recently jumped into .NET 6 or newer, the first file you see might be Program.cs which looks very different. The old Startup.cs file is gone, and everything is in one, minimal file.

It might look confusing, but this new Program.cs is really just a file split into two distinct jobs.

The "Builder" Phase: Setting up all your tools and services.
The "Pipeline" Phase: Defining the steps to handle a web request.

Let's break it down.

Part 1: The "Builder" Phase (The Setup)

Every new .NET web app starts with this line:

var builder = WebApplication.CreateBuilder(args);

Builder is like a setup-kit. Before you can do anything, you need to "prepare" the application. This is where you setup all the services, tools, and configurations needed to run your application.

This is the phase where you register things. You'll see code that uses builder.Services:

// Example: Adding the tools for controllers
builder.Services.AddControllers();

// Example: Adding a custom tool (service) you built
// This is "Dependency Injection"
builder.Services.AddScoped<IMyService, MyService>();

// Example: Adding configuration from appsettings.json
builder.Configuration.AddJsonFile("appsettings.json");

This part isn't running your website yet. It's just you, gathering all your tools (like registering services) and reading the details (like loading configuration).

Once you've registered all your services, you "build" the app:

var app = builder.Build();

This line is the transition. It takes all the services and configurations you defined and bundles them into an actual application, which we call app.

That's it for Part 1. Setup is complete.

Part 2: The "Pipeline" Phase (The Recipe)

Now that we have our app, we need to tell it what to do when it receives a request from a user's browser.

This is done by creating a "middleware pipeline."

Middleware is just a piece of code that a request passes through. You chain these pieces of code together, one after another, to create a "pipeline."

The most important thing to remember here is that the order matters. A lot.

The request goes through the pipeline from top to bottom. Then, the response goes back up through the pipeline in reverse order.

Think of it like this:
Request -> Middleware 1 -> Middleware 2 -> Your Code -> Middleware 2 -> Middleware 1 -> Response

This setup is powerful. It lets you do things before your main code runs (like checking if the user is authenticated) and things after your code runs (like logging the response).

You define this pipeline using app.Use...() methods:

// This is the pipeline
// We are "using" different pieces of middleware

// 1. First, if we're not in development, handle errors
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts(); // Add security headers
}

// 2. Redirect HTTP requests to HTTPS
app.UseHttpsRedirection();

// 3. Find out which "endpoint" (like a method) to run
app.UseRouting();

// 4. Check if the user is allowed to be here
app.UseAuthorization();

// 5. Finally, map the request to our actual code
app.MapGet("/", () => "Hello World!");

// This is the very last step.
// This line actually starts the server and listens for requests.
app.Run();

In the example above:

A request comes in.

It's checked for HTTPS (UseHttpsRedirection).
It's checked for which endpoint it matches (UseRouting).
It's checked for permissions (UseAuthorization).
Finally, it hits our endpoint (MapGet) and "Hello World!" is returned.

That "Hello World!" string then travels back up the pipeline, and the final response is sent to the user.

Conclusion

So, next time you look at a Program.cs file, don't get overwhelmed. Just split it in your mind:

The Top Half (builder): This is just setup. We're registering our services (Dependency Injection).
The Bottom Half (app): This is the recipe. We're defining the step-by-step pipeline to handle requests.

Simple, right?

Async Programming in C#

Ellie — Mon, 27 Oct 2025 20:48:37 +0000

Asynchronous programming is needed to write code that can handle a long-running requests (like querying a database, calling an API, or reading a large file) instead of just stopping and waiting for response.
This Async Programming is essential for having a responsive application. The UI freeze without using async in mobile app and using async programming on web servers allows handling a massive number of requests instead of being blocked by one slow request.

using sync means the main thread will be blocked till it finish the current task.

while via async the main thread won't get blocked and is immediately freed up to do other things. Whenever the task finishes, the main thread will pick up the result and continue.

The Analogy: Doing Chores

Imagine it's a weekend and you have to do some Cores at home. you might need to do laundries, washing some dishes and probably you want to watch a new episode of your favourite series. So you probably first load washer machine and start the washing cycle and while machine is washing the laundries you might fill up the dish washer and start the machine. While both machines are working so you have time for watching a new episode.
all the step above you will do them async. It means that you are not standing in front of washer doing nothing till the cycle finish. you have just start the task and then you are free to do some other tasks. you are the main thread and by starting each machine you starting a task and free up the main thread.

Syntax at a glance

Here is the example using analogy described above

You only need to know three main things.

Task: The promise
This object represents the work-in-progress. Think of it as a "receipt" we get from the washer. It's not the clean clothes, but it's the promise of clean clothes.

Task: Use this for an async method that doesn't return a value (like void).
Task<T>: Use this for an async method that does return a value. (e.g., Task promises to give you a string eventually).

async: The marker
We add this keyword to a method signature (e.g., public async Task DoLaundry()). It simply "unlocks" the ability to use the await keyword inside that method. It's just like a signal to the compiler.

await: The "Pause Button"
This is the operator we need to put in front of a Task (e.g., string result = await GetSomeDataAsync();).and It actually tells the compiler that here is a long-running task. Compiler can pause this method here, give control back to the caller, and later when the task is finished it can come back to this exact line to continue.

Scenario: Pricing service

Consider you have a train ticket and you want to calculate the total price for the customers. let's consider for each ticket we have Ticket Price, Insurance price, Vat and Admin Fee that needs to get calculated.

Sync Solution:

so here we have multiple fees need to calculated and each will take couple of seconds:

private int GetTicketPrice()
    {
        Console.WriteLine($" getting Ticket Price at {DateTime.Now}");
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
        return 20;
    }

    private int GetInsurancePrice()
    {
        Console.WriteLine($" getting insurance Price at {DateTime.Now}");
        Thread.Sleep(TimeSpan.FromSeconds(1));
        return 5;
    }

    private int CalculateVat()
    {
        Console.WriteLine($" Calculating Vat at {DateTime.Now}");
        Thread.Sleep(TimeSpan.FromSeconds(5));
        return 1;
    }

    private int CalculateAdminFee()
    {
        Console.WriteLine($" Calculating Admin fee at {DateTime.Now}");
        Thread.Sleep(TimeSpan.FromSeconds(2));
        return 2;
    }

and we have a this Fee Calculator which I've added a Stopwatch to see how much time it will takes to perform:

public class SyncPricingService
{
    public int CalculateFees()
    {
        var watch = Stopwatch.StartNew();

       var  ticketFee = GetTicketPrice();
       var insuranceFee = GetInsurancePrice();
       var vatFee = CalculateVat();
       var adminFee = CalculateAdminFee();

       var fees = new[] { ticketFee, insuranceFee, vatFee, adminFee }; 

       watch.Stop();
       Console.WriteLine($"Total time <CalculateFees>: {watch.ElapsedMilliseconds}ms");

        return fees.Sum();
    }
}

Later we will calculate the fee with sync approach by simply using syncPricingService.CalculateFees();

Here is the flow which will take 8.5 second:

▶️ Runnable sample: Sync Fee Calculator

Async Solution:

again we have multple functions for calculating fees:

private async Task<int> GetTicketPriceAsync()
    {
        Console.WriteLine($" getting Ticket Price at {DateTime.Now}");
        await Task.Delay( TimeSpan.FromSeconds(0.5));
        return 20;
    }

    private async Task<int> GetInsurancePriceAsync()
    {
        Console.WriteLine($" getting Insurance Price at {DateTime.Now}");
        await Task.Delay( TimeSpan.FromSeconds(1));
        return 5;
    }

    private async Task<int> CalculateVatAsync()
    {
        Console.WriteLine($" Calculating Vat at {DateTime.Now}");
        await Task.Delay( TimeSpan.FromSeconds(5));
        return 1;
    }

    private async Task<int> CalculateAdminFeeAsync()
    {
        Console.WriteLine($" Calculating Admin fee at {DateTime.Now}");
        await Task.Delay( TimeSpan.FromSeconds(2));
        return 2;
    }

and here we have this Fee Calculator:

public class AsyncPricingService
{
    public async Task<int> CalculateFeesAsync()
    {
        var watch = Stopwatch.StartNew();

        var  ticketFeeTask = GetTicketPriceAsync();
        var insuranceFeeFeeTask =  GetInsurancePriceAsync();
        var vatFeeTask = CalculateVatAsync();
        var adminFeeTask = CalculateAdminFeeAsync();

        var fees = await Task.WhenAll( ticketFeeTask, insuranceFeeTask, vatFeeTask, adminFeeTask );

        watch.Stop();
        Console.WriteLine($"Total time <CalculateFeesAsync>: {watch.ElapsedMilliseconds}ms");



        return fees.Sum();
    }
}

Later we can simply calculate the fee with async approach by calling await asyncPricingService.CalculateFeesAsync();

Here is the flow which will take 5 second:

▶️ Runnable sample: Async Fee Calculator

Actions — delegates that return void

Ellie — Thu, 23 Oct 2025 10:46:14 +0000

Before Make sure to read about delegate here

Action is just a built‑in delegate for “do something and don’t return a value.” So Action is the same shape as a custom delegate that returns void.

If delegates are “function references,” then Action is the ready‑made one for void.

Same example as delegate, using Action

// Built-in delegate: Action<T> == delegate void Something(T)
static void FormalSay(string name)   => Console.WriteLine($"Hello, {name}.");
static void FriendlySay(string name) => Console.WriteLine($"Hey {name}!");

Action<string> say = FormalSay;   // reference to a void-returning function
say("Ava");                       // Hello, Ava.

say = FriendlySay;                 // swap behaviour
say("Ava");                       // Hey Ava!

▶️ Tiny runnable sample

welldone if you have reached here, bellow I'm trying to explain the action in an example more closed to real world(the same example as delegate)

Scenario: train ticket AddOns with Action

Imagine you have a Train ticket and you want to add some Extras to your ticket such as Insurance, Coffee , ...
let's write this code without Actions and then with Actions.

Basics:

First Lets have TrainTicket Model:

public class TrainTicket
{
    public string TicketId { get; }
    public decimal Price { get; set; }  // base + add-ons    
    public decimal Discount { get; set; }   // from promo
    public decimal FinalPrice => Price - Discount;
    public List<string> Extras { get; } = new();

    public TrainTicket(string ticketId, decimal basePrice)
    {
        TicketId = ticketId;
        Price = basePrice;
    }
}

and now Let's consider we have these AddOns:

public static class TrainAddOns
{
    public static void AddInsurance(TrainTicket ticket)
    {
        ticket.Price += 7m; 
        ticket.Extras.Add("Insurance");
    }

    public static void CoffeeToSeat(TrainTicket ticket)
    {
        ticket.Price += 3m;
        ticket.Extras.Add("Coffee to seat");
    }

    public static void FoodDelivery(TrainTicket ticket)
    {
        ticket.Price += 8m; 
        ticket.Extras.Add("Food delivered to seat");
    }

    public static void ExtraLegroom(TrainTicket ticket)
    {
        ticket.Price += 12m;
        ticket.Extras.Add("Extra legroom");
    }
}

Apply AddOns Without Actions

We get a addOns as a string and add the extras with a switch statement:

public  static TrainTicket ApplyAddOns(TrainTicket ticket, IEnumerable<string> addOns)
    {
        foreach (var name in addOns)
        {
            switch (name)
            {
                case "insurance":
                {
                    TrainAddOns.AddInsurance(ticket);
                    break;
                }
                case "coffee":
                {
                    TrainAddOns.CoffeeToSeat(ticket);
                    break;
                }
                case "food":
                {
                    TrainAddOns.FoodDelivery(ticket);
                    break;
                }
            }
        }
        return ticket;
    }

and here is how we call this method to apply addons:

ApplyAddOns(ticket, new List<string> { "insurance", "coffee", "food" });

Apply AddOns With Actions

What makes the code more simple is using the code and passing the actions( ref to void function) to the ApplyAddOns method. this Method doesn't need to know the implementation, it will call the action so that it can apply the AddOns as expected.

public  static TrainTicket ApplyAddOns(TrainTicket ticket, List<Action<TrainTicket>> addOnActions)
    {
        foreach (var addOnAction in addOnActions)
        {
            addOnAction(ticket);
        }
        return ticket;
    }

and here is how we call this metgod to apply addons:

ApplyAddOns(ticket,new List<Action<TrainTicket>>
        {
            TrainAddOns.AddInsurance,
            TrainAddOns.CoffeeToSeat,
            TrainAddOns.FoodDelivery
        });

▶️ Runnable sample: Apply AddOns Without Action
▶️ Runnable sample: Apply AddOns With Action

Delegates — A Simple Introduction

Ellie — Mon, 20 Oct 2025 21:08:59 +0000

I think of a delegate as a reference to a function. It’s a type that says “I can point at any method that has this parameter list and this return type.” You create one, point it to a compatible method, and call the method through the delegate. Because you can pass delegates around, they’re great for plugging behaviour into APIs. C# events are built on delegates too.

Real-World Analogy: Delegates as a Phone Number

Think of a delegate like a phone number you hand to someone with simple instructions: “when It's done, call this number and say something”
The caller doesn’t need to know who picks up or what they do—just that dialing the number (invoking the delegate) with the message will trigger the right action. If you later give them a different number (swap the delegate), they dial the same way but reach someone else who can handle it differently, without them changing their routine.

Syntax at a glance

// 1) Declare a delegate type
public delegate string Greeter(string name);


// 2) Point it at compatible methods
static string Formal(string name) => $"Hello, {name}.";
static string Friendly(string name) => $"Hey {name}!";


// 3) Invoke through the delegate instance
Greeter g = Formal; // reference to a function
Console.WriteLine(g("Ava")); // "Hello, Ava."


g = Friendly; // swap behaviour on the fly
Console.WriteLine(g("Ava")); // "Hey Ava!"

▶️ Tiny runnable sample

welldone if you have reached here, bellow I'm trying to explain the delegate in an example more closed to real world

Scenario: train ticket promos with delegates

Imagine you have a Train ticket and you want to add some promo code which apply some discount to your final price.
let's write this code without delegates and then with delegates.

Basics:

First Lets have TrainTicket Model:

public class TrainTicket
{
    public string TicketId { get; }
    public decimal Price { get; set; }      
    public decimal Discount { get; set; }   // from promo
    public decimal FinalPrice => Price - Discount;

    public TrainTicket(string ticketId, decimal basePrice)
    {
        TicketId = ticketId;
        Price = basePrice;
    }
}

and now Let's consider we have these Rules for the promos:

public static class PromoRules
{
    public static decimal TenOff(decimal price)
    {
        return Math.Min(10m, price);
    }
    public static decimal HalfOff(decimal price)
    {
        return price * 0.50m;
    } 
    public static decimal LoyalCap(decimal price)
    {
        return Math.Min(price * 0.05m, 5m);
    }
}

Apply promo Without Delegate

We get a promoCode as a string and choose the rule with a switch:

public static TrainTicket ApplyPromo(TrainTicket ticket, string? promoCode)
    {
        switch (promoCode)
        {
            case "TENOFF": // flat £10 off, capped by price
                ticket.Discount = PromoRules.TenOff(ticket.Price);
                break;
            case "HALF":   // 50% off
                ticket.Discount = PromoRules.HalfOff(ticket.Price);
                break;
            case "LOYAL":  // 5% off, max £5
                ticket.Discount = PromoRules.LoyalCap(ticket.Price);
                break;
            default:
                // unknown code -> no discount
                break;
        }

        return ticket;
    }

Apply promo With Delegate

what would make the code more simple would be a way to avoid having this switch statement and figuring out a way which make it easier to determind which rule fits which promo code.
Here delegate would help us to defind this relationship and applying the rules.

public delegate decimal PromoRuleDelegate(decimal price);

// single place to add/remove codes
    private static readonly (string Code, PromoRuleDelegate Rule)[] PromoRuleMap = new[]
    {
        ("TENOFF", PromoRules.TenOff),
        ("HALF",   PromoRules.HalfOff),
        ("LOYAL",  PromoRules.LoyalCap),
        // add more 
    };

public static TrainTicket ApplyPromo(TrainTicket ticket, string? promoCode)
{
        foreach (var promoRule in PromoRuleMap)
        {
            if (promoRule.Code == promoCode) 
            {
                   ticket.Discount = promoRule.Rule(ticket.Price);
                   break;
            }
        }

        return ticket; 
    }

Why this helps

You keep rule selection logic in one place while the call-site stays simple.
Adding a new promo becomes: write a method, add one tuple to PromoRuleMap.

▶️ Runnable sample: Apply Promo Without Delegate
▶️ Runnable sample: Apply Promo With Delegate

Navigating the .NET Ecosystem: My Take on a Practical Roadmap

Ellie — Mon, 20 Oct 2025 21:00:38 +0000

Hi everyone, I'm Ellie. I'm a Senior .NET Engineer now, but my career actually started in game development using Unity and C#. That transition from games to backend services gave me what I feel is a unique perspective on the specific challenges developers can face when moving into the .NET ecosystem.

As a mentor, I've recently guided a few engineers through this exact transition. I found myself repeatedly sketching out the same core concepts and tools that seemed essential for day-to-day work in a large-scale company. To help others on the same path, I’ve tried to turn that advice into what I hope is a practical roadmap.

While there are many excellent .NET roadmaps out there, this one is my attempt to capture the day-to-day realities of a .NET engineer. It covers concepts and libraries that I've found to be crucial for building confidence and getting up to speed on real-world projects. I plan to write detailed guides for each of these topics as I work through them with my mentees.

So, here’s the roadmap I've pieced together. It's just my opinion, but I hope you find it helpful.

C# Fundamentals

Delegates, Actions, and Funcs: Understand the core of event-driven programming in C#.

Delegates — A Simple Introduction

Ellie
Ellie

Ellie

Follow

Oct 20 '25

Delegates — A Simple Introduction

#csharp #dotnet #beginners #programming

5 reactions
Comments Add Comment

3 min read

Actions — delegates that return void

Ellie
Ellie

Ellie

Follow

Oct 23 '25

Actions — delegates that return void

#beginners #csharp #dotnet

2 reactions
Comments Add Comment

2 min read
Asynchronous Programming: Master async/await and the Task Parallel Library for responsive applications.

Async Programming in C#

Ellie
Ellie

Ellie

Follow

Oct 27 '25

Async Programming in C#

#dotnet #csharp #beginners #development

Comments Add Comment

4 min read
Interfaces and Casting: Grasp these key concepts for building flexible and maintainable object-oriented code.
HttpClient and HttpClientFactory: Learn the modern way to make HTTP requests.
Collections: Get comfortable with Dictionary and thread-safe collections like ConcurrentDictionary.
Date and Time: Understand the difference between DateTime and DateTimeOffset and when to use each.

.NET Core Basics

Application Setup: Dive into Program.cs and appsettings.json to understand how a .NET application is configured and launched.

The Two Halves of Program.cs in .NET

Ellie
Ellie

Ellie

Follow

Nov 10 '25

The Two Halves of Program.cs in .NET

#beginners #webdev #dotnet #csharp

1 reaction
Comments Add Comment

3 min read
Middleware: Learn how to build and use middleware to handle requests and responses in the HTTP pipeline.
Error and Exception Handling: Implement robust strategies for managing errors gracefully.
Filters and Attributes: Use filters and attributes to add cross-cutting concerns to your application.

Dependency Injection (DI)

Service Lifecycles: Understand the different DI lifetimes (Singleton, Scoped, Transient) and how to use them effec tively.

Background Task Scheduling

Hosted Services: Learn to use IHostedService for running background tasks.
Hangfire: Explore popular libraries like Hangfire for more advanced job scheduling.

Testing Strategies

Unit Testing:

Frameworks: NUnit, xUnit
Assertions: FluentAssertions
Mocks & Fakes: Moq, AutoFixture

Integration Testing: Use WebApplicationFactory to test your application's components together.

Behavioral Testing: Get familiar with SpecFlow for BDD (Behavior-Driven Development).

End-to-End Testing: Understand the principles of testing your application from the user's perspective.

Essential Libraries

Polly: Implement resilience and transient-fault-handling policies.

Logging: Explore powerful logging frameworks like NLog and Serilog.

Monitoring & Telemetry: Learn to instrument your application with OpenTelemetry and use tools like New Relic.

Caching:

In-Memory: IMemoryCache, FusionCache
Distributed: Redis

I hope this roadmap is helpful! I'm excited to start digging into these topics and sharing them here.

Let me know if there is anything I have missed.