C# + Tools

# a solution file groups projects (.NET 10 creates the simpler XML .slnx format)
dotnet new sln -n Shop

dotnet new webapi   -o src/Shop.Api        # ASP.NET Core API
dotnet new classlib -o src/Shop.Core       # business logic
dotnet new xunit    -o tests/Shop.Tests    # tests

dotnet sln add src/Shop.Api src/Shop.Core tests/Shop.Tests
dotnet add src/Shop.Api reference src/Shop.Core
dotnet add tests/Shop.Tests reference src/Shop.Core

dotnet build                               # restore packages + compile everything
dotnet test                                # build + run all tests
dotnet run --project src/Shop.Api          # start the API
dotnet watch --project src/Shop.Api        # restart / hot reload on every save
dotnet publish src/Shop.Api -c Release -o out   # optimised build to deploy

# Shop/
#   Shop.slnx
#   src/Shop.Api/Shop.Api.csproj, Program.cs, appsettings.json
#   src/Shop.Core/Shop.Core.csproj
#   tests/Shop.Tests/Shop.Tests.csproj

<!-- Directory.Packages.props (solution root) -->
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="Polly.Core" Version="8.6.4" />
    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.0" />
    <PackageVersion Include="xunit" Version="2.9.3" />
  </ItemGroup>
</Project>

<!-- src/Shop.Api/Shop.Api.csproj: name only, no version -->
<ItemGroup>
  <PackageReference Include="Polly.Core" />
  <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
</ItemGroup>

using System.Collections.Concurrent;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IProductStore, InMemoryProductStore>();
builder.Services.AddOpenApi();                     // /openapi/v1.json in development

var app = builder.Build();
if (app.Environment.IsDevelopment()) app.MapOpenApi();

var products = app.MapGroup("/api/products");

products.MapGet("/", (IProductStore store) => store.All());

products.MapGet("/{id:int}", (int id, IProductStore store) =>
    store.Find(id) is { } p ? Results.Ok(p) : Results.NotFound());

products.MapPost("/", (NewProduct body, IProductStore store) =>
{
    if (string.IsNullOrWhiteSpace(body.Name) || body.PriceCents < 0)
        return Results.ValidationProblem(new Dictionary<string, string[]>
        {
            ["product"] = ["Name is required and price cannot be negative."],
        });
    Product saved = store.Add(body);
    return Results.Created($"/api/products/{saved.Id}", saved);
});

app.Run();

public record Product(int Id, string Name, int PriceCents);
public record NewProduct(string Name, int PriceCents);

public interface IProductStore
{
    IEnumerable<Product> All();
    Product? Find(int id);
    Product Add(NewProduct p);
}

public class InMemoryProductStore : IProductStore
{
    private readonly ConcurrentDictionary<int, Product> _items = new();   // many requests at once
    private int _nextId;

    public IEnumerable<Product> All() => _items.Values.OrderBy(p => p.Id);
    public Product? Find(int id) => _items.GetValueOrDefault(id);
    public Product Add(NewProduct p)
    {
        int id = Interlocked.Increment(ref _nextId);
        return _items[id] = new Product(id, p.Name, p.PriceCents);
    }
}

// curl -X POST localhost:5000/api/products -H "Content-Type: application/json" \
//      -d '{"name":"Pen","priceCents":150}'
// curl localhost:5000/api/products/1

// src/Shop.Core/Pricing.cs
namespace Shop.Core;

public static class Pricing
{
    public static int TotalCents(int unitCents, int qty)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(qty);
        int total = unitCents * qty;
        return qty >= 10 ? total * 90 / 100 : total;   // 10% bulk discount
    }
}

// tests/Shop.Tests/PricingTests.cs
using Shop.Core;

namespace Shop.Tests;

public class PricingTests
{
    [Fact]
    public void SingleItemHasNoDiscount()
    {
        int total = Pricing.TotalCents(250, 1);
        Assert.Equal(250, total);
    }

    [Theory]
    [InlineData(100, 0, 0)]
    [InlineData(100, 9, 900)]
    [InlineData(100, 10, 900)]     // discount starts at 10
    [InlineData(100, 20, 1800)]
    public void BulkDiscount(int unit, int qty, int expected)
    {
        Assert.Equal(expected, Pricing.TotalCents(unit, qty));
    }

    [Fact]
    public void NegativeQuantityIsRejected()
    {
        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => Pricing.TotalCents(100, -1));
        Assert.Equal("qty", ex.ParamName);
    }
}

// Data/ShopDb.cs
using Microsoft.EntityFrameworkCore;

public class ShopDb(DbContextOptions<ShopDb> options) : DbContext(options)
{
    public DbSet<Order> Orders => Set<Order>();
}

public class Order
{
    public int Id { get; set; }
    public required string Customer { get; set; }
    public decimal Total { get; set; }
    public DateTime CreatedAt { get; set; }
}

// Program.cs
builder.Services.AddDbContext<ShopDb>(o =>
    o.UseNpgsql(builder.Configuration.GetConnectionString("Shop")));

app.MapGet("/api/orders/big", async (ShopDb db, CancellationToken ct) =>
    await db.Orders
        .Where(o => o.Total > 100)               // becomes WHERE "Total" > 100
        .OrderByDescending(o => o.CreatedAt)
        .Take(20)
        .AsNoTracking()                          // read-only: skip change tracking
        .ToListAsync(ct));

app.MapPost("/api/orders", async (Order order, ShopDb db) =>
{
    db.Orders.Add(order);
    await db.SaveChangesAsync();                 // INSERT ... RETURNING "Id"
    return Results.Created($"/api/orders/{order.Id}", order);
});

// appsettings.json:
//   "ConnectionStrings": { "Shop": "Host=localhost;Database=shop;Username=postgres;Password=dev" }
//
// dotnet tool install --global dotnet-ef
// dotnet ef migrations add InitialCreate     # generates Migrations/*.cs
// dotnet ef database update                  # applies them to the database

using System.Text.Json;
using Microsoft.Extensions.Caching.Distributed;

// Program.cs
builder.Services.AddStackExchangeRedisCache(o =>
{
    o.Configuration = builder.Configuration.GetConnectionString("Redis");   // "localhost:6379"
    o.InstanceName = "shop:";                                                // key prefix
});
builder.Services.AddScoped<ProductCatalog>();

// ProductCatalog.cs
public class ProductCatalog(IDistributedCache cache, ShopDb db)
{
    private static readonly DistributedCacheEntryOptions FiveMinutes = new()
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5),
    };

    public async Task<Product?> GetAsync(int id, CancellationToken ct)
    {
        string key = $"product:{id}";
        string? json = await cache.GetStringAsync(key, ct);
        if (json is not null)
            return JsonSerializer.Deserialize<Product>(json);          // hit

        Product? product = await db.Products.FindAsync([id], ct);       // miss
        if (product is not null)
            await cache.SetStringAsync(key, JsonSerializer.Serialize(product), FiveMinutes, ct);
        return product;
    }

    public Task InvalidateAsync(int id, CancellationToken ct) =>
        cache.RemoveAsync($"product:{id}", ct);                        // call after an update
}

@page "/todos"
@rendermode InteractiveServer

<h3>@Title (@items.Count(i => !i.Done) left)</h3>

<input @bind="newTitle" @bind:event="oninput" placeholder="Something to do" />
<button @onclick="Add" disabled="@string.IsNullOrWhiteSpace(newTitle)">Add</button>

<ul>
    @foreach (var item in items)
    {
        <li>
            <input type="checkbox" @bind="item.Done" />
            <span style="@(item.Done ? "text-decoration: line-through" : "")">@item.Title</span>
        </li>
    }
</ul>

@code {
    [Parameter] public string Title { get; set; } = "My list";

    private readonly List<TodoItem> items = new();
    private string newTitle = "";

    private void Add()
    {
        items.Add(new TodoItem { Title = newTitle.Trim() });
        newTitle = "";                  // clears the textbox via @bind
    }

    private class TodoItem
    {
        public required string Title { get; init; }
        public bool Done { get; set; }
    }
}

# ---- build stage ----
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src

# restore first: this layer is cached until a .csproj changes
COPY src/Shop.Api/Shop.Api.csproj src/Shop.Api/
COPY src/Shop.Core/Shop.Core.csproj src/Shop.Core/
RUN dotnet restore src/Shop.Api/Shop.Api.csproj

COPY src/ src/
RUN dotnet publish src/Shop.Api/Shop.Api.csproj -c Release -o /app --no-restore

# ---- runtime stage ----
FROM mcr.microsoft.com/dotnet/aspnet:10.0
WORKDIR /app
COPY --from=build /app .

USER $APP_UID
ENV ASPNETCORE_HTTP_PORTS=8080
EXPOSE 8080
ENTRYPOINT ["dotnet", "Shop.Api.dll"]

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: 10.0.x

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore -c Release

      - name: Test
        run: dotnet test --no-build -c Release --logger trx --results-directory TestResults

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: TestResults