函数式编程模式常常给人一种学术性和抽象的感觉。"单子"(monads)和"函子"(functors)这样的术语往往会吓退许多开发者。但在这些令人生畏的术语背后，其实隐藏着一些能让代码更安全、更易维护的实用模式。
C#多年来已经采纳了许多函数式编程特性：
Records用于实现不可变性
LINQ用于函数式转换
Lambda表达式实现一等函数
这些特性不仅仅是语法糖 — 它们能帮助预防bug，使代码更容易理解。
让我们来看看今天就能在C#项目中使用的五种实用模式。
高阶函数 高阶函数可以接收其他函数作为参数或将函数作为结果返回。它们让你能够编写更灵活和可组合的代码，因为你可以像传递数据一样传递行为。
高阶函数的常见例子是LINQ中的Where和Select，它们接收用于转换数据的函数。
让我们用高阶函数重构这个验证示例：
public class OrderValidator
{
public bool ValidateOrder(Order order)
{
if (order.Items.Count == 0) return false;
if (order.TotalAmount <= 0) return false;
if (order.ShippingAddress == null) return false;
return true;
}
}
// What if we need:
// - different validation rules for different countries?
// - to reuse some validations but not others?
// - to combine validations differently?
这里展示了如何使用高阶函数使其更灵活：
public static class OrderValidation
{
public static Func<Order, bool> CreateValidator(string countryCode, decimal minimumOrderValue)
{
var baseValidations = CombineValidations(
o => o.Items.Count > 0,
o => o.TotalAmount >= minimumOrderValue,
o => o.ShippingAddress != null
);
return countryCode switch
{
"US" => CombineValidations(
baseValidations,
order => IsValidUSAddress(order.ShippingAddress)),
"EU" => CombineValidations(
baseValidations,
order => IsValidVATNumber(order.VatNumber)),
_ => baseValidations
};
}
private static Func<Order, bool> CombineValidations(params Func<Order, bool>[] validations) =>
order => validations.All(v => v(order));
}
// Usage
var usValidator = OrderValidation.CreateValidator("US", minimumOrderValue: 25.0m);
var euValidator = OrderValidation.CreateValidator("EU", minimumOrderValue: 30.0m);
高阶函数方法使验证器变得可组合、可测试且易于扩展。每个验证规则都是一个简单的函数，我们可以将它们组合起来。
将错误作为值 C#中的错误处理通常是这样的：
public class UserService
{
public User CreateUser(string email, string password)
{
if (string.IsNullOrEmpty(email))
{
throw new ArgumentException("Email is required");
}
if (password.Length < 8)
{
throw new ArgumentException("Password too short");
}
if (_userRepository.EmailExists(email))
{
throw new DuplicateEmailException(email);
}
// Create user...
}
}
存在的问题？
异常处理代价高昂
调用者常常忘记处理异常
方法签名具有欺骗性 — 它声称返回User但可能会抛出异常
我们可以使用OneOf库使错误变得明确。它为C#提供了判别联合，使用自定义类型OneOf<T0, ... Tn>。
public class UserService
{
public OneOf<User, ValidationError, DuplicateEmailError> CreateUser(string email, string password)
{
if (string.IsNullOrEmpty(email))
{
return new ValidationError("Email is required");
}
if (password.Length < 8)
{
return new ValidationError("Password too short");
}
if (_userRepository.EmailExists(email))
{
return new DuplicateEmailError(email);
}
return new User(email, password);
}
}
通过使错误明确化：
方法签名完全说明了真相
调用者必须处理所有可能的结果
没有异常带来的性能开销
流程更容易理解
使用方式如下：
var result = userService.CreateUser(email, password);
result.Switch(
user => SendWelcomeEmail(user),
validationError => HandleError(validationError),
duplicateError => HandleError(duplicateError)
);
单子绑定 单子是值的容器 — 像List
你每天都在使用LINQ时都在使用单子绑定，只是可能不知道。它允许我们链式操作来转换数据。
Map (Select) 转换值：
// Simple transformations with Select (Map)
var numbers = new[] { 1, 2, 3, 4 };
var doubled = numbers.Select(x => x * 2);
Bind (SelectMany) 转换并展平：
// Operations that return multiple values use SelectMany (Bind)
var folders = new[] { "docs", "photos" };
var files = folders.SelectMany(folder => Directory.GetFiles(folder));
在实践中应用单子的一个流行例子是Result模式，它提供了一种清晰的方式来链接可能失败的操作。
纯函数 纯函数是可预测的：它们只依赖于输入，不会改变系统中的任何东西。没有数据库调用，没有API请求，没有全局状态。这种约束使它们更容易理解、测试和调试。
// Impure - relies on hidden state
public class PriceCalculator
{
private decimal _taxRate;
private List<Discount> _activeDiscounts;
public decimal CalculatePrice(Order order)
{
var price = order.Items.Sum(i => i.Price);
foreach (var discount in _activeDiscounts)
{
price -= discount.Calculate(price);
}
return price * (1 + _taxRate);
}
}
这是同样的例子作为纯函数：
// Pure - everything is explicit
public static class PriceCalculator
{
public static decimal CalculatePrice(
Order order,
decimal taxRate,
IReadOnlyList<Discount> discounts)
{
var basePrice = order.Items.Sum(i => i.Price);
var afterDiscounts = discounts.Aggregate(
basePrice,
(price, discount) => price - discount.Calculate(price));
return afterDiscounts * (1 + taxRate);
}
}
纯函数是线程安全的，易于测试，并且易于理解，因为所有依赖都是显式的。
不可变性 不可变对象在创建后不能被更改。相反，它们为每个更改创建新的实例。这个简单的约束消除了整类bug：竞态条件、意外修改和不一致状态。
这是一个可变类型的例子：
public class Order
{
public List<OrderItem> Items { get; set; }
public decimal Total { get; set; }
public OrderStatus Status { get; set; }
public void AddItem(OrderItem item)
{
Items.Add(item);
Total += item.Price;
// Bug: Thread safety issues
// Bug: Can modify shipped orders
// Bug: Total might not match Items
}
}
让我们将其改造为不可变类型：
public record Order
{
public ImmutableList<OrderItem> Items { get; init; }
public OrderStatus Status { get; init; }
public decimal Total => Items.Sum(x => x.Price);
public Order AddItem(OrderItem item)
{
if (Status != OrderStatus.Created)
{
throw new InvalidOperationException("Can't modify shipped orders");
}
return this with
{
Items = Items.Add(item)
};
}
}
不可变版本的特点：
默认线程安全
使无效状态变得不可能
保持数据和计算的一致性
使更改明确且可追踪
函数式编程不仅仅是关于写"更干净"的代码。这些模式从根本上改变了你处理复杂性的方式：
将错误推送到编译时 — 在运行代码之前捕获问题
使无效状态变得不可能 — 不依赖文档或约定
使正确路径明显 — 当一切都是显式的，流程就很清晰
你可以逐步采用这些模式。从一个类、一个模块、一个功能开始。目标不是写纯函数式代码。目标是写出更安全、更可预测、更易维护的代码。
如果你喜欢我的文章，请给我一个赞！谢谢
