C# 泛型 使用详解

总目录

---

前言

在 C# 编程中，代码的复用性和灵活性是至关重要的。

在传统编程方式中，若需处理不同数据类型的相似逻辑，往往需要为每个类型编写重复代码。例如，针对int和string的集合操作需分别实现，这不仅冗余，还可能导致类型安全隐患。

在C# 2.0引入泛型后，它彻底改变了开发者编写可复用代码的方式。C#泛型（Generics）通过延迟类型指定（或称 类型参数化）的机制，允许开发者编写可复用的类型安全代码，更通过消除装箱拆箱操作显著优化了性能。接下来，我们就来深入探讨一下 C# 泛型的使用吧。

---

一、什么是泛型

1. 基本概念

• 泛型（Generics）是一种编程范式，它允许我们在定义类、方法或接口时，使用占位符（类型参数）代替具体的类型。在实际使用时，这些占位符会被具体的类型替换，从而实现类型安全的代码复用。
• 通过使用泛型，我们可以编写适用于多种数据类型的代码，而无需为每种类型单独写代码，这不仅提高了代码的复用性，还增强了类型安全性和效率。

2. 泛型的优点

• 类型安全：由于泛型代码在编译时会进行类型检查，因此减少了运行时出现错误的可能性。
• 性能提升：泛型在运行时会生成特定类型的代码，避免了装箱和拆箱操作，提高了性能。
• 代码复用：通过泛型，我们可以编写多种数据类型通用的类和方法，减少重复代码。
• 可读性增强：泛型代码更清晰，意图更明确。

3. 痛点场景

示例：要求实现输入int ,string,datetime类型的值的时候，打印出对应的类型和值

	public class CommonMethod
    {
        //打印int的数据类型和值
        public static void ShowInt(int a)
        {
            Console.WriteLine($"result：type={a.GetType().Name},value={a}");
        }
        
        //打印string的数据类型和值
        public static void ShowString(string s)
        {
            Console.WriteLine($"result：type={s.GetType().Name},value={s}");
        }
        
        //打印DateTime 的数据类型和值
        public static void ShowDateTime(DateTime dt)
        {
            Console.WriteLine($"result：type={dt.GetType().Name},value={dt}");
        }
    }

以上示例中除了传入参数的数据类型不同，其余的处理逻辑相同，明显代码没有得到复用，于是简化代码如下：

        // 打印输入参数的数据类型和值
        public static void ShowObject(object o)
        {
            Console.WriteLine($"result:type={o.GetType().Name},value={o}");
        }

示例中，直接使用object 完成了代码的复用，让代码变得更加简洁通用，但是在这个过程中存在数据类型转化，也就涉及到了装箱和拆箱，严重的影响程序的性能。

那么现在能不能找一个 既能满足 代码复用的需求 又能避免装箱和拆箱带来性能损耗的方法呢？
有，那就是使用泛型，使用泛型优化示例代码：

        //打印输入参数的数据类型和值
        public static void ShowResult<T>(T t)
        {
            Console.WriteLine($"result:type={t.GetType().Name},value={t}");
        }

二、如何使用泛型？

1. 类型参数

• 类型参数：是指在定义类、接口或方法时使用的占位符，代表实际使用时指定的数据类型。
  • 例如，在List中，T就是类型参数。
  • 类型参数 可以代表任何类型，也可识别任何类型
• 类型参数命名规范：推荐使用T、TKey、TValue等有意义的类型参数名
  • 泛型参数一般用T表示，但是不代表不可以使用别的代表，也可使用V、K等自定义的名称，但是推荐命名的时候使用T或者T开头
• 类型参数数量：数量不限，业务中需要几个类型参数，就设置几个类型参数，不过建议类型参数不要过多

使用一对尖括号 + 类型参数 T ，如 MyGenericClass 、List这种形式来定义泛型对象。

2. 泛型类

泛型类是最常见的泛型形式。它允许我们定义一个类，其行为可以独立于具体的数据类型。

1）泛型类

• 定义泛型类的基本语法如下：
  • 这里T是类型参数，代表任何数据类型。创建对象时，需要指定实际的数据类型。

	public class Box<T>
	{
	    private T _item;
	
	    public void Set(T item)
	    {
	        _item = item;
	    }
	
	    public T Get()
	    {
	        return _item;
	    }
	}

在这个例子中，Box 是一个泛型类，T 是类型参数。我们可以通过指定具体的类型来实例化这个类：

• 使用泛型类

	Box<int> intBox = new Box<int>();
	intBox.Set(42);
	Console.WriteLine(intBox.Get()); // 输出：42
	
	Box<string> stringBox = new Box<string>();
	stringBox.Set("Hello, World!");
	Console.WriteLine(stringBox.Get()); // 输出：Hello, World!

实例化 泛型对象的时候，必须指明具体的数据类型（如Box、Box），否则是无法实例化的。

2）多类型参数

• 泛型类可以接受多个类型参数。例如，一个字典类可能需要键和值两种类型：

public class Dictionary<TKey, TValue>
{
    // 实现细节...
}

• 根据实际业务需求，可以定义多个泛型 类型参数 ，如 MyGeneric

    public class MyGenericClass<T1,T2>
    {
        public void Test(T1 t1,T2 t2)
        {
            Console.WriteLine($"result:T={t1.GetType().Name};V={t2.GetType().Name}");
        }
    }

3） 泛型类和普通类

泛型类定义的时候与普通使用上基本相同，只不过类名后面多了个尖括号，尖括号中放了泛型参数用于占位

//普通类
public class MyClass
//泛型类
public class MyGenericClass<T>

3. 泛型接口

泛型接口（如IEnumerable）支持统一操作不同数据类型的集合。

public interface IRepository<T>
{
    T GetById(int id);
    void Add(T item);
    void Update(T item);
    void Delete(T item);
}

在这个例子中，IRepository 是一个泛型接口，T 是类型参数。我们可以为不同的类型实现这个接口：

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class UserRepository : IRepository<User>
{
    public User GetById(int id)
    {
        // 实现逻辑
        return new User { Id = id, Name = "John Doe" };
    }

    public void Add(User item)
    {
        // 实现逻辑
    }

    public void Update(User item)
    {
        // 实现逻辑
    }

    public void Delete(User item)
    {
        // 实现逻辑
    }
}

4. 泛型方法

泛型方法允许我们在方法级别上使用类型参数。这使得方法可以独立于具体类型，从而提高代码的复用性。

1） 泛型方法

除了类之外，我们还可以定义泛型方法，即使它们所在的类不是泛型类：

public class Utility
{
    public static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
}

在这个例子中，Swap方法可以交换任意类型的两个变量的值。

public class Utility
{
    public static T GetMax<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

在这个例子中，GetMax 是一个泛型方法，T 是类型参数。它接受两个参数并返回较大的值。我们可以通过指定具体的类型来调用这个方法：

int maxInt = Utility.GetMax(10, 20);
Console.WriteLine(maxInt); // 输出：20

string maxString = Utility.GetMax("Apple", "Banana");
Console.WriteLine(maxString); // 输出：Banana

2）泛型方法和普通方法

    public class MyGeneric<T>
    {
        public MyGeneric(T t)
        {
            Console.WriteLine($"result:type={t.GetType().Name};value={t}");
        }

        public void Show(T t)
        {
            Console.WriteLine($"result:type={t.GetType().Name};value={t}");
        }

        public void Test<V>(V v)
        {
            
        }
    }

在这个例子中，Show 是 具有泛型参数的 普通方法，Test 是泛型方法，MyGeneric是泛型类。

5. 泛型委托

泛型委托允许我们定义通用的委托类型，其行为可以独立于具体的数据类型。

public delegate T MyDelegate<T>(T a, T b);

public class Program
{
    public static T GetMax<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }

    static void Main()
    {
        MyDelegate<int> intDelegate = GetMax;
        int maxInt = intDelegate(10, 20);
        Console.WriteLine(maxInt); // 输出：20

        MyDelegate<string> stringDelegate = GetMax;
        string maxString = stringDelegate("Apple", "Banana");
        Console.WriteLine(maxString); // 输出：Banana
    }
}

在这个例子中，MyDelegate 是一个泛型委托，它接受两个参数并返回一个值。我们可以通过指定具体的类型来使用这个委托。

6. 静态成员与泛型

若误以为静态成员跨类型共享，可能导致数据不一致或逻辑错误。示例如下：

public class StaticGeneric<T>
{
    public static int Count;

    public StaticGeneric()
    {
        Count++;
    }
}

public class Program
{
    public static void Main()
    {
        StaticGeneric<int> staticGenericInt=new StaticGeneric<int>();
        Console.WriteLine($"Count = {StaticGeneric<int>.Count}");       //输出：Count = 1

        StaticGeneric<string> staticGenericString=new StaticGeneric<string>();       
        Console.WriteLine($"Count = {StaticGeneric<string>.Count}");    //输出：Count = 1
    }
}

在C#中，静态成员与泛型结合使用时需特别注意以下几点

• 静态成员不共享：
  • 不同类型参数的泛型实例会生成独立的静态成员，导致数据无法共享。
• 避免在泛型类型中声明静态成员：
  • 泛型类型（如StaticGeneric）的静态成员与具体类型参数绑定，不同类型参数的实例视为不同类型。
  • 如 StaticGeneric.Count 结果为1，StaticGeneric.Count结果仍为1

7. 泛型与default、dynamic关键字

1）与 default

• 获取类型默认值

  • 在泛型中处理默认值时，可以使用default来获取类型的默认值。
  • 对于引用类型，默认值为null；对于数值类型，默认值为0。

  public T GetDefault<T>()
  {
  	return default(T); // 引用类型返回null，值类型返回0等
  }
  

  从 C# 7.1 开始，可以直接使用 default 而不带括号来简化语法：

  class GenericExample<T>
  {
  	public T GetDefaultValue()
  	{
      	return default;
  	}
  }
  

• 设置类型默认值

class GenericExample<T,V>
{
    private T t;
    private V v;
    public GenericExample()
    {
        t = default;
        v = default;
    }
}

2） 与 dynamic

如上图，Add用于计算t1和t2之和的时候，直接使用int sum= t1+t2，会报错，因为还没有实例化，没有指定数据类型，无法直接适用于加法，但是如果使用dynamic，就可以跳过编译类型检查，改为在运行时解析这些操作。 就可以完成相关的业务逻辑。

8. 协变与逆变中的泛型

• 协变（Covariance）：允许子类泛型赋值给父类（IEnumerable → IEnumerable