C#泛型概念

C#泛型主要有以下作用：

1. 类型安全：泛型允许程序员编写类型安全的代码。使用泛型，编译器可以在编译时检查类型，而不是在运行时，这有助于减少运行时错误。
2. 提高复用：泛型允许创建可重用的组件，这些组件可以处理不同的数据类型，而无需为每一种类型重写代码。
3. 灵活性：泛型提供了更大的灵活性。例如，你可以创建一个列表来存储任何类型的对象。
4. 性能优化：泛型可以提供更好的性能。因为.NET运行时可以使用类型信息进行优化，比如避免装箱和拆箱操作。
5. 更好的代码清晰度：使用泛型，可以使代码更加模块化和清晰。因为你可以将特定类型的代码限制在特定部分，而不是在代码的多个地方处理不同类型的对象。
6. 便于单元测试：泛型使得单元测试更加容易，因为你可以创建模拟对象来测试代码的各个部分，而无需关心这些部分的实现细节。
7. 处理复杂的数据类型：对于一些复杂的数据类型，比如用户自定义的类型，使用泛型可以简化代码的复杂性。

1.泛型方法

修饰符 Void 方法名 <类型参数T>
{

    //方法体

}

PS:泛型方法可以使用多类型参数进行重载

在C#中，泛型参数约束包括以下几种：

1. where T : struct：约束类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。
2. where T : class：约束类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。
3. where T : new()：约束类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
4. where T : <基类名>：约束类型参数必须是指定的基类或派生自指定的基类。
5. where T : <接口名称>：约束类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。 约束接口也可以是泛型的。
6. where T : U：为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。

泛型的分类：

1.在C#中，泛型基本类型主要包括泛型数组、泛型枚举和泛型结构。

泛型数组 int[] arr = new int[10]，或者创建一个泛型枚举enum Color { Red, Green, Blue }。

2.泛型类

好的，以下是对上述代码的逐行注释：

csharp
// 引入命名空间 System，使用 System 下的类、接口、值类型等。  
using System;  
  
// 定义一个泛型类 Box<T>，T 为类型参数，表示这个类可以存储任意类型的对象。  
class Box<T>  
{  
    // 定义一个类型为 T 的私有变量 item，用于存储泛型对象的值。  
    private T item;  
  
    // 定义一个构造函数，接受一个类型为 T 的参数，用于初始化私有变量 item。  
    public Box(T item)  
    {  
        this.item = item;  
    }  
  
    // 定义一个公共属性 Item，使用 T 表示返回值的类型，允许外部代码获取和设置私有变量 item 的值。  
    public T Item  
    {  
        get  
        {  
            // 定义一个 getter 方法，用于获取私有变量 item 的值。  
            return item;  
        }  
        set  
        {  
            // 定义一个 setter 方法，用于设置私有变量 item 的值。  
            item = value;  
        }  
    }  
}  
  
// 定义一个类 Program，作为程序的入口点。  
class Program  
{  
    // 定义一个静态方法 Main，作为程序的入口点。  
    static void Main()  
    {  
        // 创建一个 Box<int> 类型的对象 intBox，并传入整数值 10 作为参数初始化私有变量 item。  
        Box<int> intBox = new Box<int>(10);  
        // 调用 intBox 的 Item 属性获取其私有变量 item 的值，并输出到控制台。输出结果为 "10"。  
        Console.WriteLine(intBox.Item); // 输出 "10"  
        // 修改 intBox 的私有变量 item 的值为整数值 20。  
        intBox.Item = 20;  
        // 再次调用 intBox 的 Item 属性获取其私有变量 item 的值，并输出到控制台。输出结果为 "20"。  
        Console.WriteLine(intBox.Item); // 输出 "20"  
          
        // 创建一个 Box<string> 类型的对象 strBox，并传入字符串值 "hello" 作为参数初始化私有变量 item。  
        Box<string> strBox = new Box<string>("hello");  
        // 调用 strBox 的 Item 属性获取其私有变量 item 的值，并输出到控制台。输出结果为 "hello"。  
        Console.WriteLine(strBox.Item); // 输出 "hello"  
        // 修改 strBox 的私有变量 item 的值为字符串值 "world"。  
        strBox.Item = "world";  
        // 再次调用 strBox 的 Item 属性获取其私有变量 item 的值，并输出到控制台。输出结果为 "world"。  
        Console.WriteLine(strBox.Item); // 输出 "world"  
    }  
}

3.泛型接口

好的，以下是对上述代码的逐行注释：

csharp
// 引入命名空间 System，使用 System 下的类、接口、值类型等。  
using System;  
  
// 定义一个泛型接口 ICalculator<T>，T 为类型参数，表示这个接口可以应用于任意类型的参数。  
interface ICalculator<T>  
{  
    // 定义一个方法 Add，接受两个类型为 T 的参数 x 和 y，返回一个类型为 T 的结果。  
    T Add(T x, T y);  
    // 定义一个方法 Subtract，接受两个类型为 T 的参数 x 和 y，返回一个类型为 T 的结果。  
    T Subtract(T x, T y);  
}  
  
// 定义一个类 IntegerCalculator，实现泛型接口 ICalculator<int>，提供对整数类型的加法和减法操作。  
class IntegerCalculator : ICalculator<int>  
{  
    // 实现接口方法 Add，返回两个整数参数的和。  
    public int Add(int x, int y)  
    {  
        return x + y;  
    }  
  
    // 实现接口方法 Subtract，返回两个整数参数的差。  
    public int Subtract(int x, int y)  
    {  
        return x - y;  
    }  
}  
  
// 定义一个类 FloatingCalculator，实现泛型接口 ICalculator<double>，提供对浮点数类型的加法和减法操作。  
class FloatingCalculator : ICalculator<double>  
{  
    // 实现接口方法 Add，返回两个浮点数参数的和。  
    public double Add(double x, double y)  
    {  
        return x + y;  
    }  
  
    // 实现接口方法 Subtract，返回两个浮点数参数的差。  
    public double Subtract(double x, double y)  
    {  
        return x - y;  
    }  
}  
  
// 定义一个类 Program，作为程序的入口点。  
class Program  
{  
    // 定义一个静态方法 Main，作为程序的入口点。  
    static void Main(string[] args)  
    {  
        // 创建一个 ICalculator<int> 类型的对象 intCalculator，并使用 new IntegerCalculator() 进行实例化。  
        ICalculator<int> intCalculator = new IntegerCalculator();  
        // 调用 intCalculator 的 Add 方法，传入参数 3 和 4，并将结果输出到控制台。输出结果为 "7"。  
        Console.WriteLine(intCalculator.Add(3, 4)); // 输出 "7"  
        // 调用 intCalculator 的 Subtract 方法，传入参数 3 和 4，并将结果输出到控制台。输出结果为 "-1"。  
        Console.WriteLine(intCalculator.Subtract(3, 4)); // 输出 "-1"  
                                    
        // 创建一个 ICalculator<double> 类型的对象 floatCalculator，并使用 new FloatingCalculator() 进行实例化。                                     
        ICalculator<double> floatCalculator = new FloatingCalculator();  
        // 调用 floatCalculator 的 Add 方法，传入参数 3.0 和 4.0，并将结果输出到控制台。输出结果为 "7.0"。                                
        Console.WriteLine(floatCalculator.Add(3.0, 4.0)); // 输出 "7.0"                                 
        // 调用 floatCalculator 的 Subtract 方法，传入参数 3.0 和 4.0，并将结果输出到控制台。输出结果为 "-1.0"。                                 
        Console.WriteLine(floatCalculator.Subtract(3.0, 4.0)); // 输出 "-1.0"                                 
    }  
}

4.泛型方法

以下是一个泛型方法的示例代码及其应用，带有逐行注释：

csharp
using System;  
  
class Program  
{  
    static void Main(string[] args)  
    {  
        // 调用泛型方法 PrintArray，传入整数数组，打印数组元素  
        int[] intArray = { 1, 2, 3, 4, 5 };  
        PrintArray(intArray);  
          
        // 调用泛型方法 PrintArray，传入浮点数数组，打印数组元素  
        double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };  
        PrintArray(doubleArray);  
    }  
  
    // 定义一个泛型方法 PrintArray，接收一个数组参数，打印数组元素  
    static void PrintArray<T>(T[] array) where T : IComparable<T>  
    {  
        foreach (T element in array)  
        {  
            Console.WriteLine(element.ToString()); // 将数组元素转换为字符串并打印到控制台  
        }  
    }  
}
注释代码：

csharp
// 使用 System 命名空间，引入 System 类、接口、值类型等。  
using System;  
  
// 定义一个类 Program，作为程序的入口点。  
class Program  
{  
    // 定义一个静态方法 Main，作为程序的入口点。该方法是程序执行的起点。  
    static void Main(string[] args)  
    {  
        // 定义一个整数数组 intArray，包含五个元素。  
        int[] intArray = { 1, 2, 3, 4, 5 };  
        // 调用泛型方法 PrintArray，将 intArray 作为参数传入，打印整数数组的元素。  
        PrintArray(intArray);  
          
        // 定义一个浮点数数组 doubleArray，包含五个元素。  
        double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };  
        // 调用泛型方法 PrintArray，将 doubleArray 作为参数传入，打印浮点数数组的元素。  
        PrintArray(doubleArray);  
    }  
  
    // 定义一个泛型方法 PrintArray，接收一个数组参数 array。该方法使用泛型类型参数 T，表示可以适用于任意类型的数组。  
    // 在方法参数中加入 where T : IComparable<T> 约束，表示 T 必须实现 IComparable<T> 接口，以确保可以比较 T 类型的对象。  
    static void PrintArray<T>(T[] array) where T : IComparable<T>  
    {  
        // 使用 foreach 循环遍历数组，依次取出数组中的元素。  
        foreach (T element in array)  
        {  
            // 将数组元素转换为字符串并打印到控制台。这里使用 ToString 方法将元素转换为字符串。注意这里没有进行异常处理，假设输入的数组元素都是可转换为字符串的类型。  
            Console.WriteLine(element.ToString()); // 将数组元素转换为字符串并打印到控制台  
        }  
    }  
}