C# 如何使用泛型类型

本文关键字：泛型类型 何使用 | 更新日期: 2023-09-27 18:33:26

>我有一个使用像这样的泛型的类型

public class Stack<T> {
    public void MyMethod() ...
}

在另一个类中，我想编写一个方法，该方法对任何 T 都采用此 Stack 类型：

public class MyClass  {
    public void MyMethod(Stack<T> stack) {
        stack.MyMethod();
    }
}

这可能吗？

C# 如何使用泛型类型

将类或方法设置为泛型MyClass。

泛型类：

public class MyClass<T>  {
    public void MyMethod(Stack<T> stack) {
        stack.MyMethod();
    }
}

通用方法：

public class MyClass  {
    public void MyMethod<T>(Stack<T> stack) {
        stack.MyMethod();
    }
}

哪个合适取决于您希望T变量的范围。 如果 MyClass 的单个实例应该能够使用几种不同类型的堆栈调用MyMethod，则该方法应该是泛型的。 如果 MyClass 的单个实例应要求对MyMethod的所有调用传递相同类型的堆栈，则整个类应该是泛型的。

要么：

public class MyClass 
{
  public void MyMethod<T>(Stack<T> stack) 
  {
     stack.MyMethod();
  }
}

或

public class MyClass<T>  
{
  public void MyMethod(Stack<T> stack) 
  {
     stack.MyMethod();
  }
}

是正确的。

有两种类型的泛型：

一 = 泛型方法

二 = 泛型类

例如：

using System;
class Test<T>
{
    T _value;
    public Test(T t)
    {
    // The field has the same type as the parameter.
        this._value = t;
    }
    public void Write()
    {
        Console.WriteLine(this._value);
    }
}
class Program
{
    static void Main()
    {
    // Use the generic type Test with an int type parameter.
    Test<int> test1 = new Test<int>(5);
    // Call the Write method.
    test1.Write();
    // Use the generic type Test with a string type parameter.
    Test<string> test2 = new Test<string>("cat");
    test2.Write();
    }
}

您可以在泛型类中设置constraints。

例如

using System;
using System.Data;
/// <summary>
/// Requires type parameter that implements interface IEnumerable.
/// </summary>
class Ruby<T> where T : IDisposable
{
}
/// <summary>
/// Requires type parameter that is a struct.
/// </summary>
class Python<T> where T : struct
{
}
/// <summary>
/// Requires type parameter that is a reference type with a constructor.
/// </summary>
class Perl<V> where V : class, new()
{
}
class Program
{
    static void Main()
    {
        // DataTable implements IDisposable so it can be used with Ruby.
        Ruby<DataTable> ruby = new Ruby<DataTable>();
    // Int is a struct (ValueType) so it can be used with Python.
    Python<int> python = new Python<int>();
    // Program is a class with a parameterless constructor (implicit)
    // ... so it can be used with Perl.
    Perl<Program> perl = new Perl<Program>();
    }
}

对于通用方法 

using System;
using System.Collections.Generic;
class Program
{
    static List<T> GetInitializedList<T>(T value, int count)
        {
        // This generic method returns a List with ten elements initialized.
        // ... It uses a type parameter.
        // ... It uses the "open type" T.
        List<T> list = new List<T>();
        for (int i = 0; i < count; i++)
        {
            list.Add(value);
        }
        return list;
        }
    static void Main()
        {
        // Use the generic method.
        // ... Specifying the type parameter is optional here.
        // ... Then print the results.
        List<bool> list1 = GetInitializedList(true, 5);
        List<string> list2 = GetInitializedList<string>("Perls", 3);
        foreach (bool value in list1)
        {
            Console.WriteLine(value);
        }
        foreach (string value in list2)
        {
            Console.WriteLine(value);
        }
        }
    }

资源 我的答案是这些链接。C# 泛型类泛型方法

是的，你可以，但你必须"通知"另一个类你正在使用哪种类型，如下所示：

public class StackType<t>
{
    public void Generate()
    {
    }
}
public class MyClass<T>
{
    public MyClass(StackType<T> stack)
    {
        stack.Generate();
    }
}
相关文章：