专栏首页技术博客C# 泛型的简单理解(安全、集合、方法、约束、继承)

C# 泛型的简单理解(安全、集合、方法、约束、继承)

前言

泛型允许你在编译时实现类型安全。它们允许你创建一个数据结构而不限于一特定的数据类型。然而,当使用该数据结构时,编译器保证它使用的类型与类型安全是相一致的。泛型提供了类型安全,但是没有造成任何性能损失和代码臃肿。在这方面,它们很类似于C++中的模板,不过它们在实现上是很不同的。

使用泛型集合

.NET 2.0的System.Collections.Generics 命名空间包含了泛型集合定义。各种不同的集合/容器类都被"参数化"了。为使用它们,只需简单地指定参数化的类型即可。

            ArrayList array = new ArrayList();
            array.Add(3);
            array.Add(4);
            array.Add(5.0);
            int total = 0;
            foreach (int val in array)
            {
                total = total + val;
            }
            Console.WriteLine("Total is {0}", total);

这段代码编译肯定没问题的,不过在运行的时候就会报错。因为在foreach哪里定义的都是int,而在添加的是5.0很明显是个double类型的。

            List<int> aList = new List<int>();
            aList.Add(3);
            aList.Add(4);
            //aList.Add(5.0);
            int totalList = 0;
            foreach(int val in aList)
            {
                totalList = totalList + val;
            }
            Console.WriteLine("Total is {0}", totalList);

这段代码其实也没什么问题,如果把注释的哪一行的注释去掉,那么在编译的时候就直接报错了,因为编译器指出它不能发送值5.0到方法Add(),因为该方法仅接受int型。

不同于ArrayList,这里的代码实现了类型安全。

CLR对于泛型的支持

泛型不仅是一个语言级上的特征。.NET CLR能识别出泛型。在这种意义上说,泛型的使用是.NET中最为优秀的特征之一。对每个用于泛型化的类型的参数,类也同样没有脱离开微软中间语言(MSIL)。换句话说,你的配件集仅包含你的参数化的数据结构或类的一个定义,而不管使用多少种不同的类型来表达该参数化的类型。例如,如果你定义一个泛型类型MyList<T>,仅仅该类型的一个定义出现在MSIL中。当程序执行时,不同的类被动态地创建,每个类对应该参数化类型的一种类型。如果你使用MyList<int>和MyList<double>,有两种类即被创建。

接下来创建一个简单的泛型类

    public class MyList<T>
    {
        private static int objCount = 0;
        public  MyList()
        {
            objCount++;
        }

        public int Count
        {
            get { return objCount; }
        }
    }

该例中,我创建了一个称为MyList泛型类。为把它参数化,我简单地插入了一个尖括号。在<>内的T代表了实际的当使用该类时要指定的类型。在MyList类中,定义了一个静态字段objCount。我在构造器中增加它的值。因此我能发现使用我的类的用户共创建了多少个那种类型的对象。属性Count返回与被调用的实例同类型的实例的数目。

    public class SampleClass
    {

    }

    class Program
    {
        static void Main(string[] args)
        {
            MyList<int> myIntList=new MyList<int>();
            MyList<int> myIntList2=new MyList<int>();
            MyList<double> myDoubleList=new MyList<double>();
            MyList<SampleClass> mySampleList=new MyList<SampleClass>();

            Console.WriteLine(myIntList.Count);
            Console.WriteLine(myIntList2.Count);
            Console.WriteLine(myDoubleList.Count);
            Console.WriteLine(mySampleList.Count);
            Console.WriteLine(new MyList<SampleClass>().Count);
            Console.ReadLine();
        }
    }

在Main()方法,我创建了MyList<int>的两个实例,一个MyList<double>的实例,还有两个MyList<SampleClass>的实例--其中SampleClass是我已定义了的类。问题是:Count(上面的程序的输出)的值该是多少?在你继阅读之前,试一试回答这个问题。

前面两个2对应MyList<int>,第一个1对应MyList<double>,第二个1对应MyList<SampleClass>--在此,仅创建一个这种类型的实例。最后一个2对应MyList<SampleClass>,因为代码中又创建了这种类型的另外一个实例。上面的例子说明MyList<int>是一个与MyList<double>不同的类,而MyList<double>又是一个与MyList<SampleClass>不同的类。因此,在这个例中,我们有四个类:MyList: MyList<T>,MyList<int>,MyList<double>和MyList<X>。注意,虽然有4个MyList类,但仅有一个被存储在MSIL。怎么能证明这一点?请看下图显示出的使用工具ildasm.exe生成的MSIL代码。

泛型方法

除了有泛型类,你也可以有泛型方法。泛型方法可以是任何类的一部分。

        public static void Copy<T>(List<T> source, List<T> destination)
        {
            foreach (T obj in source)
            {
                destination.Add(obj);
            }
        }
        static void Main(string[] args)
        {
            List<int> lst1 = new List<int>();
            lst1.Add(2);
            lst1.Add(4);
            List<int> lst2 = new List<int>();
            Copy(lst1, lst2);
            Console.WriteLine(lst2.Count);
            Console.ReadLine();
        }

Copy()方法就是一个泛型方法,它与参数化的类型T一起工作。当在Main()中激活Copy()时,编译器根据提供给Copy()方法的参数确定出要使用的具体类型。

约束机制及其优点

一个泛型类允许你写自己的类而不必拘泥于任何类型,但允许你的类的使用者以后可以指定要使用的具体类型。通过对可能会用于参数化的类型的类型施加约束,这给你的编程带来很大的灵活性--你可以控制建立你自己的类。让我们分析一个例子:

        public static T Max<T>(T op1, T op2) 
        {
            if (op1.CompareTo(op2) < 0)
                 return op1;
            return op2;
        }

编译代码将会有一个错误。

假定我需要这种类型以支持CompareTo()方法的实现。我能够通过加以约束--为参数化类型指定的类型必须要实现IComparable接口--来指定这一点。

        public static T Max<T>(T op1, T op2)where T:IComparable
        {
            if (op1.CompareTo(op2) < 0)
                 return op1;
            return op2;
        }

好了,我指定的约束是,用于参数化类型的类型必须继承自(实现)Icomparable。现在可以编译成功,并且调用了。

下面的约束是可以使用的:   where T : struct 类型必须是一种值类型(struct)   where T : class 类型必须是一种引用类型(class)   where T : new() 类型必须有一个无参数的构造器   where T : class_name 类型可以是class_name或者是它的一个子类   where T : interface_name 类型必须实现指定的接口   你可以指定约束的组合,就象: where T : IComparable, new()。这就是说,用于参数化类型的类型必须实现Icomparable接口并且必须有一个无参构造器。

继承与泛型

一个使用参数化类型的泛型类,象MyClass1<T>,称作开放结构的泛型。一个不使用参数化类型的泛型类,象MyClass1<int>,称作封闭结构的泛型。

 你可以从一个封闭结构的泛型进行派生;也就是说,你可以从另外一个称为MyClass1的类派生一个称为MyClass2的类,就象:

public class MyClass2<T> : MyClass1<int>

你也可以从一个开放结构的泛型进行派生,如果类型被参数化的话,如:

public class MyClass2<T> : MyClass2<T>

是有效的,但是

public class MyClass2<T> : MyClass2<Y>

是无效的,这里Y是一个被参数化的类型。非泛型类可以从一个封闭结构的泛型类进行派生,但是不能从一个开放结构的泛型类派生。

public class MyClass : MyClass1<int>

是有效的, 但是

public class MyClass : MyClass1<T>

是无效的。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 编写高质量代码改善C#程序的157个建议[优先考虑泛型、避免在泛型中声明静态成员、为泛型参数设定约束]

      泛型并不是C#语言一开始就带有的特性,而是在FCL2.0之后实现的新功能。基于泛型,我们得以将类型参数化,以便更大范围地进行代码复用。同时,它减少了泛型类及...

    aehyok
  • 编写高质量代码改善C#程序的157个建议[4-9]

      本文首先亦同步到http://www.cnblogs.com/aehyok/p/3624579.html。本文主要来学习记录一下内容:

    aehyok
  • C#函数方法集

    1、DateTime 数字型 System.DateTime currentTime=new System.DateTime();

    aehyok
  • 编写高质量代码改善C#程序的157个建议[优先考虑泛型、避免在泛型中声明静态成员、为泛型参数设定约束]

      泛型并不是C#语言一开始就带有的特性,而是在FCL2.0之后实现的新功能。基于泛型,我们得以将类型参数化,以便更大范围地进行代码复用。同时,它减少了泛型类及...

    aehyok
  • HaspMap的原理

    前几天有想法弄懂HashMap的实现的原理,我自己也YY了一个想法去实现一个简单的Map, 代码如下:

    付威
  • kibana-1:使用timeline构建时间序列图

    最常用的需求是根据时间轴画出日志中不同的日志级别(level)的曲线图。ELK体系下的kibana可以很方便的解决这类问题。

    千里行走
  • 《项目架构那点儿事》——工具类,你喜欢你就拿去

    【前言】众所周知,各式各样的Util类为我们提供了便利,也同时减少了我们对底层硬编码的时间,包括对字符串的操作,文件操作,反射的操作,泛型的操作,以及熟知 的分...

    I Tech You_我教你
  • 关于 “栈” 的那点破事

    用生活中最实际的例子来说,类似于砌砖,加入我们要砌一堵墙,我们肯定是从下往上砌,先拿的砖头就砌在最下边,后拿的砖头就砌到最上边。但是如果监工觉得这堵墙不合适,我...

    村雨遥
  • C语言基础知识总结

    1°memcpy函数(头文件<cstring) 数组不能直接复制,可利用memcpy函数

    风骨散人Chiam
  • java_方法的定义、调用、重载

    方法:就是将一个功能抽取出来,把代码单独定义在一个大括号内,形成一个单独的功能。 当我们需要这个功能的时候,就可以去调用。这样即实现了代码的复用性,也解决了代...

    咕咕星

扫码关注云+社区

领取腾讯云代金券