深入解析C#中的泛型类与泛型接口

泛型类

泛型类封装不是特定于具体数据类型的操作。泛型类最常用于集合,如链接列表、哈希表、堆栈、队列、树等。像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关。
对于大多数需要集合类的方案,推荐的方法是使用 .NET Framework 类库中所提供的类。

  • 一般情况下,创建泛型类的过程为:从一个现有的具体类开始,逐一将每个类型更改为类型参数,直至达到通用化和可用性的最佳平衡。创建您自己的泛型类时,需要特别注意以下事项:
  • 将哪些类型通用化为类型参数。
  • 通常,能够参数化的类型越多,代码就会变得越灵活,重用性就越好。但是,太多的通用化会使其他开发人员难以阅读或理解代码。
  • 如果存在约束,应对类型参数应用什么约束。
  • 一条有用的规则是,应用尽可能最多的约束,但仍使您能够处理必须处理的类型。例如,如果您知道您的泛型类仅用于引用类型,则应用类约束。这可以防止您的类被意外地用于值类型,并允许您对 T 使用 as 运算符以及检查空值。
  • 是否将泛型行为分解为基类和子类。
  • 由于泛型类可以作为基类使用,此处适用的设计注意事项与非泛型类相同。请参见本主题后面有关从泛型基类继承的规则。
  • 是否实现一个或多个泛型接口。

例如,如果您设计一个类,该类将用于创建基于泛型的集合中的项,则可能必须实现一个接口,如 IComparable<T>,其中 T 是您的类的类型。

类型参数和约束的规则对于泛型类行为有几方面的含义,特别是关于继承和成员可访问性。您应当先理解一些术语,然后再继续进行。对于泛型类 Node<T>,客户端代码可通过指定类型参数来引用该类,以便创建封闭式构造类型 (Node<int>)。或者可以让类型参数处于未指定状态(例如在指定泛型基类时)以创建开放式构造类型 (Node<T>)。泛型类可以从具体的、封闭式构造或开放式构造基类继承:

class BaseNode { }
class BaseNodeGeneric<T> { }

// concrete type
class NodeConcrete<T> : BaseNode { }

//closed constructed type
class NodeClosed<T> : BaseNodeGeneric<int> { }

//open constructed type
class NodeOpen<T> : BaseNodeGeneric<T> { }

非泛型类(换句话说,即具体类)可以从封闭式构造基类继承,但无法从开放式构造类或类型参数继承,因为在运行时客户端代码无法提供实例化基类所需的类型参数。

//No error
class Node1 : BaseNodeGeneric<int> { }

//Generates an error
//class Node2 : BaseNodeGeneric<T> {}

//Generates an error
//class Node3 : T {}

从开放式构造类型继承的泛型类必须为任何未被继承类共享的基类类型参数提供类型变量,如以下代码所示:

class BaseNodeMultiple<T, U> { }

//No error
class Node4<T> : BaseNodeMultiple<T, int> { }

//No error
class Node5<T, U> : BaseNodeMultiple<T, U> { }

//Generates an error
//class Node6<T> : BaseNodeMultiple<T, U> {}

从开放式构造类型继承的泛型类必须指定约束,这些约束是基类型约束的超集或暗示基类型约束:

class NodeItem<T> where T : System.IComparable<T>, new() { }
class SpecialNodeItem<T> : NodeItem<T> where T : System.IComparable<T>, new() { }

泛型类型可以使用多个类型参数和约束,如下所示:

class SuperKeyType<K, V, U>
  where U : System.IComparable<U>
  where V : new()
{ }

开放式构造类型和封闭式构造类型可以用作方法参数:

void Swap<T>(List<T> list1, List<T> list2)
{
  //code to swap items
}

void Swap(List<int> list1, List<int> list2)
{
  //code to swap items
}

如果某个泛型类实现了接口,则可以将该类的所有实例强制转换为该接口。
泛型类是不变的。也就是说,如果输入参数指定 List<BaseClass>,则当您尝试提供 List<DerivedClass> 时,将会发生编译时错误。

泛型接口
为泛型集合类或表示集合中项的泛型类定义接口通常很有用。对于泛型类,使用泛型接口十分可取,例如使用 IComparable<T> 而不使用 IComparable,这样可以避免值类型的装箱和取消装箱操作。.NET Framework 类库定义了若干泛型接口,以用于 System.Collections.Generic 命名空间中的集合类。
将接口指定为类型参数的约束时,只能使用实现此接口的类型。下面的代码示例显示从 SortedList<T> 类派生的 GenericList<T> 类。
 SortedList<T> 添加约束 where T : IComparable<T>。这将使 SortedList<T> 中的 BubbleSort 方法能够对列表元素使用泛型 CompareTo 方法。在此示例中,列表元素为简单类,即实现 Person 的 IComparable<Person>。

//Type parameter T in angle brackets.
public class GenericList<T> : System.Collections.Generic.IEnumerable<T>
{
  protected Node head;
  protected Node current = null;

  // Nested class is also generic on T
  protected class Node
  {
    public Node next;
    private T data; //T as private member datatype

    public Node(T t) //T used in non-generic constructor
    {
      next = null;
      data = t;
    }

    public Node Next
    {
      get { return next; }
      set { next = value; }
    }

    public T Data //T as return type of property
    {
      get { return data; }
      set { data = value; }
    }
  }

  public GenericList() //constructor
  {
    head = null;
  }

  public void AddHead(T t) //T as method parameter type
  {
    Node n = new Node(t);
    n.Next = head;
    head = n;
  }

  // Implementation of the iterator
  public System.Collections.Generic.IEnumerator<T> GetEnumerator()
  {
    Node current = head;
    while (current != null)
    {
      yield return current.Data;
      current = current.Next;
    }
  }

  // IEnumerable<T> inherits from IEnumerable, therefore this class
  // must implement both the generic and non-generic versions of
  // GetEnumerator. In most cases, the non-generic method can
  // simply call the generic method.
  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  {
    return GetEnumerator();
  }
}

public class SortedList<T> : GenericList<T> where T : System.IComparable<T>
{
  // A simple, unoptimized sort algorithm that
  // orders list elements from lowest to highest:

  public void BubbleSort()
  {
    if (null == head || null == head.Next)
    {
      return;
    }
    bool swapped;

    do
    {
      Node previous = null;
      Node current = head;
      swapped = false;

      while (current.next != null)
      {
        // Because we need to call this method, the SortedList
        // class is constrained on IEnumerable<T>
        if (current.Data.CompareTo(current.next.Data) > 0)
        {
          Node tmp = current.next;
          current.next = current.next.next;
          tmp.next = current;

          if (previous == null)
          {
            head = tmp;
          }
          else
          {
            previous.next = tmp;
          }
          previous = tmp;
          swapped = true;
        }
        else
        {
          previous = current;
          current = current.next;
        }
      }
    } while (swapped);
  }
}

// A simple class that implements IComparable<T> using itself as the
// type argument. This is a common design pattern in objects that
// are stored in generic lists.
public class Person : System.IComparable<Person>
{
  string name;
  int age;

  public Person(string s, int i)
  {
    name = s;
    age = i;
  }

  // This will cause list elements to be sorted on age values.
  public int CompareTo(Person p)
  {
    return age - p.age;
  }

  public override string ToString()
  {
    return name + ":" + age;
  }

  // Must implement Equals.
  public bool Equals(Person p)
  {
    return (this.age == p.age);
  }
}

class Program
{
  static void Main()
  {
    //Declare and instantiate a new generic SortedList class.
    //Person is the type argument.
    SortedList<Person> list = new SortedList<Person>();

    //Create name and age values to initialize Person objects.
    string[] names = new string[]
    {
      "Franscoise",
      "Bill",
      "Li",
      "Sandra",
      "Gunnar",
      "Alok",
      "Hiroyuki",
      "Maria",
      "Alessandro",
      "Raul"
    };

    int[] ages = new int[] { 45, 19, 28, 23, 18, 9, 108, 72, 30, 35 };

    //Populate the list.
    for (int x = 0; x < 10; x++)
    {
      list.AddHead(new Person(names[x], ages[x]));
    }

    //Print out unsorted list.
    foreach (Person p in list)
    {
      System.Console.WriteLine(p.ToString());
    }
    System.Console.WriteLine("Done with unsorted list");

    //Sort the list.
    list.BubbleSort();

    //Print out sorted list.
    foreach (Person p in list)
    {
      System.Console.WriteLine(p.ToString());
    }
    System.Console.WriteLine("Done with sorted list");
  }
}

可将多重接口指定为单个类型上的约束,如下所示:

class Stack<T> where T : System.IComparable<T>, IEnumerable<T>
{
}

一个接口可定义多个类型参数,如下所示:

interface IDictionary<K, V>
{
}

适用于类的继承规则同样适用于接口:

interface IMonth<T> { }

interface IJanuary   : IMonth<int> { } //No error
interface IFebruary<T> : IMonth<int> { } //No error
interface IMarch<T>  : IMonth<T> { }  //No error
//interface IApril<T> : IMonth<T, U> {} //Error

如果泛型接口为逆变的,即仅使用其类型参数作为返回值,则此泛型接口可以从非泛型接口继承。在 .NET Framework 类库中,IEnumerable<T> 从 IEnumerable 继承,因为 IEnumerable<T> 只在 GetEnumerator 的返回值和 Current 属性 getter 中使用 T。
具体类可以实现已关闭的构造接口,如下所示:

interface IBaseInterface<T> { }

class SampleClass : IBaseInterface<string> { }

只要类参数列表提供了接口必需的所有参数,泛型类便可以实现泛型接口或已关闭的构造接口,如下所示:

interface IBaseInterface1<T> { }
interface IBaseInterface2<T, U> { }

class SampleClass1<T> : IBaseInterface1<T> { }     //No error
class SampleClass2<T> : IBaseInterface2<T, string> { } //No error
(0)

相关推荐

  • 深入浅析C#泛型类型

    上篇文章给大家介绍了浅析C# 中的类型系统(值类型和引用类型),接下来通过本文给大家介绍下c# 泛型类型, 说下C#中的泛型,熟练地使用泛型能提高代码的重用性,使用我们代码瞬间就高大上了,当然只有一点点,真的只有一点点,因为后面要学习和掌握的知识还有很多.先来看下一个使用Dictionary<TKey,TValue>的例子. static void Main(string[] args) { Dictionary<int, string> result = GetAll(); }

  • C# 泛型类(函数)的实例化小例子

    泛型可以用于类,也可以用于函数.如 泛型类: 复制代码 代码如下: public class MyClass<T> {     public T MyElement { get; set; } } 泛型函数: 复制代码 代码如下: public T ReturnElement<T>() {     throw new NotImplementedException(); } 但是当需要对MyElement进行实例化的时候,却不能使用new(),只要添加如下代码即可进行实例化了: 泛

  • c#自定义泛型类的实现

    闲来无事,自己研究了泛型类的简单的使用,where表示泛型约束,表示泛型类型中的参数只能是car类型,IEnumerable是一个接口,一个集合要支持FOREAch遍历,必须实现IEnumerable接口 复制代码 代码如下: public class Car    {        public string PetName;        public int Speed;        public Car(string name, int currentSpeed)        {  

  • c# 泛型类型参数与约束的深入分析

    泛型类型参数简介在定义泛型类型和泛型方法时,常用到泛型类型参数,泛型类型参数是在实例化泛型时指定类型的占位符.泛型类型参数放在"<>"内.泛型类型参数命名建议:(1)当泛型类型参数为单个字母时,建议用T表示.(2)当泛型类型参数用单词定义时,建议在单词前加T. 复制代码 代码如下: private void PromptName<T>(T t) {}private void PromptName<Tuser>(Tuser user){} 泛型类型参数

  • 自定义的Troop<T>泛型类( c++, java和c#)的实现代码

    Troop<T>是一个泛型列表操作类,适用于非高性能和非大数据量的要求.包括了:取值get,赋值set,追加append,插入insert,清除remove,进队enqueue,出队dequeue,交换swap,滚动roll,进栈push,出栈pop等日常操作. //for more information, please access http://www.one-lab.net using System; using System.Collections.Generic; using Sy

  • 介绍C# 泛型类在使用中约束

    首先看一下泛型的基本语法 访问修饰符 返回类型 泛型方法名 <T>(T 参数) 1):无法在泛型方法内部给任何 T 类型创建实例的对象,因为在泛型方法内部不知道传进来的对象有哪些构造函数2):约束是对内部的!(对于泛型方法)约束也是会被继承的! 3):给泛型类 加类型(引用类型,值类型)的约束:where T:class,new ( ) 遇到的问题:在写MongodbHelper类的时候,为了能处理多种类别,所以如下定义了该类: 复制代码 代码如下: public class MongodbH

  • 浅谈c# 泛型类的应用

    泛型类泛型类封装不是特定于具体数据类型的操作. 泛型类最常用于集合,如链接列表.哈希表.堆栈.队列.树等. 像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关.对大多集合类的操作,推荐使用 .NET Framework 类库中所提供的类.(1)泛型类可以继承具体类.封闭式构造.开放式构造基类. 复制代码 代码如下: class BaseNode { }class BaseNodeGeneric<T> { }// 继承具体类class NodeConcrete<

  • Java泛型类型通配符和C#对比分析

    c#的泛型没有类型通配符,原因是.net的泛型是CLR支持的泛型,而Java的JVM并不支持泛型,只是语法糖,在编译器编译的时候都转换成object类型 类型通配符在java中表示的是泛型类型的父类 public void test(List<Object> c) { for(int i = 0;i < c.size();i++) { System.out.println(c.get(i)); } } //创建一个List<String>对象 List<String&g

  • C#泛型类创建与使用的方法

    本文实例为大家分享了C#泛型类创建与使用的具体代码,供大家参考,具体内容如下 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication13 { class Program { static void Main(string[] args) { Test<string,int> t = new Test<string,i

  • 深入解析C#中的泛型类与泛型接口

    泛型类 泛型类封装不是特定于具体数据类型的操作.泛型类最常用于集合,如链接列表.哈希表.堆栈.队列.树等.像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关. 对于大多数需要集合类的方案,推荐的方法是使用 .NET Framework 类库中所提供的类. 一般情况下,创建泛型类的过程为:从一个现有的具体类开始,逐一将每个类型更改为类型参数,直至达到通用化和可用性的最佳平衡.创建您自己的泛型类时,需要特别注意以下事项: 将哪些类型通用化为类型参数. 通常,能够参数化的

  • 一篇文章带你了解java泛型--泛型类,泛型方法,泛型接口

    目录 Java 泛型 Java 泛型是什么 泛型类 泛型类的格式 泛型类举例 泛型方法 泛型方法的格式 泛型方法举例 泛型接口 泛型接口的格式 泛型接口举例 泛型接口实现类: 测试接口类: 打印结果: 总结 Java 泛型 Java 泛型是什么 官方定义: 泛型是Java SE 1.5的新特性,泛型的本质就是参数化类型,也就是说所操作的数据类型被指定为一个参数 这种参数类型可以用在类.接口和方法的创建中,分别成为泛型类.泛型接口.泛型方法 优缺点: ​ 优点:可以不用再类型转换了 ​ 缺点:降低

  • 解析iOS10中的极光推送消息的适配

    iOS10发布后,发现项目中的极光推送接收消息异常了. 查了相关资料后才发现,iOS10中对于通知做了不少改变.同时也发现极光也很快更新了对应的SDK. 现在就把适配修改的做法分享一下,希望对有需要的童鞋有所帮助. 具体做法如下: 注意:必须先安装Xcode8.0版本. 一.添加相关的SKD,或framework文件 1.添加UserNotification.framework 2.更新jpush的SDK(最新版本:jpush-ios-2.1.9.a)https://www.jiguang.cn

  • Python解析xml中dom元素的方法

    本文实例讲述了Python解析xml中dom元素的方法.分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: from xml.dom import minidom try:     xmlfile = open("path.xml", "a+")     #xmldoc = minidom.parse( sys.argv[1])     xmldoc = minidom.parse(xmlfile) except :     #updatelogger.

  • 解析MySQL中存储时间日期类型的选择问题

    一般应用中,我们用timestamp,datetime,int类型来存储时间格式: int(对应javaBean中的Integer或int) 1. 占用4个字节 2. 建立索引之后,查询速度快 3. 条件范围搜索可以使用使用between 4. 不能使用mysql提供的时间函数 结论:适合需要进行大量时间范围查询的数据表 datetime(javaBean中用Date类型) 1. 占用8个字节 2. 允许为空值,可以自定义值,系统不会自动修改其值. 3. 实际格式储存(Just stores w

  • 实例解析Java中的构造器初始化

    1.初始化顺序 当Java创建一个对象时,系统先为该对象的所有实例属性分配内存(前提是该类已经被加载过了),接着程序开始对这些实例属性执行初始化,其初始化顺序是:先执行初始化块或声明属性时制定的初始值,再执行构造器里制定的初始值. 在类的内部,变量定义的先后顺序决定了初始化的顺序,即时变量散布于方法定义之间,它们仍就会在任何方法(包括构造器)被调用之前得到初始化. class Window { Window(int maker) { System.out.println("Window(&quo

  • 全面解析JavaScript中“&&”和“||”操作符(总结篇)

    1.||(逻辑或), 从字面上来说,只有前后都是false的时候才返回false,否则返回true. alert(true||false); // true alert(false||true); // true alert(true||true); // true alert(false||false); // false 这个傻子都知道~~ 但是,从深层意义上来说的话,却有另一番天地,试下面代码 alert(0||1);//1 显然,我们知道,前面0意味着false,而后面1意味着true,

  • 浅谈java中定义泛型类和定义泛型方法的写法

    1.方法中的泛型 public static <T> T backSerializable(Class<T> clazz , String path ,String fileName){ FileInputStream fis = null; ObjectInputStream ois = null; Object obj = null; try { fis = new FileInputStream(path + fileName); ois = new ObjectInputS

  • 通过实例解析java8中的parallelStream

    这篇文章主要介绍了通过实例解析java8中的parallelStream,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 about Stream 什么是流? Stream是java8中新增加的一个特性,被java猿统称为流. Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的,它更像一个高级版本的 Iterator.原始版本的 Iterator,用户只能显式地一个一个遍历元素并对其执行某些操作:高级版本的 Stream

  • 解析正则表达式中的.*,.*?,.+?的含义

    1. .* . 表示匹配除换行符 \n 之外的任何单字符,*表示零次或多次.所以.*在一起就表示任意字符出现零次或多次.没有?表示贪婪模式.比如a.*b,它将会匹配最长的以a开始,以b结束的字符串.如果用它来搜索aabab的话,它会匹配整个字符串aabab.这被称为贪婪匹配. 又比如模式src=`.*`, 它将会匹配最长的以 src=` 开始,以`结束的最长的字符串.用它来搜索 <img src=``test.jpg` width=`60px` height=`80px`/> 时,将会返回 s

随机推荐