C中的泛型委托是什么|极客教程

C# 中的泛型委托是什么

在本文中，我们将介绍C#中的泛型委托。泛型委托是一种强大的功能，它可以让我们更灵活地定义委托类型并重用委托的代码。我们将讨论泛型委托的语法、用法和示例，以便更好地理解和应用它在C#中的作用。

阅读更多：C# 教程

什么是委托？

在介绍泛型委托之前，我们先来回顾一下委托的基本概念。委托是一种引用类型，它存储了对一个或多个方法的引用。通过委托，我们可以将方法作为参数传递给其他方法，从而实现方法的回调或事件的触发。委托可以看作是一个函数指针，它可以指向具有相同签名的方法。

在C#中，委托使用delegate关键字来声明和定义。下面是一个简单的示例，演示了如何声明和使用委托。

delegate void MyDelegate(string message);

class MyClass
{
    public void PrintMessage(string message)
    {
        Console.WriteLine("Message: " + message);
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyClass myObj = new MyClass();
        MyDelegate del = myObj.PrintMessage;

        del("Hello, World!");
    }
}

上面的代码中，我们定义了一个委托MyDelegate，它引用了一个方法PrintMessage。在Main方法中，我们创建了一个MyClass对象myObj，然后把myObj.PrintMessage赋值给了委托del。最后，我们通过委托del调用了PrintMessage方法，并传递了一个字符串参数。

为什么需要泛型委托？

在上面的示例中，我们定义了一个特定的委托MyDelegate，它只能引用一个特定签名的方法。如果我们需要引用其他签名的方法，就需要定义新的委托类型。这样就导致了很多重复的代码。

泛型委托的出现解决了这个问题。它允许我们在声明委托时使用泛型类型参数，从而实现对不同签名的方法的引用。这样，我们可以定义一个通用的委托类型，然后在需要的地方根据具体的方法签名来实例化委托。

泛型委托的语法和用法

在C#中，泛型委托的语法是在委托名称后面添加尖括号，然后在尖括号中指定泛型类型参数。下面是一个示例，演示了如何声明一个泛型委托Action<T>。

delegate void Action<T>(T obj);

class MyClass
{
    public void PrintMessage(string message)
    {
        Console.WriteLine("Message: " + message);
    }

    public void PrintNumber(int number)
    {
        Console.WriteLine("Number: " + number);
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyClass myObj = new MyClass();
        Action<string> del1 = myObj.PrintMessage;
        Action<int> del2 = myObj.PrintNumber;

        del1("Hello, World!");
        del2(123);
    }
}

上面的代码中，我们定义了一个泛型委托Action<T>，它接受一个类型为T的参数并返回void。在Main方法中，我们通过myObj.PrintMessage和myObj.PrintNumber实例化了两个泛型委托del1和del2。然后，我们分别通过这两个委托调用了PrintMessage和PrintNumber方法。

除了Action<T>之外，C#中还预定义了许多常用的泛型委托类型，如Func<T>、Predicate<T>等。它们都是根据特定的使用场景和返回值类型进行了定义。

泛型委托的示例

下面我们通过一个示例来进一步理解和应用泛型委托。假设我们有一个字符串列表，我们希望对其中的每个字符串进行处理，并返回处理之后的结果。我们可以使用泛型委托来实现这个需求。

delegate T Process<T>(T item);

class MyList<T>
{
    private List<T> data = new List<T>();

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

    public List<T> ProcessList(Process<T> process)
    {
        List<T> result = new List<T>();

        foreach (T item in data)
        {
            result.Add(process(item));
        }

        return result;
    }
}

class Program
{
    static string ToUpper(string str)
    {
        return str.ToUpper();
    }

    static int Length(string str)
    {
        return str.Length;
    }

    static void Main(string[] args)
    {
        MyList<string> myList = new MyList<string>();
        myList.Add("hello");
        myList.Add("world");

        List<string> upperList = myList.ProcessList<string>(ToUpper);
        List<int> lengthList = myList.ProcessList<int>(Length);

        foreach (string str in upperList)
        {
            Console.WriteLine(str);
        }

        foreach (int length in lengthList)
        {
            Console.WriteLine(length);
        }
    }
}

上面的代码中，我们定义了一个泛型委托Process<T>，它接受一个类型为T的参数并返回类型为T的结果。然后，我们创建了一个泛型类MyList<T>，它封装了一个列表并提供了一个ProcessList方法，用于对列表中的每个元素进行处理。在Main方法中，我们创建了一个MyList<string>对象myList，并向其中添加了两个字符串。然后，我们通过myList.ProcessList<string>(ToUpper)和myList.ProcessList<int>(Length)分别对字符串列表进行了大小写转换和获取长度的操作，并将结果分别存储在upperList和lengthList中。