.NET基础之自定义泛型国际太阳娱乐网站2138

国际太阳娱乐网站2138 12

本篇文章主要介绍泛型的应用。

泛型、函数类型、闭包

在.NET中泛型使用非常频繁,在控制台应用程序中,默认的引入了System.Collection.Generics名称空间,其中就提供了我们经常使用的泛型:List<T>和Dictionary<T>,相信用过它们的都知道它们的强大。还有一种我们经常使用的简单的泛型:System.Nullable<T>,即可空类型。我们可以:

泛型是.NET Framework 2.0
版类库就已经提供的语法,主要用于提高代码的可重用性、类型安全性和效率。

泛型

泛型是什么?简单说来泛型就是泛指的类型,里面可以实例化任何你想要的类型。
比如我想写个函数交换两个数大小:

System.Nullable<int> nullableInt;

泛型的定义

泛型函数

func exchange (x: inout Int, y: inout Int)
{
    let a = x
    x = y
    y = a 
}
var a = 55
var b = 22
print("a is (a), b is (b).")
//输出结果:a is 55, b is 22.
exchange(x: &a, y: &b)
print("After exchange: a is (a), b is (b).")
//输出结果:After exchange: a is 22, b is 55. 

好,看起来很完美,可是你有没有发现这个函数只能交换两个整数,如果要交换小数呢?也许你会说,这不简单,把参数类型换成
Double
就好了嘛。可是如果你又想交换两个字符串呢?这样换来换去不是个办法,所以泛型自然应运而生。

func exchange<T>(x: inout T, y: inout T)
{
    let a = x
    x = y
    y = a
}
var a = "xiaoMing"
var b = "xiaoHong"
print("a is (a), b is (b).")
//输出结果:a is xiaoMing, b is xiaoHong.
exchange(x: &a, y: &b)
print("After exchange: a is (a), b is (b).")
//输出结果:After exchange: a is xiaoHong, b is xiaoMing.

我们把参数类型换成 T ,然后在函数名后面加一个尖括号,也写上T
,实际上你可以写上任何你想写的字符,只要后面参数类型与它保持一致就行了。
一点点小改动,现在我们即可用来交换整数,又可以交换字符串啦。
现在看起来貌似很不错了,可是如果你想比较 a 和 b
大小可能会碰到一点小问题。你如何能保证传进去的参数支持 “<”、“>”
呢?幸好 Swift 早就想好这个问题了,所以引入了泛型约束。

声明一个可空的int类型,由于C#语法对这个做了简化通常我们都不这样写,而是这样写:

下面定义了一个普通类和一个泛型类,我们可以明确看到泛型类和普通类最大的区别就是多了一个<T>。

泛型约束

这个怎么用,看代码:

func max<T:Comparable>(array: [T]) -> T {
    var value=array[0]
    for index in 1..<array.count
    {
        if array[index]>value {
            value=array[index]
        }
    }
    return value
}
var data1=[1,6,3,8,5,2]
var data2=[12.3, 87.6, 77.8, 20.1, 50.2]
let m1=max(array: data1) // m1 = 8
let m2=max(array: data2) // m2 = 87.6

和泛型函数非常类似,我们只是添加了一个泛型的返回值,再让函数名背后的泛型
T 遵循 Comparable 协议,就这么简单?就这么简单。
只要你传进去的类型遵循 Comparable
协议,那你就可以随意调用这个函数,大家可以点进去看看 Comparable
协议都实现了定义了哪些东西。这样,只要我们想拿该类型做什么事,我们就让他遵循什么协议就好了,如果你随意传个自己写的类,那编译器就会提示你错了,非常方便。

  • 除了协议约束,还有基类约束,二者语法一样,不再赘述。
  • Where 字句约束

func find<T:Container>(sequence :T, item:T.ItemType)->Bool where T.ItemType: Equatable{
 for index in 0..<sequence.count{
 if(sequence[index]==item){
            return true
        }
    }
    return false
} ```
这个奇奇怪怪的东西是什么?在了解它之前,我们得先知道协议的关联类型。
#### 关联类型

protocol Container {
associatedtype ItemType //关联类型
func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}

class Stack<T>: Container {

typealias ItemType=T

var items = [T]()

func push(item: T) {
    items.append(item)
}

func pop() -> T {
    return items.removeLast()
}

func append(item: T) {
    self.push(item: item)
}

var count: Int {
    return items.count
}
subscript(i: Int) -> T {
    return items[i]
}

} “`
哇,不要说你看不懂,我也看晕了,怎么又是 T 又是 ItemType
,这都是些什么啊?
不要慌,先看第一个 Container,它是一个协议。其实它的意思如下伪码:

protocol Container<ItemType> {
 func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

是不是有点儿眉目了,这不就是泛型协议吗,Swift
为啥还要画蛇添足搞出一个关联类型出来?稍安勿躁,苹果这么做自然有他的好处了。
参考链接
我简单总结下好处:

  • 让代码更简洁清晰,特别是当你的协议需要定义多个泛型类型时
  • 可以使用“.”表达式,方便 where 约束
    好了,有了关联类型,我们就可以像上方那样使用 T.ItemType 的语法来用
    where 约束了,是不是非常清晰明了,当你定义的 associatedtype
    多了之后,好处就更加明显了。
int? nullableInt

所以,这个<T>就标记了,这个类是泛型类。其中这个T,也可以写成A,B,C,D或其他字符。

函数类型与闭包

下面重点介绍一下如何自定义泛型。

public class Generic
{
    public String Name;
}

public class Generic<T>
{
    public T Name;
}

基本概念

闭包是函数类型的实例,而函数类型就是一个指针,类似于类,栈上储存指针,指向堆上的对象。

国际太阳娱乐网站2138 1

函数类型内存模型.png

乍一看有点儿犯迷糊?不要紧,一个个来分析。
函数类型是一个指针,它在堆上有两个对象,这两个对象也是指针。一个叫对象指针,一个叫函数指针。

  • 对象指针:这个指针并不是每个函数类型的实例都会有,对象指针,看名字就知道它指向的是一个对象,至于什么样的函数类型拥有对象指针,咱们放到变量捕获那儿讲。
  • 函数指针:这个指向的就是这个函数类型里面的函数真正内存所在地
    函数类型怎么用呢?你可以将它用在任何使用类型的地方。例如:
  • 声明一个变量 var addInt : (Int, Int) -> Int
    现在你可以将任何参数是两个 Int 返回值是一个 Int 的函数赋值给
    addInt,就像使用一个变量去使用它,只不过现在该变量是一个函数。
  • 传递给某个函数作为一个参数
  • 将它作为某个函数的返回值
    这两种不具体写出来了,总之当做它是一个类型就可以了。

 

泛型,顾名思义,就是泛指的类型。好比男人,女人,白人,黑人,可以泛称为【人】。

函数类型实例化

那既然是一个类型,可以被赋值,那它支持哪些函数给它赋值呢?

  • 全局函数
  • 嵌套函数

//嵌套函数
func algorithmFunction(symbol:String)-> (Double, Double)->Double{

    func add(x:Double, y:Double)->Double{
        return x+y
    }

    func minus(x:Double, y:Double)->Double{
        return x-y
    }

    func multiply(x:Double, y:Double)->Double{
        return x*y
    }

    func divide(x:Double, y:Double)->Double{
        return x/y
    }

    switch(symbol){
    case "+":
        return add
    case "-":
        return minus
    case "*":
        return multiply
    case "/":
        return divide
    default:
        return add
    }
}
var algorithm=algorithmFunction(symbol: "/")
let result4 = algorithm(600,80)   // result4 = 7.5
  • 成员函数(实例方法与静态方法)

定义泛型类

但类型只能是一个类型。 那么泛型和类型之间是什么关系呢?

闭包

闭包就是函数类型实例,一样可用于变量、参数、返回值,他俩内存模型一致,那为啥要叫这个为闭包呢?说到这里不得不谈谈捕获了,在谈捕获前,想先介绍下内存泄漏。
内存在结构上可以分为堆和栈,栈上的内存由系统分配系统回收又迅捷又方便,不用我们操心。但栈的空间是极其有限的,所以必须要有堆来存放比较庞大的数据,在
Swift 中类和闭包的实例就存放在堆上并且受到 ARC 管理。
基础数值类型、结构、枚举、元组等不受 ARC 管理。
ARC
又叫自动引用计数管理机制,在堆上的对象只要有一个指针指向它,它的引用计数就加一,如图:

国际太阳娱乐网站2138 2

引用计数示意.png

FileStream
此时的引用计数就为三,因为有三个指针指向它。当某个对象没有指针引用的时候,表明此对象没有任何利用价值了,ARC
会将引用计数降为零,并且销毁这个对象,释放所占内存。
好,目前看起来非常完美,perfect!可是,大家应该很快就会发现有个小问题:

国际太阳娱乐网站2138 3

循环引用.png

这是两个类,每个类都有一个属性,而这个属性刚好又指向这两个类。真是你中有我我中有你不可分离啊,代码大概会是这样:

import Foundation
class Computer{
    var name: String
    var display: Monitor?
    init(name:String){
        self.name=name
        print("Computer init")
    }
    deinit{
        print("Computer deinit")
    }
}
class Monitor{
    var no: Int
    var device: Computer?
    init(no:Int){
        self.no=no
        print("Monitor init")
    }
    deinit{
        print("Monitor deinit")
    }
}
var imac:Computer?
var screen:Monitor?
imac=Computer(name: "Jason's iMac")
screen=Monitor(no: 29)
imac!.display=screen
screen!.device=imac
//imac!.display=nil
imac=nil
screen=nil
/* print : 
Computer init
Monitor init */

!!是不是少了点什么,析构器怎么没被调用?这就是经典的内存泄漏了。看了上面的内存模型,相信大家对这段代码为何会输出如此结构就了解了,这两个类对象还互相指着呢,引用计数都为一,怎么可能会被释放呢?
还好,世界上的聪明人早就猜到会发生这种事所以,我们有了处理这种办法的措施,那就是。。。手工赋值其中一个堆对象指针为
nil
!哈,开个玩笑,其实这也是一种非常好的处理办法,非常灵活,下面我们来看看更普适的方法。

国际太阳娱乐网站2138 4

内存泄漏处理办法.png

解决办法也着实简单,只要我们将其中一个强引用指针换成弱引用就 OK
了,也就是说这个弱引用指针将不被算进 ARC
引用计数里去,这样当栈上的两个指针断掉后,两个对象循环引用自然被打破,如图:

国际太阳娱乐网站2138 5

弱引用.png

有时人们并不想该对象可被赋值为
nil,所以我们又创造了一个无主引用,和弱引用一样,只是无主引用声明的对象不许为
nil:

国际太阳娱乐网站2138 6

无主引用.png

好了下面再来讲捕获。

创建泛型类是需要在类定义中用尖括号语法:

其实很简单,泛型在定义的时候,是泛指类型;在使用的时候,就需要被指定,到底使用哪个类型。

捕获

国际太阳娱乐网站2138 7

捕获.png

这里重点要讲的是捕获生存周期小于闭包对象的参数和局部变量,因为其他的值谈不上捕获,顶多算使用而已,但是这二者却截然不同,我们是真真正正的复制了他们封装在临时对象上,并且闭包的对象指针指向该临时对象。还记得前面讲函数类型时我说过不是所有函数类型的实例都会有这个对象指针吗?
有对象指针有两种情况,一是捕获了类的实例成员,包括实例方法和实例属性;二就是捕获了参数或局部变量。第一种就是将该闭包的对象指针指向该类的实例对象,第二种则是将对象指针指向闭包自己创建的临时对象。
并且,很重要一点,这个对象指针是强引用该对象,这样,大家可能明白又要出事情了。还是先看内存模型吧:

国际太阳娱乐网站2138 8

捕获内存模型.png

似乎并没有什么不对,那我们现在思考一种情形。我是一个闭包,我捕获了类的实例成员,这样我的对象指针就将指向该实例对象;我是这个类,我定义了一个属性,该属性是这个闭包,这样我的实例对象就将有一个属性指针指向该闭包。看代码:

class Employee{
    var name: String
    var printer:(()->())?  
 /*   lazy var printer: (()->())? = {
        print("name: (self.name)")
    } */
   init(name:String){
        self.name=name
        self.printer = {
            print("name: (self.name)")
        }
        print("Employee init")
    }
     deinit {
     print("Employee deinit")
    }
}
var employee:Employee?
employee=Employee(name: "Jason")
employee?.printer?()
//employee?.printer=nil
employee = nil
/* print : 
Employee init
name: Jason */

同样析构器不会被调用,因为闭包和这个对象还两两相指呢,只有当我手动赋值该对象的闭包属性为
nil 时,析构器才会调用。看图:

国际太阳娱乐网站2138 9

闭包循环引用.png

那解决办法大家应该也猜到了,同样是声明弱引用。

国际太阳娱乐网站2138 10

弱引用.png

只放出不同部分:
self.printer = { [weak self] in print("name: (self!.name)") }

国际太阳娱乐网站2138 11

弱引用内存图.png

class MyGenericClass<T>
{
    ...
}

即,使用时,就不在是泛指类型,而是特定类型。

Weak-Strong Dance

这个有点儿诗意的名字是用来延长弱引用对象的生存周期的,别还没等到你要用,对象就被系统给咔嚓了。

国际太阳娱乐网站2138 12

Weak-Strong Dance.png

下面运用了一点多线程知识,不详讲了,总之你要明白在代码中弱引用是非常不安全的。在进行一系列操作时,可能等不到你要使用它,就被系统回收了它的内存。在本例中,注释部分就是临时转换成一个强引用局部变量,没有被注释的代码就是
withExtendedLifetime 函数了。

import UIKit
class Employee {
 var name: String
 init(name:String){
        self.name=name
        print("Employee init")
    }
func doClosure() {
        DispatchQueue.global().async { [weak self] in
        /*
            self?.process("first process")
            usleep(500)
            self?.process("second process")
            */
       /*
            if let strongRef=self {
                strongRef.process("first process")
                usleep(500)
                strongRef.process("second process")
            }*/
          withExtendedLifetime(self){
                self?.process(message: "first process")
                usleep(500)
                self?.process(message: "second process")
            }   
        }
    }
 deinit {
        print("Employee deinit")
    }
    func process(message: String) {
        print(message)
    }
}
var employee: Employee? = Employee(name:"Jason")
employee?.doClosure()
DispatchQueue.global().async {
    usleep(100)
    employee = nil
}
dispatchMain()
/* print :
Employee init
first process
second process
Employee deinit
*/

T可以是任意的标示符,只要遵守命名规则即可。

好比,定义时,定义了一个人。但在使用时,必须明确指定,到底是黑人还是白人。

第三周作业

 

泛型的使用

题目

请说出下面代码存在的问题,以及改进方式。
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("(name) is being deinitialized") }
}
class CreditCard {
    let number: UInt64
    let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #(number) is being deinitialized") }
}

可以把类型用在类成员的返回类型,方法参数类型等,例如:

泛型类跟普通类的使用方式一样,都需要实例化对象,再由对象来调用内部的属性或方法。

答案

一个简单的循环引用,不解释了。

class Customer {
    let name: String
    weak var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("(name) is being deinitialized") }
}
class CreditCard {
    let number: UInt64
    let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #(number) is being deinitialized") }
}
var xiaoMing: Customer?
var xiaoMingID: CreditCard?
xiaoMing = Customer(name: "xiaoMing")
xiaoMingID = CreditCard(number: 522644, customer: xiaoMing!)
xiaoMing?.card = xiaoMingID
xiaoMing = nil
xiaoMingID = nil
class MyGenericClass<T1, T2, T3>
{
    private T1 t1Object;

    public MyGenericClass(T1 item)
    {
        t1Object = item;
    }

    public T1 T1Object
    {
        get
        {
            return t1Object;
        }
    }
}

下面代码实例化了泛型Generic,实例化时,还指定了该泛型Generic的指定类型为String。

注意如果不能假定提供了什么类型。下面的代码不能执行:

所以要给泛型Generic的属性Name赋值,就需要赋值字符串类型的值。

class MyGenericClass<T1, T2, T3>
{
    private T1 t1Object;

    public MyGenericClass()
    {
        t1Object = new T1();
    }
}
public static void Excute()
{
    Generic<String> gs = new Generic<String>();
    gs.Name = "Kiba518";
}

因为我们不知道T1是否有公有的默认构造函数。

下面代码定义了一个Int类型的泛型Generic。

 

public static void Excute()
{
    Generic<int> gs = new Generic<int>();
    gs.Name = 518;
}

default关键字

泛型的默认值

如果我们定义了一个泛型的字段,我们想在构造函数中初始化它,但是我们不知道它的引用类型还是值类型,那么default就派上用处了:

泛型的默认值,如下面代码所示。需要使用default(T)来赋值。

public MyGenericClass()
{
    t1Object = default(T1);
}
You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图