Hi Work Notes

Frp Tunneling: Server and Client Configuration

Sat, 29 Aug 2026 20:00:00 +0800

Frp (fast reverse proxy) is an open-source tunneling tool: a server with a public IP runs frps, machines behind NAT run frpc, and the two keep a persistent connection. Traffic hitting ports on the public server is forwarded through that connection to internal services. Typical use case: exposing a web service or SSH on your home machine to the outside world.

Configuration files use TOML (frps.toml / frpc.toml; the INI format is deprecated since v0.52+).

About the EditorConfig File

Tue, 10 Mar 2026 15:55:34 +0800

EditorConfig helps maintain consistent coding styles for multiple developers working on the same project across various editors and IDEs.

The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable the editors to read the file format and adhere to the defined styles. EditorConfig files are easy to read and work well with version control systems.

https://editorconfig.org

Visual Studio 2019 and later support EditorConfig files, so you can use an EditorConfig file in Visual Studio to define and maintain code style settings.

Adding File Header Comments to the Project

Tue, 10 Mar 2026 15:55:34 +0800

File Header Comments

A file header comment is a comment used to state a file’s copyright and license. It usually includes the copyright notice, license information, author information, and other related details. File header comments are a good practice that helps developers understand the copyright and licensing information of a file.

Copyright Declaration Convention

// Copyright (c) HelloShop Corporation. All rights reserved.
// See the license file in the project root for more information.

namespace HelloShop.AppHost
{
 internal class Class1
 {
 }
}

About the EditorConfig Configuration File

It maintains a consistent coding style across multiple developers working on the same project in different editors and IDEs.

Aggregation OpenApi documentation

Tue, 10 Mar 2026 15:55:34 +0800

Each microservice has its own OpenApi document, but in actual development, we prefer to aggregate the OpenApi documents of all microservices together for easy viewing and debugging. Microservices are all developed based on the Aspire framework, so we can use the service discovery function provided by the Aspire framework to automatically aggregate the OpenApi documents of all microservices.

Automatically configure OpenApi documentation using Aspire Service Discovery

public class OpenApiConfigureOptions() : IConfigureOptions<SwaggerUIOptions>

builder.Services.AddTransient<IConfigureOptions<SwaggerUIOptions>, OpenApiConfigureOptions>();

Customize OpenApi document styles

Create the Custom.css file under the Resource/OpenApi folder.

API Gateway Aggregation

Tue, 10 Mar 2026 15:55:34 +0800

Use a gateway to aggregate multiple individual requests into a single request. This pattern is useful when a client must make multiple calls to different backend systems to perform an operation.

Context and problem

In some cases, a client needs to make multiple requests to multiple backend systems. For example, a client may need to retrieve data from multiple services and then aggregate that data into a single response. In this situation, the client must issue multiple requests, which can lead to performance problems. In addition, the client must also handle multiple responses, which can lead to complexity problems.

Authenticating with JwtBearer Tokens

Tue, 10 Mar 2026 15:55:34 +0800

Introduction

JwtBearer token authentication is a JSON Web Token-based authentication method used to verify a user’s identity. It is a stateless authentication approach well suited to Web APIs and web applications.

Installing the NuGet package

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer

Building your own Identity API endpoints

builder.Services.AddIdentity<User, Role>(options =>
{
 options.SignIn.RequireConfirmedAccount = false;
 options.Password.RequireDigit = false;
 options.Password.RequireLowercase = false;
 options.Password.RequireUppercase = false;
 options.Password.RequireNonAlphanumeric = false;
 options.Password.RequiredLength = 5;
}).AddEntityFrameworkStores<IdentityServiceDbContext>();

Validating tokens with JwtBearer


builder.Services.AddAuthentication(options =>
{
 options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
 options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
 options.DefaultSignInScheme = CustomJwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
 options.TokenValidationParameters.ValidateIssuer = false;
 options.TokenValidationParameters.ValidateAudience = false;
 options.TokenValidationParameters.IssuerSigningKey = new SymmetricSecurityKey(Encoding.Default.GetBytes(issuerSigningKey));

})

A custom authentication handler

public class CustomJwtBearerDefaults

public class CustomJwtBearerOptions

public class CustomJwtBearerHandler

public class CustomJwtBearerExtensions

Configuring token generation

builder.Services.AddAuthentication().AddJwtBearer().AddCustomJwtBearer(options =>
{
 options.IssuerSigningKey = issuerSigningKey;
 options.SecurityAlgorithm = SecurityAlgorithms.HmacSha256;
});

Running the pgAdmin management tool in a container


docker pull dpage/pgadmin4

docker run --name pgadmin -e PGADMIN_DEFAULT_EMAIL=test@test.com -e PGADMIN_DEFAULT_PASSWORD=test -e TZ=Asia/Shanghai -d -p 5050:80 dpage/pgadmin4

Automatic mapping of entities and models

Tue, 10 Mar 2026 15:55:34 +0800

Automatically map entities and models using AutoMapper

AutoMapper is an object mapping tool that can automatically map entity objects and model objects, reducing the workload of manual mapping and improving development efficiency. In addition, Mapster is also a high-performance object mapping tool that supports source generation code and has better performance. AutoMapper is more popular, more mature, more stable, easier to use, more flexible, more powerful, more comprehensive, and more popular than Mapster. AutoMapper is part of the .NET Foundation, an open source project, and a very excellent object mapping tool.

Automatic Migration and Database Seeding

Tue, 10 Mar 2026 15:55:34 +0800

Generating migration scripts

dotnet ef migrations add InitialCreate --output-dir Infrastructure/Migrations

Applying the latest migration to the database manually

dotnet ef database update

Creating the database with code

await dbContext.Database.EnsureCreatedAsync();

EnsureCreatedAsync creates the database if it does not exist and creates all the tables, but it does not apply migration scripts. It is suitable for development environments.

Applying the latest migration to the database with code

await dbContext.Database.MigrateAsync();

MigrateAsync applies migration scripts and creates the database first if it does not exist. It is suitable for production environments.

Automatic Model Validation

Tue, 10 Mar 2026 15:55:34 +0800

Model validation is an important feature in ASP.NET Core MVC that helps us verify that the data entered by users matches expectations.

Validation with data annotations

See the Microsoft data annotations documentation.

public class User
{
 [Required]
 [StringLength(32)]
 public string Name { get; set; }

 [Required]
 [EmailAddress]
 public string Email { get; set; }
}

Validation with fluent chaining

FluentValidation is a .NET library for building type-safe validation rules. Its design goal is to provide a simple, clear API while still supporting complex validation rules.

Best Practices for Resource-Based Authorization

Tue, 10 Mar 2026 15:55:34 +0800

Providing a Permission Check Endpoint in the Identity Service

[HttpHead]
public async Task<IActionResult> CheckPermission(string permissionName, string? resourceType = null, string? resourceId = null
{
 if (await permissionChecker.IsGrantedAsync(permissionName, resourceType, resourceId))
 {
 return Ok();
 }

 return Forbid();
}

Remote Permission Checker

Dictionary<string, string?> parameters = new()
{
 [nameof(name)] = name,
 [nameof(resourceType)] = resourceType,
 [nameof(resourceId)] = resourceId
};

string queryString = QueryHelpers.AddQueryString(string.Empty, parameters);

HttpRequestMessage request = new(HttpMethod.Head, queryString);

using HttpResponseMessage response = await httpClient.SendAsync(request);

return response.IsSuccessStatusCode;

Reimplementing the Permission Handler

public class PermissionRequirementHandler(IPermissionChecker permissionChecker) : AuthorizationHandler<OperationAuthorizationRequirement>
{
 protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement)
 {
 if (context.Resource is IAuthorizationResource resource)
 {
 if (await permissionChecker.IsGrantedAsync(context.User, requirement.Name, resource.ResourceType, resource.ResourceId))
 {
 context.Succeed(requirement);
 }
 else
 {
 context.Fail();
 }

 return;
 }

 if (await permissionChecker.IsGrantedAsync(context.User, requirement.Name))
 {
 context.Succeed(requirement);
 return;
 }

 context.Fail();
 }
}

Invalidating the Cache for Testing

await distributedCache.SetObjectAsync(cacheKey, new PermissionGrantCacheItem(isGranted), new DistributedCacheEntryOptions
{
 AbsoluteExpiration = DateTimeOffset.Now
});

Readability Refactoring

Regenerate the demo data and rename Name in authorization to PermissionName, which is more readable.

Blazor Form Validation

Tue, 10 Mar 2026 15:55:34 +0800

Validation with DataAnnotations

public class Employee
{
 [Required(ErrorMessage = "Name is required")]
 public string Name { get; set; }
}

@page "/employee"
@using System.ComponentModel.DataAnnotations
@using Microsoft.AspNetCore.Components.Forms

<h3>Employee Form</h3>

<EditForm Model="@employee" OnValidSubmit="@HandleValidSubmit">
 <DataAnnotationsValidator />
 <ValidationSummary />

 <div class="form-group">
 <label for="Name">Name</label>
 <InputText id="Name" @bind-Value="employee.Name" class="form-control" />
 <ValidationMessage For="@(() => employee.Name)" />
 </div>

 <button type="submit" class="btn btn-primary">Submit</button>
</EditForm>

@code {
 private Employee employee = new Employee();
}

Validation with FluentValidation

dotnet add package Blazored.FluentValidation

public class EmployeeValidator : AbstractValidator<Employee>
{
 public EmployeeValidator()
 {
 RuleFor(x => x.Name).NotEmpty().WithMessage("Name is required");
 }
}

@page "/employee"
@using FluentValidation
@using FluentValidation.Results

<h3>Employee Form</h3>

<EditForm Model="@employee" OnValidSubmit="@HandleValidSubmit">
 <FluentValidationValidator DisableAssemblyScanning="@true" />
 <ValidationSummary />

 <div class="form-group">
 <label for="Name">Name</label>
 <InputText id="Name" @bind-Value="employee.Name" class="form-control" />
 <ValidationMessage For="@(() => employee.Name)" />
 </div>

 <button type="submit" class="btn btn-primary">Submit</button>
</EditForm>

Custom Validation

Blazor Globalization and Localization

Tue, 10 Mar 2026 15:55:34 +0800

Blazor applications can support multiple languages and cultures by using the globalization and localization features of .NET Core. This article describes how to implement globalization and localization in a Blazor application.

Blazor WebAssembly

<PropertyGroup>
 <BlazorWebAssemblyLoadAllGlobalizationData>true</BlazorWebAssemblyLoadAllGlobalizationData>
</PropertyGroup>

dotnet add package Microsoft.Extensions.Localization

Blazor Server

builder.Services.AddCustomLocalization();

app.UseCustomLocalization();

Blazor JavaScript Interoperability

Tue, 10 Mar 2026 15:55:34 +0800

About JavaScript Location

Load a script in the `<head>` tag

<head>
 <script src="js/first.js"></script>
 <script>
 window.jsMethod = (methodParameter) => {
 ...
 };
 </script>
</head>

Load a script in the `<body>` tag

<body>
 <script src="js/first.js"></script>
 <script>
 window.jsMethod = (methodParameter) => {
 ...
 };
 </script>
</body>

Colocate with the component

Component: CountComponent.razor
Component: CountComponent.razor.cs
Style: CountComponent.razor.css
Script: CountComponent.razor.js

Call JS from .NET

Create an app.js file under wwwroot

function helloWorld() {
 alert('Hello World');
}

function add(a, b) {
 return a + b;
}

Include the JS file in App.razor

Script inclusion in the current web project

Coding with GitHub Copilot

Tue, 10 Mar 2026 15:55:34 +0800

What is GitHub Copilot?

GitHub Copilot is an AI-powered coding assistant developed by GitHub and OpenAI. It can generate code snippets based on context, helping developers write code faster.

How to use GitHub Copilot

GitHub Copilot can be used as an extension in Visual Studio Code and Visual Studio. After installation, suggestions are available while you write code.

Is GitHub Copilot paid?

GitHub Copilot is a paid product. During its early preview period, it was available for free for a limited time.

Configuring Distributed Events with Dapr Pub/Sub

Tue, 10 Mar 2026 15:55:34 +0800

Dapr Technical Architecture

https://docs.dapr.io/concepts/overview

Installing the Dapr CLI Scaffolding Tool

https://docs.dapr.io/zh-hans/getting-started/install-dapr-cli

Initializing the Dapr Runtime with Containers

https://docs.dapr.io/zh-hans/getting-started/install-dapr-selfhost

dapr init

Initializing the Dapr Runtime Offline Without Containers

dapr init -s

Initializing the Dapr Runtime from an Offline Bundle

https://docs.dapr.io/zh-hans/operations/hosting/self-hosted/self-hosted-airgap/

dapr init --from-dir C:\daprbundle

Opening the Default Initialization Directory

explorer "$env:USERPROFILE\.dapr"
explorer "%USERPROFILE%\.dapr"

Viewing Dapr Runtime Status with the Dashboard

dapr dashboard

Configuring Distributed Events with Pub/Sub

/components/redis-pubsub.yaml

Redis-Based Pub/Sub Configuration

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
 name: pubsub
spec:
 type: pubsub.redis
 version: v1
 metadata:
 - name: redisHost
 value: localhost:6379
 - name: redisPassword
 value: ""

RabbitMQ-Based Pub/Sub Configuration

/components/rabbitmq-pubsub.yaml

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
 name: pubsub
spec:
 type: pubsub.rabbitmq
 version: v1
 metadata:
 - name: host
 value: "amqp://guest:guestpwd@localhost:5672"
 - name: durable
 value: "false"
 - name: deletedWhenUnused
 value: "false"
 - name: autoAck
 value: "false"
 - name: reconnectWait
 value: "0"
 - name: concurrency
 value: parallel

Starting the Sidecar and Application with the Dapr Command

dapr run --app-id myapp --dapr-http-port 3500 --dapr-grpc-port 50001 --app-port 5000 --log-level debug --config ./configuration/config.yaml --components-path ./components dotnet run

Starting the Sidecar and Application with Aspire

dotnet add package Aspire.Hosting.Dapr

var pubsub = builder.AddDaprPubSub("pubsub", new DaprComponentOptions { LocalPath = "./DaprComponents/" });

var productService = builder.AddProject<Projects.HelloWorld_ProductService>("productservice")
 .WithReference(identityService)
 .WithDaprSidecar()
 .WithReference(pubsub);

RabbitMQ Pub/Sub Configuration

var username = builder.AddParameter("username", secret: true);
var password = builder.AddParameter("password", secret: true);

var messaging = builder.AddRabbitMQ("messaging", username, password);

// Service consumption
builder.AddProject<Projects.ExampleProject>()
 .WithReference(messaging);

Copyright

Tue, 10 Mar 2026 15:55:34 +0800

Copyright

Generally the copyright notice for a project in the .NET Foundation is given as “Copyright (c) .NET Foundation and Contributors. All Rights Reserved”. The copyright notice should be placed in the LICENSE for the project so the beginning of the LICENSE for an MIT Licensed project would be:

The MIT License (MIT)
Copyright (c) .NET Foundation and Contributors
All Rights Reserved
Permission is hereby granted...

And an Apache 2.0 Licensed project would begin

Creating Code Repositories

Tue, 10 Mar 2026 15:55:34 +0800

Warehouse naming convention

Create a code repository named HelloShop on Github. Regarding the naming convention of the code repository, use the SnakeCaseLower nomenclature.

Naming policy	Original	Converted
PascalCase	HelloShop	HelloShop
CamelCase	HelloShop	helloShop
SnakeCaseLower	HelloShop	hello_shop
SnakeCaseUpper	HelloShop	HELLO_SHOP
KebabCaseLower	HelloShop	hello-shop
KebabCaseUpper	HelloShop	HELLO-SHOP

Warehouse folder structure

Create a folder named src in the repository to store the source code.

Documentation

Create a file named README.md in the warehouse to store the warehouse documentation. Of course, each folder should have a documentation if possible.

Creating Dynamic Flowcharts and Architecture Diagrams

Tue, 10 Mar 2026 15:55:34 +0800

Microsoft Visio

Visio is Microsoft’s diagramming tool. It is very powerful, but it is paid, and it only runs on Windows, with no support for Mac or Linux. Although Microsoft has released Visio Online, its features are still fairly limited, and it is also paid.

The Open-Source Drawio Tool

Drawio is an open-source diagramming tool. It supports both online and desktop use, multiple formats, multiple platforms, multiple languages, many kinds of shapes, many export formats, many plugins, and many integration options. It also supports diagramming in Visual Studio Code via a plugin.

Database Object Naming Conventions

Tue, 10 Mar 2026 15:55:34 +0800

Different database objects follow different naming conventions. To accommodate different databases, EF Core provides several naming convention configuration options.

Common Naming Styles

Naming policy	Original	Converted
PascalCase	HelloShop	HelloShop
CamelCase	HelloShop	helloShop
SnakeCaseLower	HelloShop	hello_shop
SnakeCaseUpper	HelloShop	HELLO_SHOP
KebabCaseLower	HelloShop	hello-shop
KebabCaseUpper	HelloShop	HELLO-SHOP

You can use the Humanizr library to convert strings between different naming styles.

Singular or Plural Table Names

By default, EF Core uses the singular form for table names. You can use a convention-based configurator or manually specify plural table names. The community debate over singular versus plural table names has always existed and there is no unified standard, but Zero recommends the singular form.

Designing Permission Definitions and Permission Providers

Tue, 10 Mar 2026 15:55:34 +0800

Permission Definitions

Each microservice is autonomous, and permission definitions are also the responsibility of each microservice. They each define their own permissions. The permission manager will automatically merge permission definitions. The permission definition context is a collection of permission definitions within the microservice and global permission definitions. The permission provider will provide permission data based on the permission definition context. Permission grouping is to facilitate the management of permission definitions. Permission grouping is part of the permission definition. The permission provider is automatically injected into the container to provide permission query endpoints.

Developing Blazor Hybrid Apps

Tue, 10 Mar 2026 15:55:34 +0800

Component-Based Development

Component-based development allows developers to encapsulate UI components as independent Blazor components and reuse them across applications. This approach improves the maintainability and reusability of the code, similar to modern front-end frameworks such as React and Vue.

Component = HTML + CSS + JS

Blazor component = Razor + CSS + C#

Introduction to MAUI

MAUI is the cross-platform UI framework introduced in .NET 6, which allows developers to create native applications using C# and XAML. It is the evolution of Xamarin.Forms and supports Android, iOS, macOS, and Windows.

Gateway and Service Discovery

Tue, 10 Mar 2026 15:55:34 +0800

Building and Designing an API Gateway

An API gateway is a server that acts as an intermediary between clients and backend services. It receives requests from clients and forwards them to the backend services. An API gateway can also perform other tasks, such as authentication, monitoring, load balancing, caching, request analysis, and logging.

The BFF Pattern for Aggregating Multiple Services

An API gateway can aggregate multiple services based on the BFF (Backend for Frontend) pattern. When a client requests data, the API gateway can call multiple services to fetch the data and then aggregate it into a single response returned to the client, reducing the number of round trips between the client and backend services and thereby improving performance.

Generating API Documentation with the OpenAPI Specification

Tue, 10 Mar 2026 15:55:34 +0800

Swagger is a language-agnostic specification for describing REST APIs. It lets computers and users understand what a REST API does without directly accessing the source code. The Swagger project was donated to the OpenAPI Initiative, and since then it has been known as the OpenAPI Specification.

Swashbuckle is an open-source project for .NET Core. It is a collection of OpenAPI tools used to generate OpenAPI specification documents. It can generate API documentation automatically, including API descriptions, request and response formats, parameter descriptions, and more.

Getting the Time with TimeProvider

Tue, 10 Mar 2026 15:55:34 +0800

Getting the Time the Traditional Way

We usually use DateTime.Now and DateTimeOffset.Now to get the current time, but code written this way is hard to test: the time depends on the system clock, which is difficult to control and reproduce — the only way to change it is to change the system time.

var now1 = DateTime.Now;
var nowUtc1 = DateTime.UtcNow;

var now2 = DateTimeOffset.Now;
var nowUtc2 = DateTimeOffset.UtcNow;

The New TimeProvider Type

To solve the problems above, .NET 8 introduced the TimeProvider type, which can be used to get the time and makes it easy to control the time in tests.

Globalization and Localization

Tue, 10 Mar 2026 15:55:34 +0800

Globalization means a web application can adapt to different cultures and regions without code changes. Localization means a web application can display different content based on the user’s culture and region. Globalization and localization are two different concepts, but they are often used together.

There are many ways to implement multiple languages: resource files, databases, configuration files, and so on. This article focuses on the resource file approach, which is also what Microsoft officially recommends. Other options such as PO files and JSON files can also achieve multilingual support, but they are less convenient than resource files.

How to use Git version control gracefully

Tue, 10 Mar 2026 15:55:34 +0800

Introduction to Git

Git is an open source distributed version control system for agile and efficient handling of any project, small or large.

Clone repository

Clone the remote repository locally, make modifications locally, and commit to the remote repository.

Create repository

Create a repository locally and push the local repository to the remote repository. Regarding the use of naming conventions for code repositories, use the KebabCaseLower nomenclature.

Naming policy	Original	Converted
PascalCase	HelloShop	HelloShop
CamelCase	HelloShop	helloShop
SnakeCaseLower	HelloShop	hello_shop
SnakeCaseUpper	HelloShop	HELLO_SHOP
KebabCaseLower	HelloShop	hello-shop
KebabCaseUpper	HelloShop	HELLO-SHOP

Local warehouse settings

Git settings include global settings and repository settings, and multiple remote repositories can be set up.

Identity System and Identity API Endpoints

Tue, 10 Mar 2026 15:55:34 +0800

ASP.NET Core Identity architecture

ASP.NET Core Identity is a mature identity system that provides user management, role management, claim management, password management, sign-in management, external login management, two-factor authentication, email confirmation, phone number confirmation, security token management, user lockout, user unlock, user sign-out, user deletion, user recovery, and more.

Identity architecture explained

Entity type	Description
`User`	Represents a user.
`Role`	Represents a role.
`UserClaim`	Represents a claim that a user possesses.
`UserToken`	Represents an authentication token for a user.
`UserLogin`	Associates a user with a login.
`RoleClaim`	Represents a claim granted to all users within a role.
`UserRole`	A join entity that links users and roles.

Storing Identity data with EF Core

Defining entity types

public class User : IdentityUser<int>
{
 public DateTimeOffset CreationTime { get; set; } = DateTimeOffset.UtcNow;
}

public class Role : IdentityRole<int>
{
 public DateTimeOffset CreationTime { get; set; } = DateTimeOffset.UtcNow;
}

Configuring entity types

public class UserEntityTypeConfiguration : IEntityTypeConfiguration<User>
{
 public void Configure(EntityTypeBuilder<User> builder)
 {
 builder.ToTable("Users");
 builder.HasKey(x => x.Id);
 builder.Property(x => x.CreationTime);
 }
}

Reusing the Identity database context

dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore

public class IdentityServiceDbContext(DbContextOptions<IdentityServiceDbContext> options) : IdentityDbContext<User, Role, int>(options)
{
 protected override void OnModelCreating(ModelBuilder builder)
 {
 base.OnModelCreating(builder);
 builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
 AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
 AppContext.SetSwitch("Npgsql.DisableDateTimeInfinityConversions", true);
 }
}

Using the Identity API endpoints

builder.Services.AddIdentityApiEndpoints<User>(options => {
 options.Password.RequireDigit = false;
 options.Password.RequireLowercase = false;
 options.Password.RequireUppercase = false;
 options.Password.RequireNonAlphanumeric = false;
 options.Password.RequiredLength = 5;
 options.SignIn.RequireConfirmedAccount = false;
}).AddEntityFrameworkStores<IdentityServiceDbContext>();

app.MapGroup("identity").MapIdentityApi<User>();

Working with Identity data

Services such as UserManager, RoleManager, SignInManager, and PasswordValidator can all be used to work with Identity data. Unless there is a special case, it is not recommended to manipulate Identity data directly with a DbContext.

Implementing a Distributed Event Bus with Dapr

Tue, 10 Mar 2026 15:55:34 +0800

Abstracting the Distributed Bus

Using design patterns, the way a distributed bus is used is abstracted, defining the basic capabilities of the bus.

Event Bus-Based Components

The distributed event bus is implemented in a componentized way, encapsulating the implementation details of the bus inside components.

RabbitMQ-based implementation: https://github.com/dotnet/eShop/tree/main/src/EventBusRabbitMQ

The Dapr Implementation of the Event Bus

Dapr is an open-source distributed application runtime. Its publish and subscribe module enables microservices to communicate with each other using event-driven architecture messaging. Dapr provides an implementation of the event bus: publish events via Dapr, expose Dapr subscription endpoints, and route messages to different event handlers.

Implementing the Basket Service with gRPC

Tue, 10 Mar 2026 15:55:34 +0800

What Is the gRPC Communication Framework

gRPC is a high-performance, open source, general-purpose RPC framework developed by Google. It is based on HTTP/2 and supports multiple languages (such as Go, Java, Python, C++, Node.js, Ruby, C#, Objective-C, PHP, and Dart).

gRPC uses Protocol Buffers as its interface definition language (IDL). Protocol Buffers is a lightweight and efficient structured data serialization method, similar to XML or JSON, but smaller, faster, and simpler.

Implementing the Ordering Service with the CQRS Pattern

Tue, 10 Mar 2026 15:55:34 +0800

CQRS is short for Command Query Responsibility Segregation. It is a pattern that separates read operations from update operations: queries return results without changing system state and have no side effects, while commands change system state. Idempotency means that executing the same command multiple times produces the same result with no side effects.

Why Use the CQRS Pattern

In traditional architectures, the same data model is used to query and update the database. This is simple and works well for basic CRUD operations.

Implementing the Permission Access Control List

Tue, 10 Mar 2026 15:55:34 +0800

Three Elements of Authorization

Subject, resource, and operation. For example: a user (subject) reading and writing (operations) a file (resource). The relationship among subject, resource, and operation is called an authorization relation. Based on this relationship, we can abstract it into a triple (subject, resource, operation), and this triple is the basic unit of authorization.

Role-Based Access Control

Role-Based Access Control (RBAC) is an access control model that manages users’ access to resources through roles. A role is a collection of permissions, and users acquire the corresponding permissions by being assigned roles. The role-based access control model is simple and easy to use. There are other access control models as well, such as Attribute-Based Access Control (ABAC).

Implementing the Product Management Microservice

Tue, 10 Mar 2026 15:55:34 +0800

Creating Entities

HelloWorld.ProductService.Entities.Products

Product & CatalogBrand

Using PostgreSQL with EF Core

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

Creating the DbContext

namespace HelloWorld.ProductService.EntityFrameworks
{
 public class ProductServiceDbContext(DbContextOptions<ProductServiceDbContext> options) : DbContext(options)
 {
 protected override void OnModelCreating(ModelBuilder builder)
 {
 base.OnModelCreating(builder);

 builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
 }
 }
}

Creating Entity Configuration Classes

namespace HelloWorld.ProductService.EntityFrameworks.EntityConfigurations.Products
{
 public class ProductEntityTypeConfiguration : IEntityTypeConfiguration<Product>
 {
 public void Configure(EntityTypeBuilder<Product> builder)
 {
 builder.ToTable("Products");

 builder.Property(x => x.Name).HasMaxLength(32);

 builder.HasOne(x => x.Brand).WithMany();
 }
 }
}

Database Connection String

{
 "ConnectionStrings": {
 "ProductDatabase": "Host=localhost;Port=5432;Database=ProductService;Username=postgres;Password=postgres"
 }
}

Registering the DbContext

builder.Services.AddDbContext<ProductServiceDbContext>(options =>
{
 options.UseNpgsql(builder.Configuration.GetConnectionString(DbConstants.ConnectionStringName));
});

Migrating the Database

dotnet tool install --global dotnet-ef
dotnet add package Microsoft.EntityFrameworkCore.Design

dotnet ef migrations add InitialCreate --output-dir EntityFrameworks/Migrations
dotnet ef database update

Creating Models

namespace HelloWorld.ProductService.Models.Products
{
 public class ProductCreateRequest
 {
 public required string Name { get; init; }

 public string? Description { get; init; }

 public decimal Price { get; init; }

 public int BrandId { get; init; }

 public string? ImageUrl { get; init; }
 }
}

Creating Automatic Mappings

namespace HelloWorld.ProductService.AutoMapper
{
 public class ProductsMapConfiguration : Profile
 {
 public ProductsMapConfiguration()
 {
 CreateMap<ProductCreateRequest, Product>();
 CreateMap<ProductUpdateRequest, Product>();
 CreateMap<Product, ProductListItem>().AfterMap((src, dest) => dest.BrandName = src.Brand.Name);
 CreateMap<Product, ProductDetailsResponse>();

 CreateMap<BrandCreateRequest, Brand>();
 CreateMap<BrandUpdateRequest, Brand>();
 CreateMap<Brand, BrandDetailsResponse>();
 CreateMap<Brand, BrandListItem>();
 }
 }
}

Creating Validators

namespace HelloWorld.ProductService.Validations.Products
{
 public class BrandUpdateRequestValidator : AbstractValidator<BrandUpdateRequest>
 {
 public BrandUpdateRequestValidator()
 {
 RuleFor(x => x.Id).GreaterThan(0);
 RuleFor(x => x.Name).NotNull().NotEmpty().Length(8, 32);
 }
 }
}

Creating Controllers


namespace HelloWorld.ProductService.Controllers
{
 [Route("api/[controller]")]
 [ApiController]
 public class ProductsController : ControllerBase
}

Defining Permissions

namespace HelloWorld.ProductService.PermissionProviders
{
 public static class CatalogPermissions

 public class CatalogPermissionDefiitionProvider : IPermissionDefinitionProvider
}

Localizing Permissions

CatalogPermissionDefinitionProvider.en-US.resx
CatalogPermissionDefinitionProvider.zh-CN.resx

Localizing Entity Properties

namespace HelloWorld.ProductService.Entities.Products
{
 public class Product
 {
 [Display(Name = "ProductName")]
 public string Name { get; set; }
 }
}

Repetitive Work

Repetitive work can be reduced with code generation tools, such as Visual Studio plugins, T4 templates, Roslyn, and so on.

Implementing the Query Pattern in CQRS

Tue, 10 Mar 2026 15:55:34 +0800

CQRS stands for Command Query Responsibility Segregation. In the CQRS pattern, commands and queries are implemented separately: commands handle write operations while queries handle read operations. This better fulfills the single responsibility principle and also enables better performance optimization.

https://learn.microsoft.com/zh-cn/azure/architecture/patterns/cqrs

https://www.xcode.me/Training/UnitNote/576

Defining the Order Query Interface

public interface IOrderQueries
{
 Task<OrderDetails> GetOrderAsync(int id);
}

Implementing the Order Query Interface

public class OrderQueries : IOrderQueries
{
 private readonly OrderingContext _context;

 public OrderQueries(OrderingContext context)
 {
 _context = context;
 dbContext.Database.SetConnectionString("db2_connection_string");
 }

 public async Task<OrderDetails> GetOrderAsync(int id)
 {
 // do something
 }
}

Registering the Order Query Interface

services.AddScoped<IOrderQueries, OrderQueries>();

Using the Order Query Interface

public class OrderController : ControllerBase
{
 private readonly IOrderQueries _orderQueries;

 public OrderController(IOrderQueries orderQueries)
 {
 _orderQueries = orderQueries;
 }

 [HttpGet("{id}")]
 public async Task<IActionResult> GetOrderAsync(int id)
 {
 var order = await _orderQueries.GetOrderAsync(id);
 return Ok(order);
 }
}

Improving System Performance with Caching

Tue, 10 Mar 2026 15:55:34 +0800

Caching is a common technique aimed at improving the performance and scalability of a system. To cache data, frequently accessed data is temporarily copied into fast storage located close to the application. If this fast data store is closer to the application than the original source, caching can dramatically improve the response time of client applications by serving data more quickly.

Cache Types

Private In-Memory Cache

A private cache means the caching service runs on the same server as the application; it is part of the application, usually a library or module. A private cache is typically an in-memory cache, such as MemoryCache or ConcurrentDictionary. It is a lightweight cache suitable for small applications. The advantage of a private cache is that it is simple and easy to use; the drawback is that data cannot be shared across servers, making it unsuitable for large applications. The IMemoryCache interface can be used to work with a private cache in .NET.

Injecting Time with the TimeProvider Class

Tue, 10 Mar 2026 15:55:34 +0800

System.TimeProvider is an abstraction of time that provides a point in time as a DateTimeOffset value. By using TimeProvider, you can make sure your code is testable and predictable. TimeProvider was introduced in .NET 8.

Default Implementation

By default, TimeProvider uses DateTimeOffset.UtcNow as its time source.

Console.WriteLine($"Local: {TimeProvider.System.GetLocalNow()}");
Console.WriteLine($"Utc: {TimeProvider.System.GetUtcNow()}");

Custom Implementation

public class CustomTimeProvider: TimeProvider
{
 public override DateTimeOffset GetUtcNow() => DateTimeOffset.UtcNow.AddHours(1);
}

builder.Services.AddSingleton(TimeProvider.System);
builder.Services.AddSingleton<TimeProvider, CustomTimeProvider>();

public class MyService
{
 private readonly TimeProvider _timeProvider;

 public MyService(TimeProvider timeProvider)
 {
 _timeProvider = timeProvider;
 }

 public void DoSomething()
 {
 var now = _timeProvider.Now;
 Console.WriteLine(now);
 }
}

FakeTimeProvider Implementation

dotnet add package Microsoft.Extensions.TimeProvider.Testing

FakeTimeProvider fakeTimeProvider = new();
fakeTimeProvider.SetUtcNow(fakeTimeProvider.GetUtcNow().AddHours(1));

MyService service = new (timeProvider);
service.DoSomething();

Integrating PostgreSQL database in Aspire

Tue, 10 Mar 2026 15:55:34 +0800

Add the PostgreSQL database to the Host project

dotnet add package Aspire.Hosting.PostgreSQL

var builder = DistributedApplication.CreateBuilder(args);

var postgres = builder.AddPostgres("postgres");
var postgresdb = postgres.AddDatabase("postgresdb");

var exampleProject = builder.AddProject<Projects.ExampleProject>().WithReference(postgresdb);

Add PostgreSQL pgAdmin resource

var postgres = builder.AddPostgres("postgres").WithPgAdmin();

Add PostgreSQL pgWeb resource

var postgres = builder.AddPostgres("postgres").WithPgWeb();

Reference the PostgreSQL database in the final application

dotnet add package Aspire.Npgsql.EntityFrameworkCore.PostgreSQL

builder.AddNpgsqlDbContext<IdentityServiceDbContext>(connectionName: DbConstants.ConnectionStringName, configureDbContextOptions: options =>
{
 new NpgsqlDbContextOptionsBuilder(options).MigrationsHistoryTable(DbConstants.MigrationsHistoryTableName);
});

Learn and Use PostgreSQL

Tue, 10 Mar 2026 15:55:34 +0800

Why is PostgreSQL considered an advanced relational database?

Powerful features: PostgreSQL supports advanced capabilities such as complex queries, triggers, and MVCC.
Strong consistency: Its concurrency model helps keep data consistent under high load.
Great scalability: It supports both vertical and horizontal growth scenarios.
Security: It provides access control and encryption options.
Backup and recovery: It includes robust backup and recovery mechanisms.
Free and open source: You can use, modify, and distribute it freely.

Install PostgreSQL and pgAdmin

There are multiple installation options. A simple setup is to install PostgreSQL with pgAdmin, then use pgAdmin for management and remote connections.

Load Testing and Stress Testing

Tue, 10 Mar 2026 15:55:34 +0800

Load testing

Test whether the app can handle a specified user load under specific conditions while still meeting the response goals. The app runs in a normal state.

Stress testing

Test the app’s stability when running under extreme conditions, usually for a long period. The test places high user load on the app (spike or gradually increasing load) or restricts the app’s compute resources. Stress testing determines whether the app under stress can recover from failure and correctly return to the expected behavior. Under stress, the app runs under unusually high pressure.

Managing Databases with Azure Data Studio

Tue, 10 Mar 2026 15:55:34 +0800

Azure Data Studio is a lightweight, cross-platform database tool with a modern user interface that helps users manage databases more easily.

Fully Open Source

Azure Data Studio is an open source project with all of its code hosted on GitHub. Users are free to view the source code and can also contribute to the project.

https://github.com/Microsoft/azuredatastudio

Manageable Databases

Azure Data Studio supports a variety of databases, including SQL Server, PostgreSQL, MySQL, TimescaleDB, Oracle, and more. By installing the corresponding extensions, it can support even more databases.

Model Binding

Tue, 10 Mar 2026 15:55:34 +0800

Model binding best practices

An entity object is an EF concept; each entity object maps to a table in the database. A model object is an MVC concept; it is the data structure of HTTP requests and responses. HTTP requests carry data through URL parameters, forms, headers, JSON payloads, and so on. This data is ultimately bound into model objects, and after the model is converted to an entity object, it is persisted to the database.

Multi-Tenant Application Design

Tue, 10 Mar 2026 15:55:34 +0800

What Is a Multi-Tenant Application

A multi-tenant application is a software architecture design that allows a single instance of software to serve multiple customers. Each customer is called a tenant; data across tenants is automatically isolated, so one tenant’s data never affects another’s.

Search for “multi-tenancy” on the ZeroDegree Programming website to watch the multi-tenant design video tutorial.

Isolating Tenant Data with a Shared Table and a Discriminator Column

The shared-table multi-tenant design stores data for multiple tenants in a single table, distinguishing each tenant’s rows with an added TenantId column.

Orchestration with the Aspire App Host

Tue, 10 Mar 2026 15:55:34 +0800

Adding Application Components via Add Methods

Using methods such as AddProject, AddContainer, AddExecutable, AddParameter, and AddConnectionString, you can orchestrate the app host into a complete application.

Configuring Explicit Resource Startup

builder.AddProject<Projects.MyApp>("dbmigration").WithExplicitStart();

Using the WithExplicitStart method, you can configure explicit resource startup; resources configured for explicit startup need to be started manually.

Referencing Resources with the WithReference Method

builder.AddProject<Projects.MyApp>("myapp").WithReference(postgresdb);

The referenced resource can be an endpoint, a connection string, or another resource. The referenced resource is passed to the referencing resource via environment variables.

Ordering Microservice Architecture Overview

Tue, 10 Mar 2026 15:55:34 +0800

The ordering part covers many technical topics, including the CQRS pattern, MediatR for local command dispatch, local event handling, abstraction and implementation of distributed events, the outbox pattern, distributed locks, and more.

Ordering Service Architecture Diagram

Microservice Communication

Client Side

The client side mainly covers order creation, payment, cancellation, and querying. The client calls the ordering microservice through the API Gateway; the ordering microservice processes commands via MediatR, then publishes events through the event bus; the event bus dispatches the events to event handlers, which process them and then persist the events to the database.

Overview of New Features in .NET 10

Tue, 10 Mar 2026 15:55:34 +0800

Library Improvements

Numeric Ordering for String Comparison

In .NET 10, the System.String class adds a CompareAsNumbers method for comparing strings as numbers. This is very useful for sorting strings that contain numbers, such as file names or version numbers.

StringComparer numericStringComparer = StringComparer.Create(CultureInfo.CurrentCulture, CompareOptions.NumericOrdering);

Console.WriteLine(numericStringComparer.Equals("02", "2"));
// Output: True

foreach (string os in new[] { "Windows 8", "Windows 10", "Windows 11" }.Order(numericStringComparer))
{
 Console.WriteLine(os);
}

// Output:
// Windows 8
// Windows 10
// Windows 11

HashSet<string> set = new HashSet<string>(numericStringComparer) { "007" };
Console.WriteLine(set.Contains("7"));
// Output: True

UTF-8 Support for Hexadecimal String Conversion

.NET 10 adds UTF-8 support for hexadecimal string conversion operations in the Convert class. These new methods provide an efficient way to convert between UTF-8 byte sequences and hexadecimal representations without intermediate string allocations:

Paging, Sorting, and Multi-Condition Queries

Tue, 10 Mar 2026 15:55:34 +0800

Paging Parameters

Requests should use the GET method

http://localhost:8080/api/products?keyword=test&pagenumber=1&pagesize=5&orderby=id desc,price asc

The response is as follows

{
 "totalCount": 100,
 "items": [
 {
 "id": 1,
 "name": "test",
 "price": 100
 },
 {
 "id": 2,
 "name": "test",
 "price": 200
 }
 ]
}

Paged Request Model

public class PagedAndSortedRequest : PagedRequest
{
 public string? OrderBy { get; init; }
}

Paged Response Model

public class PagedResponse<T>(IReadOnlyList<T> items, int totalCount)
{
 public IReadOnlyList<T> Items { get; init; } = items;

 public int TotalCount { get; init; } = totalCount;
}

Extending IQueryable to Sort by Property Name

QueryableOrderByExtensions.cs

Convert a string condition into a sort expression

IOrderedQueryable<TSource> OrderBy(IQueryable<TSource> source, string propertyName)

Extending IQueryable for Searching and Sorting

QueryableExtensions.cs

Extension methods for paging and sorting

Policy-based and Resource-based Authorization

Tue, 10 Mar 2026 15:55:34 +0800

After authentication, identity data is available in HttpContext.User. However, identity is not equal to permission. Permissions should be evaluated by the authorization system.

Authorization in ASP.NET Core

ASP.NET Core provides a policy-based authorization model. Policies can be defined by role, resource, or custom conditions.

Use `IAuthorizationService`

IAuthorizationService is the core authorization service in ASP.NET Core:

public interface IAuthorizationService
{
 Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, IEnumerable<IAuthorizationRequirement> requirements);
 Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, string policyName);
 Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, AuthorizationPolicy policy);
}

AuthorizationResult contains success/failure information and reasons.

Implement a custom policy provider

You can use OperationAuthorizationRequirement to model permission requirements and inject them into policies.

PostgreSQL High Availability and Read/Write Splitting

Tue, 10 Mar 2026 15:55:34 +0800

Basic Concepts

A single operating system can run multiple PostgreSQL instances, each with its own configuration file, data directory, and port. Each instance can host multiple databases, and each database can contain multiple tables. Docker makes it easy to create multiple PostgreSQL instances.

Installing the Primary and Replica Servers

docker run --name postgres1 -e POSTGRES_PASSWORD=postgres -d -p 5431:5432 -v ${pwd}/postgres1/data:/var/lib/postgresql/data postgres
docker run --name postgres2 -e POSTGRES_PASSWORD=postgres -d -p 5432:5432 -v ${pwd}/postgres2/data:/var/lib/postgresql/data postgres

Logical Replication

Logical replication is a method of replicating data objects and their changes based on a replication identity (usually the primary key). We use the term “logical” in contrast to physical replication. Logical replication uses a publish and subscribe model, in which one or more subscribers subscribe to one or more publications on a publisher node. Subscribers pull data from the publications they subscribe to, and may subsequently re-publish the data to allow cascading replication or more complex configurations.

Provider used to generate initial data

Tue, 10 Mar 2026 15:55:34 +0800

Data seeding is the process of populating a database with a set of initial data. It is usually performed when the database is first created. These data are usually static and will not change over time. Data seeding is usually used to fill in some basic data, such as users, roles, permissions, products, classifications, etc.

Universal interface design

public interface IDataSeedingProvider
{
 Task SeedingAsync(IServiceProvider serviceProvider);
}

Implement specific interface

public class DataSeedingProvider(UserManager<User> userManager) : IDataSeedingProvider
{
 public async Task SeedingAsync(IServiceProvider ServiceProvider)
 {
 var user = await userManager.FindByNameAsync("admin");

 if (user == null)
 {
 await userManager.CreateAsync(new User
 {
 UserName = "admin",
 Email = "admin@test.com"
 }, "admin");
 }
 }
}

Register in the container

builder.Services.AddTransient<IDataSeedingProvider, DataSeedingProvider>();

Automated execution of extensions

public static class DataSeedingExtensions
{
 public static IApplicationBuilder UseDataSeedingProviders(this IApplicationBuilder app)
 {
 using var serviceScope = app.ApplicationServices.CreateScope();

 var dataSeedingProviders = serviceScope.ServiceProvider.GetServices<IDataSeedingProvider>();

 foreach (IDataSeedingProvider dataSeedingProvider in dataSeedingProviders)
 {
 dataSeedingProvider.SeedingAsync(serviceScope.ServiceProvider).Wait();
 }

 return app;
 }
}

Automatic registration implementation

public static class DataSeedingExtensions
{
 public static IServiceCollection AddDataSeedingProviders(this IServiceCollection services, Assembly? assembly = null)
 {
 assembly ??= Assembly.GetCallingAssembly();

 var dataSeedProviders = assembly.ExportedTypes.Where(t => t.IsAssignableTo(typeof(IDataSeedingProvider)) && t.IsClass);

 dataSeedProviders.ToList().ForEach(t => services.AddTransient(typeof(IDataSeedingProvider), t));

 return services;
 }
}

Execution order problem

The execution order of automatically registered providers is uncertain. If you need to determine the execution order, you can design the Order attribute, and then order execution according to the Order attribute in the UseDataSeedingProviders method.

RabbitMQ Management

Tue, 10 Mar 2026 15:55:34 +0800

rabbitmq-plugins enable rabbitmq_management

Default User：guest/guest
Add User：test/test

http://192.168.0.202:15672

http://mqtt.test:15672

rabbitmq-plugins enable rabbitmq_mqtt
rabbitmq-plugins disable rabbitmq_mqtt
rabbitmq-plugins enable rabbitmq_web_mqtt
rabbitmq-plugins disable rabbitmq_web_mqtt
rabbitmq-plugins enable_feature_flag all
rabbitmq-plugins disable_feature_flag all

rabbitmq-plugins enable rabbitmq_auth_backend_http

Modify the rabbitmq.conf configuration file, located at %AppData%\RabbitMQ

auth_backends.1 = http
auth_http.http_method = post
auth_http.user_path = http://some-server/api/RabbitMqAuth/User
auth_http.vhost_path = http://some-server/api/RabbitMqAuth/Vhost
auth_http.resource_path = http://some-server/api/RabbitMqAuth/Resource
auth_http.topic_path = http://some-server/api/RabbitMqAuth/Topic

RabbitMQ server to perform authentication

Readme

Tue, 10 Mar 2026 15:55:34 +0800

Friends, the new generation of the Zero framework officially starts being built today. We are very excited to announce that the new framework is named the HelloShop project. This framework will demonstrate a development architecture built on the new generation of the .NET technology stack. The name HelloShop was chosen because a simple shop application can demonstrate all the technologies of a system. Of course, this shop system could just as well be any other system — as long as you understand the design philosophy of this framework, you can quickly build a system of your own. The following document was generated by AI and may contain some grammatical errors, which we will correct later.

Solving Concurrency Problems with Distributed Locks

Tue, 10 Mar 2026 15:55:34 +0800

Locks in Single-Process Applications

In a single-machine environment, we can use thread locks to solve concurrency problems. In a distributed system, however, thread locks cannot solve concurrency problems, because a thread lock in a distributed system can only lock the current process, not other processes.

In .NET, we can use the lock keyword to implement a thread lock.

https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/statements/lock

private static readonly object _lock = new object();

public void DoSomething()
{
 lock (_lock)
 {
 // Business logic
 }
}

C# 13 introduces a new thread synchronization type, System.Threading.Lock, which simplifies lock usage through scope management, making the code clearer and more reliable.

Starting Distributed Microservices with Aspire

Tue, 10 Mar 2026 15:55:34 +0800

Preparing the Database

docker run --name postgres -e POSTGRES_PASSWORD=postgres -e TZ=Asia/Shanghai -d -p 5432:5432 postgres

docker run --name pgadmin -e PGADMIN_DEFAULT_EMAIL=test@test.com -e PGADMIN_DEFAULT_PASSWORD=test -e TZ=Asia/Shanghai -d -p 5050:80 dpage/pgadmin4

Initializing the Dapr Runtime

dapr init -s --from-dir C:\dapr

Extending the Wait Time for RabbitMQ Startup

public static IResourceBuilder<IDaprSidecarResource> WithReference(this IResourceBuilder<IDaprSidecarResource> builder, IResourceBuilder<IResourceWithConnectionString> resourceBuilder, int waitInSeconds = 10)

Updating MediatR Dependency Injection

Previously, behaviors were registered with the options.AddBehavior method; now they are registered with the options.AddOpenBehavior method.


builder.Services.AddMediatR(options =>
{
 options.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());
 options.AddOpenBehavior(typeof(LoggingBehavior<,>));
 options.AddOpenBehavior(typeof(ValidatorBehavior<,>));
 options.AddOpenBehavior(typeof(TransactionBehavior<,>));
});

Microservices Using Distributed Events Need the HttpContext Injected

builder.Services.AddHttpContextAccessor();

Dropping a Database in Azure Data Studio

-- Terminate all sessions connected to the target database
SELECT pg_terminate_backend(pg_stat_activity.pid)
FROM pg_stat_activity
WHERE pg_stat_activity.datname = 'my_database'
 AND pid <> pg_backend_pid();

-- Drop the database
DROP DATABASE my_database;

Automatically Creating the Database Before IdentityService Demo Data Generation

await serviceProvider.GetRequiredService<IdentityServiceDbContext>().Database.EnsureCreatedAsync(cancellationToken);

Consistently Use DateTimeOffset Instead of DateTime

The advantage of using UTC time is that it can be converted between time zones without losing time information, which helps programs handle time better and benefits the internationalization and localization of cross-time-zone applications.

Storing Data in a PostgreSQL Database

Tue, 10 Mar 2026 15:55:34 +0800

Starting a PostgreSQL Database in Docker

https://www.postgresql.org

docker pull postgres
docker run --name postgres -e POSTGRES_PASSWORD=postgres -e TZ=Asia/Shanghai -d -p 5432:5432 postgres

Connecting to the PostgreSQL Database with PgAdmin

https://www.pgadmin.org

SHOW timezone;

Using the PostgreSQL Database with EF Core

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

Defining the Entity Type

public class User
{
 public int Id { get; set; }
 public string UserName { get; set; }
 public string PasswordHash { get; set; }
 public DateTimeOffset CreationTime { get; set; } = DateTimeOffset.UtcNow;
}

Configuring the Entity Type

public class UserEntityTypeConfiguration : IEntityTypeConfiguration<User>
{
 public void Configure(EntityTypeBuilder<User> builder)
 {
 builder.ToTable("Users");
 builder.HasKey(x => x.Id);
 builder.Property(x => x.UserName).IsRequired().HasMaxLength(50);
 builder.Property(x => x.PasswordHash).IsRequired().HasMaxLength(50);
 builder.Property(x => x.CreationTime);
 }
}

Creating the DbContext

public class IdentityServiceDbContext : DbContext
{
 public IdentityServiceDbContext(DbContextOptions<IdentityServiceDbContext> options) : base(options)
 {
 }

 protected override void OnModelCreating(ModelBuilder builder)
 {
 base.OnModelCreating(builder);

 builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());

 AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
 AppContext.SetSwitch("Npgsql.DisableDateTimeInfinityConversions", true);
 }
}

Database Connection String

{
 "ConnectionStrings": {
 "IdentityDatabase": "Host=localhost;Port=5432;Database=IdentityService;Username=postgres;Password=postgres"
 }
}

Registering the DbContext

builder.Services.AddDbContext<IdentityServiceDbContext>(options =>
{
 options.UseNpgsql(builder.Configuration.GetConnectionString("IdentityDatabase"));
});

Migrating the Database

dotnet tool install --global dotnet-ef
dotnet add package Microsoft.EntityFrameworkCore.Design

dotnet ef migrations add InitialCreate --output-dir EntityFrameworks/Migrations
dotnet ef database update

PostgreSQL Database Naming Conventions

https://github.com/efcore/EFCore.NamingConventions

Testing in the Zero Framework

Tue, 10 Mar 2026 15:55:34 +0800

Automated testing is an excellent way to make sure application code does what its author intends. The Zero Framework provides unit tests, integration tests, and load tests. Testing frameworks on the .NET platform include xUnit, NUnit, and MSTest, with xUnit being the most widely used. Whichever testing framework you use, tests can be run from the command line or from an IDE.

Unit Tests

A unit test is a test that exercises an individual software component or method, also known as the “unit of work.” Unit tests should only test code within the developer’s control; they do not test infrastructure concerns. Infrastructure concerns include interactions with databases, file systems, and network resources. Unit tests in the Zero Framework use the xUnit framework.

Updating from .NET 8.0 to .NET 9.0

Tue, 10 Mar 2026 15:55:34 +0800

Update Visual Studio to the Latest Preview

Download and install the Visual Studio preview, and install the .NET 9.0 SDK.

Update the Project File

Open the project file and change <TargetFramework>net8.0</TargetFramework> to <TargetFramework>net9.0</TargetFramework>.

Update NuGet Packages

Open the NuGet package manager and update all NuGet packages to the latest version.

Update the Aspire and MAUI Workloads

Open the Aspire workload and update all Aspire packages to the latest version.

dotnet workload install aspire android ios maccatalyst maui-android maui-desktop maui-mobile maui-windows

To Add Tab Autocompletion to PowerShell for the .NET CLI

https://learn.microsoft.com/zh-cn/dotnet/core/tools/enable-tab-autocomplete

Upgrade Projects with .NET Upgrade Assistant

Tue, 10 Mar 2026 15:55:34 +0800

What is .NET Upgrade Assistant?

.NET Upgrade Assistant is a tool that helps migrate legacy projects to newer .NET versions. It can help you:

Identify dependencies and API usage.
Recommend an appropriate .NET target framework.
Apply or suggest code changes required for migration.

Use .NET Upgrade Assistant in Visual Studio

You can install the .NET Upgrade Assistant extension in Visual Studio.

Use .NET Upgrade Assistant from the command line

Install the CLI tool:

Upgrading the Zero Framework to Aspire 13.0

Tue, 10 Mar 2026 15:55:34 +0800

Simplified Solution File Format

From sln to slnx: the new slnx format is easier to read and maintain, removes redundant information, and makes the project structure clearer.

dotnet sln migrate

Also update the sln files referenced in slnf files to slnx files.

Upgrading the Target Framework to .NET 10

In the project files, change the target framework from net9.0 to net10.0:

<TargetFramework>net10.0</TargetFramework>

Upgrading Aspire to 13.0.0

In the project files, update the Aspire package version to 13.0.0

Upgrading the Zero Framework to Aspire 9.0

Tue, 10 Mar 2026 15:55:34 +0800

Upgrading the Visual Studio Development Tools

Use Visual Studio Installer to upgrade. After upgrading to v17.12, the .NET 9.0 SDK and the Aspire 9.0 workload are installed automatically.

Non-Visual Studio Development Environments

Install .NET Core SDK 9.0

Install the latest .NET SDK 9.0 release

Check the .NET SDK version:

dotnet --version
dotnet --list-sdks

Upgrade the Aspire Workload

Run the following commands in the project directory:

dotnet workload uninstall aspire
dotnet workload install aspire
dotnet workload list
dotnet workload update

Upgrading the Project Files

Add the new node to the Host project:

User Interfaces and Design Languages

Tue, 10 Mar 2026 15:55:34 +0800

User Experience

User Experience (UX) refers to how users feel when using a product. It is a comprehensive concept that includes users’ perceptions, emotions, attitudes, and moods toward the product. User Experience Design (UXD) is a user-centered design methodology aimed at increasing user satisfaction and improving users’ understanding and use of the product.

Factors such as color, typography, layout, and interaction all affect user experience. Therefore, user experience must be considered when designing user interfaces, providing a clean, intuitive, and easy-to-use interface to improve user satisfaction.

Using .HTTP files in Visual Studio 2022

Tue, 10 Mar 2026 15:55:34 +0800

Comment

Lines starting with # or // are comments and are ignored when Visual Studio sends an HTTP request.

variable

Lines starting with @ define variables using the syntax @VariableName=Value.

@hostname=localhost
@port=44320
GET https://{{hostname}}:{{port}}/weatherforecast

multiple requests

The request format is:

[<HTTP-verb>] <url> [<HTTP-version>]
[<request-headers>]
[<request-body>]

GET https://localhost:7220/weatherforecast

###

GET https://localhost:7220/weatherforecast?date=2023-05-11&location=98006

###

GET https://localhost:7220/weatherforecast HTTP/3

###

Request headers

GET https://localhost:7220/weatherforecast
Date: Wed, 27 Apr 2023 07:28:00 GMT

###

GET https://localhost:7220/weatherforecast
Cache-Control: max-age=604800
Age: 100

###

request body

POST https://localhost:7220/weatherforecast
Content-Type: application/json

{
 "date": "2023-05-11",
 "location": "98006"
}

Create an HTTP file using a template

Right-click the ASP.NET Core project
Add > New Item
ASP.NET Core>General
Select HTTP File, then select Add

Use the Endpoint Explorer

View > Other Windows > Endpoint Resource Management

Using HybridCache hybrid caching library

Tue, 10 Mar 2026 15:55:34 +0800

Hybrid cache can use both memory cache and distributed cache, which can improve cache hit rate and reduce access to distributed cache, thereby improving performance.

When getting data from the cache, it will first get the data from the memory cache, if there is no data in the memory cache, it will get the data from the distributed cache.
When writing data to the cache, it writes data to both the in-memory cache and the distributed cache.


Service 1 ----> HybridCache ----> MemoryCache ----> DistributedCache

https://learn.microsoft.com/zh-cn/azure/architecture/best-practices/caching

What is New in C# 12

Tue, 10 Mar 2026 15:55:34 +0800

Primary constructors

One major feature in C# 12 is primary constructors. A primary constructor is declared on the type declaration instead of inside the class body. Its parameters can be used directly in members.

Record types

public record Address(string FirstName, string LastName);

Class types

public class Person(string firstName, string lastName)
{
 public override string ToString()
 {
 return $"{firstName},{lastName}";
 }
}

public Person(string firstName) : this(firstName, "hello")
{

}

Collection expressions

C# 12 adds collection expressions for concise collection initialization.

// Create an array:
int[] a = [1, 2, 3, 4, 5, 6, 7, 8];

// Create a list:
List<string> b = ["one", "two", "three"];

// Create a span
Span<char> c = ['a', 'b', 'c', 'd', 'e', 'f', 'h', 'i'];

// Create a jagged 2D array:
int[][] twoD = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

// Create a jagged 2D array from variables:
int[] row0 = [1, 2, 3];
int[] row1 = [4, 5, 6];
int[] row2 = [7, 8, 9];
int[][] twoDFromVariables = [row0, row1, row2];

Range and index usage

sequence[0] is the first element. ^n means counting from the end. For any number n, index ^n is equivalent to sequence.Length - n.

Zero Framework upgraded to Aspire 9.3 version

Tue, 10 Mar 2026 15:55:34 +0800

Remove the IsAspireHost property from the Host project

<IsAspireHost>true</IsAspireHost>

Workload upgrade

dotnet workload update

Upgrade Visual Studio to the latest version

Upgrade to the latest version via Visual Studio Installer.

Items can be upgraded using AI

GitHub Copilot App Modernization - Upgrade for .NET is a powerful Visual Studio extension that works with you to upgrade projects to newer versions of .NET, upgrade dependencies, and apply code fixes.

GitHub Copilot application modernization is distributed as a Visual Studio extension and is an interactive upgrade process.

Hi Work Notes

Frp Tunneling: Server and Client Configuration

About the EditorConfig File

Adding File Header Comments to the Project

File Header Comments

Copyright Declaration Convention

About the EditorConfig Configuration File

Aggregation OpenApi documentation

Automatically configure OpenApi documentation using Aspire Service Discovery

Customize OpenApi document styles

API Gateway Aggregation

Context and problem

Authenticating with JwtBearer Tokens

Introduction

Installing the NuGet package

Building your own Identity API endpoints

Validating tokens with JwtBearer

A custom authentication handler

Configuring token generation

Running the pgAdmin management tool in a container

Automatic mapping of entities and models

Automatically map entities and models using AutoMapper

Automatic Migration and Database Seeding

Generating migration scripts

Applying the latest migration to the database manually

Creating the database with code

Applying the latest migration to the database with code

Automatic Model Validation

Validation with data annotations

Validation with fluent chaining

Best Practices for Resource-Based Authorization

Providing a Permission Check Endpoint in the Identity Service

Remote Permission Checker

Reimplementing the Permission Handler

Invalidating the Cache for Testing

Readability Refactoring

Blazor Form Validation

Validation with DataAnnotations

Validation with FluentValidation

Custom Validation

Blazor Globalization and Localization

Blazor WebAssembly

Blazor Server

Blazor JavaScript Interoperability

About JavaScript Location

Load a script in the <head> tag

Load a script in the <body> tag

Colocate with the component

Call JS from .NET

Create an app.js file under wwwroot

Include the JS file in App.razor

Coding with GitHub Copilot

What is GitHub Copilot?

How to use GitHub Copilot

Is GitHub Copilot paid?

Configuring Distributed Events with Dapr Pub/Sub

Dapr Technical Architecture

Installing the Dapr CLI Scaffolding Tool

Initializing the Dapr Runtime with Containers

Initializing the Dapr Runtime Offline Without Containers

Initializing the Dapr Runtime from an Offline Bundle

Opening the Default Initialization Directory

Viewing Dapr Runtime Status with the Dashboard

Configuring Distributed Events with Pub/Sub

Redis-Based Pub/Sub Configuration

RabbitMQ-Based Pub/Sub Configuration

Starting the Sidecar and Application with the Dapr Command

Starting the Sidecar and Application with Aspire

RabbitMQ Pub/Sub Configuration

Copyright

Copyright

Creating Code Repositories

Warehouse naming convention

Warehouse folder structure

Documentation

Creating Dynamic Flowcharts and Architecture Diagrams

Microsoft Visio

The Open-Source Drawio Tool

Database Object Naming Conventions

Common Naming Styles

Load a script in the `<head>` tag

Load a script in the `<body>` tag