Go 泛型之泛型约束

一、引入

虽然泛型是开发人员表达“通用代码”的一种重要方式,但这并不意味着所有泛型代码对所有类型都适用。更多的时候,我们需要对泛型函数的类型参数以及泛型函数中的实现代码设置限制。泛型函数调用者只能传递满足限制条件的类型实参,泛型函数内部也只能以类型参数允许的方式使用这些类型实参值。在 Go 泛型语法中,我们使用类型参数约束(type parameter constraint)(以下简称约束)来表达这种限制条件。

约束之于类型参数就好比函数参数列表中的类型之于参数:

函数普通参数在函数实现代码中可以表现出来的性质与可以参与的运算由参数类型限制,而泛型函数的类型参数就由约束(constraint)来限制。

2018 年 8 月由伊恩·泰勒和罗伯特·格瑞史莫主写的 Go 泛型第一版设计方案中,Go 引入了 contract 关键字来定义泛型类型参数的约束。但经过约两年的 Go 社区公示和讨论,在 2020 年 6 月末发布的泛型新设计方案中,Go 团队又放弃了新引入的 contract 关键字,转而采用已有的 interface 类型来替代 contract 定义约束。这一改变得到了 Go 社区的大力支持。使用 interface 类型作为约束的定义方法能够最大程度地复用已有语法,并抑制语言引入泛型后的复杂度。

但原有的 interface 语法尚不能满足定义约束的要求。所以,在 Go 泛型版本中,interface 语法也得到了一些扩展,也正是这些扩展给那些刚刚入门 Go 泛型的 Go 开发者带来了一丝困惑,这也是约束被认为是 Go 泛型的一个难点的原因。

下面我们来看一下 Go 类型参数的约束, Go 原生内置的约束、如何定义自己的约束、新引入的类型集合概念等。我们先来看一下 Go 语言的内置约束,从 Go 泛型中最宽松的约束:any 开始。

二、最宽松的约束:any

无论是泛型函数还是泛型类型,其所有类型参数声明中都必须显式包含约束,即便你允许类型形参接受所有类型作为类型实参传入也是一样。那么我们如何表达“所有类型”这种约束呢?我们可以使用空接口类型(interface{})来作为类型参数的约束:

func Print[T interface{}](sl []T) {
// ... ...
} func doSomething[T1 interface{}, T2 interface{}, T3 interface{}](t1 T1, t2 T2, t3 T3) {
// ... ...
}

不过使用 interface{} 作为约束至少有以下几点“不足”:

  • 如果存在多个这类约束时,泛型函数声明部分会显得很冗长,比如上面示例中的 doSomething 的声明部分;
  • interface{} 包含 {} 这样的符号,会让本已经很复杂的类型参数声明部分显得更加复杂;
  • comparableSortableordered 这样的约束命名相比,interface{} 作为约束的表意不那么直接。

为此,Go 团队在 Go 1.18 泛型落地的同时又引入了一个预定义标识符:anyany 本质上是 interface{} 的一个类型别名:

// $GOROOT/src/builtin/buildin.go
// any is an alias for interface{} and is equivalent to interface{} in all ways.
type any = interface{}

这样,我们在泛型类型参数声明中就可以使用 any 替代 interface{},而上述 interface{} 作为类型参数约束的几点“不足”也随之被消除掉了。

any 约束的类型参数意味着可以接受所有类型作为类型实参。在函数体内,使用 any 约束的形参 T 可以用来做如下操作:

  • 声明变量
  • 同类型赋值
  • 将变量传给其他函数或从函数返回
  • 取变量地址
  • 转换或赋值给 interface{} 类型变量
  • 用在类型断言或 type switch 中
  • 作为复合类型中的元素类型
  • 传递给预定义的函数,比如 new

下面是 any 约束的类型参数执行这些操作的一个示例:

// any.go
func doSomething[T1, T2 any](t1 T1, t2 T2) T1 {
var a T1 // 声明变量
var b T2
a, b = t1, t2 // 同类型赋值
_ = b f := func(t T1) {
}
f(a) // 传给其他函数 p := &a // 取变量地址
_ = p var i interface{} = a // 转换或赋值给interface{}类型变量
_ = i c := new(T1) // 传递给预定义函数
_ = c f(a) // 将变量传给其他函数 sl := make([]T1, 0, 10) // 作为复合类型中的元素类型
_ = sl j, ok := i.(T1) // 用在类型断言中
_ = ok
_ = j switch i.(type) { // 作为type switch中的case类型
case T1:
case T2:
}
return a // 从函数返回
}

但如果对 any 约束的类型参数进行了非上述允许的操作,比如相等性或不等性比较,那么 Go 编译器就会报错:

// any.go

func doSomething[T1, T2 any](t1 T1, t2 T2) T1 {
var a T1
if a == t1 { // 编译器报错:invalid operation: a == t1 (incomparable types in type set)
} if a != t1 { // 编译器报错:invalid operation: a != t1 (incomparable types in type set)
}
... ...
}

所以说,如果我们想在泛型函数体内部对类型参数声明的变量实施相等性(==)或不等性比较(!=)操作,我们就需要更换约束,这就引出了 Go 内置的另外一个预定义约束:comparable

三、支持比较操作的内置约束:comparable

Go 泛型提供了预定义的约束:comparable,其定义如下:

// $GOROOT/src/builtin/buildin.go

// comparable is an interface that is implemented by all comparable types
// (booleans, numbers, strings, pointers, channels, arrays of comparable types,
// structs whose fields are all comparable types).
// The comparable interface may only be used as a type parameter constraint,
// not as the type of a variable.
type comparable interface{ comparable }

不过从上述这行源码我们仍然无法直观看到 comparable 的实现细节,Go 编译器会在编译期间判断某个类型是否实现了 comparable 接口。

根据其注释说明,所有可比较的类型都实现了 comparable 这个接口,包括:布尔类型、数值类型、字符串类型、指针类型、channel 类型、元素类型实现了 comparable 的数组和成员类型均实现了 comparable 接口的结构体类型。下面的例子可以让我们直观地看到这一点:

// comparable.go

type foo struct {
a int
s string
} type bar struct {
a int
sl []string
} func doSomething[T comparable](t T) T {
var a T
if a == t {
} if a != t {
}
return a
} func main() {
doSomething(true)
doSomething(3)
doSomething(3.14)
doSomething(3 + 4i)
doSomething("hello")
var p *int
doSomething(p)
doSomething(make(chan int))
doSomething([3]int{1, 2, 3})
doSomething(foo{})
doSomething(bar{}) // bar does not implement comparable
}

我们看到,最后一行 bar 结构体类型因为内含不支持比较的切片类型,被 Go 编译器认为未实现 comparable 接口,但除此之外的其他类型作为类型实参都满足 comparable 约束的要求。

此外还要注意,comparable 虽然也是一个 interface,但它不能像普通 interface 类型那样来用,比如下面代码会导致编译器报错:

var i comparable = 5 // 编译器错误:cannot use type comparable outside a type constraint: interface is (or embeds) comparable

从编译器的错误提示,我们看到:comparable 只能用作修饰类型参数的约束。

四、自定义约束

我们知道,Go 泛型最终决定使用 interface 语法来定义约束。这样一来,凡是接口类型均可作为类型参数的约束。下面是一个使用普通接口类型作为类型参数约束的示例:

// stringify.go

func Stringify[T fmt.Stringer](s []T) (ret []string) {
for _, v := range s {
ret = append(ret, v.String())
}
return ret
} type MyString string func (s MyString) String() string {
return string(s)
} func main() {
sl := Stringify([]MyString{"I", "love", "golang"})
fmt.Println(sl) // 输出:[I love golang]
}

这个例子中,我们使用的是 fmt.Stringer 接口作为约束。一方面,这要求类型参数 T 的实参必须实现 fmt.Stringer 接口的所有方法;另一方面,泛型函数 Stringify 的实现代码中,声明的 T 类型实例(比如 v)也仅被允许调用 fmt.StringerString 方法。

这类基于行为(方法集合)定义的约束对于习惯了 Go 接口类型的开发者来说,是相对好理解的。定义和使用起来,与下面这样的以接口类型作为形参的普通 Go 函数相比,区别似乎不大:

func Stringify(s []fmt.Stringer) (ret []string) {
for _, v := range s {
ret = append(ret, v.String())
}
return ret
}

但现在我想扩展一下上面 stringify.go 这个示例,将 Stringify 的语义改为只处理非零值的元素:

// stringify_without_zero.go

func StringifyWithoutZero[T fmt.Stringer](s []T) (ret []string) {
var zero T
for _, v := range s {
if v == zero { // 编译器报错:invalid operation: v == zero (incomparable types in type set)
continue
}
ret = append(ret, v.String())
}
return ret
}

我们看到,针对 v 的相等性判断导致了编译器报错,我们需要为类型参数赋予更多的能力,比如支持相等性和不等性比较。这让我们想起了我们刚刚学过的 Go 内置约束 comparable,实现 comparable 的类型,便可以支持相等性和不等性判断操作了。

我们知道,comparable 虽然不能像普通接口类型那样声明变量,但它却可以作为类型嵌入到其他接口类型中,下面我们就扩展一下上面示例:

// stringify_new_without_zero.go
type Stringer interface {
comparable
String() string
} func StringifyWithoutZero[T Stringer](s []T) (ret []string) {
var zero T
for _, v := range s {
if v == zero {
continue
}
ret = append(ret, v.String())
}
return ret
} type MyString string func (s MyString) String() string {
return string(s)
} func main() {
sl := StringifyWithoutZero([]MyString{"I", "", "love", "", "golang"}) // 输出:[I love golang]
fmt.Println(sl)
}

在这个示例里,我们自定义了一个 Stringer 接口类型作为约束。在该类型中,我们不仅定义了 String 方法,还嵌入了 comparable,这样在泛型函数中,我们用 Stringer 约束的类型参数就具备了进行相等性和不等性比较的能力了!

但我们的示例演进还没有完,现在相等性和不等性比较已经不能满足我们需求了,我们还要为之加上对排序行为的支持,并基于排序能力实现下面的 StringifyLessThan 泛型函数:

func StringifyLessThan[T Stringer](s []T, max T) (ret []string) {
var zero T
for _, v := range s {
if v == zero || v >= max {
continue
}
ret = append(ret, v.String())
}
return ret
}

但现在当我们编译上面 StringifyLessThan 函数时,我们会得到编译器的报错信息 invalid operation: v >= max (type parameter T is not comparable with >=)。Go 编译器认为 Stringer 约束的类型参数 T 不具备排序比较能力。

如果连排序比较性都无法支持,这将大大限制我们泛型函数的表达能力。但是 Go 又不支持运算符重载(operator overloading),不允许我们定义出下面这样的接口类型作为类型参数的约束:

type Stringer[T any] interface {
String() string
comparable
>(t T) bool
>=(t T) bool
<(t T) bool
<=(t T) bool
}

那我们又该如何做呢?别担心,Go 核心团队显然也想到了这一点,于是对 Go 接口类型声明语法做了扩展,支持在接口类型中放入类型元素(type element)信息,比如下面的 ordered 接口类型:

type ordered interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 |
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
~float32 | ~float64 | ~string
}

在这个接口类型的声明中,我们没有看到任何方法,取而代之的是一组由竖线 “|” 分隔的、带着小尾巴 “~” 的类型列表。这个列表表示的是,以它们为底层类型(underlying type)的类型都满足 ordered 约束,都可以作为以 ordered 为约束的类型参数的类型实参,传入泛型函数。

我们将其组合到我们声明的 Stringer 接口中,然后应用一下我们的 StringifyLessThan 函数:

type Stringer interface {
ordered
comparable
String() string
} func main() {
sl := StringifyLessThan([]MyString{"I", "", "love", "", "golang"}, MyString("cpp")) // 输出:[I]
fmt.Println(sl)
}

这回编译器没有报错,并且程序输出了预期的结果。

好了,看了那么多例子,是时候正式对 Go 接口类型语法的扩展做一个说明了。下面是扩展后的接口类型定义的组成示意图:

我们看到,新的接口类型依然可以嵌入其他接口类型,满足组合的设计哲学;除了嵌入的其他接口类型外,其余的组成元素被称为接口元素(interface element)。

接口元素也有两类,一类就是常规的方法元素(method element),每个方法元素对应一个方法原型;另一类则是此次扩展新增的类型元素(type element),即在接口类型中,我们可以放入一些类型信息,就像前面的 ordered 接口那样。

类型元素可以是单个类型,也可以是一组由竖线 “|” 连接的类型,竖线 “|” 的含义是“并”,这样的一组类型被称为 union element。无论是单个类型,还是 union element 中由 “|” 分隔的类型,如果类型中不带有 “~” 符号的类型就代表其自身;而带有 “~” 符号的类型则代表以该类型为底层类型(underlying type)的所有类型,这类带有 “~” 的类型也被称为 approximation element,如下面示例:

type Ia interface {
int | string // 仅代表int和string
} type Ib interface {
~int | ~string // 代表以int和string为底层类型的所有类型
}

下图是类型元素的分解说明,供你参考:

不过要注意的是:union element 中不能包含带有方法元素的接口类型,也不能包含预定义的约束类型,如 comparable

扩展后,Go 将接口类型分成了两类,一类是基本接口类型(basic interface type),即其自身和其嵌入的接口类型都只包含方法元素,而不包含类型元素。基本接口类型不仅可以当做常规接口类型来用,即声明接口类型变量、接口类型变量赋值等,还可以作为泛型类型参数的约束。

除此之外的非空接口类型都属于非基本接口类型,即直接或间接(通过嵌入其他接口类型)包含了类型元素的接口类型。这类接口类型仅可以用作泛型类型参数的约束,或被嵌入到其他仅作为约束的接口类型中,下面的代码就很直观地展示了这两种接口类型的特征:

type BasicInterface interface { // 基本接口类型
M1()
} type NonBasicInterface interface { // 非基本接口类型
BasicInterface
~int | ~string // 包含类型元素
} type MyString string func (MyString) M1() {
} func foo[T NonBasicInterface](a T) { // 非基本接口类型作为约束
} func bar[T BasicInterface](a T) { // 基本接口类型作为约束
} func main() {
var s = MyString("hello")
var bi BasicInterface = s // 基本接口类型支持常规用法
var nbi NonBasicInterface = s // 非基本接口不支持常规用法,导致编译器错误:cannot use type NonBasicInterface outside a type constraint: interface contains type constraints
bi.M1()
nbi.M1()
foo(s)
bar(s)
}

看到这里,你可能会觉得有问题了:基本接口类型,由于其仅包含方法元素,我们依旧可以基于之前讲过的方法集合,来确定一个类型是否实现了接口,以及是否可以作为类型实参传递给约束下的类型形参。但对于只能作为约束的非基本接口类型,既有方法元素,也有类型元素,我们如何判断一个类型是否满足约束,并作为类型实参传给类型形参呢?

这时候我们就需要 Go 泛型落地时引入的新概念:类型集合(type set),类型集合将作为后续判断类型是否满足约束的基本手段。

五、类型集合(type set)

类型集合(type set)的概念是 Go 核心团队在 2021 年 4 月更新 Go 泛型设计方案时引入的。在那一次方案变更中,原方案中用于接口类型中定义类型元素的 type 关键字被去除了,泛型相关语法得到了进一步的简化。

一旦确定了一个接口类型的类型集合,类型集合中的元素就可以满足以该接口类型作为的类型约束,也就是可以将该集合中的元素作为类型实参传递给该接口类型约束的类型参数。

那么类型集合究竟是怎么定义的呢?下面我们来看一下。

结合 Go 泛型设计方案以及Go 语法规范,我们可以这么来理解类型集合:

  • 每个类型都有一个类型集合;
  • 非接口类型的类型的类型集合中仅包含其自身,比如非接口类型 T,它的类型集合为 {T},即集合中仅有一个元素且这唯一的元素就是它自身。

但我们最终要搞懂的是用于定义约束的接口类型的类型集合,所以以上这两点都是在为下面接口类型的类型集合定义做铺垫,定义如下:

  • 空接口类型(anyinterface{})的类型集合是一个无限集合,该集合中的元素为所有非接口类型。这个与我们之前的认知也是一致的,所有非接口类型都实现了空接口类型;
  • 非空接口类型的类型集合则是其定义中接口元素的类型集合的交集(如下图)。

由此可见,要想确定一个接口类型的类型集合,我们需要知道其中每个接口元素的类型集合。

上面我们说过,接口元素可以是其他嵌入接口类型,可以是常规方法元素,也可以是类型元素。当接口元素为其他嵌入接口类型时,该接口元素的类型集合就为该嵌入接口类型的类型集合;而当接口元素为常规方法元素时,接口元素的类型集合就为该方法的类型集合。

到这里你可能会很疑惑:一个方法也有自己的类型集合?

是的。Go 规定一个方法的类型集合为所有实现了该方法的非接口类型的集合,这显然也是一个无限集合,如下图所示:

通过方法元素的类型集合,我们也可以合理解释仅包含多个方法的常规接口类型的类型集合,那就是这些方法元素的类型集合的交集,即所有实现了这三个方法的类型所组成的集合。

最后我们再来看看类型元素。类型元素的类型集合相对来说是最好理解的,每个类型元素的类型集合就是其表示的所有类型组成的集合。如果是 ~T 形式,则集合中不仅包含 T 本身,还包含所有以 T 为底层类型的类型。如果使用 Union element,则类型集合是所有竖线 “|” 连接的类型的类型集合的并集。

接下来,我们来做个稍复杂些的实例分析,我们来分析一下下面接口类型I 的类型集合:

type Intf1 interface {
~int | string
F1()
F2()
} type Intf2 interface {
~int | ~float64
} type I interface {
Intf1
M1()
M2()
int | ~string | Intf2
}

我们看到,接口类型 I 由四个接口元素组成,分别是 Intf1M1M2Union element “int | ~string | Intf2”,我们只要分别求出这四个元素的类型集合,再取一个交集即可。

  • Intf1 的类型集合

Intf1 是接口类型 I 的一个嵌入接口,它自身也是由三个接口元素组成,它的类型集合为这三个接口元素的交集,即 {以 int 为底层类型的所有类型、string、实现了 F1 和 F2 方法的所有类型}

  • M1 和 M2 的类型集合

就像前面所说的,方法的类型集合是由所有实现该方法的类型组成的,因此 M1 的方法集合为 {实现了 M1 的所有类型}M2 的方法集合为 {实现了 M2 的所有类型}

  • int | ~string | Intf2 的类型集合

这是一个类型元素,它的类型集合为 int~stringIntf2 类型集合的并集。int 类型集合就是 {int}~string 的类型集合为 {以 string 为底层类型的所有类型},而 Intf2 的类型集合为 {以 int 为底层类型的所有类型,以 float64 为底层类型的所有类型}

为了更好地说明最终类型集合是如何取得的,我们在下面再列一下各个接口元素的类型集合:

  • Intf1 的类型集合:{以 int 为底层类型的所有类型、string、实现了 F1F2 方法的所有类型};
  • M1 的类型集合:{实现了 M1 的所有类型};
  • M2 的类型集合:{实现了 M2 的所有类型};
  • int | ~string | Intf2 的类型集合:{以 int 为底层类型的所有类型,以 float64 为底层类型的所有类型,以 string 为底层类型的所有类型}

接下来我们取一下上面集合的交集,也就是 {以 int 为底层类型的且实现了 F1F2M1M2 这个四个方法的所有类型}。

现在我们用代码来验证一下:

// typeset.go

func doSomething[T I](t T) {
} type MyInt int func (MyInt) F1() {
}
func (MyInt) F2() {
}
func (MyInt) M1() {
}
func (MyInt) M2() {
} func main() {
var a int = 11
//doSomething(a) //int does not implement I (missing F1 method) var b = MyInt(a)
doSomething(b) // ok
}

如上代码,我们定义了一个以 int 为底层类型的自定义类型 MyInt 并实现了四个方法,这样 MyInt 就满足了泛型函数 doSomething 中约束 I 的要求,可以作为类型实参传递。

六、简化版的约束形式

在前面的介绍和示例中,泛型参数的约束都是一个完整的接口类型,要么是独立定义在泛型函数外面(比如下面代码中的 I 接口),要么以接口字面值的形式,直接放在类型参数列表中对类型参数进行约束,比如下面示例中 doSomething2 类型参数列表中的接口类型字面值:

type I interface { // 独立于泛型函数外面定义
~int | ~string
} func doSomething1[T I](t T)
func doSomething2[T interface{~int | ~string}](t T) // 以接口类型字面值作为约束

在约束对应的接口类型中仅有一个接口元素,且该元素为类型元素时,Go 提供了简化版的约束形式,我们不必将约束独立定义为一个接口类型,比如上面的 doSomething2 可以简写为下面简化形式:

func doSomething2[T ~int | ~string](t T) // 简化版的约束形式

你看,这个简化版的约束形式就是去掉了 interface 关键字和外围的大括号,如果用一个一般形式来表述,那就是:

func doSomething[T interface {T1 | T2 | ... | Tn}](t T)

等价于下面简化版的约束形式:

func doSomething[T T1 | T2 | ... | Tn](t T)

这种简化形式也可以理解为一种类型约束的语法糖。不过有一种情况要注意,那就是定义仅包含一个类型参数的泛型类型时,如果约束中仅有一个 *int 型类型元素,我们使用上述简化版形式就会有问题,比如:

type MyStruct [T * int]struct{} // 编译错误:undefined: T
// 编译错误:int (type) is not an expression

当遇到这种情况时,Go 编译器会将该语句理解为一个类型声明:MyStruct 为新类型的名字,而其底层类型为 [T *int]struct{},即一个元素为空结构体类型的数组。

那么怎么解决这个问题呢?目前有两种方案,一种是用完整形式的约束:

type MyStruct[T interface{*int}] struct{}

另外一种则是在简化版约束的 *int 类型后面加上一个逗号:

type MyStruct[T *int,] struct{}

七、约束的类型推断

在大多数情况下,我们都可以使用类型推断避免在调用泛型函数时显式传入类型实参,Go 泛型可以根据泛型函数的实参推断出类型实参。但当我们遇到下面示例中的泛型函数时,光依靠函数类型实参的推断是无法完全推断出所有类型实参的:

func DoubleDefined[S ~[]E, E constraints.Integer](s S) S {

因为像 DoubleDefined 这样的泛型函数,其类型参数 E 在其常规参数列表中并未被用来声明输入参数,函数类型实参推断仅能根据传入的 S 的类型,推断出类型参数 S 的类型实参,E 是无法推断出来的。所以为了进一步避免开发者显式传入类型实参,Go 泛型支持了约束类型推断(constraint type inference),即基于一个已知的类型实参(已经由函数类型实参推断判断出来了),来推断其他类型参数的类型。

我们还以上面 DoubleDefined 这个泛型函数为例,当通过实参推断得到类型 S 后,Go 会尝试启动约束类型推断来推断类型参数 E 的类型。但你可能也看出来了,约束类型推断可成功应用的前提是 S 是由 E 所表示的。

八、小结

本文我们先从 Go 泛型内置的约束 anycomparable 入手,充分了解了约束对于泛型函数的类型参数以及泛型函数中的实现代码的限制与影响。然后,我们了解了如何自定义约束,知道了因为 Go 不支持操作符重载,单纯依赖基于行为的接口类型(仅包含方法元素)作约束是无法满足泛型函数的要求的。这样我们进一步学习了 Go 接口类型的扩展语法:支持类型元素

既有方法元素,也有类型元素,对于作为约束的非基本接口类型,我们就不能像以前那样仅凭是否实现方法集合来判断是否实现了该接口,新的判定手段为类型集合。并且,类型集合不是一个运行时概念,我们目前还无法通过运行时反射直观看到一个接口类型的类型集合是什么!

Go 内置了像 anycomparable 的约束,后续随着 Go 核心团队在 Go 泛型使用上的经验的逐渐丰富,Go 标准库中会增加更多可直接使用的约束。原计划在 Go 1.18 版本加入 Go 标准库的一些泛型约束的定义暂放在了 Go 实验仓库中,你可以自行参考。

Go 泛型之泛型约束的更多相关文章

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

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

  2. [转] C# 泛型类型参数的约束

    啊.紫原文C# 泛型类型参数的约束 在定义泛型类时,可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制.如果客户端代码尝试使用某个约束所不允许的类型来实例化类,则会产生编译时错误.这些限制 ...

  3. C# 泛型类型参数的约束

    在定义泛型类时,可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制.如果客户端代码尝试使用某个约束所不允许的类型来实例化类,则会产生编译时错误.这些限制称为约束.约束是使用 where 上 ...

  4. 编写高质量代码改善C#程序的157个建议——建议34:为泛型参数设定约束

    建议34:为泛型参数设定约束 “约束”这个词可能会引起歧义,有些人肯能认为对泛型参数设定约束是限制参数的使用,实际情况正好相反.没有“约束”的泛型参数作用很有限,倒是“约束”让泛型参数具有了更多的行为 ...

  5. 泛型中new()约束的用法

    一..NET中支持的类型参数约束有以下几种 where T : struct              T必须是一个结构类型where T : class               T必须是一个类( ...

  6. C#高级语法之泛型、泛型约束,类型安全、逆变和协变(思想原理)

    一.为什么使用泛型? 泛型其实就是一个不确定的类型,可以用在类和方法上,泛型在声明期间没有明确的定义类型,编译完成之后会生成一个占位符,只有在调用者调用时,传入指定的类型,才会用确切的类型将占位符替换 ...

  7. JavaSE学习总结(十六)—— 泛型与泛型应用

    一.泛型概要 泛型(Generic)的本质是类型参数化,通俗的说就是用一个占位符来表示类型,这个类型可以是String,Integer等不确定的类型,表明可接受的类型. 泛型是Java中一个非常重要的 ...

  8. .NET泛型02,泛型的使用

    在" .NET泛型01,为什么需要泛型,泛型基本语法"中,了解了泛型的基本概念,本篇偏重于泛型的使用.主要包括: ■ 泛型方法重载需要注意的问题■ 泛型的类型推断■ 泛型方法也可以 ...

  9. 【学习笔记】C#中的泛型和泛型集合

    一.什么是泛型? 泛型是C#语言和公共语言运行库(CLR)中的一个新功能,它将类型参数的概念引入.NET Framework.类型参数使得设计某些类和方法成为可能,例如,通过使用泛型类型参数T,可以大 ...

  10. Scala 深入浅出实战经典 第42讲:scala 泛型类,泛型函数,泛型在spark中的广泛应用

    王家林亲授<DT大数据梦工厂>大数据实战视频 Scala 深入浅出实战经典(1-64讲)完整视频.PPT.代码下载:百度云盘:http://pan.baidu.com/s/1c0noOt6 ...

随机推荐

  1. MinIO分布式部署

    目录 先决条件 网络和防火墙 网络 防火墙 负载均衡 顺序的主机名 驱动器要求 XFS格式性能最优 最小IO 顺序的驱动器名 任意迁移 时间同步 考虑 相同的硬软件环境 存储容量规划 推荐的操作系统 ...

  2. Solution Set -「ARC 109」

    「ARC 109A」Hands Link. 讨论即可,除了煞笔出题人写了个死马的题面. #include<cstdio> #include<algorithm> using n ...

  3. Python基于Flask的高校舆情分析,舆情监控可视化系统

    一.前言在当今社会,舆情监控越来越被重视.随着互联网技术的发展,我们从传统媒体渠道.官方报告.调查问卷等方式搜集到的舆情信息,逐渐被网络上的内容所替代.因为网络上的内容传播速度快.及时性强.覆盖范围广 ...

  4. CAP项目集成带身份和证书验证的MongoDB

    大家好,我是Edison. 最近,在使用CAP事件总线时,碰到了这样一个需求:微服务采用的是MongoDB,而且还是带身份验证 和 SSL根证书验证的.由于目前网上能找到的资料,都是不带身份验证的Mo ...

  5. 解决WordPress修改固定链接结构后出现“404 Not Found”的情况

    解决办法 在宝塔面板找到部署的站点设置 点击进入配置文件,复制下方这段代码粘贴进入配置文件,操作完这步,去刷新下我们的网站,再打开文章链接就可以正常打开.访问了. location / { try_f ...

  6. DevOps|破除壁垒,重塑协作-业务闭环释放产研运协作巨大效能

    - 会议太多了,员工开会效率降低了50%! 上篇文章<研发效能组织架构:职能独立vs业务闭环>介绍了职能独立型组织架构和业务闭环型组织架构的特点,优劣势.也许有的小伙伴可能对这两种组织架构 ...

  7. 【Flutter】如何优美地实现一个悬浮NavigationBar

    [Flutter]如何优美地实现一个悬浮NavigationBar 最近写代码的时候遇到了一个如下的需求: 整体来说,底部的条是一个浮动的悬浮窗,有如下的三个按钮: 点击左边的要进入"主页& ...

  8. Django-rest-framework框架——请求与响应、视图组件

    目录 一 请求与响应 1.1 Request 1.1.1.1 常用属性 1).data 2).query_params 1.2 Response 1.1.2.1 构造方式 1.1.2.2 常用属性 1 ...

  9. 24. 从零用Rust编写正反向代理,细说HTTP行为中的几种定时器

    wmproxy wmproxy已用Rust实现http/https代理, socks5代理, 反向代理, 静态文件服务器,四层TCP/UDP转发,内网穿透,后续将实现websocket代理等,会将实现 ...

  10. Qt源码解析——一切从QObject说起

    关键词:Qt 源码 QObject 元对象 属性 事件 信号 槽 状态机 概述 原系列文章地址 学习和理解任何框架或库,官方文档可能都是最权威.最有效的信息.Qt也不例外,https://doc.qt ...