var testDto = ModelDto(modelId: 1)
testDto.objectId = 2

而我定义这个：

protocol DataTransferObject {
    var objectType: DtoType { get }
    var parentObjectId: Int { get set }
    var objectId: Int { get }
    var objectName: String { get set }
}

struct ModelDto: DataTransferObject {
    var objectType: DtoType
    var parentObjectId: Int
    var objectId: Int
    var objectName: String

    init(modelId: Int) {
        self.objectType = DtoType.Model
        self.objectId = modelId
        self.parentObjectId = -1
        self.objectName = String()
    }
}

如果我的协议中的定义大部分被忽略(getter,setter定义),为什么还要使用它？

吸气剂和固化剂的要求可以通过各种方式的一致性类型来满足.如果属性声明包含get和set关键字,则一致的类型可以使用存储的变量属性或可读写的计算属性(即实现getter和setter的一个)来实现.但是,该属性声明不能实现为常量属性或只读计算属性.如果属性声明仅包含get关键字,则可以将其实现为任何类型的属性.

protocol SomeProtocol {
    func doSomething()
}

在辅助类中,我有一个协议变量的引用：

class someClass {
    var delegate: SomeProtocol? 
}

因为SomeProtocol没有标记为：class,所以假设委托可以是任何东西,在值类型(结构和枚举)的情况下,不需要弱变量因为值类型不能创建强引用.事实上,编译器不允许除类类型之外的任何弱变量.

但是,没有什么能阻止您将类设置为委托,并且如果协议未标记为：class(如SomeProtocol所示),则无法使用weak var`并创建保留周期.

class MyClass: NSObject,SomeProtocol {
    func doSomething() { }
}

struct MyStruct: SomeProtocol {
    func doSomething() { }
}

let someClass = SomeClass()
let myStruct = MyStruct()
someClass.delegate = myStruct 
// After myStruct gets assigned to the delegate,do the delegate and the struct refer to the same instance or does the struct get copied?D

let myClass = MyClass()
someClass.delegate = myClass // can't use weak var so myClass is retained

鉴于上面的例子,在使用委托和数据源的情况下,不应该：class总是被使用？基本上任何用于维护引用的协议都应该始终限制为类对象吗？

func containsObjectIdenticalTo(obj: T) -> Bool {
    // objectPassingTest returns the first object passing the test
    return objectPassingTest { x in x == obj }
}

显然,这不会编译,因为编译器还不知道是否为类型T实现了==我然后将代码更改为此

func containsObjectIdenticalTo(obj: T) -> Bool {
    return objectPassingTest {
        x in
        assert(x is Equatable && obj is Equatable)
        return (x as Equatable) == (obj as Equatable)
    } != nil
}

哪个也不起作用,因为无法检查对Equatable的一致性(因为Equatable没有用@obj定义)！

有什么想法吗？如果有一种方法可以直接断言如果T符合Equatable,那会很好,但我还没有读到任何地方.在这些东西中,Swift似乎没有Obj-C那么动态.

更新：
尝试了这个建议并且它不起作用(不知道究竟是什么< T：Equatable>用于,它确实编译).

func containsObjectIdenticalTo<T: Equatable>(obj: T) -> Bool {
    var x = self[0]
    var y = self[0]
    return x == y // Error here
}

func containsObjectIdenticalTo<T: Equatable>(obj: T) -> Bool {/*...*/}

我试过了 ：

protocol CustomProtocol: Hashable {}

let set = Set<CustomProtocol>()

但Xcode抱怨：

Using ‘CustomProtocol’ as a concrete type conforming to protocol
‘Hashable’ is not supported

我该如何实现呢？

提前致谢.

最简单的方法是制作,而不是一组协议,而是一组对象类型.例如,如果S是符合CustomProtocol的结构(因为它符合Hashable加上任何其他CustomProtocol所需),则可以声明一组S.

例：

protocol CustomProtocol: Hashable {

}

func ==(lhs:S,rhs:S) -> Bool {
    return lhs.name == rhs.name
}

struct S : CustomProtocol {
    var name : String
    var hashValue : Int { return name.hashValue }
}

let set = Set<S>()

如果您想要解决的问题是您想要一个混合类型的集合,但是在某种程度上彼此相当,那么这是通过协议扩展解决的同样的问题,如协议中的讨论所解释的 – 面向WWDC 2015视频.

但是,只要使所有类型的类从NSObject派生,这将变得更简单.您仍然可以使它们采用一些辅助协议,当然,但是该集合不会被定义为一组该协议,而是NSObject.