即日起在codingBlog上分享您的技术经验即可获得积分,积分可兑换现金哦。

.NET编程30分钟泛型学习

微信 DotNet 15℃ 0评论

(点击上方蓝字,可快速关注我们)


来源:liulun

cnblogs.com/liulun/archive/2013/05/02/3033599.html


一、泛型入门

我们先来看一个最为常见的泛型类型List的定义(真正的定义比这个要复杂的多,我这里删掉了很多东西)

[Serializable]

public class List : IList, ICollection, IEnumerable

{

    public T this[int index] { get; set; }

    public void Add(T item);

    public void Clear();

    public bool Contains(T item);

    public int IndexOf(T item);

    public bool Remove(T item);

    public void Sort();

    public T[] ToArray();

}

List后面紧跟着一个表示它操作的是一个未指定的数据类型(T代表着一个未指定的数据类型)

可以把T看作一个变量名,T代表着一个类型,在List的源代码中任何地方都能使用T,T被用作方法的参数和返回值,Add方法接收T类型的参数,ToArray方法返回一个T类型的数组

注意:

泛型参数应该以T开头,要么就叫T,要么就叫TKey、TValue之类的;

这跟接口要以I开头是一样的,这是约定。

下面来看一段使用泛型类型的代码

var a = new List();

a.Add(1);

a.Add(2);

//这是错误的,因为你已经指定了泛型类型为int,就不能在这个容器中放入其他的值

//这是编译器错误,更提升了排错效率,如果是运行期错误,不知道要多么烦人

a.Add(“3”);

var item = a[2];

请注意上面代码里的注释

二、泛型的作用(1)

作为程序员,写代码时刻不忘代码重用。代码重用可以分成很多类,其中算法重用就是非常重要的一类

假设你要为一组整型数据写一个排序算法,又要为一组浮点型数据写一个排序算法,如果没有泛型类型,你会怎么做呢?

你可能想到了方法的重载,写两个同名方法,一个方法接收整型数组,另一个方法接收浮点型的数组

但有了泛型,你就完全不必这么做,只要设计一个方法就够用了,你甚至可以用这个方法为一组字符串数据排序

三、泛型的作用(2)

假设你是一个方法的设计者,这个方法需要有一个输入参数,但你并能确定这个输入参数的类型,那么你会怎么做呢?

有一部分人可能会马上反驳:“不可能有这种时候!”,那么我会跟你说,编程是一门经验型的工作,你的经验还不够,还没有碰到过类似的地方。

另一部分人可能考虑把这个参数的类型设置成Object的,这确实是一种可行的方案,但会造成下面两个问题

如果我给这个方法传递整形的数据(值类型的数据都一样),就会产生额外的装箱、拆箱操作,造成性能损耗

如果你这个方法里的处理逻辑不适用于字符串的参数,而使用者又传了一个字符串进来,编译器是不会报错的,只有在运行期才会报错,(如果质管部门没有测出这个运行期BUG,那么不知道要造成多大的损失呢),这就是我们常说的:类型不安全

四、泛型的示例

像List和Dictionary之类的泛型类型我们经常用到

下面我介绍几个不常用到的泛型类型

ObservableCollection

当这个集合发生改变后会有相应的事件得到通知,请看如下代码:

static void Main(string[] args)

{

    var a = new ObservableCollection();

    a.CollectionChanged += a_CollectionChanged;

}

static void a_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)

{

    //可以通过Action来判断是什么操作触发了事件

    //e.Action == NotifyCollectionChangedAction.Add

    //可以根据以下两个属性来得到更改前和更改后的内容

    //e.NewItems;

    //e.OldItems;

}

使用这个集合需要引用如下两个名称空间

using System.Collections.ObjectModel;

using System.Collections.Specialized;

 

BlockingCollection是线程安全的集合,来看看下面这段代码

var bcollec = new BlockingCollection(2);

//试图添加1-50

Task.Run(() =>

{

    //并行循环

    Parallel.For(1, 51, i =>

    {

        bcollec.Add(i);

        Console.WriteLine(“加入:” + i);

    });

});

Thread.Sleep(1000);

Console.WriteLine(“调用一次Take”);

bcollec.Take();

//等待无限长时间

Thread.Sleep(Timeout.Infinite);

输出结果为:

加入:1

加入:37

调用一次Take

加入:13

BlockingCollection还可以设置CompleteAdding和IsCompleted属性来拒绝加入新元素,.NET类库还提供了很多的泛型类型,在这里就不一一例举了

五、泛型的继承

在.net中一切都继承自Object,泛型也不例外,泛型类型可以继承自其他类型,来看一下如下代码

public class MyType

{

    public virtual string getOneStr()

    {

        return “base object Str”;

    }

}

public class MyOtherType : MyType

{

    public override string getOneStr()

    {

        return typeof(T).ToString();

    }

}

class Program

{

    static void Main(string[] args)

    {

        MyType target = new MyOtherType();

        Console.WriteLine(target.getOneStr());

        Console.ReadKey();

    }

}

泛型类型MyOtherType成功的重写了非泛型类型MyType的方法,如果我试图按如下方式从MyOtherType类型派生子类型就会导致编译器错误

//编译期错误

public class MyThirdType : MyOtherType

{

}

但是如果写成这种方式,就不会出错

public class MyThirdType : MyOtherType

{

    public override string getOneStr()

    {

        return “MyThirdType”;

    }

}

如果一个方法接收MyThirdType类型的参数,那么不能将一个MyOtherType的实例传递给这个方法,然而一个方法如果接收MyOtherType类型的参数

却可以把MyThirdType类型的实例传递给这个方法,写成如下方式也不会出错

public class MyThirdType : MyOtherType

{

    public override string getOneStr()

    {

        return typeof(T).ToString() + ” from MyThirdType”;

    }

}

此中诀窍,只可意会,不可言传

六、泛型接口

.NET类库里有很多泛型的接口,比如:IEnumerator、IList等,这里不对这些接口做详细描述了,值说说为什么要有泛型接口。

其实泛型接口出现的原因和泛型出现的原因类似,拿IComparable这个接口来说,,此接口只描述了一个方法:

int CompareTo(object obj);

大家看到,如果是值类型的参数,势必会导致装箱和拆箱操作,同时,也不是强类型的,不能在编译期确定参数的类型,有了IComparable就解决掉这个问题了

int CompareTo(T other);

七、泛型委托

委托描述方法,泛型委托的由来和泛型接口类似

定义一个泛型委托也比较简单:

public delegate void MyAction(T obj);

这个委托描述一类方法,这类方法接收T类型的参数,没有返回值

来看看使用这个委托的方法

public delegate void MyAction(T obj);

static void Main(string[] args)

{

    var method = new MyAction(printInt);

    method(3);

    Console.ReadKey();

}

static void printInt(int i)

{

    Console.WriteLine(i);

}

由于定义委托比较繁琐,.NET类库在System名称空间,下定义了三种比较常用的泛型委托

Predicate委托:

public delegate bool Predicate(T obj);

这个委托描述的方法为接收一个T类型的参数,返回一个BOOL类型的值,一般用于比较方法

Action委托

public delegate void Action(T obj);

public delegate void Action(T1 arg1, T2 arg2);

这个委托描述的方法,接收一个或多个T类型的参数(最多16个,我这里只写了两种类型的定义方式),没有返回值

Func委托

public delegate TResult Func();

public delegate TResult Func(T arg);

这个委托描述的方法,接收零个或多个T类型的参数(最多16个,我这里只写了两种类型的定义方式),与Action委托不同的是,它有一个返回值,返回值的类型为TResult类型的.

八、泛型方法

泛型类型中的T可以用在这个类型的任何地方,然而有些时候,我们不希望在使用类型的时候就指定T的类型,我们希望在使用这个类型的方法时,再指定T的类型,来看看如下代码:

public class MyClass

{

    public TParam CompareTo(TParam other)

    {

        Console.WriteLine(other.ToString());

        return other;

    }

}

上面的代码中MyClass并不是一个泛型类型,但这个类型中的CompareTo()却是一个泛型方法,TParam可以用在这个方法中的任何地方。

使用泛型方法一般用如下代码就可以了:

obj.CompareTo(4);

obj.CompareTo(“ddd”);

然而,你可以写的更简单一些,写成如下的方式

obj.CompareTo(2);

obj.CompareTo(“123”);

有人会问:“这不可能,没有指定CompareTo方法的TParam类型,肯定会编译出错的”,我告诉你:不会的,编译器可以帮你完成类型推断的工作。

注意:

如果你为一个方法指定了两个泛型参数,而且这两个参数的类型都是T,

那么如果你想使用类型推断,你必须传递两个相同类型的参数给这个方法

不能一个参数用string类型,另一个用object类型,这会导致编译错误。

九、泛型约束

我们设计了一个泛型类型,很多时候,我们不希望使用者传入任意类型的参数

也就是说,我们希望“约束”一下T的类型,来看看如下代码:

public class MyClass where T : IComparable

{

    public int CompareTo(T other)

    {

        return 0;

    }

}

上面的代码要求T类型必须实现了IComparable接口,如你所见:泛型的约束通过关键字where来实现。

泛型方法当然也可以通过类似的方式对泛型参数进行约束,请看如下代码:

public class MyClass

{

    public TParam CompareTo(TParam other) where TParam:class

    {

        Console.WriteLine(other.ToString());

        return other;

    }

}

上面代码中用了class关键字约束泛型参数TParam;具体稍后解释。

注意1:


如果我有一个类型也定义为MyClass但没有做约束,那么这个时候,做过约束的MyClass将与没做约束的MyClass冲突,编译无法通过

注意2:


当你重写一个泛型方法时,如果这个方法指定了约束,在重写这个方法时,不能再指定约束了

注意3:


虽然我上面的例子写的是接口约束,但你完全可以写一个类型,比如说BaseClass,而且,只要是继承自BaseClass的类型都可以当作T类型使用,你不要试图约束T为Object类型,编译不会通过的。(傻子才这么干)

注意4:


有两个特殊的约束:class和struct。

where T : class   约束T类型必须为引用类型

where T : struct  约束T类型必须为值类型

注意5:


如果你没有对T进行class约束,那么你不能写这样的代码:T obj = null;  这无法通过编译,因为T有可能是值类型的。

如果你没有对T进行struct约束,也没有对T进行new约束,那么你不能写这样的代码:T obj = new T();  这无法通过编译,因为值类型肯定有无参数构造器,而引用类型就不一定了。

如果你对T进行了new约束:where T : new();  那么new T()就是正确的,因为new约束要求T类型有一个公共无参构造器。

注意6:


就算没有对T进行任何约束,也有一个办法来处理值类型和引用类型的问题

T temp = default(T);如果T为引用类型,那么temp就是null;如果T为值类型,那么temp就是0;

注意7:


试图对T类型的变量进行强制转化,一般情况下会报编译期错误。但你可以先把T转化成object再把object转化成你要的类型(一般不推荐这么做,你应该考虑把T转化成一个约束兼容的类型),你也可以考虑用as操作符进行类型转化,这一般不会报错,但只能转化成引用类型。


十、逆变和协变

 一般情况下,我们使用泛型时,由T标记的泛型类型是不能更改的

也就是说,如下两种写法都是错误的

var a = new List();

List b = a;

var c = new List();

List d = c;

注意:这里没有写强制转换,即使写了强制转换也是错误的,编译就无法通过

然而泛型提供了逆变和协变的特性,有了这两种特性,这种转换就成为了可能。

逆变:

泛型类型T可以从基类型更改为该类的派生类型,用in关键字标记逆变形式的类型参数,而且这个参数一般作输入参数。

协变:

泛型类型T可以从派生类型更改为它的基类型,用out关键字来标记协变形式的类型参数,而且这个参数一般作为返回值

如果我们定义了一个这样的委托:

public delegate TResult MyAction(T obj);

那么,就可以让如下代码通过编译(不用强制转换)

var a = new MyAction(o => new ArgumentException(o.ToString()));

MyAction b = a;

这就是逆变和协变的威力。

注意:

只有接口和委托的泛型类型才可以使用逆变和协变的特性

关注「DotNet」 

看更多精选 .Net 技术文章

↓↓↓

转载请注明:CodingBlog » .NET编程30分钟泛型学习

喜欢 (0)or分享 (0)
发表我的评论
取消评论

*

表情
(1)个小伙伴在吐槽
  1. 可以再深入介绍
    秋仔2017-02-11 06:40 回复