Pregunta Utilizando como tipo concreto conforme al protocolo AnyObject no es compatible


Estoy usando Swift 2 y uso de WeakContainer como una forma de almacenar un conjunto de objetos débiles, muy parecido a NSHashTable.weakObjectsHashTable()

struct WeakContainer<T: AnyObject> {
    weak var value: T?
}

public protocol MyDelegate : AnyObject {

}

Luego, en mi ViewController, declaro

public var delegates = [WeakContainer<MyDelegate>]

Pero es un error

Usando MyDelegate como un tipo concreto conforme al protocolo AnyObject no es compatible

Veo que el error es que WeakContainer tiene value miembro declarado como weak, asi que T se espera que sea un objeto. Pero también declaro MyDelegate como AnyObject, también. Cómo evitar esto?


32
2017-09-27 12:34


origen


Respuestas:


Tuve la misma idea de crear contenedores débiles con genéricos.
Como resultado, he creado contenedor para NSHashTable e hizo alguna solución para su error de compilación.

class WeakSet<ObjectType>: SequenceType {

    var count: Int {
        return weakStorage.count
    }

    private let weakStorage = NSHashTable.weakObjectsHashTable()

    func addObject(object: ObjectType) {
        guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
        weakStorage.addObject(object as? AnyObject)
    }

    func removeObject(object: ObjectType) {
        guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
        weakStorage.removeObject(object as? AnyObject)
    }

    func removeAllObjects() {
        weakStorage.removeAllObjects()
    }

    func containsObject(object: ObjectType) -> Bool {
        guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
        return weakStorage.containsObject(object as? AnyObject)
    }

    func generate() -> AnyGenerator<ObjectType> {
        let enumerator = weakStorage.objectEnumerator()
        return anyGenerator {
            return enumerator.nextObject() as! ObjectType?
        }
    }
}

Uso:

protocol MyDelegate : AnyObject {
    func doWork()
}

class MyClass: AnyObject, MyDelegate {
    fun doWork() {
        // Do delegated work.
    }
}

var delegates = WeakSet<MyDelegate>()
delegates.addObject(MyClass())

for delegate in delegates {
    delegate.doWork()
}

No es la mejor solución, porque WeakSet se puede inicializar con cualquier tipo, y si este tipo no se ajusta a AnyObject protocolo entonces la aplicación se bloqueará. Pero no veo ninguna solución mejor en este momento.


11
2017-11-14 05:32



Me encontré con el mismo problema cuando traté de implementar contenedores débiles. Como señala @plivesey en un comentario anterior, esto parece ser un error en Swift 2.2 / Xcode 7.3, pero es espera que funcione.

Sin embargo, el problema no ocurre para algunos protocolos de Foundation. Por ejemplo, esto compila:

let container = WeakContainer<NSCacheDelegate>()

Descubrí que esto funciona para los protocolos marcados con @objc atributo. Puede usar esto como una solución alternativa:

Solución 1

@objc
public protocol MyDelegate : AnyObject { }

let container = WeakContainer<MyDelegate>() // No compiler error

Como esto puede conducir a otros problemas (algunos tipos no se pueden representar en Objective-C), aquí hay un enfoque alternativo:

Solución 2

Suelta el AnyObject requisito del contenedor, y arrojar el valor a AnyObject internamente.

struct WeakContainer<T> {
  private weak var _value:AnyObject?
  var value: T? {
    get {
      return _value as? T
    }
    set {
      _value = newValue as? AnyObject
    }
  }
}

protocol MyDelegate : AnyObject { }

var container = WeakContainer<MyDelegate>() // No compiler error

Advertencia: Guardar valores que se ajusten a T pero no son AnyObjects falla


15
2018-04-28 11:27



¿Por qué estás tratando de usar genéricos? Sugeriría hacer lo siguiente:

import Foundation
import UIKit

protocol MyDelegate : AnyObject {

}

class WeakContainer : AnyObject {
    weak var value: MyDelegate?
}

class ViewController: UIViewController {
    var delegates = [WeakContainer]()
}

También hay NSValuees nonretainedObject


2
2017-11-10 03:45



Tu problema es que WeakContainer requiere su tipo genérico T ser un subtipo de AnyObject - un protocol declaración no es un subtipo de AnyObject. Tienes cuatro opciones:

  1. En lugar de declarar WeakContainer<MyDelegate> reemplazarlo con algo que realmente implemente MyDelegate. El enfoque de Swift-y para esto es usar el AnyX patrón: struct AnyMyDelegate : MyDelegate { ... }

  2. Definir MyDelegate estar 'atado a la clase' como protocol MyDelegate : class { ... }

  3. Anotar MyDelegate con @obj que, esencialmente, lo hace 'clase limitada'

  4. Reformular WeakContainer a no requiere que su tipo genérico herede de AnyObject. Será difícil hacer que esto funcione porque necesita una propiedad declarada como weak var y hay limitaciones en cuanto a qué tipos son aceptados por weak var - que son AnyObject esencialmente.


1
2018-04-28 14:05



Si su protocolo puede marcarse como @obj, puede usar el código a continuación

protocol Observerable {

    associatedtype P : AnyObject

    var delegates: NSHashTable<P> { get }
}

@objc protocol MyProtocol {

    func someFunc()

}

class SomeClass : Observerable {

    var delegates = NSHashTable<MyProtocol>.weakObjects()

}

1
2018-04-09 08:42



Aquí está mi implementación de WeakSet en Swift puro (sin NSHashTable).

internal struct WeakBox<T: AnyObject> {
    internal private(set) weak var value: T?
    private var pointer: UnsafePointer<Void>
    internal init(_ value: T) {
        self.value = value
        self.pointer = unsafeAddressOf(value)
    }
}


extension WeakBox: Hashable {
    var hashValue: Int {
        return self.pointer.hashValue
    }
}


extension WeakBox: Equatable {}

func ==<T>(lhs: WeakBox<T>, rhs: WeakBox<T>) -> Bool {
    return lhs.pointer == rhs.pointer
}



public struct WeakSet<Element>: SequenceType {
    private var boxes = Set<WeakBox<AnyObject>>()

    public mutating func insert(member: Element) {
        guard let object = member as? AnyObject else {
            fatalError("WeakSet's member (\(member)) must conform to AnyObject protocol.")
        }

        self.boxes.insert(WeakBox(object))
    }

    public mutating func remove(member: Element) {
        guard let object = member as? AnyObject else {
            fatalError("WeakSet's member (\(member)) must conform to AnyObject protocol.")
        }

        self.boxes.remove(WeakBox(object))
    }

    public mutating func removeAll() {
        self.boxes.removeAll()
    }

    public func contains(member: Element) -> Bool {
        guard let object = member as? AnyObject else {
            fatalError("WeakSet's member (\(member)) must conform to AnyObject protocol.")
        }

        return self.boxes.contains(WeakBox(object))
    }

    public func generate() -> AnyGenerator<Element> {
        var generator = self.boxes.generate()

        return AnyGenerator {
            while(true) {
                guard let box = generator.next() else {
                    return nil
                }

                guard let element = box.value else {
                    continue
                }

                return element as? Element
            }
        }
    }
}

0
2018-05-02 17:43