Ios Swift将泛型类型限制为

如何将泛型类型限制为类型，而不是类型的实例

如果我有课：

class-SomeClass{}

如何确保

T

只是

AnyClass

的一个实例（它只是

AnyObject.Type

）

我的协议只有静态方法，为了调用这些方法，我必须执行

instance.dynamicType.protocolMethod

，而我想执行

someType.protocolMethod

protocol P {
    static func foo()
}
class A : P {
    static func foo() {
        print("A class")
    }
}
class B : P {
    static func foo() {
        print("C class")
    }
}

var type1 = A.self
var type2 = B.self

func check(cls: AnyClass)->Void {
    switch cls {
    case is A.Type:
        A.foo()
    case is B.Type:
        B.foo()
    default:
        break
    }
}

check(type1) // A class
check(type2) // C class

let i = Int.self         // Int.Type
let ao = AnyObject.self  // AnyObject.Protocol
let ac = AnyClass.self   // AnyClass.Protocol
let p = P.self           // P.Protocol
let f = check.self       // (AnyClass)->Void

编辑

协议P{
静态函数f（）
}
甲级：P{
静态函数f（）{
打印（“A”）
}
}
B类：P{
静态函数f（）{
打印（“B”）
}
}
函数f（cls:P.Type）{
cls.f（）
}
f（A）//A
f（B）//B
课堂测试{
func foo（）{
T.f（）
}
}
Test（）.foo（）//A
Test（）.foo（）//B

好吧，Swift不允许您将元类型用作泛型类型。（我相信这与山姆·吉丁斯的观点是一致的。）

但是，您可以将其用作值。不要将

T

设置为类型参数，而是将其设置为属性：

protocol SomeProtocol {
    static func foo()
}

struct Concrete: SomeProtocol {
    static func foo() {
        print("I am concrete")
    }
}

class SomeClass {
    let T: SomeProtocol.Type

    init(T: SomeProtocol.Type) {
        self.T = T
    }

    func go() {
        T.foo()  // no need for dynamicType
    }
}

SomeClass(T: Concrete.self).go()

如您所说，如果您的协议只包含静态方法，那么这就足够了。但是，如果需要将泛型参数绑定到类型，也可以：

class SomeClass<U: SomeProtocol> {
    let T: U.Type

    init(T: U.Type) {
        self.T = T
    }

    func go(value: U) {
        T.foo()
    }
}

SomeClass(T: Concrete.self).go(Concrete())

class-SomeClass{
让T：U型
初始（T:U.Type）{
self.T=T
}
func go（值：U）{
傅先生（）
}
}
SomeClass（T:Concrete.self）.go（Concrete（））

同样，这不涉及泛型。同样，AnyClass是所有类类型隐式符合的协议。可能是我不明白你的问题。AnyClass不是协议，它是

AnyObject.Type的类型别名
AnyObject
但是它是一个协议。请检查文档。（cmd在操场上的点击应该有效）我做到了。你有@user3441734吗
@objc public protocol AnyObject{}
public typealias AnyClass=AnyObject.Type
太糟糕了，你不能对泛型使用元类型。不管怎样，我相信你的解决方案是最好的。
class SomeClass<U: SomeProtocol> {
    let T: U.Type

    init(T: U.Type) {
        self.T = T
    }

    func go(value: U) {
        T.foo()
    }
}

SomeClass(T: Concrete.self).go(Concrete())