【.NET高级开发必修课】：C#多播委托异常处理的7种经典场景与应对方案

第一章：C#多播委托异常处理的核心机制

异常中断执行流

// 定义一个无返回值的委托
public delegate void NotifyHandler(string message);

// 示例方法
static void EmailNotify(string msg) => Console.WriteLine("发送邮件: " + msg);
static void SmsNotify(string msg) => throw new Exception("短信服务不可用");
static void LogNotify(string msg) => Console.WriteLine("日志记录: " + msg); // 此方法不会被执行

var multicast = (NotifyHandler)EmailNotify + SmsNotify + LogNotify;

try
{
    multicast("系统告警");
}
catch (Exception ex)
{
    Console.WriteLine("捕获异常: " + ex.Message);
}

安全遍历解决方案

• 通过 GetInvocationList() 获取所有方法引用
• 逐个调用并使用独立的 try-catch 块包裹
• 记录错误而不中断整体流程

第二章：多播委托异常场景的深度剖析

2.1 委托链中单个调用抛出异常的传播行为

异常中断执行流程

Action handler = () => Console.WriteLine("A");
handler += () => { throw new Exception("Error in B"); };
handler += () => Console.WriteLine("C"); // 不会被执行

try {
    handler();
} catch (Exception ex) {
    Console.WriteLine(ex.Message); // 输出：Error in B
}

安全调用策略

• 使用 GetInvocationList() 获取独立的委托数组
• 逐个调用并包裹在 try-catch 中
• 确保其他方法不受影响

2.2 异常中断后剩余委托方法的执行策略

异常安全的委托链执行

foreach (var handler in multicastDelegate.GetInvocationList())
{
    try
    {
        handler.DynamicInvoke(args);
    }
    catch (Exception ex)
    {
        // 记录异常但不中断后续执行
        Log.Error($"Handler failed: {ex.Message}");
    }
}

策略对比

2.3 异步多播委托中的异常捕获与上下文同步

异常安全的委托调用

foreach (var handler in multicastDelegate.GetInvocationList())
{
    try
    {
        await Task.Run(handler.Method.Invoke);
    }
    catch (Exception ex)
    {
        // 记录异常但不中断其余调用
        Logger.LogError(ex, "Handler failed: " + handler.Method.Name);
    }
}

上下文同步机制

• 调用前捕获当前上下文：ExecutionContext.Capture()
• 在任务内部使用 ExecutionContext.Run(context, ...) 恢复
• 确保安全性和一致性跨线程传递

2.4 带返回值的多播委托异常处理陷阱

异常中断执行流

Func<int> multiCast = () => 1;
multiCast += () => { throw new Exception("Error"); };
multiCast += () => 3;

try { multiCast(); }
catch (Exception e) { Console.WriteLine(e.Message); } // 输出：Error

安全获取所有返回值

• 使用 GetInvocationList() 获取独立委托项
• 逐个调用并捕获各自异常
• 收集有效返回值与错误信息

2.5 跨线程多播委托引发的异常隔离问题

异常传播机制

代码示例与分析

Action del = Method1;
del += Method2;
try {
    del();
} catch (Exception ex) {
    Console.WriteLine(ex.Message);
}

foreach (Action handler in del.GetInvocationList()) {
    Task.Run(() => {
        try { handler(); }
        catch (Exception e) { Log(e); }
    });
}

第三章：典型异常应对模式与代码实践

3.1 使用Invoke逐一调用并捕获异常的防御模式

异常隔离与调用控制

for _, client := range clients {
    resp, err := invokeWithTimeout(client, request)
    if err != nil {
        log.Printf("调用失败: %s, 错误: %v", client.ServiceName, err)
        continue
    }
    processResponse(resp)
}

错误分类与日志记录

• 网络超时：记录为警告，触发重试机制
• 服务返回错误：归类为业务异常，进入审计流程
• 序列化失败：标记接口兼容性问题

3.2 利用GetInvocationList实现细粒度异常控制

逐个调用避免中断

public void SafeInvoke(EventHandler handler)
{
    if (handler == null) return;
    
    foreach (var invocation in handler.GetInvocationList())
    {
        try
        {
            ((EventHandler)invocation)?.Invoke(this, EventArgs.Empty);
        }
        catch (Exception ex)
        {
            // 记录异常但不中断其他调用
            Log.Error($"Handler {invocation.Method.Name} failed: {ex.Message}");
        }
    }
}

3.3 包装回调逻辑以统一异常处理边界

统一异常包装器

func WrapCallback(callback func() error) func() error {
    return func() error {
        defer func() {
            if r := recover(); r != nil {
                log.Printf("panic recovered: %v", r)
            }
        }()
        return callback()
    }
}

优势分析

• 集中管理异常，提升可观测性
• 避免重复的错误处理代码
• 增强系统健壮性，防止未捕获 panic 终止服务

第四章：高级异常管理与架构优化方案

4.1 构建可恢复的事件通知系统容错机制

重试策略设计

// 指数退避重试逻辑
func WithExponentialBackoff(maxRetries int) RetryPolicy {
    return func(attempt int) time.Duration {
        if attempt >= maxRetries {
            return -1 // 停止重试
        }
        return time.Second * time.Duration(1<

try 
{
    var tasks = new[]
    {
        Task.Run(() => throw new InvalidOperationException("Task 1 failed")),
        Task.Run(() => throw new ArgumentException("Task 2 failed"))
    };
    await Task.WhenAll(tasks);
}
catch (AggregateException ex)
{
    foreach (var innerEx in ex.InnerExceptions)
    {
        Console.WriteLine($"Aggregated error: {innerEx.Message}");
    }
}

@Aspect
@Component
public class ExceptionMonitorAspect {
    @AfterThrowing(pointcut = "@annotation(MonitorException)", throwing = "ex")
    public void logException(JoinPoint jp, Throwable ex) {
        String methodName = jp.getSignature().getName();
        // 上报异常至监控系统
        MonitoringClient.report("Exception in " + methodName, ex);
    }
}

// 伪代码示例：带回滚的消息处理
func (s *Subscriber) Process(msg Message) error {
    tx := s.Begin()
    if err := s.Handle(msg); err != nil {
        tx.Rollback() // 触发状态回滚
        return err
    }
    tx.Commit()
    return nil
}

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func processRequest(data []byte) *bytes.Buffer {
    buf := bufferPool.Get().(*bytes.Buffer)
    buf.Reset()
    buf.Write(data)
    return buf
}
// 使用完毕后归还对象
// defer bufferPool.Put(buf)