56、编程中的递归、LINQ与反射技术解析-优快云博客

本文链接：https://blog.youkuaiyun.com/css33/article/details/149378370

编程中的递归、LINQ与反射技术解析

1. 递归函数与迭代函数的差异

递归函数和迭代函数在代码的表层外观上存在差异，但在计算机内存操作方面的差异更为显著。在许多情况下，递归函数在计算机内存中的运行速度比迭代函数更快。随着复杂度的增加，迭代函数的运行速度会显著下降。即使不深入了解计算机内存的管理方式，使用递归函数也可能会稍微提高程序的运行速度。

2. LINQ的基本概念

LINQ（Language-Integrated Query，语言集成查询）是一种用于对对象和数据进行排序的技术。在Unity 3D的数据驱动游戏中，需要跟踪和更新各种统计信息，如生命值、魔法值、能力和技能等。这些数据通常存储在电子表格、XML、JSON文件或数据库中，生成包含大量物品及其相应统计信息的列表。LINQ提供了一种简单的方法来查找和组织这些物品。

2.1 Lambdas和数组的应用

在处理庞大的数据库信息时，手动编写循环来搜索数组并处理每个数据项是一项冗长且繁琐的任务。LINQ可以解决这个问题。例如，我们可以使用LINQ库来筛选出场景中生命值最高的怪物，而不是手动逐个查找。

下面是一个简单的示例，用于在整数数组中查找偶数：

// 代码示例
// 假设存在一个整数数组
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNums = from n in numbers
               where n % 2 == 0
               select n;
// 当游戏运行时，上述代码将输出偶数

在这个示例中， from 关键字用于指定数据源， n 是一个重用的变量，类似于 foreach 语句中的变量。 where 语句是一个布尔操作，如果条件为真，则将 n 添加到结果输出数组中。

2.2 Var关键字的使用

System.Linq 库引入了许多新的关键字，LINQ的使用深度可能超出了本文的范围。我们主要介绍其基础知识和一些应用场景。以 evenNums 变量为例，它是一个 IEnumerable<int> 类型的值。 var 关键字可以根据变量的使用方式动态分配类型，其类型一旦确定就不能更改。例如：

var someThing = 1; // 类型为int
var anotherThing = new GameObject(); // 类型为GameObject

在Visual Studio中，将鼠标悬停在变量上可以显示其类型信息，这在使用LINQ时特别有用，因为结果输出类型可能并不总是显而易见的。

2.3 LINQ From的应用

为了更详细地说明LINQ的使用，我们以一个嵌套类 Zombie 为例。 Zombie 类有一个随机分配的生命值（1到100之间）。我们创建一个包含100个 Zombie 对象的数组，并使用LINQ表达式查找生命值小于50的僵尸：

// 创建Zombie类
class Zombie
{
    public int hitPoints;
    public Zombie()
    {
        Random random = new Random();
        hitPoints = random.Next(1, 101);
    }
}

// 创建Zombie数组
Zombie[] zombies = new Zombie[100];
for (int i = 0; i < 100; i++)
{
    zombies[i] = new Zombie();
}

// 使用LINQ查找生命值小于50的僵尸
var weakZombies = from zombie in zombies
                  where zombie.hitPoints < 50
                  select zombie;

// 输出生命值小于50的僵尸的生命值
foreach (var zombie in weakZombies)
{
    Console.WriteLine(zombie.hitPoints);
}

通过这个示例可以看出，LINQ在处理大量对象的排序和筛选时非常灵活且高效。

2.4 LINQ的奇怪行为

当创建一个LINQ查询时，它并不会立即执行。例如，在创建一个可被三整除的数字查询后，我们可以修改数组中的值，只有在使用 foreach 语句遍历查询结果时，实际的查询才会执行。

int[] numbers = { 1, 2, 3, 4, 5, 6 };
var divisibleByThree = from n in numbers
                       where n % 3 == 0
                       select n;

// 修改数组中的值
numbers = new int[] { 30, 300 };

// 执行查询
foreach (var num in divisibleByThree)
{
    Console.WriteLine(num); // 输出30和300
}

这种行为表明，LINQ查询所关联的操作在变量被使用时仍然有效。

2.5 LINQ在列表上的应用

LINQ语句通过点运算符提供了额外的功能。例如，在数组上使用 .Where() 函数时，可以结合lambda表达式来替代之前的 where 选择语句。在语句之后，还可以应用其他函数将结果转换为数组。

int[] numbers = { 1, 2, 3, 4, 5, 6 };
var divisibleByThree = numbers.Where(n => n % 3 == 0).ToArray();

ToArray() 函数使用所谓的贪婪运算符将查询转换为数组，避免了LINQ的奇怪行为。如果将LINQ语句封装在括号中并添加 .ToList() ，可以强制将查询结果转换为列表。

除了 .Where() 函数，还可以使用 Distinct() 函数去除数组中的重复值，使用 Union() 函数合并两个数组。例如：

int[] array1 = { 1, 2, 3, 4 };
int[] array2 = { 3, 4, 5, 6 };
var mergedArray = array1.Union(array2).Distinct().ToArray();

3. 怪物类的LINQ应用

我们定义一个怪物类，包含名称、阵营、生命值和位置等属性。每个怪物在创建时都是唯一的。使用 Distinct() 函数过滤怪物数组时，默认情况下会考虑所有属性。

// 定义Alignment枚举
enum Alignment { Good, Evil, Neutral }

// 定义怪物类
class Monster
{
    public string name;
    public Alignment alignment;
    public int HP;
    public Vector3 position;

    public Monster(string name, Alignment alignment, int HP, Vector3 position)
    {
        this.name = name;
        this.alignment = alignment;
        this.HP = HP;
        this.position = position;
    }
}

为了自定义 Distinct() 函数的使用方式，我们可以实现 IEqualityComparer 接口，编写自定义的比较器。例如，只根据怪物的名称来判断两个怪物是否相等：

class MonsterNameEqualityComparer : IEqualityComparer<Monster>
{
    public bool Equals(Monster x, Monster y)
    {
        return x.name == y.name;
    }

    public int GetHashCode(Monster obj)
    {
        return obj.name.GetHashCode();
    }
}

使用自定义比较器后，调用 Distinct() 函数可以去除数组中名称重复的怪物：

Monster[] monsters = new Monster[100];
// 初始化怪物数组

var uniqueMonsters = monsters.Distinct(new MonsterNameEqualityComparer()).ToList();

我们还可以使用 OrderBy 函数对怪物数组按名称进行字母排序，使用 GroupBy 函数选择唯一的名称，再使用 .Select() 函数和 .First() 函数提取所需的信息：

var orderedUniqueMonsters = monsters.OrderBy(m => m.name).GroupBy(m => m.name).Select(group => group.First());

下面是一个简单的mermaid流程图，展示了使用LINQ处理怪物数组的基本流程：

graph TD;
    A[创建怪物数组] --> B[使用Distinct过滤重复怪物];
    B --> C[使用OrderBy排序];
    C --> D[使用GroupBy分组];
    D --> E[使用Select和First提取信息];

4. 反射的基本概念

在编程中，像 int 或 string 这样的类型是明确定义的数据类型。当创建自己的类时，实际上也定义了一种新的类型。在编写新类的过程中，经常需要检查对象的属性。

反射允许代码读取代码，通过 System.Reflection 命名空间中的 MemberInfo 可以读取类的公共内容。例如，有一个 Type Stuff 类，包含一个浮点数、一个整数和两个公共函数：

class Stuff
{
    public float PubFloat;
    public int PubInt;

    public void AFunction() { }
    public int IntFunction() { return 0; }
}

使用反射可以获取该类的公共成员信息：

Type type = typeof(Stuff);
MemberInfo[] members = type.GetMembers();
foreach (MemberInfo member in members)
{
    Console.WriteLine(member.Name);
}

5. 反射的基本示例

在一个简单的示例中，我们可以使用反射来查找具有特定名称的函数：

// 假设有一个类
class MyClass
{
    public void MyFunction() { }
}

// 使用反射查找函数
Type type = typeof(MyClass);
MethodInfo method = type.GetMethod("MyFunction");
if (method != null)
{
    Console.WriteLine("找到函数: " + method.Name);
}

这个示例虽然简单，但说明了反射是使用对象的类型定义来发现对象的属性，而不是直接使用对象本身。

6. 反射的MethodInfo应用

除了类的字段，还可以使用反射来检查函数。在游戏开发中，如果有各种具有特定行为的道具，为角色编写每个道具对应的激活函数会很繁琐。通过反射，可以在运行时动态调用函数。

在一个 MonoBehaviour 中，有一个枚举器用于处理委托任务队列。委托从队列中取出任务并获取其名称，然后使用 GetMethodInfo() 函数获取方法的信息。

// 定义Person类
class Person : MonoBehaviour
{
    public int Life;
    public int Money;
    public Queue<Action<int>> ThingsToDo;

    void Start()
    {
        ThingsToDo = new Queue<Action<int>>();
        // 向队列中添加任务
        ThingsToDo.Enqueue(IncreaseLife);
        ThingsToDo.Enqueue(DecreaseMoney);
        StartCoroutine(DoTheThings());
    }

    IEnumerator DoTheThings()
    {
        while (ThingsToDo.Count > 0)
        {
            Action<int> task = ThingsToDo.Dequeue();
            MethodInfo method = task.Method;
            ParameterInfo[] parameters = method.GetParameters();
            if (parameters.Length > 0)
            {
                string paramName = parameters[0].Name;
                if (paramName == "life")
                {
                    task(Life);
                }
                else if (paramName == "money")
                {
                    task(Money);
                }
            }
            yield return new WaitForSeconds(1);
            if (Life <= 0)
            {
                Destroy(gameObject);
            }
        }
    }

    void IncreaseLife(int value)
    {
        Life += value;
    }

    void DecreaseMoney(int value)
    {
        Money -= value;
    }
}

在这个示例中， Person 类在创建时初始化了一个任务队列，每个任务都是一个委托。在处理队列中的任务时，通过反射获取方法的参数信息，并根据参数名称调用相应的函数。

下面是一个表格，总结了递归、LINQ和反射的主要特点：
| 技术 | 主要特点 |
| ---- | ---- |
| 递归函数 | 内存运行速度可能更快，复杂度增加时迭代函数更慢 |
| LINQ | 灵活高效，可处理各种数据类型，支持多种操作 |
| 反射 | 允许代码读取代码，可动态获取类的成员信息 |

通过以上内容，我们详细介绍了递归函数、LINQ和反射在编程中的应用，这些技术可以提高代码的灵活性和效率，帮助开发者更好地处理复杂的数据和对象。

编程中的递归、LINQ与反射技术解析

7. 反射在处理类属性和委托中的应用

为了进一步探索反射在处理类属性和委托方面的应用，我们来看一个 HasStuff 类的例子。 HasStuff 类包含一些类成员，如数字、位置和游戏对象。我们可以通过反射来查找这些成员，并将其与委托的输入参数进行匹配。

// 定义HasStuff类
class HasStuff
{
    public int number;
    public Vector3 position;
    public GameObject gameObject;
}

// 定义委托
delegate void threeIns(int number, Vector3 position, GameObject gameObject);

// 创建HasStuff对象
HasStuff hasStuff = new HasStuff();
hasStuff.number = 10;
hasStuff.position = new Vector3(1, 2, 3);
hasStuff.gameObject = new GameObject();

// 创建委托实例
threeIns threeInsDelegate = (num, pos, obj) =>
{
    Console.WriteLine($"Number: {num}, Position: {pos}, GameObject: {obj.name}");
};

// 使用反射获取类的属性信息
Type type = hasStuff.GetType();
PropertyInfo[] properties = type.GetProperties();
object[] pars = new object[properties.Length];
for (int i = 0; i < properties.Length; i++)
{
    pars[i] = properties[i].GetValue(hasStuff);
}

// 动态调用委托
threeInsDelegate.DynamicInvoke(pars);

在这个例子中，我们首先定义了 HasStuff 类和一个委托 threeIns 。然后创建了 HasStuff 对象并初始化其属性。接着使用反射获取 HasStuff 类的属性信息，并将这些属性值存储在一个对象数组 pars 中。最后，使用 DynamicInvoke 方法动态调用委托，并将属性值作为参数传递给委托。

8. 总结与应用建议

通过前面的介绍，我们对递归、LINQ和反射这三种编程技术有了较为深入的了解。下面是对这三种技术的总结以及在实际应用中的建议：

8.1 递归函数

优点：在某些情况下，递归函数在计算机内存中的运行速度比迭代函数更快，尤其是在处理复杂问题时。
缺点：递归函数可能会导致栈溢出，特别是在递归深度较大时。
应用建议 ：当问题具有明显的递归结构时，如树的遍历、阶乘计算等，可以考虑使用递归函数。但在使用时要注意递归深度，避免栈溢出。

8.2 LINQ

优点：LINQ提供了一种简洁、灵活的方式来处理数据，可用于排序、筛选、分组等操作。它可以大大减少代码量，提高代码的可读性和可维护性。
缺点：LINQ查询可能会导致性能问题，特别是在处理大量数据时。此外，LINQ的延迟执行特性可能会导致一些意外的行为。
应用建议 ：在处理数据集合时，如数组、列表等，可以优先考虑使用LINQ。但在性能要求较高的场景中，要注意优化查询语句，避免不必要的延迟执行。

8.3 反射

优点：反射允许代码在运行时动态获取类的信息，从而实现更灵活的编程。它可以用于插件系统、依赖注入等场景。
缺点：反射的性能相对较低，因为它需要在运行时进行类型检查和方法调用。此外，反射可能会破坏类的封装性。
应用建议 ：在需要动态调用函数、获取类的属性信息等场景中，可以使用反射。但要注意性能问题，避免在性能敏感的代码中频繁使用反射。

下面是一个mermaid流程图，展示了在实际编程中选择使用递归、LINQ和反射的决策过程：

graph TD;
    A[遇到编程问题] --> B{问题是否具有递归结构};
    B -- 是 --> C[考虑使用递归函数];
    B -- 否 --> D{是否需要处理数据集合};
    D -- 是 --> E[考虑使用LINQ];
    D -- 否 --> F{是否需要动态获取类的信息};
    F -- 是 --> G[考虑使用反射];
    F -- 否 --> H[选择其他合适的方法];