C#中Predicate与Func泛型委托的用法实例

下面是关于“C#中Predicate与Func泛型委托的用法实例”的详细攻略。

1. 概述

在C#中，Predicate<T>与Func<T, bool>是两个重要的泛型委托类型。它们的主要作用是作为参数来传递一些特定的方法，来进行预测和筛选操作。

其中，Predicate<T>主要用于检索、查找等操作，它的定义如下：

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

而Func<T, bool>则更加通用，它可用于任意可调用对象，其定义如下：

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

2. 实例说明

2.1 使用Predicate进行查找操作

我们假设有一个整数数组，现在要查找其中能被3整除的数。可以使用Predicate委托定义一个方法来检查整数是否能够被3整除，代码如下：

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Predicate<int> divisibleByThree = (int number) =>
{
    return number % 3 == 0;
};

int[] divisibleNumbers = Array.FindAll(numbers, divisibleByThree);

foreach (int number in divisibleNumbers)
{
    Console.WriteLine(number);
}

在上面的代码中，我们使用数组的FindAll方法，将定义好的divisibleByThree方法作为参数传递进去。方法返回一个新的数组，其中只包含能被3整除的数。最后，我们使用foreach循环来遍历输出这个数组。

2.2 使用Func进行筛选操作

现在我们想要筛选出员工工资大于10000的员工，并计算这些员工的年薪总和。我们需要首先定义一个员工类，代码如下：

public class Employee
{
    public string Name { get; set; }

    public decimal Salary { get; set; }

    public decimal AnnualSalary
    {
        get
        {
            return Salary * 12;
        }
    }
}

然后，我们创建一个包含多个员工信息的列表，并使用Func<T, bool>委托来筛选工资大于10000的员工。最后，我们遍历符合筛选条件的员工，计算它们的年薪总和，代码如下：

List<Employee> employees = new List<Employee>
{
    new Employee {Name = "Alice", Salary = 12000},
    new Employee {Name = "Bob", Salary = 9000},
    new Employee {Name = "Charlie", Salary = 15000},
    new Employee {Name = "David", Salary = 11000},
    new Employee {Name = "Eva", Salary = 13000}
};

Func<Employee, bool> salaryGreaterThan10000 = (Employee em) =>
{
    return em.Salary > 10000;
};

decimal totalAnnualSalary = 0;
foreach (Employee em in employees.Where(salaryGreaterThan10000))
{
    totalAnnualSalary += em.AnnualSalary;
}

Console.WriteLine("Total annual salary of employees with salary greater than 10000 is {0}", totalAnnualSalary);

在上面的代码中，我们使用列表的Where方法进行筛选，并将salaryGreaterThan10000方法作为参数传递进去。最后，我们使用foreach循环来遍历所有符合条件的员工，计算它们的年薪总和，并输出结果。

3. 总结

上面是关于“C#中Predicate与Func泛型委托的用法实例”的完整攻略。通过上面的说明，相信大家已经能够理解它们的使用方法和场景了。使用这两个泛型委托可以让我们的代码更加灵活，可读性更强。