Alternativa al metodo di caricamento in Swift

Question

Sto lavorando allo sviluppo di un'applicazione in Swift. Volevo progettare un sistema per l'applicazione che consentisse un accoppiamento lento tra gli oggetti, e una strategia (che ho usato con successo in altri linguaggi) era creare qualcosa che io chiamo una fabbrica di istanze. E 'abbastanza semplice e qui è l'implementazione di base mi è venuta a Swift:

import Foundation 

private var typeGenerators = Dictionary<String, InstanceFactory.GeneratorCallback>() 

public class InstanceFactory: NSObject { 
    public typealias GeneratorCallback =() -> AnyObject! 

    public class func registerGeneratorFor(typeName: String, callback: GeneratorCallback) { 
     typeGenerators[typeName] = callback 
    } 

    public class func instanceOf(typeName: String) -> AnyObject! { 
     return typeGenerators[typeName]?() 
    } 
} 

L'idea è che quando un'istanza oggetto ha bisogno di accedere a un'altra istanza oggetto, piuttosto che la creazione di tale istanza a titolo definitivo che sarebbe più strettamente paio i due oggetti, il primo oggetto si rimanda alla fabbrica per fornire l'istanza necessaria chiamando il metodo instanceOf. La fabbrica saprebbe come fornire vari tipi di istanze perché quei tipi sarebbero registrati con la fabbrica e fornirebbero una chiusura che potrebbe generare l'istanza.

Il trucco è come ottenere le classi per registrarsi in fabbrica. In precedenza avevo creato uno stabilimento simile in Objective-C e il modo in cui ho ottenuto la registrazione al lavoro era di sovrascrivere il metodo di caricamento + per ogni classe che aveva bisogno di registrarsi con la fabbrica. Questo ha funzionato alla perfezione con Objective-C, e ho pensato che potesse funzionare anche per Swift dato che limitavo la factory a fornire solo oggetti derivati ​​da NSObject. Mi è sembrato che riuscissi a far funzionare tutto questo e ho dedicato uno sforzo significativo alla progettazione di corsi per far uso della fabbrica.

Tuttavia, dopo l'aggiornamento a Xcode 6.3, ho scoperto che Apple non ha consentito l'utilizzo del metodo della classe di carico in Swift. Senza questo, non sono a conoscenza di un meccanismo che consenta alle classi di registrarsi automaticamente con la fabbrica.

Mi chiedo se ci sia un altro modo per far funzionare la registrazione.

Quali alternative sono disponibili per consentire alle classi di registrarsi in fabbrica o quali altre tecniche potrebbero essere utilizzate per realizzare lo stesso tipo di accoppiamento libero fornito dalla fabbrica?

Answer 1

Considerare di adottare l'approccio Swift utilizzando invece un protocollo. Penso che la soluzione sia in realtà più semplice dell'approccio Objective-C. Ci sono variazioni di questo con vincoli di auto che sono ancora meglio se hai più controllo sulle classi.

// define a protocol to create an instance of a class 
protocol FactoryInstantiable { 
    static func makeFactoryInstance() -> AnyObject 
} 

// Factory for generating new instances 
public class InstanceFactory: NSObject { 
    public class func instanceOf(typeName: String) -> AnyObject! { 
     if let ProductType = NSClassFromString(typeName) as? FactoryInstantiable.Type { 
      return ProductType.makeFactoryInstance() 
     } else { 
      return nil 
     } 
    } 
} 


// your class which generally could be defined somewhere else 
class MyClass { 
    var counter : Int 

    init(counter: Int) { 
     self.counter = 0 
    } 
} 

// extension of your class to conform to the FactoryInstantiable protocol 
extension MyClass : FactoryInstantiable { 
    static func makeFactoryInstance() -> AnyObject { 
     return MyClass(counter: 0) 
    } 
} 

Answer 2

ho trovato una possibile soluzione al vostro problema dopo che ho voluto registrare tutti ViewControllers che sarebbe l'attuazione di un certo protocollo nella mia richiesta e mi sono imbattuto in questa domanda e sia una possibile risposta.

L'originale è stato postato qui: How to list all classes conforming to protocol in Swift?

mi sono adattato a Swift 3 e ne ha fatto un po 'più Swift-y e generica:

import UIKit 

class ContextRoute: NSObject { 

} 

@objc protocol ContextRoutable { 
    static var route: ContextRoute { get } 
} 

class ContextRouter: NSObject { 
    private static var storedRoutes: [ContextRoute]? 
    static var routes: [ContextRoute] { 
     get { 
      if let storedRoutes = storedRoutes { 
       return storedRoutes 
      } 

      let routables: [ContextRoutable.Type] = classes(implementing: ContextRoutable.self) 
      let newRoutes = routables.map { routable in routable.route } 

      storedRoutes = newRoutes 

      return newRoutes 
     } 
    } 

    private class func classes<T>(implementing objcProtocol: Protocol) -> [T] { 
     let classes = classList().flatMap { objcClass in objcClass as? T } 

     return classes 
    } 

    private class func classList() -> [AnyObject] { 
     let expectedClassCount = objc_getClassList(nil, 0) 
     let allClasses = UnsafeMutablePointer<AnyClass?>.allocate(capacity: Int(expectedClassCount)) 
     let autoreleasingAllClasses = AutoreleasingUnsafeMutablePointer<AnyClass?>(allClasses) 
     let actualClassCount:Int32 = objc_getClassList(autoreleasingAllClasses, expectedClassCount) 

     var classes = [AnyObject]() 
     for i in 0 ..< actualClassCount { 
      if let currentClass: AnyClass = allClasses[Int(i)], 
       class_conformsToProtocol(currentClass, ContextRoutable.self) { 
        classes.append(currentClass) 
      } 
     } 

     allClasses.deallocate(capacity: Int(expectedClassCount)) 

     return classes 
    } 
} 

ho provato nella mia richiesta e funziona. L'ho cronometrato nel simulatore e ci vogliono 0,05 secondi per un'applicazione che ha circa 12000 classi.