C#性能优化：类型系统中的关键细节与示例代码

C#性能优化：类型系统中的关键细节与示例代码

引用

CSDN

1.

https://m.blog.csdn.net/cplvfx/article/details/145877000

在C#开发中，性能优化是提升系统响应速度和资源利用率的关键环节。通过遵循下述建议，可以有效地减少不必要的对象创建，从而减轻GC的负担，提高应用程序的整体性能。记住，优化应该是有针对性的，只有在确定了性能瓶颈之后，才应该采取相应的措施。

6.1. 避免无意义的变量初始化动作

CLR保证所有对象在访问前已初始化，其做法是将分配的内存清零。因此，不需要将变量重新初始化为0、false或null。

需要注意的是：方法中的局部变量不是从堆而是从栈上分配，所以C#不会做清零工作。如果使用了未赋值的局部变量，编译期间即会报警。不要因为有这个印象而对所有类的成员变量也做赋值动作，两者的机理完全不同！

理解CLR（Common Language Runtime）如何处理变量的初始化对于编写高效且无误的C#代码至关重要。下面是对这个问题更详细的解释：

对象字段的自动初始化

在C#中，当一个对象被实例化时，CLR会为该对象分配内存，并将这些新分配的内存区域清零。这意味着所有的字段（包括值类型和引用类型）都会有一个默认值：

• 对于数值类型的字段，默认值是0或者其对应的零值。
• 对于引用类型的字段，默认值是null。
• 对于布尔类型的字段，默认值是false。

因此，在类定义中显式地将字段初始化为其默认值（如int x = 0; 或 bool isActive = false;）是不必要的，因为CLR已经保证了这一点。这样做不仅没有带来任何好处，还可能增加代码的冗余度，降低代码的可读性。

public class ExampleClass
{
    private int number; // 不需要初始化为0，CLR已经保证了
    private bool flag; // 默认就是false
    private string text; // 默认是null
}

局部变量的初始化

与上述情况不同的是，局部变量（即方法内部声明的变量）并不享受这种自动初始化的待遇。这是因为局部变量是从栈上分配而非堆上，CLR不会对它们进行类似的零初始化操作。如果尝试使用未赋值的局部变量，编译器会在编译期间发出警告或错误。

public void ExampleMethod()
{
    int localVar; // 错误：使用未赋值的局部变量
    Console.WriteLine(localVar); // 编译器报错
}

因此，在使用局部变量之前，必须明确地给它们赋值。

结论

• 成员变量：不需要手动将其设置为其默认值（0、false、null等），因为CLR已经确保了这一点。
• 局部变量：必须在使用前手动赋值，否则会导致编译错误。

正确理解和应用这些原则可以帮助你避免不必要的变量初始化动作，从而编写更加简洁、高效的代码。同时，这也反映了深入理解语言运行机制的重要性，有助于提高代码质量和开发效率。

6.2. ValueType 和 ReferenceType

6.2.1. 以引用方式传递值类型参数

值类型从调用栈分配，引用类型从托管堆分配。当值类型用作方法参数时，默认会进行参数值复制，这抵消了值类型分配效率上的优势。作为一项基本技巧，以引用方式传递值类型参数可以提高性能。

在C#中，值类型（如int, struct等）和引用类型（如class）有着不同的内存分配方式和传递机制。默认情况下，当你将一个值类型作为参数传递给方法时，实际上是传递了这个值类型的一个副本，这意味着方法内部对参数的任何修改都不会影响到原始变量。这种行为确保了数据的安全性，但可能会带来性能上的开销，特别是对于较大的结构体。

以引用方式传递值类型

为了克服值类型传递带来的性能问题，C#提供了两种关键字来以引用的方式传递参数：ref和out。

• ref：用于传递之前已经初始化过的变量。它允许方法内部对该变量进行读写操作。
• out：类似于ref，但是被标记为out的参数在方法内必须被赋值，且在调用方法前无需初始化。

下面通过示例说明如何使用ref关键字：

public struct LargeStruct
{
    public int[] Data;
    // 假设这里有很多其他字段
    public LargeStruct(int size)
    {
        Data = new int[size];
        for (int i = 0; i < size; ++i)
        {
            Data[i] = i;
        }
    }
}
public class Program
{
    public static void ModifyStruct(ref LargeStruct ls)
    {
        // 修改结构体内的数据
        if (ls.Data.Length > 0)
        {
            ls.Data[0] = -1;
        }
    }
    public static void Main()
    {
        var ls = new LargeStruct(1000);
        Console.WriteLine(ls.Data[0]); // 输出: 0
        ModifyStruct(ref ls); // 以引用方式传递
        Console.WriteLine(ls.Data[0]); // 输出: -1
    }
}

在这个例子中，通过使用ref关键字，我们避免了复制LargeStruct实例所带来的性能损耗，并且能够直接修改原始结构体的内容。

使用ref和out的注意事项

• 在方法签名和方法调用点都必须使用ref或out关键字。
• 使用ref传递参数时，调用方提供的实参必须是已明确赋值的。
• 使用out时，方法内部必须为out参数赋值，但在调用前不需要初始化该参数。

通过合理使用ref和out关键字，可以有效地提升涉及大型值类型的数据处理效率，同时保持代码清晰和意图明确。然而，过度使用这些特性也可能导致代码复杂度增加，因此应当谨慎应用。

• 推荐文章：《C#中ref、out、in的区别与使用》

6.2.2. 为 ValueType 提供 Equals 方法

.net 默认实现的 ValueType.Equals 方法使用了反射技术，依靠反射来获得所有成员变量值做比较，这个效率极低。如果我们编写的值对象其 Equals 方法要被用到（例如将值对象放到 HashTable 中），那么就应该重载 Equals 方法。

public struct Rectangle
{
    public double Length;
    public double Breadth;
    public override bool Equals(object obj)
    {
        // 判断是否为相同类型，并使用强类型的Equals方法进行比较
        if (obj is Rectangle other)
        {
            return Equals(other);
        }
        return false;
    }
    private bool Equals(Rectangle other)
    {
        // 比较两个Rectangle实例的Length和Breadth字段
        return this.Length == other.Length && this.Breadth == other.Breadth;
    }
    public override int GetHashCode()
    {
        // 使用组合函数生成基于Length和Breadth的哈希码
        return HashCode.Combine(Length, Breadth);
    }
}

关键点解释

• Equals 方法：在重写的Equals(object obj)方法中，我们首先检查传入的对象是否可以转换为Rectangle类型。如果是，则调用私有的Equals(Rectangle other)方法来执行实际的字段比较。
• GetHashCode 方法：为了支持哈希集合（例如HashSet或作为字典的键），我们需要重写GetHashCode方法。这里使用了HashCode.Combine方法来根据Length和Breadth字段计算哈希码，这样可以保证具有相同尺寸的矩形拥有相同的哈希码。
• 在C#中，所有值类型都隐式继承自System.ValueType。
  ValueType自身重写了Object类的Equals方法，提供了基于值比较的实现。默认情况下，这个实现使用反射来比较两个值类型实例的所有字段是否相等。虽然这种方法非常通用，可以适用于任何结构体，但由于反射带来的性能开销，在高性能要求的场景下可能不是最佳选择。
• 因此，如果您的值类型需要频繁进行相等性比较（例如作为哈希表的键），推荐您重写Equals方法和GetHashCode方法，以提高性能。这样做不仅能加快相等性检查的速度，还能确保哈希表操作（如查找、插入）更加高效。

如何重写 Equals 和 GetHashCode 方法

以下是一个示例，展示了如何为一个简单的结构体重写Equals和GetHashCode方法：

public struct Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
    public override bool Equals(object obj)
    {
        if (obj is Point p)
        {
            return this.X == p.X && this.Y == p.Y;
        }
        return false;
    }
    public override int GetHashCode()
    {
        // 为了简化，这里直接组合X和Y的哈希码。
        // 在实际应用中，可能需要考虑更好的混合策略以避免哈希冲突。
        return HashCode.Combine(X, Y);
    }
    // 还可以实现IEquatable<T>接口，提供更强类型的Equals方法
    public bool Equals(Point other)
    {
        return this.X == other.X && this.Y == other.Y;
    }
}

在这个例子中，我们首先通过判断传入的对象是否是Point类型来优化Equals方法。然后直接比较了X和Y字段的值，而不是使用反射。对于GetHashCode方法，我们使用了HashCode.Combine方法来生成哈希码，这是一个更有效的方法来计算多个字段的哈希值。

• 默认的ValueType.Equals实现由于使用反射而导致性能低下，特别是当值类型包含大量字段时。
• 通过重写Equals和GetHashCode方法，可以根据具体情况优化性能。
• 实现IEquatable接口也是一个不错的选择，它允许你定义强类型的相等性比较方法，从而避免装箱操作并进一步提升性能。

这种优化对于那些将值对象用于字典键或其他需要频繁进行相等性检查的数据结构中特别重要。

6.3. 避免装箱和拆箱

C#可以在值类型和引用类型之间自动转换，方法是装箱和拆箱。装箱需要从堆上分配对象并拷贝值，有一定性能消耗。如果这一过程发生在循环中或是作为底层方法被频繁调用，则应该警惕累计的效应。

一种经常的情形出现在使用集合类型时。例如：

下面的代码示例展示了由于使用了非泛型集合ArrayList而导致的装箱和拆箱操作：

ArrayList al = new ArrayList();
for (int i = 0; i < 1000; i++)
{
    al.Add(i); // Implicitly boxed because Add() takes an object
}
int f = (int)al[0]; // The element is unboxed

在这个例子中，每次调用Add()方法时都会对整数i进行装箱操作，因为ArrayList的Add()方法接受一个object类型的参数。同样地，在获取元素时需要进行拆箱操作以将其转换回int类型。

解决方案

为了避免不必要的装箱和拆箱操作，可以使用泛型集合类，比如List，它允许指定列表中存储的数据类型。这样做的好处是可以避免装箱操作，因为不需要将值类型转换为object类型。下面是使用List的改进版本：

List<int> list = new List<int>();
for (int i = 0; i < 1000; i++)
{
    list.Add(i); // No boxing occurs, since List<int> can directly store integers
}
int f = list[0]; // Direct access without unboxing

在这个改进后的版本中，没有发生装箱和拆箱操作，因为List直接支持存储整数类型的数据。这样做不仅提高了性能，还增强了类型安全性和代码清晰度。

总结

• 尽量使用泛型集合（如List、Dictionary<TKey,TValue>等）代替非泛型集合（如ArrayList、Hashtable），以减少装箱和拆箱。
• 在设计API或编写公共方法时，考虑使用泛型来提高灵活性和效率。
• 对于性能关键的应用部分，特别注意避免装箱和拆箱带来的额外开销。通过优化数据结构的选择，可以有效提升程序运行效率。