协议与通用功能的关联类型协议

Question

是否可以在另一协议的通用功能中提供确认协议？ 我试着让它像这样工作，但这是不可能的，或者我犯了一些错误。

我的代码：

protocol DataModelProtocol { 
    associatedtype ObjectProtocol: Protocol 
    func fetchObjects<T: ObjectProtocol>() -> [T]? 
    func fetch<T: ObjectProtocol>(object: T) -> T? 
    func delete<T: ObjectProtocol>(allObjectOf type: T.Type) 
    func insert<T: ObjectProtocol>(_ object: T) 
    func save<T: ObjectProtocol>(_ object: T) 
    func update<T: ObjectProtocol>(_ object: T) 
    func delete<T: ObjectProtocol>(_ object: T) 
} 

错误消息：

从非协议，非类类型'Self.ObjectProtocol的继承

Image of Xcode error

它作品只是这样，但我想让它更灵活：

protocol DataModelProtocol { 
    typealias ObjectProtocol = NSManagedObject 
    ... 
} 

Answer 1

这便叫更容易的是你将返回类型的责任赋予了对象类本身。

您将需要两个协议，但它会避免混合协议和仿制药：

// The first protocol is for the base class of data objects 
protocol DataProtocol 
{} 

// The protocol provides the "typed" equivalents of the model's 
// data manipulation methods. 
// By using an extension to DataProtocol, this only needs to 
// be done once for all models and data objects. 
extension DataProtocol 
{ 
    static func fetchObjects(from model:DataModelProtocol) -> [Self]? 
    { return model.fetchObjects(object: Self.self) as! [Self]? } 

    static func fetch(from model:DataModelProtocol) -> Self? 
    { return model.fetch(object: Self.self) as! Self? } 

    // ... 
} 

// The second protocol is for the data models 
// It requires implementation of the data manipulation methods 
// using the general "DataProtocol" rather than any specific class 
// The actual instances it produces must be of the appropriate class 
// however because they will be type casted by the DataProtocol's 
// default methods 
protocol DataModelProtocol 
{ 
    func fetchObjects(object:DataProtocol.Type) -> [DataProtocol]? 
    func fetch(object:DataProtocol.Type) -> DataProtocol? 
    // ... and so on 
} 

... 这里的协议可以如何使用简单的（幼稚）的例子。 （我故意选择不使用核心数据来说明解决方案的一般性） ...

// The base class (or each one) can be assigned the DataProtocol 
// (it doesn't add any requirement) 

class LibraryObject : DataProtocol 
{} 

class Author: LibraryObject 
{ 
    var name = "" 
} 

class Book: LibraryObject 
{ 
    var title = "" 
} 

// This is a simple class that implements a DataModelProtocol 
// in a naive (and non-core-data way) 

struct LibraryModel:DataModelProtocol 
{ 
    var authors:[Author] = [ Author(), Author() ] 

    var books:[Book] = [ Book(), Book(), Book(), Book(), Book() ] 

    func fetchObjects(object: DataProtocol.Type) -> [DataProtocol]? 
    { 
    return object == Book.self ? books 
      : object == Author.self ? authors 
      : nil 
    } 

    func fetch(object:DataProtocol.Type) -> DataProtocol? 
    { return nil } 

} 

... 使用的协议将是你的做法有点不同，因为你会从首发对象类，而不是将它们作为参数传递给模型 ...

var library = LibraryModel() 
let allBooks = Book.fetchObjects(from:library) // this almost reads like english 

Answer 2

如果想要另一个协议的通用功能要符合，只是简单地创建T符合该协议，无需进行额外的ObjectProtocol的associatedType：

​​