聆途笔记

C#匿名类型与Lambda表达式

匿名类型(Anonymous Types)

匿名类型是C# 3.0引入的一种特殊的数据类型，它允许开发者在不需要预先定义类型的情况下创建临时使用的对象结构。

匿名类型的基本语法

var anonymousObject = new { Property1 = value1, Property2 = value2, ... };

匿名类型的特点

  1. 只读属性：匿名类型的属性都是只读的，初始化后不能修改
  2. 类型推断：编译器自动推断属性类型
  3. 局部使用：主要用于方法内部的临时数据存储
  4. 隐式命名：如果属性名未指定，编译器会使用初始化表达式中的变量名

匿名类型示例

// 基本匿名类型
var person = new { Name = "张三", Age = 30, IsMarried = false };

// 使用变量初始化
string productName = "笔记本电脑";
decimal price = 5999.99m;
var product = new { productName, price };

// 嵌套匿名类型
var order = new {
    OrderId = 1001,
    OrderDate = DateTime.Now,
    Customer = new { Name = "李四", Email = "lisi@example.com" },
    Items = new[] {
        new { ProductName = "鼠标", Quantity = 2, Price = 99.99m },
        new { ProductName = "键盘", Quantity = 1, Price = 199.99m }
    }
};

// 在LINQ查询中使用
var query = from p in products
            select new { p.Name, p.Price, DiscountedPrice = p.Price * 0.9m };

匿名类型的实际应用

  1. LINQ查询结果投影：从查询中只选择需要的字段
  2. 临时数据传输对象：在方法间传递不需要持久化的数据
  3. 简化代码：避免为临时使用创建正式的类型定义

Lambda表达式

Lambda表达式是C# 3.0引入的一种简洁的函数定义方式，它极大地简化了委托和匿名方法的编写。

Lambda表达式的基本语法

// 表达式Lambda
(input-parameters) => expression

// 语句Lambda
(input-parameters) => { 
    // 语句块
    return result; 
}

Lambda表达式的特点

  1. 简洁性：比匿名方法更简洁
  2. 类型推断：编译器可以推断参数类型
  3. 闭包支持：可以捕获外部变量
  4. 多用途：可用于委托、表达式树、LINQ等场景

Lambda表达式示例

// 基本Lambda表达式
Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // 输出25

// 多参数Lambda
Func<int, int, int> add = (x, y) => x + y;
Console.WriteLine(add(3, 4)); // 输出7

// 无参数Lambda
Action greet = () => Console.WriteLine("Hello!");
greet();

// 语句Lambda
Action<string> log = message => {
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
    Console.WriteLine($"[{timestamp}] {message}");
};
log("系统启动");

// 在LINQ中使用
var evenNumbers = numbers.Where(n => n % 2 == 0);
var orderedProducts = products.OrderBy(p => p.Price);

Lambda表达式的实际应用

  1. 集合操作：与LINQ配合进行数据查询和处理
  2. 事件处理：简化事件处理程序的编写
  3. 异步编程：用于Task的延续操作
  4. 表达式树：构建动态查询

匿名类型与Lambda的结合使用

匿名类型和Lambda表达式经常在LINQ查询中一起使用，形成强大的数据处理能力。

结合使用示例

// 数据准备
var employees = new List<Employee> {
    new Employee { Id = 1, Name = "张三", Department = "研发部", Salary = 15000 },
    new Employee { Id = 2, Name = "李四", Department = "市场部", Salary = 12000 },
    new Employee { Id = 3, Name = "王五", Department = "研发部", Salary = 18000 },
    new Employee { Id = 4, Name = "赵六", Department = "人事部", Salary = 10000 }
};

// 使用Lambda和匿名类型的LINQ查询
var result = employees
    .Where(e => e.Salary > 11000)  // Lambda筛选
    .OrderByDescending(e => e.Salary)  // Lambda排序
    .Select(e => new {  // 匿名类型投影
        e.Name,
        e.Department,
        AnnualSalary = e.Salary * 12,
        Tax = e.Salary > 15000 ? e.Salary * 0.1m : e.Salary * 0.05m
    })
    .GroupBy(e => e.Department);  // 按部门分组

// 输出结果
foreach (var group in result)
{
    Console.WriteLine($"部门: {group.Key}");
    foreach (var emp in group)
    {
        Console.WriteLine($"  {emp.Name}, 年薪: {emp.AnnualSalary}, 税费: {emp.Tax}");
    }
}

高级应用：表达式树与Lambda

Lambda表达式可以转换为表达式树(Expression Trees)，实现动态查询构建：

// 构建动态查询条件
Expression<Func<Employee, bool>> filter = e => e.Salary > 10000 && e.Department == "研发部";

// 修改表达式树
var parameter = filter.Parameters[0];
var body = filter.Body as BinaryExpression;

if (body != null)
{
    // 添加额外条件
    var newCondition = Expression.GreaterThan(
        Expression.Property(parameter, "Salary"),
        Expression.Constant(12000));

    var newBody = Expression.AndAlso(body, newCondition);
    var newFilter = Expression.Lambda<Func<Employee, bool>>(newBody, parameter);

    // 使用新过滤器
    var highlyPaidDevs = employees.AsQueryable().Where(newFilter).ToList();
}

性能考量与最佳实践

匿名类型的注意事项

  1. 类型相等性：相同结构的匿名类型会被编译器视为相同类型
  2. 作用域限制：不适合在方法边界外传递
  3. 调试信息：调试时可以看到属性名和值

Lambda表达式的注意事项

  1. 闭包陷阱：注意捕获的变量生命周期
  2. 性能影响：频繁创建的Lambda可能导致GC压力
  3. 表达式树限制：并非所有Lambda都能转换为表达式树

最佳实践

  1. 合理使用匿名类型：
  • 适合临时、局部使用的数据结构
  • 避免在公共API中使用
  • 考虑使用元组(Tuple)作为替代
  1. 高效使用Lambda：
  • 重用可复用的Lambda表达式
  • 注意捕获变量的作用域
  • 在性能关键路径避免频繁创建Lambda
  1. 代码可读性平衡：
  • 避免过度复杂的Lambda表达式
  • 当逻辑复杂时，考虑使用命名方法

实际应用案例

案例1：数据转换管道

// 原始数据
var rawData = new[] {
    "1,张三,研发部,15000",
    "2,李四,市场部,12000",
    "3,王五,研发部,18000",
    "4,赵六,人事部,10000"
};

// 使用Lambda和匿名类型的数据处理管道
var processedData = rawData
    .Select(line => line.Split(','))
    .Where(parts => parts.Length == 4)
    .Select(parts => new {
        Id = int.Parse(parts[0]),
        Name = parts[1],
        Department = parts[2],
        Salary = decimal.Parse(parts[3])
    })
    .GroupBy(e => e.Department)
    .Select(g => new {
        Department = g.Key,
        Count = g.Count(),
        TotalSalary = g.Sum(e => e.Salary),
        AverageSalary = g.Average(e => e.Salary)
    })
    .OrderByDescending(d => d.TotalSalary);

// 输出结果
foreach (var dept in processedData)
{
    Console.WriteLine($"{dept.Department}: {dept.Count}人, 总薪资: {dept.TotalSalary}, 平均薪资: {dept.AverageSalary}");
}

案例2：动态查询构建器

public static class QueryBuilder
{
    public static IQueryable<T> ApplyFilters<T>(this IQueryable<T> query, 
        params Expression<Func<T, bool>>[] filters)
    {
        return filters.Aggregate(query, (current, filter) => current.Where(filter));
    }
}

// 使用示例
var filters = new List<Expression<Func<Employee, bool>>>
{
    e => e.Department == "研发部",
    e => e.Salary > 12000,
    e => e.Name.Contains("张")
};

var filteredEmployees = dbContext.Employees
    .ApplyFilters(filters.ToArray())
    .Select(e => new { e.Name, e.Department, e.Salary })
    .ToList();

总结

C#的匿名类型和Lambda表达式是现代C#编程中不可或缺的特性：

  1. 匿名类型提供了创建临时数据结构的便捷方式，特别适合LINQ查询中的投影操作，避免了为临时使用创建正式类型的开销。
  2. Lambda表达式极大地简化了委托和匿名方法的编写，使代码更加简洁清晰，特别是在集合操作、事件处理和异步编程等场景中表现突出。
  3. 两者的结合在LINQ查询中展现出强大的能力，可以实现复杂的数据处理逻辑，同时保持代码的简洁性和可读性。
  4. 实际开发中，应当根据场景合理选择使用匿名类型或命名类型，平衡Lambda表达式的简洁性与代码可维护性，特别是在团队协作和长期维护的项目中。

掌握匿名类型和Lambda表达式的正确使用方式，可以显著提高C#开发的效率和代码质量，是每个C#开发者必须熟练运用的核心技能。

a_a_a

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注