C#委托详解：Action、Func与Predicate核心用法

1. C#委托基础与核心概念

在C#开发中，委托(delegate)是实现事件驱动和回调机制的核心技术。简单来说，委托就是类型安全的函数指针，它定义了方法的签名，可以将方法作为参数传递或赋值给变量。委托的核心价值在于解耦调用方和被调用方，让代码更灵活。

.NET框架内置了三种常用的泛型委托：Action、Func和Predicate。它们本质上都是预定义好的委托类型，区别主要在于：

• Action：无返回值的方法委托
• Func：有返回值的方法委托
• Predicate：返回bool的特定用途委托

重要提示：从.NET 3.0开始，这些泛型委托就已经包含在核心库中，无需额外引用命名空间。

2. Action委托详解与应用场景

2.1 基本定义与用法

Action委托表示没有返回值的方法，其泛型版本可以接受最多16个输入参数。基础声明形式如下：

csharp复制public delegate void Action<in T>(T obj);

典型使用场景包括：

• 事件处理程序
• 异步回调
• LINQ的ForEach操作
• 需要执行但不需要返回结果的操作

2.2 实际应用示例

假设我们需要记录用户操作日志：

csharp复制// 定义Action委托
Action<string> logAction = message => 
{
    Console.WriteLine($"[{DateTime.Now}] {message}");
    File.AppendAllText("log.txt", $"[{DateTime.Now}] {message}\n");
};

// 使用委托
logAction("用户登录系统");
logAction("用户修改了个人资料");

2.3 多参数Action的高级用法

Action支持最多16个泛型参数，适合处理复杂场景：

csharp复制Action<string, int, bool> multiParamAction = (name, age, isVip) =>
{
    Console.WriteLine($"用户:{name}, 年龄:{age}, VIP:{isVip}");
};

multiParamAction("张三", 30, true);

3. Func委托深度解析

3.1 核心特点与定义

Func委托表示有返回值的方法，最后一个泛型类型参数总是返回值类型：

csharp复制public delegate TResult Func<in T, out TResult>(T arg);

Func的典型应用场景：

• LINQ查询表达式
• 需要返回值的回调方法
• 延迟计算
• 工厂模式

3.2 实际开发案例

计算员工薪资的示例：

csharp复制Func<int, double, double> calculateSalary = (workHours, hourlyRate) =>
{
    double baseSalary = workHours * hourlyRate;
    double bonus = workHours > 160 ? baseSalary * 0.1 : 0;
    return baseSalary + bonus;
};

var salary = calculateSalary(175, 50);
Console.WriteLine($"应发工资: {salary:C}");

3.3 多参数Func的复杂应用

Func最多支持16个输入参数+1个返回参数：

csharp复制Func<int, int, int, double> calculateVolume = (length, width, height) =>
{
    return length * width * height;
};

var boxVolume = calculateVolume(10, 20, 30);
Console.WriteLine($"箱子体积: {boxVolume} cm³");

4. Predicate委托的特殊用途

4.1 定义与特点

Predicate是返回bool值的特殊委托，主要用于条件判断：

csharp复制public delegate bool Predicate<in T>(T obj);

常见使用场景：

• 集合过滤(如List.FindAll)
• 验证逻辑
• 条件筛选

4.2 实战应用示例

筛选符合条件的产品：

csharp复制List<Product> products = GetProducts();
Predicate<Product> filter = p => 
    p.Price < 100 && p.StockQuantity > 0;

var cheapProducts = products.FindAll(filter);

4.3 Predicate与Func的区别

虽然都可以返回bool，但Predicate语义更明确，专为条件判断设计：

csharp复制// 使用Predicate更符合语义
Predicate<int> isEven = x => x % 2 == 0;

// 使用Func也能实现同样功能
Func<int, bool> isEvenFunc = x => x % 2 == 0;

5. 三种委托的性能对比与优化

5.1 性能基准测试

通过BenchmarkDotNet测试简单场景下的性能：

测试结论：内置泛型委托性能优于自定义委托，因为避免了额外的内存分配。

5.2 使用建议

1. 优先使用内置委托而非自定义委托
2. 避免在循环中频繁创建委托实例
3. 对于高频调用的场景，考虑缓存委托实例

6. 高级技巧与最佳实践

6.1 委托组合(multicast)

可以使用+=组合多个委托：

csharp复制Action<string> logger = Console.WriteLine;
logger += message => Debug.WriteLine(message);
logger("测试消息"); // 会同时输出到控制台和调试窗口

6.2 与Lambda表达式的配合

Lambda表达式是创建委托实例的简洁方式：

csharp复制Func<int, int> square = x => x * x;
Action<string> greet = name => Console.WriteLine($"Hello, {name}");

6.3 异常处理模式

为委托添加统一的异常处理：

csharp复制Action safeAction = () =>
{
    try
    {
        // 可能抛出异常的代码
    }
    catch (Exception ex)
    {
        Logger.LogError(ex);
        throw;
    }
};

7. 常见问题与解决方案

7.1 委托与空值问题

安全调用委托的模式：

csharp复制Action<string> handler = null;
handler?.Invoke("message"); // 不会抛出NullReferenceException

7.2 内存泄漏预防

事件订阅导致的内存泄漏：

csharp复制// 错误的做法 - 可能导致内存泄漏
eventSource.Event += HandleEvent;

// 正确的做法 - 及时取消订阅
eventSource.Event -= HandleEvent;

7.3 多线程环境下的委托调用

线程安全的委托调用方式：

csharp复制EventHandler handler = SomeEvent;
if (handler != null)
{
    foreach (EventHandler singleCast in handler.GetInvocationList())
    {
        singleCast.BeginInvoke(this, EventArgs.Empty, null, null);
    }
}

8. 实际项目中的应用案例

8.1 插件系统设计

使用Func实现可扩展的插件架构：

csharp复制public class PluginSystem
{
    private List<Func<string, string>> _plugins = new();
    
    public void RegisterPlugin(Func<string, string> plugin)
    {
        _plugins.Add(plugin);
    }
    
    public string Process(string input)
    {
        return _plugins.Aggregate(input, (current, plugin) => plugin(current));
    }
}

8.2 条件规则引擎

利用Predicate构建灵活的规则系统：

csharp复制public class RuleEngine<T>
{
    private List<(Predicate<T> condition, Action<T> action)> _rules = new();
    
    public void AddRule(Predicate<T> condition, Action<T> action)
    {
        _rules.Add((condition, action));
    }
    
    public void Apply(T item)
    {
        foreach (var rule in _rules)
        {
            if (rule.condition(item))
            {
                rule.action(item);
            }
        }
    }
}

8.3 缓存策略实现

使用Func实现带缓存的调用：

csharp复制public class Cached<TKey, TValue>
{
    private readonly Func<TKey, TValue> _valueFactory;
    private readonly ConcurrentDictionary<TKey, TValue> _cache = new();
    
    public Cached(Func<TKey, TValue> valueFactory)
    {
        _valueFactory = valueFactory;
    }
    
    public TValue Get(TKey key)
    {
        return _cache.GetOrAdd(key, _valueFactory);
    }
}

9. 委托在C#生态系统中的演进

9.1 .NET Framework到.NET Core的变化

• 委托签名更加统一
• 性能持续优化
• 与异步编程模型更好集成

9.2 与现代C#特性的结合

1. 模式匹配：

csharp复制Func<object, string> describe = obj => obj switch
{
    int i => $"整数: {i}",
    string s => $"字符串: {s}",
    _ => "未知类型"
};

2. 本地函数与委托：

csharp复制Func<int, int> GetMultiplier(int factor)
{
    return x => x * factor; // 闭包捕获factor
}

3. 记录类型与委托：

csharp复制record Person(string Name, int Age);

Func<Person, string> format = p => $"{p.Name} ({p.Age})";

10. 面试常见问题解析

10.1 基础概念题

1. Q: Action和Func的主要区别是什么？
   A: Action没有返回值，Func有返回值。Func的最后一个泛型参数总是返回类型。

2. Q: Predicate和Func有什么区别？
   A: 功能上可以互换，但Predicate语义更明确，专为条件判断设计，常用于集合过滤。

10.2 编码实践题

1. 实现一个通用的重试机制：

csharp复制public static TResult Retry<TResult>(Func<TResult> func, int retryCount)
{
    while (true)
    {
        try
        {
            return func();
        }
        catch when (retryCount-- > 0)
        {
            Thread.Sleep(1000);
        }
    }
}

2. 构建一个简单的管道处理系统：

csharp复制public static class Pipeline
{
    public static TOut Then<TIn, TOut>(this TIn input, Func<TIn, TOut> func)
    {
        return func(input);
    }
}

// 使用示例
var result = 10
    .Then(x => x * 2)
    .Then(x => x.ToString());

10.3 性能优化题

1. Q: 如何优化高频调用的委托？
   A:

   • 缓存委托实例
   • 避免在循环中创建委托
   • 对于静态方法，使用MethodGroup转换
   • 考虑使用值类型的委托(如F#的FSharpFunc)

2. Q: 委托调用与直接方法调用性能差异？
   A: 现代.NET中，简单委托调用的开销已经很小(约0.5ns)，但大量调用时仍需注意：

   • 虚方法调用比委托更快
   • 接口调用与委托性能相当
   • 动态生成的委托可能比反射快很多

11. 委托的底层原理探究

11.1 CLR层面的实现

委托在CLR中是通过特殊的类实现的，包含三个重要字段：

• _target: 方法所属对象实例(静态方法为null)
• _methodPtr: 方法指针
• _invocationList: 多播委托的调用列表

11.2 JIT编译优化

现代JIT编译器会对委托调用进行特殊优化：

• 内联小型委托
• 缓存常用委托的调用桩(stub)
• 对多播委托生成高效调用代码

11.3 内存模型分析

委托实例的内存布局：

code复制+-----------+-----------+
| MethodPtr | Target    |  (单播委托)
+-----------+-----------+
| MethodPtr | Target    |  (多播委托)
| Invocation| Count     |
| List      |           |
+-----------+-----------+

12. 跨语言视角的委托

12.1 与其他语言的对比

12.2 在混合编程中的应用

通过P/Invoke将C#委托传递给原生代码：

csharp复制// C#侧定义
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeCallback(int value);

[DllImport("NativeLib")]
public static extern void RegisterCallback(NativeCallback callback);

// 使用
NativeCallback callback = x => Console.WriteLine(x);
RegisterCallback(callback);

13. 设计模式中的委托应用

13.1 观察者模式实现

使用事件(基于委托)实现松耦合通知：

csharp复制public class Subject
{
    public event Action<string> StateChanged;
    
    private string _state;
    public string State
    {
        get => _state;
        set
        {
            _state = value;
            StateChanged?.Invoke(value);
        }
    }
}

13.2 策略模式简化

用委托替代策略接口：

csharp复制public class Sorter
{
    private Func<int[], int[]> _strategy;
    
    public Sorter(Func<int[], int[]> strategy)
    {
        _strategy = strategy;
    }
    
    public int[] Sort(int[] data)
    {
        return _strategy(data);
    }
}

// 使用
var bubbleSorter = new Sorter(data => /* 冒泡排序实现 */);
var quickSorter = new Sorter(data => /* 快速排序实现 */);

13.3 命令模式轻量化

用Action代替命令对象：

csharp复制public class CommandManager
{
    private readonly Stack<Action> _undoStack = new();
    private readonly Stack<Action> _redoStack = new();
    
    public void Execute(Action command)
    {
        command();
        _undoStack.Push(command);
        _redoStack.Clear();
    }
    
    public void Undo()
    {
        if (_undoStack.Count > 0)
        {
            var command = _undoStack.Pop();
            command(); // 假设命令本身知道如何撤销
            _redoStack.Push(command);
        }
    }
}

14. 委托与异步编程

14.1 异步委托调用

使用BeginInvoke/EndInvoke进行APM模式异步调用：

csharp复制Func<string, string> longRunningTask = input =>
{
    Thread.Sleep(2000);
    return input.ToUpper();
};

// 开始异步调用
IAsyncResult result = longRunningTask.BeginInvoke("hello", null, null);

// 可以做其他工作...

// 获取结果
string output = longRunningTask.EndInvoke(result);

注意：在现代代码中更推荐使用Task-based异步模式(TAP)

14.2 与async/await集成

将同步委托包装为异步操作：

csharp复制Func<string, Task<string>> asyncWrapper = input =>
{
    return Task.Run(() =>
    {
        Thread.Sleep(1000);
        return input.ToUpper();
    });
};

// 使用
var result = await asyncWrapper("test");

14.3 异步事件模式

基于委托实现异步事件：

csharp复制public class AsyncEventSource
{
    public event Func<object, EventArgs, Task> AsyncEvent;
    
    public async Task RaiseEventAsync()
    {
        var handlers = AsyncEvent?.GetInvocationList();
        if (handlers != null)
        {
            foreach (Func<object, EventArgs, Task> handler in handlers)
            {
                await handler(this, EventArgs.Empty);
            }
        }
    }
}

15. 委托的调试技巧

15.1 Visual Studio调试支持

1. 在调试器中查看委托的Target和Method属性
2. 使用"快速监视"查看多播委托的调用列表
3. 设置断点时可以条件过滤特定委托调用

15.2 诊断委托内存泄漏

使用内存分析工具检查：

1. 委托持有意外对象引用
2. 未取消的事件订阅
3. 闭包捕获的大对象

15.3 日志记录技巧

为委托调用添加日志：

csharp复制public static Func<T, TResult> WithLogging<T, TResult>(
    this Func<T, TResult> func, 
    string name)
{
    return input =>
    {
        Console.WriteLine($"调用 {name} 输入: {input}");
        var result = func(input);
        Console.WriteLine($"调用 {name} 结果: {result}");
        return result;
    };
}

// 使用
Func<int, int> squared = x => x * x;
var loggedSquared = squared.WithLogging("平方计算");

16. 委托的性能优化进阶

16.1 避免闭包分配

闭包会导致额外的堆分配：

csharp复制// 不好的做法 - 创建闭包
void ProcessItems(List<int> items)
{
    int threshold = GetThreshold();
    items.RemoveAll(x => x > threshold); // 闭包捕获threshold
}

// 更好的做法
void ProcessItems(List<int> items)
{
    int threshold = GetThreshold();
    var predicate = new Predicate<int>(x => x > threshold);
    items.RemoveAll(predicate); // 显式创建委托实例
}

16.2 使用Method Group转换

更高效的委托创建方式：

csharp复制// 较慢 - 使用lambda
Func<int, int> square = x => x * x;

// 更快 - 使用方法组
Func<int, int> square = Square;
private static int Square(int x) => x * x;

16.3 值类型委托

在极端性能场景下，可以使用值类型委托：

csharp复制// 使用System.Runtime.CompilerServices提供的功能
public readonly struct ValueFunc<T, TResult>
{
    private readonly T _target;
    private readonly delegate*<T, TResult> _methodPtr;
    
    public ValueFunc(T target, delegate*<T, TResult> methodPtr)
    {
        _target = target;
        _methodPtr = methodPtr;
    }
    
    public TResult Invoke() => _methodPtr(_target);
}

17. 委托的安全考虑

17.1 输入验证

对委托参数进行验证：

csharp复制public static Func<T, TResult> WithValidation<T, TResult>(
    this Func<T, TResult> func,
    Predicate<T> validator)
{
    return input =>
    {
        if (!validator(input))
            throw new ArgumentException("无效输入");
        return func(input);
    };
}

17.2 权限控制

基于调用者的权限过滤委托执行：

csharp复制public static Action WithAuthorization(
    this Action action,
    string requiredPermission)
{
    return () =>
    {
        if (!CurrentUser.HasPermission(requiredPermission))
            throw new SecurityException("权限不足");
        action();
    };
}

17.3 防篡改保护

保护委托不被替换：

csharp复制public class ProtectedDelegate<T>
{
    private Func<T> _original;
    private Func<T> _wrapper;
    
    public ProtectedDelegate(Func<T> original)
    {
        _original = original;
        _wrapper = () =>
        {
            // 可以添加审计日志等
            return _original();
        };
    }
    
    public Func<T> AsFunc() => _wrapper;
    
    // 只有特定代码可以替换原始委托
    internal void Replace(Func<T> newDelegate)
    {
        _original = newDelegate;
    }
}

18. 委托在领域特定语言(DSL)中的应用

18.1 构建流畅接口

使用委托创建DSL：

csharp复制public class QueryBuilder<T>
{
    private Predicate<T> _filter = _ => true;
    
    public QueryBuilder<T> Where(Predicate<T> predicate)
    {
        _filter = x => _filter(x) && predicate(x);
        return this;
    }
    
    public List<T> Execute(IEnumerable<T> source)
    {
        return source.Where(x => _filter(x)).ToList();
    }
}

// 使用
var query = new QueryBuilder<Person>()
    .Where(p => p.Age > 18)
    .Where(p => p.Name.StartsWith("A"));
    
var results = query.Execute(people);

18.2 规则引擎实现

基于委托的简单规则引擎：

csharp复制public class RuleEngine<T>
{
    private List<(Predicate<T> condition, Action<T> action)> _rules = new();
    
    public RuleEngine<T> When(Predicate<T> condition, Action<T> action)
    {
        _rules.Add((condition, action));
        return this;
    }
    
    public void Execute(T item)
    {
        foreach (var (condition, action) in _rules)
        {
            if (condition(item))
            {
                action(item);
            }
        }
    }
}

// 使用
var engine = new RuleEngine<Order>()
    .When(o => o.Total > 1000, o => o.ApplyDiscount(0.1))
    .When(o => o.Items.Count > 10, o => o.FlagForReview());
    
engine.Execute(currentOrder);

18.3 工作流定义

用委托定义业务流程：

csharp复制public class WorkflowBuilder
{
    private List<Func<Context, Context>> _steps = new();
    
    public WorkflowBuilder Then(Func<Context, Context> step)
    {
        _steps.Add(step);
        return this;
    }
    
    public Context Execute(Context initial)
    {
        return _steps.Aggregate(initial, (current, step) => step(current));
    }
}

// 使用
var workflow = new WorkflowBuilder()
    .Then(c => c.Validate())
    .Then(c => c.ProcessPayment())
    .Then(c => c.SendConfirmation());
    
var result = workflow.Execute(new Context(order));

19. 委托与源代码生成

19.1 编译时代码生成

使用Source Generators创建高性能委托：

csharp复制[Generator]
public class DelegateGenerator : ISourceGenerator
{
    public void Initialize(GeneratorInitializationContext context)
    {
        context.RegisterForSyntaxNotifications(() => new DelegateSyntaxReceiver());
    }

    public void Execute(GeneratorExecutionContext context)
    {
        // 生成优化的委托代码
    }
}

19.2 表达式树编译

运行时生成委托：

csharp复制// 创建 x => x * x 的表达式树
var param = Expression.Parameter(typeof(int), "x");
var body = Expression.Multiply(param, param);
var lambda = Expression.Lambda<Func<int, int>>(body, param);

// 编译为委托
Func<int, int> square = lambda.Compile();

19.3 AOP实现

通过委托实现面向切面编程：

csharp复制public static Func<T, TResult> WithLogging<T, TResult>(
    Func<T, TResult> func, 
    ILogger logger)
{
    return input =>
    {
        logger.LogInformation($"调用开始，参数: {input}");
        try
        {
            var result = func(input);
            logger.LogInformation($"调用成功，结果: {result}");
            return result;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "调用失败");
            throw;
        }
    };
}

20. 未来发展与替代方案

20.1 函数指针(C# 9+)

在性能关键场景替代委托：

csharp复制unsafe class FunctionPointerDemo
{
    static int Square(int x) => x * x;
    
    public static void Demo()
    {
        delegate*<int, int> ptr = &Square;
        int result = ptr(5); // 25
    }
}

20.2 接口默认方法

在某些场景可以替代委托：

csharp复制interface IProcessor<T>
{
    T Process(T input) => DefaultProcess(input);
    
    private static T DefaultProcess(T input)
    {
        // 默认实现
    }
}

20.3 本地函数与委托

C# 7+的本地函数可以作为轻量级替代：

csharp复制public Func<int, int> GetMultiplier(int factor)
{
    return Multiply;
    
    int Multiply(int x) => x * factor;
}

在实际项目中，我发现委托的正确使用可以显著提升代码的灵活性和可维护性。特别是在需要实现策略模式、回调机制或事件处理的场景中，合理运用Action、Func和Predicate能让代码更简洁优雅。但也要注意避免过度使用导致的性能问题和代码可读性下降。