C#笔记之一 泛型

泛型的定义

个人理解为允许在调用对应代码段时再给出具体参数或者数据类型。

泛型的创建

泛型类

在类中使用未明确的数据类型。

public class MyGenericClass<T>
{
    private T myField;

    public MyGenericClass(T initialValue)
    {
        myField = initialValue;
    }

    public T GetValue()
    {
        return myField;
    }
}

泛型接口

public interface IMyGenericInterface<T>
{
    T GetValue();
}

泛型方法

public T GenericMethod<T>(T parameter)
{
    // 在这里使用类型参数 T
    return parameter;
}

泛型的使用

例子：

List<int> intList = new List<int>();
Dictionary<string, double> myDictionary = new Dictionary<string, double>();

进一步的:

泛型的重载

基本的重载：方法参数类型不同

public class GenericOverloadExample<T>
{
    public void ProcessItem(T item)
    {
        Console.WriteLine($"Processing item: {item}");
    }

    public void ProcessItem<U>(U item)
    {
        Console.WriteLine($"Processing item of type U: {item}");
    }
}

GenericOverloadExample<int> example = new GenericOverloadExample<int>();

example.ProcessItem(42);          // 调用第一个方法，使用 int 类型
example.ProcessItem("Hello");     // 调用第二个方法，使用 string 类型

进一步的重载：可以对比和普通参数重载时的区别

public class OverloadExample
{
    // 泛型方法重载
    public void ProcessItem<T>(T item)
    {
        Console.WriteLine($"Processing item: {item}");
    }

    public void ProcessItem<T, U>(T item1, U item2)
    {
        Console.WriteLine($"Processing items: {item1} and {item2}");
    }

    // 参数数目的重载
    public void ProcessItems(int item1)
    {
        Console.WriteLine($"Processing one item: {item1}");
    }

    public void ProcessItems(int item1, string item2)
    {
        Console.WriteLine($"Processing two items: {item1} and {item2}");
    }
}

OverloadExample example = new OverloadExample();

// 调用泛型方法重载
example.ProcessItem(42);                    // 使用单个类型参数
example.ProcessItem("Hello", 3.14);         // 使用两个类型参数

// 调用参数数目的重载
example.ProcessItems(10);                   // 使用一个整数参数
example.ProcessItems(20, "World");          // 使用一个整数和一个字符串参数

 

 泛型的约束

泛型在使用上是为了方便复用，也可以加上一些限制条件来约束泛型实际传入的类型。

约束为引用类型

public class MyClass<T> where T : class
{
    // ...
}

约束为值类型

public class MyStruct<T> where T : struct
{
    // ...
}

约束其拥有某种构造函数

public class MyClassWithConstructor<T> where T : new()
{
    // ...
}

约束其是某一个接口或基类的实现

public class MyBaseClass { }

public class MyClass<T> where T : MyBaseClass
{
    // ...
}

public interface ISomeInterface { }

public class MyClass<T> where T : ISomeInterface
{
    // ...
}

泛型本身也可以写入约束条件 

要求T实现U：

public class MyClass<T, U> where T : U
{
    // ...
}