// ResourceNode构建依赖图
class ResourceNode
{
    public IResource Resource { get; set; }
    public List<IResource> StrongDependencies { get; set; } // 强依赖：资源A必须在资源B之前开启
    public List<IResource> WeakDependencies { get; set; }   // 弱依赖：资源A开启后通知资源B
    public List<IResource> Dependents { get; set; }         // 依赖此资源的其他资源
}

// 资源开启的核心调度逻辑
void OpenResource(ResourceNode node, WaitHandle canStart)
{
    // 1. 等待所有强依赖资源完成开启
    var taskArray = node.StrongDependencies.Select(dep => openTasks[dep]).ToArray();
    Task.WaitAll(taskArray);
    
    // 2. 执行当前资源开启
    ResourcePreOpenEvent.Invoke(node.Resource);
    node.Resource.Open();
    
    // 3. 触发资源开启事件
    ResourceOpened?.Invoke(node.Resource);
    
    // 4. 通知弱依赖资源
    foreach(var weakDep in node.WeakDependencies)
    {
        // 通知弱依赖资源可以开始初始化
        ResourceWeakDependencyOpened?.Invoke(weakDep, node.Resource);
    }
}

// 主要开启任务跟踪
readonly ConcurrentDictionary<IResource, Task> openTasks = new();

// 完成通知任务跟踪  
readonly ConcurrentDictionary<IResource, Task> finallyTasks = new();

// 资源开启的完整流程
public Task OpenAsync(IEnumerable<IResource> resources, CancellationToken cancellationToken)
{
    // 1. 构建资源依赖图
    var resourceNodes = BuildResourceGraph(resources);
    
    // 2. 为每个资源创建开启任务
    foreach(var node in resourceNodes)
    {
        var openTask = Task.Run(() => OpenResource(node, canStart), cancellationToken);
        openTasks[node.Resource] = openTask;
        
        // 3. 创建完成通知任务
        var finallyTask = CreateFinallyTask(node, openTask);
        finallyTasks[node.Resource] = finallyTask;
    }
    
    // 4. 等待所有任务完成
    return Task.WhenAll(finallyTasks.Values);
}

// 定义资源属性开关行为
public enum ResourceOpenBehavior
{
    Before,      // 默认：串行开启，依赖资源先开启
    InParallel,  // 并行开启，可与主资源同时初始化
    Ignore       // 忽略此资源属性，不自动开关
}

// 使用示例
public class PowerSupply : Resource
{
    // 与主资源并行开启的子资源
    [ResourceOpen(ResourceOpenBehavior.InParallel)]
    public InstrumentChannel Channel { get; set; }
    
    // 需要提前开启的依赖资源
    [ResourceOpen(ResourceOpenBehavior.Before)]
    public CoolingSystem Cooler { get; set; }
    
    // 手动管理的资源，不自动开关
    [ResourceOpen(ResourceOpenBehavior.Ignore)]
    public ExternalMonitor Monitor { get; set; }
}

// 依赖循环检测算法
bool HasCircularDependency(IResource resource, HashSet<IResource> visited, HashSet<IResource> recursionStack)
{
    if(recursionStack.Contains(resource))
        return true; // 发现循环依赖
        
    if(visited.Contains(resource))
        return false;
        
    visited.Add(resource);
    recursionStack.Add(resource);
    
    foreach(var dep in GetDependencies(resource))
    {
        if(HasCircularDependency(dep, visited, recursionStack))
            return true;
    }
    
    recursionStack.Remove(resource);
    return false;
}

// 异常隔离和资源回滚
try
{
    node.Resource.Open();
}
catch(Exception ex)
{
    log.Error("Failed to open resource {0}: {1}", node.Resource.Name, ex.Message);
    
    // 标记失败状态
    ResourceOpenFailed?.Invoke(node.Resource, ex);
    
    // 触发依赖此资源的其他资源的失败处理
    foreach(var dependent in node.Dependents)
    {
        CancelDependentResource(dependent, $"Dependency {node.Resource.Name} failed");
    }
    
    throw; // 重新抛出异常，通知上层
}

using OpenTap;
using System;
using System.Threading;

[Display("依赖资源测试")]
public class DependencyResourceTest : TestStep
{
    public override void Run()
    {
        // 创建测试资源
        var mainInstrument = new MockInstrument() { Name = "MainInstrument" };
        var subInstrument = new MockInstrument() { Name = "SubInstrument" };
        var powerSupply = new MockPowerSupply() { Name = "PowerSupply" };
        
        // 设置依赖关系
        mainInstrument.DependentResource = subInstrument;
        subInstrument.DependentResource = powerSupply;
        
        // 创建测试计划并执行
        var plan = new TestPlan();
        plan.ChildTestSteps.Add(this);
        
        // 验证资源开启顺序
        Log.Info("开始执行测试计划，观察资源开启顺序...");
        var result = plan.Execute();
        
        Log.Info($"测试执行结果: {(result.Passed ? "通过" : "失败")}");
    }
}

// 模拟带依赖的资源
public class MockInstrument : Instrument
{
    public IResource DependentResource { get; set; }
    
    public override void Open()
    {
        Log.Info($"正在开启资源: {Name}");
        Thread.Sleep(100); // 模拟开启时间
        base.Open();
    }
    
    public override void Close()  
    {
        Log.Info($"正在关闭资源: {Name}");
        base.Close();
    }
}

// 注解器接口 - 所有注解器的基座
public interface IAnnotator : ITapPlugin
{
    double Priority { get; }
    void Annotate(AnnotationCollection annotations);
}

// 标记接口 - 标识注解数据
public interface IAnnotation { }

// 显示注解接口 - 定义UI展示相关属性
public interface IDisplayAnnotation : IAnnotation
{
    string Description { get; }
    string[] Group { get; }
    string Name { get; }
    double Order { get; }
    bool Collapsed { get; }
}

public class AnnotationCollection : List<Annotation>, IAnnotation
{
    private static readonly ConcurrentDictionary<object, AnnotationCollection> Cache 
        = new ConcurrentDictionary<object, AnnotationCollection>();
    
    // 关键方法：获取或创建对象的注解集合
    public static AnnotationCollection GetAnnotations(object obj)
    {
        return Cache.GetOrAdd(obj, o =>
        {
            var annotations = new AnnotationCollection();
            // 调用所有注册的IAnnotator插件
            var annotators = PluginManager.GetPlugins<IAnnotator>()
                .OrderBy(a => a.Priority);
            
            foreach (var annotator in annotators)
            {
                annotator.Annotate(annotations);
            }
            
            return annotations;
        });
    }
}

public class Annotation : IAnnotation, IReflectable
{
    private readonly Dictionary<Type, IAnnotation> data = 
        new Dictionary<Type, IAnnotation>();
    
    // 关键方法：获取指定类型的注解数据
    public T Get<T>() where T : class, IAnnotation
    {
        return data.TryGetValue(typeof(T), out var value) 
            ? value as T : null;
    }
    
    // 添加注解数据
    public void Add(IAnnotation annotation)
    {
        data[annotation.GetType()] = annotation;
    }
}

// DisplayNameAnnotator - 处理显示名称
public class DisplayNameAnnotator : IAnnotator
{
    public double Priority => 100;
    
    public void Annotate(AnnotationCollection annotations)
    {
        if (annotations.AnnotatedElement is MemberData member)
        {
            // 获取DisplayNameAttribute特性
            var displayAttr = member.GetAttribute<DisplayNameAttribute>();
            if (displayAttr != null)
            {
                // 创建显示注解
                var displayAnnotation = new DisplayAnnotation
                {
                    Name = displayAttr.DisplayName,
                    Description = member.GetAttribute<DescriptionAttribute>()?.Description
                };
                annotations.Add(displayAnnotation);
            }
        }
    }
}

// 示例：自定义验证注解器
[PluginType(true)] // 标记为全局插件
public class ValidationAnnotator : IAnnotator
{
    public double Priority => 200;
    
    public void Annotate(AnnotationCollection annotations)
    {
        if (annotations.AnnotatedElement is MemberData member)
        {
            // 检查是否有验证特性
            var validationAttrs = member.GetAttributes<ValidationAttribute>();
            if (validationAttrs.Any())
            {
                var validationAnnotation = new ValidationAnnotation
                {
                    Rules = validationAttrs.Select(attr => attr.FormatErrorMessage(member.Name))
                                          .ToArray()
                };
                annotations.Add(validationAnnotation);
            }
        }
    }
}

// 获取对象的注解
var testStep = new MyTestStep();
var annotations = AnnotationCollection.GetAnnotations(testStep);

// 获取显示信息
var displayInfo = annotations.Get<IDisplayAnnotation>();
if (displayInfo != null)
{
    Console.WriteLine($"显示名称: {displayInfo.Name}");
    Console.WriteLine($"描述: {displayInfo.Description}");
}

// 获取所有验证规则
var validationInfo = annotations.Get<IValidationAnnotation>();
if (validationInfo != null)
{
    foreach (var rule in validationInfo.Rules)
    {
        Console.WriteLine($"验证规则: {rule}");
    }
}

// 线程安全示例
public static class AnnotationHelper
{
    private static readonly object lockObj = new object();
    
    public static T GetAnnotationSafe<T>(object obj) where T : class, IAnnotation
    {
        var annotations = AnnotationCollection.GetAnnotations(obj);
        lock (lockObj)
        {
            return annotations.Get<T>();
        }
    }
}

// 推荐：使用特性标记进行扩展
[AttributeUsage(AttributeTargets.Property)]
public class CustomDisplayAttribute : Attribute, IAnnotation
{
    public string Category { get; set; }
    public bool ReadOnly { get; set; }
}

// 对应的注解器
public class CustomDisplayAnnotator : IAnnotator
{
    public double Priority => 150;
    
    public void Annotate(AnnotationCollection annotations)
    {
        var member = annotations.AnnotatedElement as MemberData;
        var customAttr = member?.GetAttribute<CustomDisplayAttribute>();
        if (customAttr != null)
        {
            annotations.Add(new CustomDisplayAnnotation
            {
                Category = customAttr.Category,
                IsReadOnly = customAttr.ReadOnly
            });
        }
    }
}

// 线程管理器核心结构
internal class ThreadManager : IDisposable
{
    readonly ConcurrentQueue<TapThread> workQueue = new ConcurrentQueue<TapThread>();
    readonly Semaphore freeWorkSemaphore = new Semaphore(0, Int32.MaxValue);
    int freeWorkers = 0;
    int MaxWorkerThreads = 1024;
}

public enum TapThreadStatus
{
    Queued,              // 工作已排队，尚未开始
    Running,             // 工作正在处理
    Completed,           // 工作已完成
    HierarchyCompleted   // 该线程及其所有子线程已完成
}

internal class ThreadField<T> : ThreadField
{
    public T Value
    {
        get => Get();
        set => Set(value);
    }
    
    T Get()
    {
        var thread = TapThread.Current;
        bool isParent = false;
        
        // 遍历父线程链，支持值继承
        while (thread != null)
        {
            if (TryGetFieldValue(thread, out var found))
            {
                if (isCached && isParent)
                    SetFieldValue(found); // 缓存到当前线程
                return (T)found;
            }
            thread = thread.Parent;
            isParent = true;
        }
        return default;
    }
}

void StartWorker()
{
    Interlocked.Increment(ref freeWorkers);
    
    ThreadPool.QueueUserWorkItem(_ =>
    {
        try
        {
            while (!cancelSrc.IsCancellationRequested)
            {
                freeWorkSemaphore.WaitOne();
                
                if (workQueue.TryDequeue(out var thread))
                {
                    Interlocked.Decrement(ref freeWorkers);
                    ProcessThread(thread);
                    Interlocked.Increment(ref freeWorkers);
                }
            }
        }
        finally
        {
            Interlocked.Decrement(ref freeWorkers);
        }
    });
}

// 推荐：使用缓存模式减少查找开销
static readonly ThreadField<string> cachedField = 
    new ThreadField<string>(ThreadFieldMode.Cached);

// 避免：频繁创建 ThreadField 实例
var field = new ThreadField<object>(); // 每次调用都创建新实例

TapThread.Start(() =>
{
    try
    {
        // 测试逻辑
        DoTestWork();
    }
    catch (Exception ex)
    {
        Log.Error($"Thread execution failed: {ex.Message}");
        // 适当的错误恢复机制
    }
});

public static class ThreadPoolMonitor
{
    public static void LogThreadPoolStatus()
    {
        int workerThreads, completionPortThreads;
        ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
        
        Log.Info($"Available Worker Threads: {workerThreads}");
        Log.Info($"Available IOCP Threads: {completionPortThreads}");
    }
}

// 根据系统配置调整线程池
ThreadPool.SetMinThreads(100, 100);
ThreadPool.SetMaxThreads(500, 500);

// 推荐：使用 async/await 模式
public async Task ExecuteTestAsync()
{
    await TapThread.StartAsync(async () =>
    {
        var result = await RunTestStepAsync();
        ProcessResult(result);
    });
}

// 避免：阻塞式等待
var thread = TapThread.Start(() => DoWork());
thread.Wait(); // 可能导致死锁

private TestPlanRun DoExecute(IEnumerable<IResultListener> resultListeners, 
    IEnumerable<ResultParameter> metaDataParameters, HashSet<ITestStep> stepsOverride)
{
    // 1. 初始化执行上下文
    var execStage = new TestPlanRun(this, resultListeners.ToList(), initTime, initTimeStamp);
    
    // 2. 打开资源
    OpenInternal(execStage, continuedExecutionState, allEnabledSteps, Array.Empty<IResource>());
    
    // 3. 执行测试计划
    runWentOk = ExecTestPlan(execStage, steps);
    
    // 4. 清理和收尾
    finishTestPlanRun(execStage, preRun_Run_PostRunTimer, runWentOk, planRunLog, logStream);
}

private FailState ExecTestPlan(TestPlanRun planRun, IList<ITestStep> steps)
{
    try
    {
        // 执行 PrePlanRun 阶段
        if (!RunPrePlanRunMethods(steps, planRun))
            return FailState.StartFail;
            
        // 执行测试步骤
        for (int i = 0; i < steps.Count; i++)
        {
            var step = steps[i];
            if (step.Enabled == false) continue;
            
            var run = step.DoRun(planRun, planRun);
            if (!run.Skipped)
                runs.Add(run);
                
            // 处理 Break 条件
            if (run.BreakConditionsSatisfied())
            {
                addBreakResult(breakingRun);
                break;
            }
        }
    }
    catch(TestStepBreakException breakEx)
    {
        // 处理测试步骤中断异常
        var breakingRun = getBreakingRun(breakEx.Run);
        addBreakResult(breakingRun);
        Log.Info("{0}", breakEx.Message);
    }
    finally
    {
        // 等待所有步骤完成
        foreach (var run in runs)
        {
            run.WaitForCompletion();
            planRun.UpgradeVerdict(run.Verdict);
        }    
    }
    
    return FailState.Ok;
}

internal static ThreadHierarchyLocal<TestPlanRun> executingPlanRun = new ThreadHierarchyLocal<TestPlanRun>();

finally
{
    execStage.FailedToStart = (runWentOk == FailState.StartFail);
    finishTestPlanRun(execStage, preRun_Run_PostRunTimer, runWentOk, planRunLog, logStream);
    
    // 清理步骤运行状态
    foreach (var step in allSteps)
        step.StepRun = null;
}

public Task<TestPlanRun> ExecuteAsync(CancellationToken abortToken)
{
    return ExecuteAsync(ResultSettings.Current, null,null, abortToken);
}

// 创建测试计划执行示例
var testPlan = new TestPlan();
testPlan.Name = "Execution Demo";

// 添加测试步骤
var delayStep = new OpenTap.Tutorial.SimpleDelayTestStep();
delayStep.DelaySecs = 1.0;
testPlan.Steps.Add(delayStep);

// 执行测试计划（带异常处理）
try
{
    var result = testPlan.Execute();
    Console.WriteLine($"Test plan completed with verdict: {result.Verdict}");
    Console.WriteLine($"Duration: {result.Duration.TotalSeconds} seconds");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Test plan was cancelled");
}
catch (Exception ex)
{
    Console.WriteLine($"Test plan failed: {ex.Message}");
}

public static void Search()
{
    var dirs = DirectoriesToSearch.ToArray();
    searcher = new PluginSearcher();
    searcher.Search(dirs);
    searchTask.Set();
}

// PluginSearcher 核心搜索逻辑
foreach (var file in GetAssemblyFiles(directories))
{
    try
    {
        using (var stream = File.OpenRead(file))
        using (var peReader = new PEReader(stream))
        {
            var metadataReader = peReader.GetMetadataReader();
            // 分析程序集元数据，查找插件类型
            AnalyzeAssembly(metadataReader, file);
        }
    }
    catch (Exception ex)
    {
        log.Warning("Failed to analyze assembly {0}: {1}", file, ex.Message);
    }
}

private static ICollection<TypeData> GetPlugins(PluginSearcher searcher, string baseTypeFullName)
{
    TypeData baseType;
    if (!searcher.AllTypes.TryGetValue(baseTypeFullName, out baseType))
        return Array.Empty<TypeData>();

    var specializations = new List<TypeData>();
    foreach (TypeData st in baseType.DerivedTypes)
    {
        if (st.TypeAttributes.HasFlag(TypeAttributes.Interface) || 
            st.TypeAttributes.HasFlag(TypeAttributes.Abstract))
            continue;
        
        if(shouldLoadAssembly(st.Assembly.Name, st.Assembly.Version))
            specializations.Add(st);
    }
    return specializations;
}

public static ReadOnlyCollection<Type> GetPlugins(Type pluginBaseType)
{
    // 获取未加载的插件列表
    var unloadedPlugins = PluginManager.GetPlugins(searcher, pluginBaseType.FullName);
    
    // 批量加载未加载的程序集
    var notLoadedAssemblies = unloadedPlugins
        .Select(x => x.Assembly)
        .Distinct()
        .Where(asm => asm.Status == LoadStatus.NotLoaded)
        .ToArray();
    
    if (notLoadedAssemblies.Length > 0)
    {
        // 并行加载多个程序集，提升性能
        notLoadedAssemblies.AsParallel().ForAll(asm => asm.Load());
    }
    
    return unloadedPlugins
        .Select(td => td.Load())
        .Where(x => x != null)
        .ToList()
        .AsReadOnly();
}

[assembly: OpenTap.PluginAssembly(true)]
[assembly: OpenTap.PluginAssembly(true, "MyNamespace.PluginInitializer.Init")]

PluginManager.AddAssemblyLoadFilter((asmName, version) => 
{
    // 拒绝加载特定版本的程序集
    if (asmName == "ProblematicAssembly" && version < new Version("2.0.0"))
        return false;
    return true;
});

if (notLoadedTypesCnt > 8)
{
    plugins = plugins
        .AsParallel()
        .AsOrdered();
}

public interface ITestStep : ITestStepParent, IValidatingObject, ITapPlugin
{
    Verdict Verdict { get; set; }
    string Name { get; set; }
    bool Enabled { get; set; }
    
    // 生命周期方法
    void PrePlanRun();
    void Run();
    void PostPlanRun();
}

public abstract class TestStep : ValidatingObject, ITestStep
{
    protected TestStep()
    {
        Name = GetType().GetDisplayName();
        Enabled = true;
        Verdict = Verdict.NotSet;
    }
    
    // 可重写的生命周期方法
    public virtual void PrePlanRun()
    {
        // 默认空实现，子类可重写
    }
    
    public abstract void Run();
    
    public virtual void PostPlanRun()
    {
        // 默认空实现，子类可重写
    }
}

static bool RunPrePlanRunMethods(IList<ITestStep> steps, TestPlanRun planRun)
{
    foreach (ITestStep step in steps)
    {
        if (step.Enabled == false)
            continue;
            
        try
        {
            // 1. 设置执行上下文
            step.PlanRun = planRun;
            
            // 2. 执行预处理
            planRun.AddTestStepStateUpdate(step.Id, null, StepState.PrePlanRun);
            step.PrePlanRun();
            planRun.AddTestStepStateUpdate(step.Id, null, StepState.Idle);
            
            // 3. 递归处理子步骤
            if (!RunPrePlanRunMethods(step.ChildTestSteps, planRun))
            {
                return false;
            }
        }
        catch (Exception ex)
        {
            Log.Error($"PrePlanRun of '{step.Name}' failed: {ex.Message}");
            return false;
        }
        finally
        {
            step.PlanRun = null;
        }
    }
    return true;
}

using OpenTap;

[Display("自定义延时测试步骤")]
public class DelayTestStep : TestStep
{
    [Display("延时时间(秒)")]
    public double DelayTime { get; set; } = 1.0;
    
    private DateTime startTime;
    
    public override void PrePlanRun()
    {
        Log.Info($"[{Name}] 开始预处理，准备延时测试环境");
        startTime = DateTime.Now;
        
        // 验证参数
        if (DelayTime <= 0)
        {
            throw new ArgumentException("延时时间必须大于0");
        }
    }
    
    public override void Run()
    {
        Log.Info($"[{Name}] 开始执行，延时 {DelayTime} 秒");
        
        try
        {
            // 执行核心逻辑
            TapThread.Sleep(TimeSpan.FromSeconds(DelayTime));
            
            // 设置测试结果
            Verdict = Verdict.Pass;
            Log.Info($"[{Name}] 延时执行完成");
        }
        catch (Exception ex)
        {
            Verdict = Verdict.Error;
            Log.Error($"[{Name}] 执行失败: {ex.Message}");
            throw;
        }
    }
    
    public override void PostPlanRun()
    {
        var elapsed = DateTime.Now - startTime;
        Log.Info($"[{Name}] 后处理完成，总耗时: {elapsed.TotalSeconds:F2} 秒");
        
        // 清理资源
        Verdict = Verdict.NotSet; // 重置状态
    }
}

// 核心加载方法
public static TestPlan Load(string filePath, bool cacheXml)
{
    if (filePath == null)
        throw new ArgumentNullException(nameof(filePath));
    var timer = Stopwatch.StartNew();
    // Open document
    using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        var loadedPlan = Load(fs, filePath, cacheXml);
        Log.Info(timer, "Loaded test plan from {0}", filePath);
        return loadedPlan;
    }
}

// 保存到文件流
public void Save(Stream stream, TapSerializer serializer)
{
    if (xmlCache != null)
    {
        stream.Write(xmlCache, 0, xmlCache.Length);
        return;
    }
    
    if (CacheXml)
    {
        var str = new MemoryStream();
        serializer.Serialize(str, this);
        xmlCache = str.ToArray();
        str.CopyTo(stream);
    }
    else
    {
        serializer.Serialize(stream, this);
    }
}

// CliActionTree构造函数核心逻辑
var commands = TypeData.GetDerivedTypes(TypeData.FromType(typeof(ICliAction)))
    .Where(t => t.CanCreateInstance && t.GetDisplayAttribute() != null)
    .ToList();

// 递归构建命令树
foreach (var item in commands)
    ParseCommand(item, item.GetDisplayAttribute().Group, Root);

// 命令匹配算法
public CliActionTree GetSubCommand(string[] args)
{
    if (args.Length == 0) return null;
    
    foreach (var item in SubCommands)
    {
        if (item.Name == args[0])
        {
            if (args.Length == 1 || item.SubCommands.Any() == false)
               return item;
            var subCmd = item.GetSubCommand(args.Skip(1).ToArray());
            return subCmd ?? item;
        }
    }
    return null;
}

[DisplayName("run")]
[DisplayDescription("Runs a test plan")]
public class RunCliAction : ICliAction
{
    [CommandLineArgument("testplan", Description = "Path to the test plan file")]
    [UnnamedCommandLineArgument("testplan", Required = true)]
    public string TestPlanPath { get; set; }
    
    [CommandLineArgument("non-interactive", ShortName = "n")]
    public bool NonInteractive { get; set; }
    
    public int Execute(CancellationToken cancellationToken)
    {
        // 执行逻辑
        return 0;
    }
}

// 执行核心逻辑
int skip = SelectedAction.GetDisplayAttribute().Group.Length + 1;
return packageAction.Execute(args.Skip(skip).ToArray());

// Unix信号处理
if (OperatingSystem.Current != OperatingSystem.Windows)
{
    PosixSignals.AddSignalHandler(PosixSignals.SIGINT, handler);
    PosixSignals.AddSignalHandler(PosixSignals.SIGTERM, handler);
}

using OpenTap.Cli;
using System;

[DisplayName("hello")]
[DisplayDescription("Say hello to someone")]
public class HelloCliAction : ICliAction
{
    [CommandLineArgument("name", ShortName = "n", Description = "Name of the person")]
    [UnnamedCommandLineArgument("name", Required = true)]
    public string Name { get; set; }
    
    [CommandLineArgument("uppercase", ShortName = "u", Description = "Convert to uppercase")]
    public bool Uppercase { get; set; }
    
    public int Execute(System.Threading.CancellationToken cancellationToken)
    {
        var message = $"Hello, {Name}!";
        if (Uppercase)
            message = message.ToUpper();
        
        Console.WriteLine(message);
        return 0; // 成功返回0
    }
}