委托高阶应用

委托高阶应用

 

Func 和 Predicate 是 C# 中非常强大的工具，它们不仅可以简化代码，还能让代码更具表达力和灵活性。在掌握了它们的基础用法后，我们可以进一步探索它们的高阶应用场景，尤其是在复杂的逻辑处理、数据操作和设计模式中的应用。

以下是一些 Func 和 Predicate 的高阶应用场景和技巧：

---

1. 高阶应用场景

1.1 动态逻辑处理

Func 和 Predicate 可以用于动态定义逻辑，尤其是在运行时需要根据条件改变行为的情况下。

示例：动态筛选条件

假设我们有一个玩家列表，需要根据不同的条件动态筛选玩家。

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

using System.Collections.Generic;

using System.Linq;

public class Player

{

    public string Name { get; set; }

    public int Score { get; set; }

    public bool IsActive { get; set; }

}

public class Program

{

    public static void Main()

    {

        List<Player> players = new List<Player>

        {

            new Player { Name = "Alice", Score = 100, IsActive = true },

            new Player { Name = "Bob", Score = 200, IsActive = false },

            new Player { Name = "Charlie", Score = 150, IsActive = true }

        };

        // 动态定义筛选条件

        Predicate<Player> filterByScore = player => player.Score > 120;

        Predicate<Player> filterByActive = player => player.IsActive;

        // 组合筛选条件

        var filteredPlayers = players.Where(player => filterByScore(player) && filterByActive(player)).ToList();

        foreach (var player in filteredPlayers)

        {

            Console.WriteLine($"Name: {player.Name}, Score: {player.Score}, Active: {player.IsActive}");

        }

    }

}

 

 

---

1.2 策略模式（Strategy Pattern）

Func 可以用于实现策略模式，允许在运行时动态选择算法或行为。

示例：动态选择计算方法

假设我们需要根据不同的策略计算玩家的得分。

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

public class Player

{

    public string Name { get; set; }

    public int Score { get; set; }

}

public class ScoreCalculator

{

    public static int CalculateBonus(Player player, Func<Player, int> strategy)

    {

        return strategy(player);

    }

}

public class Program

{

    public static void Main()

    {

        Player player = new Player { Name = "Alice", Score = 100 };

        // 定义不同的计算策略

        Func<Player, int> bonusStrategy1 = p => p.Score + 50;

        Func<Player, int> bonusStrategy2 = p => p.Score * 2;

        // 动态选择策略

        int bonus1 = ScoreCalculator.CalculateBonus(player, bonusStrategy1);

        int bonus2 = ScoreCalculator.CalculateBonus(player, bonusStrategy2);

        Console.WriteLine($"Bonus 1: {bonus1}");

        Console.WriteLine($"Bonus 2: {bonus2}");

    }

}

 

 

---

1.3 数据转换与映射

Func 可以用于将一种数据类型转换为另一种数据类型，尤其是在处理集合数据时非常有用。

示例：将玩家列表映射为名字列表

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

using System.Collections.Generic;

using System.Linq;

public class Player

{

    public string Name { get; set; }

    public int Score { get; set; }

}

public class Program

{

    public static void Main()

    {

        List<Player> players = new List<Player>

        {

            new Player { Name = "Alice", Score = 100 },

            new Player { Name = "Bob", Score = 200 },

            new Player { Name = "Charlie", Score = 150 }

        };

        // 使用 Func 将玩家列表映射为名字列表

        Func<Player, string> nameSelector = player => player.Name;

        var names = players.Select(nameSelector).ToList();

        foreach (var name in names)

        {

            Console.WriteLine(name);

        }

    }

}

 

 

---

1.4 延迟执行与惰性求值

Func 可以用于延迟执行某些操作，直到真正需要结果时才进行计算。

示例：延迟计算玩家得分

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

public class Player

{

    public string Name { get; set; }

    public int Score { get; set; }

}

public class Program

{

    public static void Main()

    {

        Player player = new Player { Name = "Alice", Score = 100 };

        // 延迟计算得分

        Func<int> delayedCalculation = () => player.Score + 50;

        // 只有在调用时才会计算结果

        Console.WriteLine("Delayed Calculation: " + delayedCalculation());

    }

}

 

 

---

2. 高阶技巧

2.1 组合委托

你可以将多个 Func 或 Predicate 组合在一起，形成更复杂的逻辑。

示例：组合多个 Predicate

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

using System.Collections.Generic;

using System.Linq;

public class Player

{

    public string Name { get; set; }

    public int Score { get; set; }

    public bool IsActive { get; set; }

}

public class Program

{

    public static void Main()

    {

        List<Player> players = new List<Player>

        {

            new Player { Name = "Alice", Score = 100, IsActive = true },

            new Player { Name = "Bob", Score = 200, IsActive = false },

            new Player { Name = "Charlie", Score = 150, IsActive = true }

        };

        // 定义多个 Predicate

        Predicate<Player> filterByScore = player => player.Score > 120;

        Predicate<Player> filterByActive = player => player.IsActive;

        // 组合 Predicate

        Predicate<Player> combinedFilter = player => filterByScore(player) && filterByActive(player);

        var filteredPlayers = players.FindAll(combinedFilter);

        foreach (var player in filteredPlayers)

        {

            Console.WriteLine($"Name: {player.Name}, Score: {player.Score}, Active: {player.IsActive}");

        }

    }

}

 

 

---

2.2 柯里化（Currying）

柯里化是一种将多参数函数转换为一系列单参数函数的技术。Func 可以很好地支持柯里化。

示例：柯里化函数

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

public class Program

{

    public static void Main()

    {

        // 定义一个多参数函数

        Func<int, int, int, int> addThreeNumbers = (a, b, c) => a + b + c;

        // 柯里化

        Func<int, Func<int, Func<int, int>>> curriedAdd = a => b => c => a + b + c;

        // 使用柯里化函数

        var result = curriedAdd(1)(2)(3);

        Console.WriteLine("Curried Result: " + result);

    }

}

 

 

---

2.3 部分应用（Partial Application）

部分应用是指固定一个函数的部分参数，生成一个新的函数。

示例：部分应用

 

 

 

xxxxxxxxxx

 

 

 

 

using System;

public class Program

{

    public static void Main()

    {

        // 定义一个多参数函数

        Func<int, int, int, int> addThreeNumbers = (a, b, c) => a + b + c;

        // 部分应用：固定第一个参数

        Func<int, int, int> addTwoNumbers = addThreeNumbers(1);

        // 使用部分应用函数

        var result = addTwoNumbers(2, 3);

        Console.WriteLine("Partial Application Result: " + result);

    }

}