C#泛型与依赖注入：模块化与测试的新境界

# 1. C#泛型基础

## 1.1 泛型简介
泛型编程允许用户定义与数据类型无关的算法和数据结构。在.NET框架中，泛型的引入主要解决了早期非泛型集合在类型安全和性能方面的限制。通过泛型，开发者可以编写更加通用和复用的代码，同时在编译时进行类型检查，以提高代码的稳定性和效率。

## 1.2 泛型的基本用法
在C#中，泛型通过尖括号`< >`来声明类型参数。例如，`List<T>`是一个泛型类，其中`T`是一个类型参数，用户可以在实例化时指定具体的数据类型：

List<int> numbers = new List<int>();
List<string> names = new List<string>();

在此示例中，`numbers`和`names`分别是整数列表和字符串列表。泛型类的使用提高了代码的复用性，并且编译器能够保证类型安全。

## 1.3 泛型与代码重构
泛型对代码重构具有重要影响。在没有泛型时，开发者可能需要编写多个几乎相同的类来处理不同类型的对象，这被称为代码重复。泛型的使用能够减少重复代码，提高程序的可维护性和可读性。通过参数化类型，开发者可以创建出更加灵活和通用的代码组件。

# 2. 泛型的高级应用

## 2.1 泛型类与接口
### 2.1.1 定义和实例化泛型类

泛型类是C#语言中支持泛型编程的核心概念，它允许你编写与数据类型无关的代码，使代码更加灵活和可重用。一个泛型类可以定义一个或多个类型参数，这些参数在创建类的实例时被具体化。

public class GenericList<T>
{
    private List<T> _items = new List<T>();

    public void Add(T item)
    {
        _items.Add(item);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _items.GetEnumerator();
    }
}

// 实例化泛型类
var intList = new GenericList<int>();
intList.Add(1);
intList.Add(2);

在上述代码中，`GenericList<T>` 是一个泛型类，它有一个类型参数 `T`。你可以用任何数据类型来实例化 `GenericList`，比如 `int`、`string` 或者自定义类型。创建 `intList` 实例时，类型参数 `T` 被确定为 `int` 类型。

### 2.1.2 泛型接口的实现

泛型接口和泛型类类似，允许接口定义中的方法参数、返回类型或其他成员引用泛型类型。这样，实现这个接口的任何类或结构都必须指定泛型类型参数的具体类型。

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

public class UserRepository : IGenericRepository<User>
{
    public void Add(User item)
    {
        // 添加用户到数据存储
    }

    public User GetById(int id)
    {
        // 从数据存储中获取指定ID的用户
        return new User();
    }
}

在这个例子中，`IGenericRepository<T>` 是一个泛型接口，定义了添加和获取数据的方法。`UserRepository` 类实现了这个接口，并具体化了泛型类型 `T` 为 `User` 类型。

## 2.2 泛型方法与委托
### 2.2.1 泛型方法的定义和使用

泛型方法可以定义在泛型或非泛型类中，可以独立于类的类型参数来使用。这种灵活性允许你在不创建新的泛型类的情况下，实现泛型操作。

public class Utility
{
    public static T Min<T>(T val1, T val2) where T : IComparable<T>
    {
        if (***pareTo(val2) < 0)
            return val1;
        else
            return val2;
    }
}

// 使用泛型方法
var minInt = Utility.Min(1, 2);
var minX = Utility.Min("a", "b");

在这里，`Min` 是一个泛型方法，它接受两个类型为 `T` 的参数，并返回较小的一个。`where T : IComparable<T>` 是一个约束，确保 `T` 类型实现了 `IComparable<T>` 接口，从而能够使用 `CompareTo` 方法进行比较。

### 2.2.2 泛型委托的创建和应用

泛型委托可以使用类型参数来定义委托的签名，这意味着可以创建一种可以接受任何类型参数的方法引用的委托。

public delegate T GenericDelegate<T>();

public static int PlusOne(int number)
{
    return number + 1;
}

public static string Concatenate(string left, string right)
{
    return left + right;
}

// 创建并使用泛型委托
GenericDelegate<int> plusOneDel = new GenericDelegate<int>(PlusOne);
GenericDelegate<string> concatenateDel = new GenericDelegate<string>(Concatenate);

int result = plusOneDel(3);  // 结果是4
string result2 = concatenateDel("Hello", " World!"); // 结果是 "Hello World!"

在上面的代码中，`GenericDelegate<T>` 是一个泛型委托，定义了一个没有参数并返回类型为 `T` 的方法。之后创建了 `plusOneDel` 和 `concatenateDel` 两个实例，分别绑定到了 `PlusOne` 和 `Concatenate` 方法。

## 2.3 泛型集合和LINQ

### 2.3.1 泛型集合的使用场景

泛型集合是存储特定类型对象的集合类，如 `List<T>`、`Dictionary<TKey, TValue>` 等。它们比非泛型集合提供了更好的类型安全性和性能。

List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);

// 使用foreach遍历
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

在这个例子中，使用泛型 `List<T>` 来存储整数。由于是泛型集合，所以不需要显式地进行类型转换，提高了代码的可读性和安全性。

### 2.3.2 LINQ在泛型编程中的应用

语言集成查询（LINQ）允许在C#中对数据进行查询，这包括泛型集合。LINQ提供了一组方法和查询语法，使得对集合的操作更加直观和强大。

using System;
using System.Linq;

// 使用LINQ查询泛型集合
var numbers = new List<int>{1, 2, 3, 4, 5, 6};
var evenNumbersQuery = from num in numbers
                       where num % 2 == 0
                       select num;

// 执行查询
var evenNumbers = evenNumbersQuery.ToList();
foreach (var num in evenNumbers)
{
    Console.WriteLine(num); // 输出偶数2, 4, 6
}

在这里，通过LINQ的查询表达式，我们创建了一个查询 `evenNumbersQuery` 来选择 `numbers` 列表中的偶数。使用 `ToList()` 方法执行了这个查询，并且最终结果被输出。

### 2.3.3 泛型集合与LINQ的优化

泛型集合与LINQ结合使用，可以进一步优化代码，减少冗余，提高查询效率。例如，使用泛型集合可以提高编译时的类型检查，并且能够利用泛型编译器的优化。

// 结合泛型集合与LINQ的优