Fast.Consul 3.5.2

简体中文 | English

<p align="center"> <img src="Fast.png" width="160" alt="Fast.NET Logo" /> </p>

<h1 align="center">Fast.NET</h1>

<p align="center"> A modular infrastructure SDK for modern .NET applications </p>

<p align="center"> <a href="https://www.nuget.org/packages/Fast.NET.Core"><img src="https://img.shields.io/nuget/v/Fast.NET.Core.svg?label=Fast.NET.Core&logo=nuget" alt="NuGet version" /></a> <a href="https://www.nuget.org/packages/Fast.NET.Core"><img src="https://img.shields.io/nuget/dt/Fast.NET.Core.svg?logo=nuget" alt="NuGet downloads" /></a> <img src="https://img.shields.io/badge/.NET-8.0%20%7C%209.0%20%7C%2010.0-512BD4?logo=dotnet" alt="Supported .NET versions" /> <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="Apache-2.0 License" /></a> </p>

Fast.NET is a set of composable .NET infrastructure libraries covering web application initialization, dependency injection, caching, event handling, logging, object mapping, authentication, data access, serialization, dynamic APIs, unified responses, Swagger/OpenAPI, and Consul integration. Every capability is delivered as an independent NuGet package, so applications reference only the modules they need.

Fast.NET is not an all-or-nothing framework. It is a family of SDK components with a consistent design and configuration experience for ASP.NET Core, Worker Services, and other modern .NET applications supported by each module.

Why Fast.NET

• Modular by design: 17 independent packages keep unrelated dependencies out of your application.
• Supported .NET releases: the primary modules target net8.0, net9.0, and net10.0 together.
• Reusable foundation: Fast.IaaS stays on netstandard2.1 for broad reuse across modern .NET projects.
• Idiomatic integration: consistent extension methods for IServiceCollection, WebApplicationBuilder, and IApplicationBuilder.
• Independent adoption: caching, logging, serialization, data access, and other modules can be used without adopting the entire stack.
• Release ready: deterministic builds, centrally managed dependencies, vulnerability auditing, symbol packages, CI, and an explicitly confirmed publishing script.

Compatibility

netstandard2.1 does not support the classic .NET Framework. Applications that still run on .NET Framework require a separate compatibility assessment.

Quick start

1. Install the modules you need

Fast.NET does not require an umbrella package. Select the NuGet packages needed by your application:

dotnet add package Fast.NET.Core
dotnet add package Fast.Serialization.System.Text.Json
dotnet add package Fast.Swagger

Add Redis caching, JWT authentication, or SqlSugar only when needed:

dotnet add package Fast.Cache
dotnet add package Fast.JwtBearer
dotnet add package Fast.SqlSugar

Fast.Serialization.System.Text.Json and Fast.Serialization.Newtonsoft.Json expose serialization extensions with the same style. Most applications should choose one according to their serialization stack.

2. Register services

The following ASP.NET Core example combines several modules. Keep only the registrations for packages installed by your application.

using Fast.Cache;
using Fast.DependencyInjection;
using Fast.DynamicApplication;
using Fast.EventBus;
using Fast.JwtBearer;
using Fast.Logging;
using Fast.Mapster;
using Fast.NET.Core;
using Fast.OpenApi;
using Fast.Serialization;
using Fast.SqlSugar;
using Fast.Swagger;
using Fast.UnifyResult;

var builder = WebApplication.CreateBuilder(args);

builder.Initialize();
builder.AddCorsAccessor();

builder.Services.AddSerialization();
builder.Services.AddGzipCompression();
builder.Services.AddMapster();
builder.Services.AddDependencyInjection();
builder.Services.AddEventBus();
builder.Services.AddCache();
builder.Services.AddLoggingService(builder.Configuration);
builder.Services.AddSqlSugar(builder.Configuration, builder.Environment);
builder.Services.AddJwtBearer(builder.Configuration);
builder.Services.AddUnifyResult();
builder.Services.AddControllers();
builder.Services.AddDynamicApplication();
builder.Services.AddSwaggerDocuments(builder.Configuration);
builder.Services.AddOpenApi(builder.Configuration);

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.EnableBuffering();
app.UseRouting();
app.UseSwaggerDocuments();
app.MapControllers();

app.Run();

For each module's default configuration section and optional parameters, see its *SettingsOptions types and extension method XML documentation.

Architecture

flowchart TB
    app["ASP.NET Core / Worker / Console applications"]

    subgraph api["Web and API integration"]
        swagger["Fast.Swagger"]
        openapi["Fast.OpenApi"]
        dynamic["Fast.DynamicApplication"]
        unify["Fast.UnifyResult"]
        jwt["Fast.JwtBearer"]
        consul["Fast.Consul"]
    end

    subgraph capability["Infrastructure capabilities"]
        cache["Fast.Cache"]
        eventbus["Fast.EventBus"]
        logging["Fast.Logging"]
        mapster["Fast.Mapster"]
        di["Fast.DependencyInjection"]
        sqlsugar["Fast.SqlSugar"]
        serialization["Fast.Serialization.*"]
    end

    subgraph foundation["Core foundation"]
        core["Fast.NET.Core"]
        runtime["Fast.Runtime"]
        iaas["Fast.IaaS · netstandard2.1"]
    end

    app --> api
    app --> capability
    api --> foundation
    capability --> foundation
    core --> runtime
    swagger --> dynamic
    dynamic --> unify
    consul --> core
    consul --> iaas

This diagram presents the responsibility layers. See the architecture guide for actual project references, startup flow, and extension boundaries.

Package catalog

Repository layout

Fast.NET/
├─ src/                         # 17 independently published SDK modules
├─ docs/                        # Bilingual usage, architecture, and release guides
├─ .github/                     # GitHub CI workflow
├─ translateTool/               # Vue i18n text extraction and update tool
├─ Directory.Build.props        # Shared target, package, and repository metadata
├─ Directory.Packages.props     # Central NuGet dependency versions
├─ global.json                  # .NET SDK selection policy
├─ Fast.NET.sln                 # Main solution
├─ UploadNuget.bat              # Build, pack, and optional publishing entry point
├─ README.zh.md / README.md     # Chinese and English entry points
└─ LICENSE                      # Apache-2.0 license

Local build

Install a .NET SDK compatible with global.json, then run:

dotnet restore Fast.NET.sln
dotnet build Fast.NET.sln -c Release --no-restore

Build and pack all SDK projects on Windows:

UploadNuget.bat pack

Create NuGet packages separately:

dotnet pack Fast.NET.sln -c Release --no-build --no-restore -p:WarnOnPackingNonPackableProject=false

Builds don't implicitly create packages. UploadNuget.bat explicitly restores, builds, and then packs into nupkgs; publishing is an optional final step and always requires an explicit PUBLISH confirmation.

Documentation and collaboration

• Getting started
• Module catalog
• Architecture guide
• Comments and public API documentation
• Release guide
• Contribution guide
• Security policy
• Support policy
• Code of conduct
• Changelog
• Localization tool
• Commit history
• Issue tracker
• Pull requests

Before submitting code, build every affected target framework and keep public Chinese and English documentation synchronized.

License

Fast.NET is released under the Apache License 2.0. Use, modification, and distribution must comply with the license and applicable laws.

Maintainer

Created and maintained by Xiao Fang (1.8K Zai). Issues and pull requests are welcome to help make Fast.NET a reliable and composable infrastructure option for the .NET ecosystem.