c#自定义泛型类的实现

实现自定义泛型类的步骤如下：

1. 定义泛型类

定义一个泛型类，可以使用 class 关键字，紧随其后的是类名和泛型参数列表。然后在类中可以使用泛型参数，类似于普通的类型。例如：

public class MyGenericClass<T>
{
    private T data;

    public MyGenericClass(T data)
    {
        this.data = data;
    }

    public T GetData()
    {
        return data;
    }
}

在上面的示例中，定义了一个泛型类 MyGenericClass，它有一个泛型参数 T。MyGenericClass 类有一个私有属性 data，它是泛型类型 T。MyGenericClass 类的构造函数接受一个 T 类型的参数 data，并将其赋给 data 属性。MyGenericClass 类还有一个公共方法 GetData，它返回泛型类型 T 的 data 属性。

1. 实例化泛型类

使用泛型类时，需要指定泛型类型参数，这样才能创建泛型类的实例。例如：

MyGenericClass<int> intInstance = new MyGenericClass<int>(10);
int intValue = intInstance.GetData();

MyGenericClass<string> stringInstance = new MyGenericClass<string>("Hello World");
string stringValue = stringInstance.GetData();

在上面的示例中，分别创建了两个泛型类 MyGenericClass<int> 和 MyGenericClass<string> 的实例，分别传递了不同类型的参数。然后使用 GetData 方法获取存储的数据，并将其赋给类型对应的变量。

示例1：实现一个泛型类，存储一组数据，并且能够对这组数据进行排序

public class MyGenericSortedList<T> where T : IComparable<T>
{
    private List<T> dataList;

    public MyGenericSortedList()
    {
        dataList = new List<T>();
    }

    public void AddData(T data)
    {
        dataList.Add(data);
    }

    public List<T> GetSortedData()
    {
        dataList.Sort();
        return dataList;
    }
}

在上面的示例中，定义了一个泛型类 MyGenericSortedList，它有一个泛型参数 T，并且限定了泛型类型参数 T 必须实现 IComparable<T> 接口。MyGenericSortedList 类使用了一个 List<T> 类型的私有变量 dataList，它存储了泛型类型 T 数据。

MyGenericSortedList 类有一个公共构造函数，用于初始化 dataList 变量。

MyGenericSortedList 类还有一个公共方法 AddData，用于向 dataList 变量中添加数据。

MyGenericSortedList 类还有一个公共方法 GetSortedData，用于将 dataList 变量中的数据进行排序，并返回排序后的列表。

示例2：实现一个泛型类，存储所有的城市名称，并且能够返回其中以指定字母开头的城市列表

public class MyGenericCityList<T> where T : class
{
    private List<T> cityList;

    public MyGenericCityList()
    {
        cityList = new List<T>();
    }

    public void AddCity(T city)
    {
        cityList.Add(city);
    }

    public List<T> GetCitiesByLetter(char letter)
    {
        List<T> result = new List<T>();
        foreach (T city in cityList)
        {
            PropertyInfo[] props = city.GetType().GetProperties();
            foreach (PropertyInfo prop in props)
            {
                if (prop.PropertyType == typeof(string))
                {
                    string value = (string)prop.GetValue(city);
                    if (!string.IsNullOrEmpty(value) && char.ToLower(value[0]) == char.ToLower(letter))
                    {
                        result.Add(city);
                        break;
                    }
                }
            }
        }
        return result;
    }
}

在上面的示例中，定义了一个泛型类 MyGenericCityList，它有一个泛型参数 T，并且限定了泛型类型参数 T 必须是一个引用类型。

MyGenericCityList 类使用了一个 List<T> 类型的私有变量 cityList，它存储了城市数据。

MyGenericCityList 类有一个公共构造函数，用于初始化 cityList 变量。

MyGenericCityList 类还有一个公共方法 AddCity，用于向 cityList 变量中添加城市数据。

MyGenericCityList 类还有一个公共方法 GetCitiesByLetter，用于返回以指定字母开头的城市列表。这个方法使用了反射技术，遍历了城市数据的属性，找到了第一个字符串类型的属性，并判断属性值的第一个字符是否匹配指定字母。如果匹配，则将城市数据加入返回列表中。