项目结构：
一个基于组合模式(Composite Pattern)实现的珠宝企业级业务系统。系统采用树形结构组织业务流程，包含12个叶子节点(如原料采购、设计制图、加工生产等)和3个组合节点(前端销售链路、生产制造链路、职能后台支撑链路)。通过IBusinessProcessNode接口统一业务节点操作，AbstractProcessNode抽象类封装公共逻辑，ProcessCompositeNode实现组合节点管理。系统使用DI容器管理组件，支持单订单顺序执行和多线程批量处理，具备完善的日志记录和异常处理机制。该设计实现了业务节点的灵活组合和高扩展性，适用于复杂业务流程的模块化管理。
cs
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : AbstractProcessNode.cs
*/
using CompositePattern.Core.Exceptions;
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Extensions.Logging;
namespace CompositePattern.Core.CompositePattern
{
/// <summary>
/// 业务节点抽象基类
/// 封装公共日志、节点名称；提供叶子节点默认不支持子节点操作实现
/// 所有叶子业务节点继承此类
/// </summary>
public abstract class AbstractProcessNode : IBusinessProcessNode
{
/// <summary>
/// 当前业务节点名称
/// </summary>
public string NodeName { get; }
/// <summary>
/// 节点专属日志实例，DI注入隔离日志分类
/// </summary>
protected readonly ILogger _logger;
/// <summary>
/// 构造函数注入日志与节点名称
/// </summary>
/// <param name="logger">ILogger<T>注入实例</param>
/// <param name="nodeName">业务节点中文名称</param>
protected AbstractProcessNode(ILogger logger, string nodeName)
{
_logger = logger;
NodeName = nodeName;
}
/// <summary>
/// 子类重写：实现当前节点专属业务逻辑
/// </summary>
/// <param name="businessOrderNo">业务单号</param>
public abstract void Execute(string businessOrderNo);
/// <summary>
/// 叶子节点默认实现：不支持添加子流程
/// </summary>
/// <param name="childNode">子节点对象</param>
public virtual void AddChild(IBusinessProcessNode childNode)
{
string errorMsg = $"叶子业务节点【{NodeName}】不支持挂载子业务流程";
_logger.LogWarning(errorMsg);
throw new BusinessProcessException(errorMsg, "未知", NodeName);
}
/// <summary>
/// 叶子节点默认实现：不支持移除子流程
/// </summary>
/// <param name="childNode">子节点对象</param>
public virtual void RemoveChild(IBusinessProcessNode childNode)
{
string errorMsg = $"叶子业务节点【{NodeName}】无下属子流程，无法移除";
_logger.LogWarning(errorMsg);
throw new BusinessProcessException(errorMsg, "未知", NodeName);
}
/// <summary>
/// 叶子节点默认实现：无任何子节点，返回空集合
/// </summary>
/// <returns>空子节点列表</returns>
public virtual List<IBusinessProcessNode> GetChildren()
{
return new List<IBusinessProcessNode>();
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：结构型模式 Structural Patterns 组合模式 Composite Pattern
# 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 : IBusinessProcessNode.cs
*/
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Core.CompositePattern
{
/// <summary>
/// 组合模式顶层抽象构件接口
/// 所有业务叶子节点、业务分组组合节点统一实现该接口
/// 对外提供统一执行、增删子节点标准方法
/// </summary>
public interface IBusinessProcessNode
{
/// <summary>
/// 获取当前业务节点名称
/// </summary>
string NodeName { get; }
/// <summary>
/// 执行业务流程
/// </summary>
/// <param name="businessOrderNo">业务唯一订单编号</param>
void Execute(string businessOrderNo);
/// <summary>
/// 添加子业务节点
/// 叶子节点实现直接抛不支持异常；组合节点实现挂载子流程
/// </summary>
/// <param name="childNode">待添加子节点</param>
void AddChild(IBusinessProcessNode childNode);
/// <summary>
/// 移除指定子业务节点
/// </summary>
/// <param name="childNode">待移除子节点</param>
void RemoveChild(IBusinessProcessNode childNode);
/// <summary>
/// 获取当前节点下全部子节点副本（线程安全返回快照）
/// </summary>
/// <returns>子节点集合</returns>
List<IBusinessProcessNode> GetChildren();
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : ProcessCompositeNode.cs
*/
using CompositePattern.Core.Exceptions;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Core.CompositePattern
{
/// <summary>
/// 组合模式容器节点（Composite）
/// 用于分组管理多个子业务节点（叶子/其他组合节点）
/// 内部全部集合操作加锁，保证多线程并发增删子节点安全
/// </summary>
public class ProcessCompositeNode : IBusinessProcessNode
{
/// <summary>
/// 分组节点名称
/// </summary>
public string NodeName { get; }
/// <summary>
/// 分组专属日志
/// </summary>
protected readonly ILogger _logger;
/// <summary>
/// 子节点存储集合
/// </summary>
private readonly List<IBusinessProcessNode> _childNodes = new List<IBusinessProcessNode>();
/// <summary>
/// 线程安全操作锁对象
/// </summary>
private readonly object _syncLock = new object();
/// <summary>
/// 构造组合分组节点
/// </summary>
/// <param name="logger">分组日志实例</param>
/// <param name="groupName">分组中文名称</param>
public ProcessCompositeNode(ILogger logger, string groupName)
{
_logger = logger;
NodeName = groupName;
}
/// <summary>
/// 批量顺序执行分组下所有子业务流程
/// 单个子流程异常仅记录日志，不阻断同组其他流程执行
/// </summary>
/// <param name="businessOrderNo">业务单号</param>
public void Execute(string businessOrderNo)
{
_logger.LogInformation("===== 开始执行业务分组【{GroupName}】，业务单号：{OrderNo} =====", NodeName, businessOrderNo);
List<IBusinessProcessNode> snapshot;
lock (_syncLock)
{
snapshot = new List<IBusinessProcessNode>(_childNodes);
}
foreach (var child in snapshot)
{
try
{
child.Execute(businessOrderNo);
}
catch (BusinessProcessException busEx)
{
_logger.LogError(busEx, "分组【{GroupName}】子节点【{ChildName}】业务异常，单号：{OrderNo}",
NodeName, child.NodeName, businessOrderNo);
}
catch (Exception ex)
{
_logger.LogError(ex, "分组【{GroupName}】子节点【{ChildName}】系统未知异常，单号：{OrderNo}",
NodeName, child.NodeName, businessOrderNo);
}
}
_logger.LogInformation("===== 业务分组【{GroupName}】全部子流程执行完毕，业务单号：{OrderNo} =====", NodeName, businessOrderNo);
}
/// <summary>
/// 线程安全添加子节点
/// </summary>
/// <param name="childNode">待挂载子流程</param>
public void AddChild(IBusinessProcessNode childNode)
{
lock (_syncLock)
{
_childNodes.Add(childNode);
_logger.LogDebug("分组【{GroupName}】成功挂载子节点：{ChildName}", NodeName, childNode.NodeName);
}
}
/// <summary>
/// 线程安全移除子节点
/// </summary>
/// <param name="childNode">待移除子流程</param>
public void RemoveChild(IBusinessProcessNode childNode)
{
lock (_syncLock)
{
bool removeResult = _childNodes.Remove(childNode);
if (removeResult)
{
_logger.LogDebug("分组【{GroupName}】移除子节点：{ChildName}", NodeName, childNode.NodeName);
}
else
{
_logger.LogDebug("分组【{GroupName}】未找到目标子节点【{ChildName}】，无需移除", NodeName, childNode.NodeName);
}
}
}
/// <summary>
/// 返回当前子节点快照副本，避免外部遍历锁竞争
/// </summary>
/// <returns>子节点列表快照</returns>
public List<IBusinessProcessNode> GetChildren()
{
lock (_syncLock)
{
return new List<IBusinessProcessNode>(_childNodes);
}
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：结构型模式 Structural Patterns 组合模式 Composite Pattern
# 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 : BusinessProcessException.cs
*/
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Core.Exceptions
{
/// <summary>
/// 珠宝业务流程全局自定义异常
/// 用于区分业务流程错误与系统底层异常，日志可单独识别
/// </summary>
public class BusinessProcessException : Exception
{
/// <summary>
/// 关联业务订单号
/// </summary>
public string BusinessOrderNo { get; }
/// <summary>
/// 异常所属业务节点名称
/// </summary>
public string ProcessNodeName { get; }
/// <summary>
/// 构造业务流程异常
/// </summary>
/// <param name="message">异常描述</param>
/// <param name="orderNo">业务单号</param>
/// <param name="nodeName">出错节点名称</param>
public BusinessProcessException(string message, string orderNo, string nodeName)
: base(message)
{
BusinessOrderNo = orderNo;
ProcessNodeName = nodeName;
}
/// <summary>
/// 构造带内部堆栈的业务流程异常
/// </summary>
/// <param name="message">异常描述</param>
/// <param name="innerException">原始异常</param>
/// <param name="orderNo">业务单号</param>
/// <param name="nodeName">出错节点名称</param>
public BusinessProcessException(string message, Exception innerException, string orderNo, string nodeName)
: base(message, innerException)
{
BusinessOrderNo = orderNo;
ProcessNodeName = nodeName;
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : JewelryFileLoggerOptions.cs
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Serilog;
using Serilog.Events;
namespace CompositePattern.Core.Logging
{
public static class JewelryFileLoggerOptions
{
public static LoggerConfiguration GetStandardOptions()
{
string logRoot = Path.Combine(Directory.GetCurrentDirectory(), "Logs");
Directory.CreateDirectory(logRoot);
return new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Console(outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] [{SourceContext}] {Message}{NewLine}{Exception}")
.WriteTo.File(
path: Path.Combine(logRoot, "app-.log"),
rollingInterval: RollingInterval.Day,
retainedFileCountLimit: 30,
rollOnFileSizeLimit: true,
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] [{SourceContext}] {Message}{NewLine}{Exception}");
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : LoggerServiceExtension.cs
*/
using Microsoft.Extensions.Logging;
using Serilog;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Core.Logging
{
/// <summary>
///
/// </summary>
public static class LoggerServiceExtension
{
public static ILoggingBuilder AddJewelryStandardLogger(this ILoggingBuilder loggingBuilder)
{
loggingBuilder.ClearProviders();
Log.Logger = JewelryFileLoggerOptions.GetStandardOptions().CreateLogger();
loggingBuilder.AddSerilog(dispose: true);
loggingBuilder.SetMinimumLevel(LogLevel.Debug);
AppDomain.CurrentDomain.ProcessExit += (sender, args) => Log.CloseAndFlush();
AppDomain.CurrentDomain.UnhandledException += (sender, args) => Log.CloseAndFlush();
return loggingBuilder;
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : ServiceCollectionExtensions.cs
*/
using CompositePattern.Business.CompositeGroups;
using CompositePattern.Business.Nodes;
using CompositePattern.Business.Scheduler;
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Extensions
{
/// <summary>
/// DI容器服务注册扩展类
/// 一次性注册所有核心、业务、调度组件，Program入口代码极简
/// 新增业务节点仅在此处追加注册，无需修改主程序
/// </summary>
public static class ServiceCollectionExtensions
{
/// <summary>
/// 批量注册珠宝系统全部业务、组合、调度服务（单例生命周期）
/// </summary>
/// <param name="services">DI服务集合</param>
/// <returns>链式服务集合</returns>
public static IServiceCollection AddJewelryAllBusinessServices(this IServiceCollection services)
{
// 1. 全局根组合节点
services.AddSingleton(sp =>
{
var log = sp.GetRequiredService<ILogger<ProcessCompositeNode>>();
return new ProcessCompositeNode(log, "珠宝全业务总流程根节点");
});
// 2. 12个叶子业务节点单例注册
services.AddSingleton<RawMaterialPurchaseNode>();
services.AddSingleton<DesignDrawNode>();
services.AddSingleton<ManufactureNode>();
services.AddSingleton<QualityCheckNode>();
services.AddSingleton<PackNode>();
services.AddSingleton<LogisticsNode>();
services.AddSingleton<FinanceNode>();
services.AddSingleton<MarketingNode>();
services.AddSingleton<BusinessSaleNode>();
services.AddSingleton<HrAdminNode>();
services.AddSingleton<ItSystemNode>();
services.AddSingleton<TrainNode>();
// 3. 三大业务分组组合节点注册
services.AddSingleton<SaleLinkComposite>();
services.AddSingleton<ProduceLinkComposite>();
services.AddSingleton<AdminSupportComposite>();
// 4. 全局业务调度器注册
services.AddSingleton<JewelryBusinessScheduler>();
return services;
}
}
}
cs
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : AdminSupportComposite.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.CompositeGroups
{
/// <summary>
/// 业务分组组合节点：职能后台支撑链路
/// 包含：财务、人事行政、IT、培训后台职能节点
/// </summary>
public class AdminSupportComposite : ProcessCompositeNode
{
public AdminSupportComposite(ILogger<AdminSupportComposite> logger)
: base(logger, "职能后台支撑链路")
{
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : ProduceLinkComposite.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.CompositeGroups
{
/// <summary>
/// 业务分组组合节点：生产制造核心链路
/// 包含：原料采购、设计、加工、质检、包装、物流全生产流程
/// </summary>
public class ProduceLinkComposite : ProcessCompositeNode
{
public ProduceLinkComposite(ILogger<ProduceLinkComposite> logger)
: base(logger, "生产制造链路")
{
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : SaleLinkComposite.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.CompositeGroups
{
/// <summary>
/// 业务分组组合节点：前端销售链路
/// 包含：业务销售、营销推广两个叶子节点
/// </summary>
public class SaleLinkComposite : ProcessCompositeNode
{
public SaleLinkComposite(ILogger<SaleLinkComposite> logger)
: base(logger, "前端销售链路")
{
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : JewelryBusinessScheduler.cs
*/
using CompositePattern.Business.CompositeGroups;
using CompositePattern.Business.Nodes;
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Scheduler
{
/// <summary>
/// 珠宝业务流程调度器（单一职责：流程组装、同步/并发批量调度）
/// 不实现任何业务逻辑，仅负责树形结构组装、批量执行调度、异常顶层捕获
/// 完全DI注入依赖，所有业务节点外部传入，低耦合高扩展
/// </summary>
public class JewelryBusinessScheduler
{
/// <summary>
/// 调度器专属日志
/// </summary>
private readonly ILogger<JewelryBusinessScheduler> _logger;
/// <summary>
/// 全局根节点：挂载三大业务分组，代表完整珠宝全业务流程
/// </summary>
private readonly ProcessCompositeNode _rootBusinessComposite;
#region 全部叶子业务节点依赖注入字段
private readonly BusinessSaleNode _saleNode;
private readonly RawMaterialPurchaseNode _materialNode;
private readonly DesignDrawNode _designNode;
private readonly ManufactureNode _manufactureNode;
private readonly QualityCheckNode _qualityNode;
private readonly PackNode _packNode;
private readonly LogisticsNode _logisticsNode;
private readonly FinanceNode _financeNode;
private readonly MarketingNode _marketingNode;
private readonly HrAdminNode _hrNode;
private readonly ItSystemNode _itNode;
private readonly TrainNode _trainNode;
#endregion
#region 业务分组组合节点依赖注入字段
private readonly SaleLinkComposite _saleComposite;
private readonly ProduceLinkComposite _produceComposite;
private readonly AdminSupportComposite _adminComposite;
#endregion
/// <summary>
/// 全依赖构造注入，所有业务节点、分组、根组合全部由DI传入
/// </summary>
public JewelryBusinessScheduler(
ILogger<JewelryBusinessScheduler> logger,
ProcessCompositeNode rootComposite,
// 叶子节点
BusinessSaleNode saleNode,
RawMaterialPurchaseNode materialNode,
DesignDrawNode designNode,
ManufactureNode manufactureNode,
QualityCheckNode qualityNode,
PackNode packNode,
LogisticsNode logisticsNode,
FinanceNode financeNode,
MarketingNode marketingNode,
HrAdminNode hrNode,
ItSystemNode itNode,
TrainNode trainNode,
// 分组组合节点
SaleLinkComposite saleComposite,
ProduceLinkComposite produceComposite,
AdminSupportComposite adminComposite)
{
_logger = logger;
_rootBusinessComposite = rootComposite;
_saleNode = saleNode;
_materialNode = materialNode;
_designNode = designNode;
_manufactureNode = manufactureNode;
_qualityNode = qualityNode;
_packNode = packNode;
_logisticsNode = logisticsNode;
_financeNode = financeNode;
_marketingNode = marketingNode;
_hrNode = hrNode;
_itNode = itNode;
_trainNode = trainNode;
_saleComposite = saleComposite;
_produceComposite = produceComposite;
_adminComposite = adminComposite;
}
/// <summary>
/// 初始化完整业务树形组合结构
/// 分层挂载：叶子节点→分组组合→全局根节点
/// 外部可随时新增节点后再次调用重新组装
/// </summary>
public void InitFullBusinessTreeStructure()
{
_logger.LogInformation("调度器开始初始化珠宝全业务组合树形结构");
// 1. 组装销售链路分组
_saleComposite.AddChild(_saleNode);
_saleComposite.AddChild(_marketingNode);
// 2. 组装生产制造链路分组
_produceComposite.AddChild(_materialNode);
_produceComposite.AddChild(_designNode);
_produceComposite.AddChild(_manufactureNode);
_produceComposite.AddChild(_qualityNode);
_produceComposite.AddChild(_packNode);
_produceComposite.AddChild(_logisticsNode);
// 3. 组装职能后台支撑分组
_adminComposite.AddChild(_financeNode);
_adminComposite.AddChild(_hrNode);
_adminComposite.AddChild(_itNode);
_adminComposite.AddChild(_trainNode);
// 4. 根节点挂载三大顶层业务分组
_rootBusinessComposite.AddChild(_saleComposite);
_rootBusinessComposite.AddChild(_produceComposite);
_rootBusinessComposite.AddChild(_adminComposite);
_logger.LogInformation("珠宝全业务树形组合结构初始化完成");
}
/// <summary>
/// 同步执行单个订单完整全业务流程
/// </summary>
/// <param name="orderNo">唯一业务订单编号</param>
public void RunSingleOrderFullProcess(string orderNo)
{
_logger.LogInformation("调度器启动单订单完整业务流程，订单号：{OrderNo}", orderNo);
try
{
_rootBusinessComposite.Execute(orderNo);
_logger.LogInformation("调度器单订单全部业务流程执行完成，订单号：{OrderNo}", orderNo);
}
catch (Exception ex)
{
_logger.LogCritical(ex, "调度器顶层捕获订单全局未知异常，订单号：{OrderNo}", orderNo);
}
}
/// <summary>
/// 多线程并发批量执行多订单业务流程
/// 使用Parallel.ForEach实现高并发调度，订单之间完全隔离
/// 单个订单异常仅内部记录，不影响其他订单执行
/// </summary>
/// <param name="orderNoList">批量订单编号集合</param>
public void RunMultiThreadBatchProcess(List<string> orderNoList)
{
if (orderNoList == null || orderNoList.Count == 0)
{
_logger.LogWarning("批量订单集合为空，跳过并发调度");
return;
}
_logger.LogInformation("调度器启动多线程高并发批量业务执行，待处理订单总数：{Count}", orderNoList.Count);
Parallel.ForEach(orderNoList, orderCode =>
{
RunSingleOrderFullProcess(orderCode);
});
_logger.LogInformation("多线程批量全部订单业务流程执行完毕");
}
}
}
cs
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : BusinessSaleNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：业务销售
/// 业务职责：客户洽谈、定制需求录入、销售订单合同建档
/// </summary>
public class BusinessSaleNode : AbstractProcessNode
{
public BusinessSaleNode(ILogger<BusinessSaleNode> logger)
: base(logger, "业务")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】客户订单建档流程启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】录入客户定制参数、签订销售合同、创建业务订单档案", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】业务销售流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : DesignDrawNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：设计制图
/// 业务职责：首饰3D建模、效果图渲染、生产图纸导出、方案归档
/// </summary>
public class DesignDrawNode : AbstractProcessNode
{
public DesignDrawNode(ILogger<DesignDrawNode> logger)
: base(logger, "设计制图")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】首饰3D建模设计启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】完成款式建模、尺寸标注、客户效果图渲染导出", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】图纸归档至设计资源库，下发至生产车间", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】设计制图流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : FinanceNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：财务
/// 业务职责：订单成本归集、销售开票、应收应付台账记账
/// </summary>
public class FinanceNode : AbstractProcessNode
{
public FinanceNode(ILogger<FinanceNode> logger)
: base(logger, "财务")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】订单成本核算流程启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】归集原料、加工、物流成本，开具销售发票，更新应收台账", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】财务核算流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : HrAdminNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：人事行政
/// 业务职责：车间工序工时统计、生产员工绩效台账更新
/// </summary>
public class HrAdminNode : AbstractProcessNode
{
public HrAdminNode(ILogger<HrAdminNode> logger)
: base(logger, "人事行政")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】订单对应生产人员绩效统计启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】统计各工序工时，更新车间员工绩效台账记录", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】人事行政流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : ItSystemNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：IT运维
/// 业务职责：订单业务数据备份、数据库归档、系统日志巡检
/// </summary>
public class ItSystemNode : AbstractProcessNode
{
public ItSystemNode(ILogger<ItSystemNode> logger)
: base(logger, "IT")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】业务订单数据备份校验启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】完成订单业务数据归档、数据库备份完整性校验", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】IT运维流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : LogisticsNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：物流
/// 业务职责：珠宝保价快递、物流单生成、配送跟踪台账登记
/// </summary>
public class LogisticsNode : AbstractProcessNode
{
public LogisticsNode(ILogger<LogisticsNode> logger)
: base(logger, "物流")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】保价发货流程启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】生成珠宝保价快递单据，录入物流跟踪管理台账", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】物流流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : ManufactureNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：加工生产
/// 业务职责：失蜡铸造、宝石镶嵌、粗抛、精抛车间工序流转
/// </summary>
public class ManufactureNode : AbstractProcessNode
{
public ManufactureNode(ILogger<ManufactureNode> logger)
: base(logger, "加工生产")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】车间生产排产启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】执行铸造、镶嵌、粗抛、精抛全生产工序", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】半成品流转至成品质检工位", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】加工生产流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : MarketingNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：营销推广
/// 业务职责：客户会员积分、用户标签、营销活动数据统计归档
/// </summary>
public class MarketingNode : AbstractProcessNode
{
public MarketingNode(ILogger<MarketingNode> logger)
: base(logger, "营销推广")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】订单客户营销数据归档启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】发放客户会员积分，更新客户用户标签，统计活动转化数据", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】营销推广流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : PackNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：包装
/// 业务职责：礼盒封装、配套证书、防尘防护、防伪封签粘贴
/// </summary>
public class PackNode : AbstractProcessNode
{
public PackNode(ILogger<PackNode> logger)
: base(logger, "包装")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】成品打包作业启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】首饰礼盒封装、配套证书放置、防伪封签粘贴完成", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】包装流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : QualityCheckNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：质检
/// 业务职责：重量、贵金属纯度、镶嵌牢固度、外观瑕疵全项检测
/// </summary>
public class QualityCheckNode : AbstractProcessNode
{
public QualityCheckNode(ILogger<QualityCheckNode> logger)
: base(logger, "质检")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】成品综合检测启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】称重、纯度检测、宝石牢固度、外观瑕疵逐项校验", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】合格品粘贴防伪证书，不良品标记退回车间返工", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】质检流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : RawMaterialPurchaseNode.cs
*/
using CompositePattern.Core.CompositePattern;
using CompositePattern.Core.Exceptions;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：原料采购核验
/// 业务职责：贵金属/宝石原料入库、资质核验、库存台账登记
/// </summary>
public class RawMaterialPurchaseNode : AbstractProcessNode
{
/// <summary>
/// DI构造注入日志实例
/// </summary>
/// <param name="logger">当前节点分类日志</param>
public RawMaterialPurchaseNode(ILogger<RawMaterialPurchaseNode> logger)
: base(logger, "原料采购核验")
{
}
/// <summary>
/// 执行原料采购核验完整业务流程
/// </summary>
/// <param name="businessOrderNo">珠宝业务订单编号</param>
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】原料入库校验流程启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】核验贵金属纯度报告、宝石鉴定证书、供应商资质文件", NodeName, businessOrderNo);
// 模拟异常分支：订单后缀带ERR代表原料资质缺失
if (businessOrderNo.EndsWith("ERR", StringComparison.OrdinalIgnoreCase))
{
string errMsg = "原料配套鉴定证书缺失，无法入库，需退回供应商重新提供";
_logger.LogWarning("【{NodeName}】业务校验失败：{Msg}，订单号：{OrderNo}", NodeName, errMsg, businessOrderNo);
throw new BusinessProcessException(errMsg, businessOrderNo, NodeName);
}
_logger.LogInformation("【{NodeName}】原料入库台账录入完成，原料库存数据同步更新", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】原料采购核验流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：组合模式 Composite 演示业务层
# 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 : TrainNode.cs
*/
using CompositePattern.Core.CompositePattern;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;
namespace CompositePattern.Business.Nodes
{
/// <summary>
/// 叶子业务节点：员工培训
/// 业务职责：新款工艺培训台账、质检标准培训记录归档
/// </summary>
public class TrainNode : AbstractProcessNode
{
public TrainNode(ILogger<TrainNode> logger)
: base(logger, "培训")
{
}
public override void Execute(string businessOrderNo)
{
_logger.LogDebug("【{NodeName}】新款工艺培训台账归档启动，订单号：{OrderNo}", NodeName, businessOrderNo);
_logger.LogInformation("【{NodeName}】更新新款首饰工艺、质检标准培训记录台账", NodeName, businessOrderNo);
_logger.LogDebug("【{NodeName}】员工培训流程执行完毕，订单号：{OrderNo}", NodeName, businessOrderNo);
}
}
}调用：
cs
/*
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：结构型模式 Structural Patterns 组合模式 Composite Pattern演示业务层
# 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 : CompositeBll.cs
*/
using System;
using System.Collections.Generic;
using System.Text;
using CompositePattern.Core.Logging;
using CompositePattern.Extensions;
using CompositePattern.Business.Scheduler;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
namespace BLL
{
public abstract class Component
{
public string Name;
protected Component(string name) => Name = name;
public abstract void Display(int depth);
}
public class Leaf : Component
{
public Leaf(string name) : base(name) { }
public override void Display(int depth)
{
Console.WriteLine(new string('-', depth) + Name);
}
}
public class Composite : Component
{
private List<Component> _children = new();
public Composite(string name) : base(name) { }
public void Add(Component c) => _children.Add(c);
public override void Display(int depth)
{
Console.WriteLine(new string('-', depth) + Name);
foreach (var c in _children) c.Display(depth + 2);
}
}
public class CompositeBll
{
public void Demo()
{
#region 1. 初始化DI服务容器 + 全局标准化日志
var serviceCollection = new ServiceCollection();
// 注册企业级标准日志（控制台+按日期分级文件，输出格式统一）
serviceCollection.AddLogging(logBuilder =>
{
logBuilder.AddJewelryStandardLogger();
});
// 一次性注册全部业务、组合、调度服务
serviceCollection.AddJewelryAllBusinessServices();
#endregion
#region 2. 构建服务提供者，获取调度器实例
var serviceProvider = serviceCollection.BuildServiceProvider();
var scheduler = serviceProvider.GetRequiredService<JewelryBusinessScheduler>();
var mainLogger = serviceProvider.GetRequiredService<ILogger<CompositeBll>>();
// 初始化完整业务树形组合结构
scheduler.InitFullBusinessTreeStructure();
#endregion
#region 3. 多场景业务流程测试
mainLogger.LogInformation("========== 珠宝企业级组合模式业务系统启动完成 ==========");
// 测试1：单个正常订单全流程
string normalOrder = "JEW20260716001";
scheduler.RunSingleOrderFullProcess(normalOrder);
// 测试2：异常订单（原料证书缺失模拟报错）
string errorOrder = "JEW20260716002-ERR";
scheduler.RunSingleOrderFullProcess(errorOrder);
// 测试3：多线程高并发批量订单测试
List<string> batchOrderList = new List<string>()
{
"JEW20260716003",
"JEW20260716004",
"JEW20260716005",
"JEW20260716006"
};
scheduler.RunMultiThreadBatchProcess(batchOrderList);
mainLogger.LogInformation("========== 全部业务流程测试执行结束，按回车退出程序 ==========");
Console.ReadLine();
#endregion
}
}
}输出：
