C#的泛型和委托

什么是泛型

泛型是C# 2.0中引入的一种编程技术，它可以让你定义一个通用的类型参数，然后在使用时指定具体的类型。这样，你就可以编写一套适用于多种类型的代码，而不需要重复编写相同的逻辑。泛型可以提高代码的可重用性和类型安全性，同时也可以避免不必要的装箱和拆箱操作，提高性能。

泛型可以用于类、接口、方法、委托、事件等地方。例如，你可以定义一个泛型类Stack<T>，表示一个存储任意类型元素的栈结构：

class Stack<T>
{
    private T[] items;
    private int top;

    public Stack(int size)
    {
        items = new T[size];
        top = -1;
    }

    public void Push(T item)
    {
        if (top == items.Length - 1)
        {
            throw new InvalidOperationException("Stack is full.");
        }
        items[++top] = item;
    }

    public T Pop()
    {
        if (top == -1)
        {
            throw new InvalidOperationException("Stack is empty.");
        }
        return items[top--];
    }

    public T Peek()
    {
        if (top == -1)
        {
            throw new InvalidOperationException("Stack is empty.");
        }
        return items[top];
    }

    public bool IsEmpty()
    {
        return top == -1;
    }
}

然后，在使用时，你可以指定具体的类型参数，例如Stack<int>或Stack<string>：

Stack<int> stack1 = new Stack<int>(10);
stack1.Push(1);
stack1.Push(2);
stack1.Push(3);
Console.WriteLine(stack1.Pop()); // 3
Console.WriteLine(stack1.Peek()); // 2
Console.WriteLine(stack1.IsEmpty()); // False

Stack<string> stack2 = new Stack<string>(5);
stack2.Push("Hello");
stack2.Push("World");
Console.WriteLine(stack2.Pop()); // World
Console.WriteLine(stack2.Peek()); // Hello
Console.WriteLine(stack2.IsEmpty()); // False

这样，你就可以使用同一个Stack<T>类来存储不同类型的数据，而不需要为每种类型都定义一个单独的类。

什么是委托

委托是C#中一种特殊的类型，它表示一个方法的引用。你可以把委托看作是一个指向方法的变量，它可以存储一个或多个具有相同签名（参数类型和返回值类型）的方法。通过委托，你可以将方法作为参数传递给其他方法，或者将方法赋值给事件，实现回调和事件驱动编程。

委托的声明使用delegate关键字，同时要指定方法的签名。例如，你可以定义一个委托Del，表示一个没有参数和返回值的方法：

public delegate void Del();

然后，在使用时，你可以给委托赋值一个或多个符合签名的方法：

public static void Method1()
{
    Console.WriteLine("Method 1");
}

public static void Method2()
{
    Console.WriteLine("Method 2");
}

Del del = Method1; // 单播委托
del += Method2; // 多播委托

然后，你可以调用委托，执行它所包含的所有方法：

del(); // 输出 Method 1 和 Method 2

你也可以使用Invoke方法来调用委托：

del.Invoke(); // 输出 Method 1 和 Method 2

委托的一个常见用途是作为事件的处理器。事件是一种特殊的委托，它表示一个发生在对象上的动作或通知。你可以给事件添加一个或多个方法，当事件被触发时，这些方法就会被执行。例如，你可以定义一个Button类，它有一个Click事件，表示用户点击了按钮：

class Button
{
    public event Del Click; // 声明一个事件

    public void OnClick()
    {
        if (Click != null) // 判断事件是否为空
        {
            Click(); // 触发事件
        }
    }
}

然后，在使用时，你可以给Click事件添加方法，例如打印一些信息：

Button button = new Button();
button.Click += () => Console.WriteLine("You clicked the button."); // 使用Lambda表达式作为方法
button.OnClick(); // 输出 You clicked the button.

什么是泛型委托

泛型委托是一种特殊的委托，它可以接受泛型类型参数，从而适用于多种类型的方法。.NET框架为我们提供了三种常用的泛型委托：Func<T>、Action<T>和Predicate<T>。

• Func<T>代表一个有返回值的泛型委托，它有多个重载，最后一个类型参数表示返回值类型，其余的表示参数类型。例如，Func<int,int,int>表示一个接受两个整数参数并返回一个整数值的方法。
• Action<T>代表一个无返回值的泛型委托，它也有多个重载，类型参数表示参数类型。例如，Action<string>表示一个接受一个字符串参数并无返回值的方法。
• Predicate<T>代表一个返回布尔值的泛型委托，它只有一个类型参数，表示参数类型。例如，Predicate<int>表示一个接受一个整数参数并返回一个布尔值的方法。

使用泛型委托可以简化代码，避免为每种类型都定义单独的委托。例如，你可以使用Func<int,int,int>来替代上面定义的MyCalculator委托：

static int Calculate(int num1, int num2, Func<int, int, int> calDel)
{
    return calDel(num1,num2);
}

你也可以使用Lambda表达式来简化委托的赋值和调用：

int calNum = Calculate(1, 2, (x,y) => x + y); // 使用Lambda表达式作为方法
Console.WriteLine(calNum); // 3

总结

泛型和委托是C#中两个非常重要和强大的特性，它们可以让你编写更灵活和高效的代码。通过使用泛型，你可以编写一套适用于多种类型的代码，而不需要重复编写相同的逻辑。通过使用委托，你可以将方法作为参数传递给其他方法，或者将方法赋值给事件，实现回调和事件驱动编程。通过使用泛型委托，你可以简化代码，避免为每种类型都定义单独的委托。

希望这篇文章对你有所帮助。如果你对C#的泛型和委托有什么问题或建议，欢迎在评论区留言。如果你觉得这篇文章对你有用，也请给我一个赞或分享。谢谢你的阅读，祝你学习愉快！