Estoy tratando de encontrar un modelo singleton apropiado para usar en Swift. Hasta ahora, he podido obtener un modelo seguro sin subprocesos que funciona como:

class var sharedInstance: TPScopeManager {
    get {
        struct Static {
            static var instance: TPScopeManager? = nil
        }

        if !Static.instance {
            Static.instance = TPScopeManager()
        }

        return Static.instance!
    }
}

Ajustar la instancia singleton en la estructura Estática debería permitir una instancia única que no colisione con instancias singleton sin esquemas de nombres complejos, y debería hacer que las cosas sean bastante privadas. Obviamente, este modelo no es seguro para subprocesos. Así que traté de agregar dispatch_oncea todo el asunto:

class var sharedInstance: TPScopeManager {
    get {
        struct Static {
            static var instance: TPScopeManager? = nil
            static var token: dispatch_once_t = 0
        }

        dispatch_once(Static.token) { Static.instance = TPScopeManager() }

        return Static.instance!
    }
}

Pero me sale un error del compilador en la dispatch_oncelínea:

No se puede convertir el tipo de expresión 'Void' a tipo '()'

He probado varias variantes diferentes de la sintaxis, pero todas parecen tener los mismos resultados:

dispatch_once(Static.token, { Static.instance = TPScopeManager() })

¿Cuál es el uso adecuado del uso de dispatch_onceSwift? Inicialmente pensé que el problema estaba en el bloque debido al ()mensaje de error, pero cuanto más lo miro, más creo que puede ser una cuestión de dispatch_once_tdefinirlo correctamente.

tl; dr: utilice el enfoque de clase constante si está utilizando Swift 1.2 o superior y el enfoque de estructura anidada si necesita admitir versiones anteriores.

Según mi experiencia con Swift, existen tres enfoques para implementar el patrón Singleton que admiten la inicialización diferida y la seguridad de subprocesos.

Constante de clase

class Singleton  {
   static let sharedInstance = Singleton()
}

Este enfoque admite la inicialización diferida porque Swift inicializa perezosamente las constantes de clase (y variables), y es seguro para subprocesos según la definición de let. Esta es ahora la forma oficialmente recomendada de instanciar un singleton.

Las constantes de clase se introdujeron en Swift 1.2. Si necesita admitir una versión anterior de Swift, use el siguiente enfoque de estructura anidada o una constante global.

Estructura anidada

class Singleton {
    class var sharedInstance: Singleton {
        struct Static {
            static let instance: Singleton = Singleton()
        }
        return Static.instance
    }
}

Aquí estamos usando la constante estática de una estructura anidada como una constante de clase. Esta es una solución para la falta de constantes de clase estática en Swift 1.1 y versiones anteriores, y aún funciona como una solución para la falta de constantes estáticas y variables en las funciones.

despacho_una vez

El enfoque tradicional de Objective-C portado a Swift. Estoy bastante seguro de que no hay ninguna ventaja sobre el enfoque de estructura anidada, pero lo pongo aquí de todos modos porque encuentro interesantes las diferencias en la sintaxis.

class Singleton {
    class var sharedInstance: Singleton {
        struct Static {
            static var onceToken: dispatch_once_t = 0
            static var instance: Singleton? = nil
        }
        dispatch_once(&Static.onceToken) {
            Static.instance = Singleton()
        }
        return Static.instance!
    }
}

Vea este proyecto de GitHub para pruebas unitarias.

Dado que Apple ahora ha aclarado que las variables de estructura estática se inicializan tanto de forma diferida como envuelta dispatch_once(vea la nota al final de la publicación), creo que mi solución final será:

class WithSingleton {
    class var sharedInstance: WithSingleton {
        struct Singleton {
            static let instance = WithSingleton()
        }

        return Singleton.instance
    }
}

Esto aprovecha la inicialización automática perezosa y segura de subprocesos de elementos de estructura estática, oculta de forma segura la implementación real del consumidor, mantiene todo compartimentado de forma compacta para la legibilidad y elimina una variable global visible.

Apple ha aclarado que el inicializador perezoso es seguro para subprocesos, por lo que no hay necesidad de dispatch_onceprotecciones similares

El inicializador diferido para una variable global (también para miembros estáticos de estructuras y enumeraciones) se ejecuta la primera vez que se accede a global, y se inicia como dispatch_once para asegurarse de que la inicialización sea atómica. Esto permite una forma genial de usar dispatch_once en su código: simplemente declare una variable global con un inicializador y márquelo como privado.

Desde aqui

Para Swift 1.2 y más allá:

class Singleton  {
   static let sharedInstance = Singleton()
}

Con una prueba de corrección (todo el crédito va aquí ), ahora hay poca o ninguna razón para usar cualquiera de los métodos anteriores para los singletons.

Actualización : ¡Esta es ahora la forma oficial de definir singletons como se describe en los documentos oficiales !

En cuanto a las preocupaciones sobre el uso staticvs class. staticdebe ser el que se debe usar incluso cuando las classvariables estén disponibles. Los singletons no están destinados a ser subclase ya que eso daría lugar a múltiples instancias del singleton base. El uso statichace cumplir esto de una manera hermosa y rápida.

Para Swift 1.0 y 1.1:

Con los cambios recientes en Swift, en su mayoría nuevos métodos de control de acceso, ahora me estoy inclinando hacia una forma más limpia de usar una variable global para singletons.

private let _singletonInstance = SingletonClass()
class SingletonClass {
  class var sharedInstance: SingletonClass {
    return _singletonInstance
  }
}

Como se menciona en el artículo del blog Swift aquí :

El inicializador diferido para una variable global (también para miembros estáticos de estructuras y enumeraciones) se ejecuta la primera vez que se accede a global, y se inicia como dispatch_once para asegurarse de que la inicialización sea atómica. Esto permite una forma genial de usar dispatch_once en su código: simplemente declare una variable global con un inicializador y márquelo como privado.

Esta forma de crear un singleton es segura para subprocesos, rápida, perezosa y también enlazada a ObjC de forma gratuita.

Swift 1.2 o posterior ahora admite variables / constantes estáticas en las clases. Entonces puedes usar una constante estática:

class MySingleton {

    static let sharedMySingleton = MySingleton()

    private init() {
        // ...
    }
}

Hay una mejor manera de hacerlo. Puede declarar una variable global en su clase sobre la declaración de clase de esta manera:

var tpScopeManagerSharedInstance = TPScopeManager()

Esto solo llama a su init predeterminado o cualquier variable init y global que esté dispatch_oncepor defecto en Swift. Luego, en cualquier clase que desee obtener una referencia, simplemente haga esto:

var refrence = tpScopeManagerSharedInstance
// or you can just access properties and call methods directly
tpScopeManagerSharedInstance.someMethod()

Así que básicamente puedes deshacerte de todo el bloque de código de instancia compartido.

Singletons Swift están expuestos en los marcos de cacao como funciones de la clase, por ejemplo NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). Por lo tanto, tiene más sentido como una función de clase para reflejar este comportamiento, en lugar de una variable de clase como algunas otras soluciones. p.ej:

class MyClass {

    private static let _sharedInstance = MyClass()

    class func sharedInstance() -> MyClass {
        return _sharedInstance
    }
}

Recupere el singleton vía MyClass.sharedInstance().

Según la documentación de Apple , se ha repetido muchas veces que la forma más fácil de hacer esto en Swift es con una propiedad de tipo estático:

class Singleton {
    static let sharedInstance = Singleton()
}

Sin embargo, si está buscando una forma de realizar una configuración adicional más allá de una simple llamada de constructor, el secreto es usar un cierre invocado de inmediato:

class Singleton {
    static let sharedInstance: Singleton = {
        let instance = Singleton()
        // setup code
        return instance
    }()
}

Esto está garantizado para ser seguro para subprocesos y vagamente inicializado solo una vez.

Swift 4+

protocol Singleton: class {
    static var sharedInstance: Self { get }
}

final class Kraken: Singleton {
    static let sharedInstance = Kraken()
    private init() {}
}

Mirando el código de muestra de Apple me encontré con este patrón. No estoy seguro de cómo Swift trata las estadísticas, pero esto sería seguro para subprocesos en C #. Incluyo tanto la propiedad como el método para la interoperabilidad Objective-C.

struct StaticRank {
    static let shared = RankMapping()
}

class func sharedInstance() -> RankMapping {
    return StaticRank.shared
}

class var shared:RankMapping {
    return StaticRank.shared
}

En breve,

class Manager {
    static let sharedInstance = Manager()
    private init() {}
}

Es posible que desee leer archivos e inicialización

El inicializador diferido para una variable global (también para miembros estáticos de estructuras y enumeraciones) se ejecuta la primera vez que se accede a global y se inicia dispatch_oncepara asegurarse de que la inicialización sea atómica.

Si está planeando usar su clase de singleton Swift en Objective-C, esta configuración hará que el compilador genere los encabezados apropiados de tipo Objective-C:

class func sharedStore() -> ImageStore {
struct Static {
    static let instance : ImageStore = ImageStore()
    }
    return Static.instance
}

Luego, en la clase Objective-C, puede llamar a su singleton de la manera en que lo hizo en los días previos a Swift:

[ImageStore sharedStore];

Esta es solo mi implementación simple.

Primera solución

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Más adelante en su código:

func someFunction() {        
    var socketManager = SocketManager        
}

Segunda solución

func SocketManager() -> SocketManagerSingleton {
    return _SocketManager
}
let _SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Y más adelante en su código podrá mantener llaves para menos confusión:

func someFunction() {        
    var socketManager = SocketManager()        
}

final class MySingleton {
     private init() {}
     static let shared = MySingleton()
}

Entonces llámalo;

let shared = MySingleton.shared

Utilizar:

class UtilSingleton: NSObject {

    var iVal: Int = 0

    class var shareInstance: UtilSingleton {
        get {
            struct Static {
                static var instance: UtilSingleton? = nil
                static var token: dispatch_once_t = 0
            }
            dispatch_once(&Static.token, {
                Static.instance = UtilSingleton()
            })
            return Static.instance!
        }
    }
}

Cómo utilizar:

UtilSingleton.shareInstance.iVal++
println("singleton new iVal = \(UtilSingleton.shareInstance.iVal)")

El mejor enfoque en Swift por encima de 1.2 es un singleton de una línea, como:

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Para conocer más detalles sobre este enfoque, puede visitar este enlace .

De Apple Docs (Swift 3.0.1),

Simplemente puede usar una propiedad de tipo estático, que se garantiza que se inicializa perezosamente solo una vez, incluso cuando se accede a través de varios subprocesos simultáneamente:

class Singleton {
    static let sharedInstance = Singleton()
}

Si necesita realizar una configuración adicional más allá de la inicialización, puede asignar el resultado de la invocación de un cierre a la constante global:

class Singleton {
    static let sharedInstance: Singleton = {
        let instance = Singleton()
        // setup code
        return instance
    }()
}

Sugeriría un enum, como lo usaría en Java, por ejemplo

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

Solo como referencia, aquí hay un ejemplo de implementación Singleton de la implementación de Nested Struct de Jack Wu / hpique. La implementación también muestra cómo podría funcionar el archivado, así como algunas funciones que lo acompañan. No pude encontrar este ejemplo completo, ¡así que espero que esto ayude a alguien!

import Foundation

class ItemStore: NSObject {

    class var sharedStore : ItemStore {
        struct Singleton {
            // lazily initiated, thread-safe from "let"
            static let instance = ItemStore()
        }
        return Singleton.instance
    }

    var _privateItems = Item[]()
    // The allItems property can't be changed by other objects
    var allItems: Item[] {
        return _privateItems
    }

    init() {
        super.init()
        let path = itemArchivePath
        // Returns "nil" if there is no file at the path
        let unarchivedItems : AnyObject! = NSKeyedUnarchiver.unarchiveObjectWithFile(path)

        // If there were archived items saved, set _privateItems for the shared store equal to that
        if unarchivedItems {
            _privateItems = unarchivedItems as Array<Item>
        } 

        delayOnMainQueueFor(numberOfSeconds: 0.1, action: {
            assert(self === ItemStore.sharedStore, "Only one instance of ItemStore allowed!")
        })
    }

    func createItem() -> Item {
        let item = Item.randomItem()
        _privateItems.append(item)
        return item
    }

    func removeItem(item: Item) {
        for (index, element) in enumerate(_privateItems) {
            if element === item {
                _privateItems.removeAtIndex(index)
                // Delete an items image from the image store when the item is 
                // getting deleted
                ImageStore.sharedStore.deleteImageForKey(item.itemKey)
            }
        }
    }

    func moveItemAtIndex(fromIndex: Int, toIndex: Int) {
        _privateItems.moveObjectAtIndex(fromIndex, toIndex: toIndex)
    }

    var itemArchivePath: String {
        // Create a filepath for archiving
        let documentDirectories = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true)
        // Get the one document directory from that list
        let documentDirectory = documentDirectories[0] as String
        // append with the items.archive file name, then return
        return documentDirectory.stringByAppendingPathComponent("items.archive")
    }

    func saveChanges() -> Bool {
        let path = itemArchivePath
        // Return "true" on success
        return NSKeyedArchiver.archiveRootObject(_privateItems, toFile: path)
    }
}

Y si no reconoció algunas de esas funciones, aquí hay un pequeño archivo de utilidad Swift vivo que he estado usando:

import Foundation
import UIKit

typealias completionBlock = () -> ()

extension Array {
    func contains(#object:AnyObject) -> Bool {
        return self.bridgeToObjectiveC().containsObject(object)
    }

    func indexOf(#object:AnyObject) -> Int {
        return self.bridgeToObjectiveC().indexOfObject(object)
    }

    mutating func moveObjectAtIndex(fromIndex: Int, toIndex: Int) {
        if ((fromIndex == toIndex) || (fromIndex > self.count) ||
            (toIndex > self.count)) {
                return
        }
        // Get object being moved so it can be re-inserted
        let object = self[fromIndex]

        // Remove object from array
        self.removeAtIndex(fromIndex)

        // Insert object in array at new location
        self.insert(object, atIndex: toIndex)
    }
}

func delayOnMainQueueFor(numberOfSeconds delay:Double, action closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue()) {
            closure()
    }
}

En swift, puede crear una clase singleton de la siguiente manera:

class AppSingleton: NSObject {

    //Shared instance of class
    static let sharedInstance = AppSingleton()

    override init() {
        super.init()
    }
}

Prefiero esta implementación:

class APIClient {

}

var sharedAPIClient: APIClient = {
    return APIClient()
}()

extension APIClient {
    class func sharedClient() -> APIClient {
        return sharedAPIClient
    }
}

Mi forma de implementación en Swift ...

ConfigurationManager.swift

import Foundation

    let ConfigurationManagerSharedInstance = ConfigurationManager()
 class ConfigurationManager : NSObject {
    var globalDic: NSMutableDictionary = NSMutableDictionary()

class var sharedInstance:ConfigurationManager {
    return ConfigurationManagerSharedInstance

}

init() {

    super.init()

    println ("Config Init been Initiated, this will be called only onece irrespective of many calls")   

}

Acceda a globalDic desde cualquier pantalla de la aplicación de la siguiente manera.

Leer:

 println(ConfigurationManager.sharedInstance.globalDic)  

Escribir:

 ConfigurationManager.sharedInstance.globalDic = tmpDic // tmpDict is any value that to be shared among the application

El único enfoque correcto está por debajo.

final class Singleton {
    static let sharedInstance: Singleton = {
        let instance = Singleton()
        // setup code if anything
        return instance
    }()

    private init() {}
}

Acceder

let signleton = Singleton.sharedInstance

Razones:

• static Se garantiza que la propiedad de tipo se inicialice perezosamente solo una vez, incluso cuando se accede a través de varios subprocesos simultáneamente, por lo que no es necesario usar dispatch_once
• Privatizar el initmétodo para que otras clases no puedan crear la instancia.
• final clase ya que no desea que otras clases hereden la clase Singleton.

Después de ver la implementación de David, parece que no hay necesidad de tener una función de clase singleton instanceMethodya que letestá haciendo más o menos lo mismo que un sharedInstancemétodo de clase. Todo lo que necesita hacer es declararlo como una constante global y eso sería todo.

let gScopeManagerSharedInstance = ScopeManager()

class ScopeManager {
   // No need for a class method to return the shared instance. Use the gScopeManagerSharedInstance directly. 
}

   func init() -> ClassA {
    struct Static {
        static var onceToken : dispatch_once_t = 0
        static var instance : ClassA? = nil
    }

    dispatch_once(&Static.onceToken) {
        Static.instance = ClassA()
    }

    return Static.instance!
}

Rápido para darse cuenta de singleton en el pasado, no es más que las tres formas: variables globales, variables internas y formas de despacho.

Aquí hay dos buenos singleton. (Nota: no importa qué tipo de escritura deba prestar atención al método de privatización init (). Debido a que en Swift, todo el constructor predeterminado del objeto es público, debe reescribirse init puede convertirse en privado , evitar otros objetos de esta clase '()' por defecto método de inicialización para crear el objeto.)

Método 1:

class AppManager {
    private static let _sharedInstance = AppManager()

    class func getSharedInstance() -> AppManager {
       return _sharedInstance
    }

    private init() {} // Privatizing the init method
}

// How to use?
AppManager.getSharedInstance()

Método 2:

class AppManager {
    static let sharedInstance = AppManager()

    private init() {} // Privatizing the init method
}

// How to use?
AppManager.sharedInstance

Este es el más simple con capacidades seguras para subprocesos. Ningún otro hilo puede acceder al mismo objeto singleton, incluso si lo desean. Swift 3/4

struct DataService {

    private static var _instance : DataService?

    private init() {}   //cannot initialise from outer class

    public static var instance : DataService {
        get {
            if _instance == nil {
                DispatchQueue.global().sync(flags: .barrier) {
                    if _instance == nil {
                        _instance = DataService()
                    }
                }
            }
            return _instance!
        }
    }
}

Requerí que mi singleton permitiera la herencia, y ninguna de estas soluciones realmente lo permitió. Entonces se me ocurrió esto:

public class Singleton {
    private static var sharedInstanceVar = Singleton()

    public class func sharedInstance() -> Singleton {
        return sharedInstanceVar
    }
}


public class SubSingleton: Singleton {

    private static var sharedInstanceToken: dispatch_once_t = 0

    public class override func sharedInstance() -> SubSingleton {
        dispatch_once(&sharedInstanceToken) {
            sharedInstanceVar = SubSingleton()
        }
    return sharedInstanceVar as! SubSingleton
    }
}

• De esta manera, al hacer Singleton.sharedInstance()primero, devolverá la instancia deSingleton
• Al hacer SubSingleton.sharedInstance()primero devolverá la instancia deSubSingleton created.
• Si se hace lo anterior, a continuación, SubSingleton.sharedInstance()es Singletones verdadera y se utiliza la misma instancia.

El problema con este primer enfoque sucio es que no puedo garantizar que las subclases implementen dispatch_once_ty me asegure de quesharedInstanceVar solo se modifique una vez por clase.

Intentaré refinar esto aún más, pero sería interesante ver si alguien tiene fuertes sentimientos en contra de esto (además del hecho de que es detallado y requiere actualizarlo manualmente).

Esta es mi implementación. También evita que el programador cree una nueva instancia:

let TEST = Test()

class Test {

    private init() {
        // This is a private (!) constructor
    }
}

Yo uso la siguiente sintaxis:

public final class Singleton {    
    private class func sharedInstance() -> Singleton {
        struct Static {
            //Singleton instance.
            static let sharedInstance = Singleton()
        }
        return Static.sharedInstance
    }

    private init() { }

    class var instance: Singleton {
        return sharedInstance()
    }
}

Esto funciona desde Swift 1.2 hasta 4, y tiene varias ventajas:

1. Le recuerda al usuario que no subclase la implementación
2. Impide la creación de instancias adicionales
3. Asegura una creación perezosa y una instanciación única
4. Acorta la sintaxis (evita ()) al permitir acceder a la instancia como Singleton.instance