CSharp: State Pattern

1. 引言

在珠宝行业数字化业务系统中，订单流转往往涉及采购核验、设计制图、加工生产、物流发货、财务结算、营销推广等多个环节，每个环节的业务逻辑不同，且状态之间存在明确的流转关系。如果使用大量的 if-else 或 switch 分支来管理状态，代码会随着业务复杂度上升而迅速膨胀，难以维护和扩展。同时，业务系统还需要对接人事行政、IT 运维、员工培训等外部异构系统，这些系统的接口签名和内部实现各不相同，直接耦合会导致系统僵化。

本文以 C# .NET 10 为技术栈，结合状态模式（State Pattern）与适配器模式（Adapter Pattern），设计并实现一个珠宝业务系统。状态模式负责订单全流程的状态流转，适配器模式负责统一封装外部异构系统的调用。通过两个模式的组合，实现高内聚、低耦合、易扩展的业务架构。

2. 核心概念

2.1 状态模式

状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变自身的行为，看起来就像修改了对象的类。其核心思想是将每个状态对应的行为封装到独立的类中，由上下文对象持有当前状态对象，并在状态切换时委托给新的状态对象执行。

• 上下文（Context）：持有当前状态对象，对外提供状态切换和业务执行入口。
• 抽象状态（State）：定义状态行为的统一接口。
• 具体状态（Concrete State）：实现特定状态下的业务逻辑，并负责触发状态流转。

2.2 适配器模式

适配器模式是一种结构型设计模式，它通过一个中间层将不兼容的接口转换为客户端期望的接口，从而让原本因接口不匹配而无法协作的类能够一起工作。在本文场景中，人事、IT、培训三个外部系统的接口签名各不相同，通过适配器统一转换为 IExternalSystemTarget 接口，业务层无需感知底层差异。

• 目标接口（Target）：客户端所期望的统一接口。
• 被适配者（Adaptee）：需要被适配的现有异构接口。
• 适配器（Adapter）：将 Adaptee 的接口转换为 Target 接口。

3. 实战步骤

3.1 项目结构设计

项目采用分层结构，将状态模式、适配器模式、调度器、日志等模块分离，便于维护和扩展。核心命名空间包括 StatePattern.Core、StatePattern.Business、StatePattern.Common 等。

3.2 定义统一目标接口

首先定义 IExternalSystemTarget 接口，作为所有外部异构系统适配的统一目标。该接口包含一个异步方法 ExecuteBusinessAsync，接收业务编码和 JSON 数据字符串，返回执行结果。

3.3 实现被适配者类

分别实现 HrPersonnelAdaptee、ItDepartmentAdaptee、TrainingAdaptee 三个被适配者类，模拟人事、IT、培训三个外部系统的原始异构接口。每个类的方法签名和内部实现各不相同，需要通过适配器进行转换。

3.4 实现适配器类

分别实现 HrPersonnelAdapter、ItDepartmentAdapter、TrainingAdapter 三个适配器类，它们实现 IExternalSystemTarget 接口，并在内部持有对应的被适配者实例。适配器负责将统一入参 JSON 解析为被适配者所需的原始参数，并调用其方法，最后返回结果。

3.5 定义订单状态接口与上下文

定义 IJewelryOrderState 状态接口，包含 HandleAsync 方法。实现 JewelryOrderContext 上下文类，持有当前状态对象，提供 ChangeState 方法切换状态，以及 AddFlowRemark 方法记录流转备注。

3.6 实现具体状态类

根据珠宝订单业务，实现多个具体状态类，包括原料采购核验、设计制图、加工生产、物流发货、财务结算、营销推广等。每个状态类在 HandleAsync 中执行当前环节的业务逻辑，记录备注，然后切换到下一个状态并继续处理。

3.7 实现业务调度器

实现 BusinessFlowScheduler 调度器，使用线程安全的 ConcurrentQueue 维护业务任务队列，后台循环消费队列并执行任务，支持高并发场景下的异步流转。

3.8 实现日志配置

基于 Karambolo 文件日志库，实现按日期创建子文件夹、按等级分文件的日志配置扩展方法，满足业务系统对日志持久化和可追溯性的要求。

3.9 组装业务服务

实现 JewelryBusinessService 主业务服务，通过构造函数注入调度器、各类适配器和日志组件。提供 SubmitJewelryOrder 方法提交订单并进入状态流转，提供 RunExternalDepartmentBusinessDemo 方法演示外部异构系统的适配调用。

3.10 编写调用入口

在 StateBll 中构建通用主机，配置日志、注册调度器、适配器和业务服务，启动调度器后台循环，提交演示订单并调用外部部门业务演示，最后优雅退出。

4. 常见问题

4.1 状态模式与策略模式的区别

状态模式侧重于对象内部状态的切换，状态之间通常存在流转关系，且状态对象能触发状态变更；策略模式侧重于算法的替换，策略之间相互独立，由客户端决定使用哪种策略。在本文场景中，订单状态之间存在明确的先后流转关系，因此使用状态模式更合适。

4.2 适配器模式与外观模式的区别

适配器模式侧重于接口转换，目的是让原本不兼容的接口能够协作；外观模式侧重于简化接口，为复杂子系统提供一个统一的高层入口。本文中适配器将三个异构系统转换为统一接口，属于典型的适配器模式应用。

4.3 如何扩展新的订单状态

新增订单状态时，只需实现 IJewelryOrderState 接口，在 HandleAsync 中编写业务逻辑并指定下一个状态，然后在 JewelryBusinessService 中调整初始状态即可，无需修改现有状态类，符合开闭原则。

4.4 如何对接新的外部异构系统

对接新系统时，只需实现对应的被适配者类和适配器类，并在依赖注入容器中注册，业务层无需改动，即可通过统一接口调用新系统。

5. 总结

本文通过一个珠宝业务系统的完整案例，展示了状态模式与适配器模式的组合应用。状态模式将订单流转的复杂分支逻辑拆分为独立的状态类，使代码结构清晰、易于扩展；适配器模式屏蔽了外部异构系统的差异，使业务层与外部系统解耦。两者结合，配合调度器和日志组件，构建了一个高内聚、低耦合、可维护、可扩展的业务系统架构。

在实际项目中，设计模式的选择应基于具体业务场景，避免过度设计。当状态流转复杂且状态之间存在明确关系时，状态模式是合适的选择；当需要对接多个接口不兼容的外部系统时，适配器模式能有效降低耦合。希望本文的实战案例能为读者在 .NET 项目中应用设计模式提供参考。

项目结构：

/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : HrPersonnelAdaptee.cs
*/
 
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.AdapterPattern.Adaptees
{
    /// <summary>
    /// 适配器模式【被适配者】人事行政外部异构系统
    /// 第三方人事系统接口方法签名和内部业务不统一，需要适配器包装
    /// </summary>
    public class HrPersonnelAdaptee
    {
        private readonly ILogger<HrPersonnelAdaptee> _logger;
 
        public HrPersonnelAdaptee(ILogger<HrPersonnelAdaptee> logger)
        {
            _logger = logger;
        }
 
        /// <summary>
        /// 人事系统原始接口：员工考勤、人事档案异动
        /// 注意：该第三方方法签名与我们目标接口不一致，需要适配器转换
        /// </summary>
        /// <param name="empId">员工编号</param>
        /// <param name="actionType">操作类型</param>
        /// <returns>原始系统返回字符串</returns>
        public async Task<string> HrRawOperate(string empId, string actionType)
        {
            _logger.LogDebug("调用外部人事行政原始系统 empId:{EmpId},action:{Action}", empId, actionType);
            await Task.Delay(70);
            return $"HR‑RAW‑OK|Emp:{empId}|Action:{actionType}";
        }
    }
}
 
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : ItDepartmentAdaptee.cs
*/
 
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.AdapterPattern.Adaptees
{
    /// <summary>
    /// 适配器模式【被适配者】IT部门外部工具系统
    /// 权限账号开通、服务器资源申请、运维工单
    /// </summary>
    public class ItDepartmentAdaptee
    {
        private readonly ILogger<ItDepartmentAdaptee> _logger;
 
        public ItDepartmentAdaptee(ILogger<ItDepartmentAdaptee> logger)
        {
            _logger = logger;
        }
 
        /// <summary>
        /// IT系统原始异构接口
        /// </summary>
        /// <param name="workOrderNo">运维工单号</param>
        /// <param name="content">工单内容</param>
        /// <returns>原始返回结果</returns>
        public async Task<string> ItRawSubmitWorkOrder(string workOrderNo, string content)
        {
            _logger.LogDebug("调用外部IT运维原始系统 workOrder:{WorkOrder}", workOrderNo);
            await Task.Delay(60);
            return $"IT‑RAW‑OK|WorkOrder:{workOrderNo}";
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : TrainingAdaptee.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.AdapterPattern.Adaptees
{
    /// <summary>
    /// 适配器模式【被适配者】员工培训外部系统
    /// 珠宝岗位技能培训记录、课程报名、考核记录
    /// </summary>
    public class TrainingAdaptee
    {
        private readonly ILogger<TrainingAdaptee> _logger;
 
        public TrainingAdaptee(ILogger<TrainingAdaptee> logger)
        {
            _logger = logger;
        }
 
        /// <summary>
        /// 培训系统原始异构接口
        /// </summary>
        /// <param name="courseId">课程编号</param>
        /// <param name="staffNo">参训员工编号</param>
        /// <returns>原始系统返回</returns>
        public async Task<string> TrainingRawRecord(string courseId, string staffNo)
        {
            _logger.LogDebug("调用外部培训原始系统 course:{Course},staff:{Staff}", courseId, staffNo);
            await Task.Delay(50);
            return $"TRAIN‑RAW‑OK|Course:{courseId}|Staff:{staffNo}";
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : HrPersonnelAdapter.cs
*/
 
 
using Microsoft.Extensions.Logging;
using StatePattern.Core.AdapterPattern.Adaptees;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json;
 
namespace StatePattern.Core.AdapterPattern.Adapters
{
    /// <summary>
    /// 适配器模式：人事行政适配器
    /// 将外部HR异构系统适配到统一IExternalSystemTarget接口
    /// </summary>
    public class HrPersonnelAdapter : IExternalSystemTarget
    {
        private readonly HrPersonnelAdaptee _adaptee;
        private readonly ILogger<HrPersonnelAdapter> _logger;
 
        public HrPersonnelAdapter(HrPersonnelAdaptee adaptee, ILogger<HrPersonnelAdapter> logger)
        {
            _adaptee = adaptee;
            _logger = logger;
        }
 
        public async Task<string> ExecuteBusinessAsync(string businessCode, string dataJson)
        {
            _logger.LogInformation("人事适配器执行业务编码:{BusinessCode}", businessCode);
            // 将统一入参JSON解析，转换为被适配对象的原始参数
            var dto = JsonSerializer.Deserialize<Dictionary<string, string>>(dataJson);
            string empId = dto!.GetValueOrDefault("EmpId", "");
            string action = dto.GetValueOrDefault("ActionType", "");
 
            string rawResult = await _adaptee.HrRawOperate(empId, action);
            _logger.LogDebug("人事适配器转换完成，原始系统返回:{RawResult}", rawResult);
            return rawResult;
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : ItDepartmentAdapter.cs
*/
 
 
using Microsoft.Extensions.Logging;
using StatePattern.Core.AdapterPattern.Adaptees;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json;
 
namespace StatePattern.Core.AdapterPattern.Adapters
{
    /// <summary>
    /// 适配器模式：IT部门适配器
    /// 把IT异构工单系统适配统一接口
    /// </summary>
    public class ItDepartmentAdapter : IExternalSystemTarget
    {
        private readonly ItDepartmentAdaptee _adaptee;
        private readonly ILogger<ItDepartmentAdapter> _logger;
 
        public ItDepartmentAdapter(ItDepartmentAdaptee adaptee, ILogger<ItDepartmentAdapter> logger)
        {
            _adaptee = adaptee;
            _logger = logger;
        }
 
        public async Task<string> ExecuteBusinessAsync(string businessCode, string dataJson)
        {
            _logger.LogInformation("IT适配器执行业务编码:{BusinessCode}", businessCode);
            var dto = JsonSerializer.Deserialize<Dictionary<string, string>>(dataJson);
            string workOrderNo = dto!.GetValueOrDefault("WorkOrderNo", "");
            string content = dto.GetValueOrDefault("Content", "");
 
            string rawResult = await _adaptee.ItRawSubmitWorkOrder(workOrderNo, content);
            _logger.LogDebug("IT适配器转换完成，原始返回:{RawResult}", rawResult);
            return rawResult;
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : TrainingAdapter.cs
*/
 
 
using Microsoft.Extensions.Logging;
using StatePattern.Core.AdapterPattern.Adaptees;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json;
 
namespace StatePattern.Core.AdapterPattern.Adapters
{
    /// <summary>
    /// 适配器模式：员工培训适配器
    /// 将外部培训异构系统适配统一接口
    /// </summary>
    public class TrainingAdapter : IExternalSystemTarget
    {
        private readonly TrainingAdaptee _adaptee;
        private readonly ILogger<TrainingAdapter> _logger;
 
        public TrainingAdapter(TrainingAdaptee adaptee, ILogger<TrainingAdapter> logger)
        {
            _adaptee = adaptee;
            _logger = logger;
        }
 
        public async Task<string> ExecuteBusinessAsync(string businessCode, string dataJson)
        {
            _logger.LogInformation("培训适配器执行业务编码:{BusinessCode}", businessCode);
            var dto = JsonSerializer.Deserialize<Dictionary<string, string>>(dataJson);
            string courseId = dto!.GetValueOrDefault("CourseId", "");
            string staffNo = dto.GetValueOrDefault("StaffNo", "");
 
            string rawResult = await _adaptee.TrainingRawRecord(courseId, staffNo);
            _logger.LogDebug("培训适配器转换完成，原始返回:{RawResult}", rawResult);
            return rawResult;
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : IExternalSystemTarget.cs
*/
 
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.AdapterPattern
{
    /// <summary>
    /// 适配器模式：目标统一接口
    /// 人事行政、IT、培训、营销外部异构系统统一适配接口
    /// </summary>
    public interface IExternalSystemTarget
    {
        /// <summary>
        /// 执行业务同步调用
        /// </summary>
        /// <param name="businessCode">业务编码</param>
        /// <param name="dataJson">业务数据JSON字符串</param>
        /// <returns>执行返回结果</returns>
        Task<string> ExecuteBusinessAsync(string businessCode, string dataJson);
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : DesignDrawState.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：设计制图状态
    /// 业务：首饰款式设计、结构图纸、镶嵌工艺方案
    /// </summary>
    public class DesignDrawState : IJewelryOrderState
    {
        private readonly ILogger _logger;
        /// <summary>
        ///
        /// </summary>
        /// <param name="logger"></param>
        public DesignDrawState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【设计制图】订单号:{OrderNo} 执行首饰款式设计制图", context.OrderNo);
            context.AddFlowRemark("设计制图：款式设计、结构图纸输出、镶嵌工艺方案确定");
 
            await Task.Delay(150);
 
            _logger.LogDebug("【设计制图】设计完成，流转下一节点：加工生产");
            context.AddFlowRemark("设计制图完成，流转加工生产工序");
 
            context.ChangeState(new ManufactureProduceState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : FinanceSettleState.cs
*/
 
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：财务结算状态
    /// 业务：应收应付、成本核算、开票、对账
    /// </summary>
    public class FinanceSettleState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public FinanceSettleState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【财务结算】订单号:{OrderNo} 执行订单财务对账结算", context.OrderNo);
            context.AddFlowRemark("财务结算：应收应付核算、成本归集、开具票据、财务记账");
 
            await Task.Delay(110);
 
            _logger.LogDebug("【财务结算】结算完成，流转下一节点：营销推广归档");
            context.AddFlowRemark("财务流程结束，流转营销推广业务归档");
 
            context.ChangeState(new MarketingPromoteState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : LogisticsState.cs
*/
 
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：物流状态
    /// 业务：贵重珠宝保价发货，物流跟踪
    /// </summary>
    public class LogisticsState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public LogisticsState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【物流发货】订单号:{OrderNo} 珠宝保价物流发货", context.OrderNo);
            context.AddFlowRemark("物流发货：贵重珠宝保价委托承运，生成物流单号");
 
            await Task.Delay(130);
 
            _logger.LogDebug("【物流】发货完成，流转下一节点：财务结算");
            context.AddFlowRemark("物流出库完成，流转财务结算");
 
            context.ChangeState(new FinanceSettleState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : ManufactureProduceState.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：加工生产状态
    /// 业务：起版、执模、镶石、抛光等珠宝加工工序
    /// </summary>
    public class ManufactureProduceState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public ManufactureProduceState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【加工生产】订单号:{OrderNo} 首饰加工生产", context.OrderNo);
            context.AddFlowRemark("加工生产：起版、执模、镶石、抛光等加工工序");
 
            await Task.Delay(200);
 
            _logger.LogDebug("【加工生产】加工完成，流转下一节点：质检");
            context.AddFlowRemark("加工完毕，流转成品质检工序");
 
            context.ChangeState(new QualityInspectState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : MarketingPromoteState.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：营销推广状态
    /// 业务：客户档案归档、营销标签、客户回访，订单全流程终点
    /// </summary>
    public class MarketingPromoteState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public MarketingPromoteState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【营销推广归档】订单号:{OrderNo} 客户档案归档，添加营销标签", context.OrderNo);
            context.AddFlowRemark("营销推广：客户档案归档，客户回访记录，打上营销客户标签");
 
            await Task.Delay(90);
 
            _logger.LogInformation("订单 {OrderNo} 珠宝完整业务全流程全部执行完毕", context.OrderNo);
            context.AddFlowRemark("========珠宝订单全流程结束========");
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : MaterialPurchaseVerifyState.cs
*/
 
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：原料采购核验状态
    /// 业务：宝石贵金属原料入库核验，质检原料，核验采购单据，核验证书
    /// </summary>
    public class MaterialPurchaseVerifyState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public MaterialPurchaseVerifyState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【原料采购核验】订单号:{OrderNo},物料编码:{MaterialCode} 开始原料核验", context.OrderNo, context.MaterialCode);
            context.AddFlowRemark("原料采购核验：执行原料入库单据核验、宝石贵金属成色检测、证书核对");
 
            // 模拟业务IO耗时
            await Task.Delay(120);
 
            _logger.LogDebug("【原料采购核验】核验通过，流转下一节点：设计制图");
            context.AddFlowRemark("原料核验完成，流转至设计制图工序");
 
            // 状态切换：原料核验完成进入设计制图
            context.ChangeState(new DesignDrawState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : PackageState.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：包装状态
    /// 业务：首饰礼盒、证书、票据配套打包
    /// </summary>
    public class PackageState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public PackageState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【成品包装】订单号:{OrderNo} 首饰礼盒包装", context.OrderNo);
            context.AddFlowRemark("成品包装：首饰礼盒、鉴定证书、销售票据配套封装");
 
            await Task.Delay(80);
 
            _logger.LogDebug("【成品包装】包装完成，流转下一节点：物流");
            context.AddFlowRemark("包装完毕，流转物流发货工序");
 
            context.ChangeState(new LogisticsState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : QualityInspectState.cs
*/
 
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern.States
{
    /// <summary>
    /// 状态模式：质检状态
    /// 业务：成品外观、宝石牢固度、贵金属成色、尺寸质检
    /// </summary>
    public class QualityInspectState : IJewelryOrderState
    {
        private readonly ILogger _logger;
 
        public QualityInspectState(ILogger logger)
        {
            _logger = logger;
        }
 
        public async Task HandleAsync(JewelryOrderContext context)
        {
            _logger.LogInformation("【成品质检】订单号:{OrderNo} 执行成品质量检测", context.OrderNo);
            context.AddFlowRemark("成品质检：外观、镶石牢固度、贵金属成色、尺寸校验");
 
            await Task.Delay(100);
 
            _logger.LogDebug("【成品质检】质检合格，流转下一节点：包装");
            context.AddFlowRemark("质检合格，流转成品包装工序");
 
            context.ChangeState(new PackageState(_logger));
            await context.ProcessAsync();
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : IJewelryOrderState.cs
*/
 
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Core.StatePattern
{
    /// <summary>
    /// 珠宝订单状态接口【状态模式】
    /// 每一个业务流程节点对应一个状态实现类
    /// </summary>
    public interface IJewelryOrderState
    {
        /// <summary>
        /// 执行当前状态对应的业务处理逻辑
        /// </summary>
        /// <param name="context">订单上下文对象</param>
        Task HandleAsync(JewelryOrderContext context);
    }
 
    /// <summary>
    /// 珠宝订单上下文，持有订单数据与当前状态实例
    /// 负责状态切换，驱动整个业务流转
    /// </summary>
    public class JewelryOrderContext
    {
        /// <summary>
        /// 订单唯一编号
        /// </summary>
        public string OrderNo { get; set; } = string.Empty;
 
        /// <summary>
        /// 珠宝原料物料编码
        /// </summary>
        public string MaterialCode { get; set; } = string.Empty;
 
        /// <summary>
        /// 当前订单状态对象
        /// </summary>
        public IJewelryOrderState CurrentState { get; private set; }
 
        /// <summary>
        /// 订单流转过程备注信息
        /// </summary>
        public List<string> FlowRemarkList { get; }
 
        public JewelryOrderContext(IJewelryOrderState initState)
        {
            CurrentState = initState;
            FlowRemarkList = new List<string>();
        }
 
        /// <summary>
        /// 切换订单状态
        /// </summary>
        /// <param name="newState">新的状态实例</param>
        public void ChangeState(IJewelryOrderState newState)
        {
            CurrentState = newState;
        }
 
        /// <summary>
        /// 添加流程流转备注
        /// </summary>
        /// <param name="remark">备注文本</param>
        public void AddFlowRemark(string remark)
        {
            FlowRemarkList.Add($"{DateTime.Now:yyyy‑MM‑dd HH:mm:ss}｜{remark}");
        }
 
        /// <summary>
        /// 驱动执行当前状态业务逻辑
        /// </summary>
        public async Task ProcessAsync()
        {
            await CurrentState.HandleAsync(this);
        }
    }
}

/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : JewelryBusinessService.cs
*/
 
using Microsoft.Extensions.Logging;
using StatePattern.Common.Scheduler;
using StatePattern.Core.AdapterPattern;
using StatePattern.Core.AdapterPattern.Adapters;
using StatePattern.Core.StatePattern;
using StatePattern.Core.StatePattern.States;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.Json;
 
namespace StatePattern.Business
{
    /// <summary>
    /// 珠宝业务主服务
    /// DI注入：调度器、各类适配器、ILogger
    /// 组合状态模式订单流转 + 适配器模式外部系统调用（人事/IT/培训）
    /// </summary>
    public class JewelryBusinessService
    {
        private readonly ILogger<JewelryBusinessService> _logger;
        private readonly BusinessFlowScheduler _scheduler;
 
        // 适配器实例：人事行政、IT、培训
        private readonly IExternalSystemTarget _hrAdapter;
        private readonly IExternalSystemTarget _itAdapter;
        private readonly IExternalSystemTarget _trainingAdapter;
 
        public JewelryBusinessService(
            ILogger<JewelryBusinessService> logger,
            BusinessFlowScheduler scheduler,
            HrPersonnelAdapter hrAdapter,
            ItDepartmentAdapter itAdapter,
            TrainingAdapter trainingAdapter)
        {
            _logger = logger;
            _scheduler = scheduler;
            _hrAdapter = hrAdapter;
            _itAdapter = itAdapter;
            _trainingAdapter = trainingAdapter;
        }
 
        /// <summary>
        /// 提交珠宝订单，入调度器异步执行完整状态流转
        /// </summary>
        /// <param name="orderNo">订单编号</param>
        /// <param name="materialCode">原料物料编码</param>
        public void SubmitJewelryOrder(string orderNo, string materialCode)
        {
            _logger.LogInformation("收到珠宝业务订单提交，订单号:{OrderNo},物料:{MaterialCode}", orderNo, materialCode);
 
            // 初始化订单上下文，初始状态：原料采购核验
            var initState = new MaterialPurchaseVerifyState(_logger);
            var orderContext = new JewelryOrderContext(initState)
            {
                OrderNo = orderNo,
                MaterialCode = materialCode
            };
 
            // 将订单流程任务入调度器队列
            _scheduler.EnqueueBusinessTask(async () =>
            {
                await orderContext.ProcessAsync();
                _logger.LogInformation("订单 {OrderNo} 全部流程备注：\n{FlowRemark}",
                    orderNo, string.Join("\n", orderContext.FlowRemarkList));
            });
        }
 
        /// <summary>
        /// 演示调用外部异构业务：人事行政、IT、培训（适配器模式）
        /// </summary>
        public async Task RunExternalDepartmentBusinessDemo()
        {
            _logger.LogInformation("====开始调用外部部门适配器业务：人事、IT、培训====");
 
            // 人事行政业务
            string hrJson = JsonSerializer.Serialize(new Dictionary<string, string>
            {
                ["EmpId"] = "EMP‑00121",
                ["ActionType"] = "StaffTransfer"
            });
            string hrResult = await _hrAdapter.ExecuteBusinessAsync("HR‑STAFF‑MOVE", hrJson);
            _logger.LogInformation("人事适配器返回:{HrResult}", hrResult);
 
            // IT部门业务
            string itJson = JsonSerializer.Serialize(new Dictionary<string, string>
            {
                ["WorkOrderNo"] = "IT‑WO‑20260830‑001",
                ["Content"] = "珠宝业务系统账号开通申请"
            });
            string itResult = await _itAdapter.ExecuteBusinessAsync("IT‑WORK‑ORDER", itJson);
            _logger.LogInformation("IT适配器返回:{ItResult}", itResult);
 
            // 员工培训业务
            string trainJson = JsonSerializer.Serialize(new Dictionary<string, string>
            {
                ["CourseId"] = "TR‑GEM‑003",
                ["StaffNo"] = "EMP‑00121"
            });
            string trainResult = await _trainingAdapter.ExecuteBusinessAsync("TRAIN‑RECORD", trainJson);
            _logger.LogInformation("培训适配器返回:{TrainResult}", trainResult);
 
            _logger.LogInformation("====外部部门适配器业务执行结束====");
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : IJewelryLogFormatter.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Common.Logging
{
    public interface IJewelryLogFormatter
    {
        string GetStandardLogTemplate();
 
        Dictionary<string, LogLevel> GetMinLevel(LogLevel level);
    }
}
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : LogFileConfigureExtension.cs
*/
 
using Karambolo.Extensions.Logging.File;
using Microsoft.Extensions.Logging;
using System;
 
namespace StatePattern.Common.Logging
{
    /// <summary>
    /// Karambolo 文件日志配置扩展方法
    /// 实现：Logs/2026-07-06/app.log（<date:yyyy-MM-dd> 为日期占位符）
    /// 按日期创建子文件夹；异步后台写入，线程安全，支持高并发
    /// </summary>
    public static class LogFileConfigureExtension
    {
        /// <summary>
        /// 配置珠宝业务文件日志
        /// </summary>
        /// <param name="builder">日志构建器</param>
        /// <returns>日志构建器</returns>
        public static ILoggingBuilder AddJewelryFileLogger(this ILoggingBuilder builder)
        {
            // Karambolo 日志配置（v4 使用 File/RootPath/BasePath/Files）
            builder.AddFile(o =>
            {
                // 日志根目录，必须是已存在的目录
                o.RootPath = AppContext.BaseDirectory;
                // 日志子目录，不存在时自动创建
                o.BasePath = "Logs";
                // 模板：Logs/2026-07-06/app.log；路径模板支持 <date:格式>、<counter:格式> 占位符
                o.Files = new[]
                {
                    new LogFileOptions
                    {
                        Path = "<date:yyyy-MM-dd>/app.log"
                    }
                };
                // 保持文件打开并即时刷新每条日志；内部异步队列缓冲，高并发不阻塞业务线程
                o.FileAccessMode = LogFileAccessMode.KeepOpenAndAutoFlush;
                // 默认文本格式即包含时间（本地时间）、日志等级、类别、消息、异常堆栈
                o.TextBuilder = FileLogEntryTextBuilder.Instance;
            });
 
            return builder;
        }
    }
}
 
 
/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : BusinessFlowScheduler.cs
*/
 
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
 
namespace StatePattern.Common.Scheduler
{
    /// <summary>
    /// 珠宝业务流程调度器
    /// 负责任务排队、异步流转；线程安全，高并发，全部操作使用ILogger输出日志
    /// </summary>
    public class BusinessFlowScheduler
    {
        private readonly ILogger<BusinessFlowScheduler> _logger;
 
        /// <summary>
        /// 线程安全的业务任务队列
        /// </summary>
        private readonly ConcurrentQueue<Func<Task>> _businessTaskQueue;
 
        /// <summary>
        /// 调度器是否正在运行标记
        /// </summary>
        private bool _isRunning;
 
        public BusinessFlowScheduler(ILogger<BusinessFlowScheduler> logger)
        {
            _logger = logger;
            _businessTaskQueue = new ConcurrentQueue<Func<Task>>();
            _isRunning = false;
        }
 
        /// <summary>
        /// 向调度器入队一个业务任务
        /// </summary>
        /// <param name="businessTask">待执行业务异步委托</param>
        public void EnqueueBusinessTask(Func<Task> businessTask)
        {
            if (businessTask == null)
            {
                _logger.LogWarning("调度器入队任务为null，直接丢弃");
                return;
            }
            _businessTaskQueue.Enqueue(businessTask);
            _logger.LogDebug("业务任务入队成功，当前队列待处理数量：{QueueCount}", _businessTaskQueue.Count);
        }
 
        /// <summary>
        /// 启动调度器后台循环消费队列
        /// </summary>
        /// <param name="cancellationToken">取消令牌</param>
        public async Task StartRunAsync(CancellationToken cancellationToken)
        {
            if (_isRunning)
            {
                _logger.LogInformation("调度器已经处于运行状态，无需重复启动");
                return;
            }
            _isRunning = true;
            _logger.LogInformation("珠宝业务流程调度器已启动");
 
            while (!cancellationToken.IsCancellationRequested)
            {
                try
                {
                    if (_businessTaskQueue.TryDequeue(out var taskItem))
                    {
                        _logger.LogDebug("调度器开始执行队列任务");
                        await taskItem.Invoke();
                        _logger.LogDebug("调度器队列任务执行完成");
                    }
                    else
                    {
                        // 无任务，短暂休眠释放CPU
                        await Task.Delay(20, cancellationToken);
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "调度器执行业务任务发生异常");
                }
            }
 
            _isRunning = false;
            _logger.LogInformation("珠宝业务流程调度器收到停止信号，调度器退出");
        }
    }
}

调用：

/*
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：状态模式  State Pattern 行为模式 Behavioral Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : vs2026 c# .net 10
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/07/04 22:16
# User      :  geovindu
# Product   : Visual Studio 2026
# Project   : CSharpDesignPattern
# File      : StateBll.cs
*/
using System;
using System.Collections.Generic;
using System.Text;
using StatePattern.Business;
using StatePattern.Common.Logging;
using StatePattern.Common.Scheduler;
using StatePattern.Core.AdapterPattern.Adapters;
using StatePattern.Core.AdapterPattern.Adaptees;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
 
 
namespace BLL
{
 
    /// <summary>
    ///
    /// </summary>
    public class StateBll
    {
 
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public async Task Demo()
        {
            // 构建通用主机
            var host = Host.CreateDefaultBuilder()
                .ConfigureLogging((context, loggingBuilder) =>
                {
                    loggingBuilder.ClearProviders();
                    // 控制台日志输出
                    loggingBuilder.AddConsole();
                    // 自定义珠宝业务文件日志（Karambolo）按日期文件夹+按等级分文件
                    loggingBuilder.AddJewelryFileLogger();
                    // 设置最低日志等级 Debug
                    loggingBuilder.SetMinimumLevel(LogLevel.Debug);
                })
                .ConfigureServices((context, services) =>
                {
                    // 调度器注册，单例；高并发全局调度实例
                    services.AddSingleton<BusinessFlowScheduler>();
 
                    // 适配器模式：被适配外部系统
                    services.AddTransient<HrPersonnelAdaptee>();
                    services.AddTransient<ItDepartmentAdaptee>();
                    services.AddTransient<TrainingAdaptee>();
 
                    // 适配器实现
                    services.AddTransient<HrPersonnelAdapter>();
                    services.AddTransient<ItDepartmentAdapter>();
                    services.AddTransient<TrainingAdapter>();
 
                    // 主业务服务
                    services.AddTransient<JewelryBusinessService>();
                })
                .Build();
 
            // 获取日志，输出启动日志
            var logger = host.Services.GetRequiredService<ILogger<StateBll>>();
            logger.LogInformation("====珠宝行业业务系统启动 .NET10｜状态模式+适配器模式====");
 
            // 获取调度器，启动后台消费循环
            var scheduler = host.Services.GetRequiredService<BusinessFlowScheduler>();
            CancellationTokenSource cts = new CancellationTokenSource();
            var schedulerTask = scheduler.StartRunAsync(cts.Token);
 
            // 获取业务服务
            var businessService = host.Services.GetRequiredService<JewelryBusinessService>();
 
            // 提交演示订单：完整珠宝业务流程流转
            businessService.SubmitJewelryOrder("JEW‑ORD‑20260830‑0001", "GEM‑D08‑0056");
 
            // 演示适配器模式：人事行政 / IT / 培训部门业务
            await businessService.RunExternalDepartmentBusinessDemo();
 
            logger.LogInformation("演示任务提交完成，等待调度器后台执行全部业务...");
            await Task.Delay(2000);
 
            // 程序退出，停止调度器
            cts.Cancel();
            await schedulerTask;
            logger.LogInformation("珠宝业务系统准备退出");
 
            await host.RunAsync();
         
        }
    }
}
　　

输出：