Estou tentando elaborar um modelo singleton apropriado para uso no Swift. Até agora, consegui obter um modelo seguro sem thread trabalhando como:

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

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

        return Static.instance!
    }
}

O agrupamento da instância singleton na estrutura estática deve permitir uma única instância que não colide com instâncias singleton sem esquemas de nomenclatura complexos e deve tornar as coisas bastante privadas. Obviamente, porém, este modelo não é seguro para threads. Então, eu tentei adicionar dispatch_onceà coisa toda:

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!
    }
}

Mas eu recebo um erro de compilador na dispatch_oncelinha:

Não é possível converter o tipo da expressão 'Void' em type '()'

Eu tentei várias variantes diferentes da sintaxe, mas todas parecem ter os mesmos resultados:

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

Qual é o uso adequado do dispatch_onceSwift? Inicialmente, pensei que o problema estava no bloco devido à ()mensagem de erro, mas quanto mais olho para ele, mais acho que pode ser uma questão de dispatch_once_tdefinir corretamente.

tl; dr: Use a abordagem de classe constante se você estiver usando o Swift 1.2 ou superior e a abordagem de estrutura aninhada se precisar oferecer suporte a versões anteriores.

Da minha experiência com Swift, existem três abordagens para implementar o padrão Singleton que oferecem suporte à inicialização lenta e à segurança de threads.

Constante de classe

class Singleton  {
   static let sharedInstance = Singleton()
}

Essa abordagem suporta a inicialização lenta porque o Swift inicializa preguiçosamente constantes de classe (e variáveis) e é seguro para threads pela definição de let. Agora é agora oficialmente recomendada a maneira de instanciar um singleton.

As constantes de classe foram introduzidas no Swift 1.2. Se você precisar oferecer suporte a uma versão anterior do Swift, use a abordagem de estrutura aninhada abaixo ou uma constante global.

Estrutura aninhada

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

Aqui estamos usando a constante estática de uma estrutura aninhada como uma constante de classe. Esta é uma solução alternativa para a falta de constantes de classe estática no Swift 1.1 e versões anteriores e ainda funciona como uma solução alternativa para a falta de constantes e variáveis ​​estáticas nas funções.

dispatch_once

A abordagem tradicional de Objective-C foi portada para Swift. Estou bastante certo de que não há vantagem sobre a abordagem de estrutura aninhada, mas estou colocando aqui de qualquer maneira, pois acho as diferenças de sintaxe interessantes.

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!
    }
}

Veja este projeto do GitHub para testes de unidade.

Como a Apple agora esclareceu que as variáveis ​​de estrutura estática são inicializadas preguiçosamente e agrupadas dispatch_once(veja a nota no final do post), acho que minha solução final será:

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

        return Singleton.instance
    }
}

Isso tira proveito da inicialização automática preguiçosa e segura de thread de elementos estáticos, oculta com segurança a implementação real do consumidor, mantém tudo compactamente compartimentado para maior legibilidade e elimina uma variável global visível.

A Apple esclareceu que o inicializador lento é seguro para threads, portanto não há necessidade de dispatch_onceproteções semelhantes

O inicializador lento para uma variável global (também para membros estáticos de estruturas e enumerações) é executado na primeira vez que global é acessado e é iniciado como dispatch_once para garantir que a inicialização seja atômica. Isso permite uma maneira legal de usar dispatch_once no seu código: apenas declare uma variável global com um inicializador e marque-a como privada.

A partir daqui

Para o Swift 1.2 e além:

class Singleton  {
   static let sharedInstance = Singleton()
}

Com uma prova de correção (todo o crédito é válido aqui ), agora há pouco ou nenhum motivo para usar qualquer um dos métodos anteriores para singletons.

Atualização : agora é a maneira oficial de definir singletons, conforme descrito nos documentos oficiais !

Quanto às preocupações sobre o uso staticvs class. staticdeve ser o único a usar, mesmo quando as classvariáveis ​​se tornam disponíveis. Singletons não devem ser subclassificados, pois isso resultaria em várias instâncias do singleton base. O uso staticreforça isso de uma maneira bonita e rápida.

Para Swift 1.0 e 1.1:

Com as recentes mudanças no Swift, principalmente os novos métodos de controle de acesso, agora estou me inclinando para uma maneira mais limpa de usar uma variável global para singletons.

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

Como mencionado no artigo do blog Swift aqui :

O inicializador lento para uma variável global (também para membros estáticos de estruturas e enumerações) é executado na primeira vez que global é acessado e é iniciado como dispatch_once para garantir que a inicialização seja atômica. Isso permite uma maneira legal de usar dispatch_once no seu código: apenas declare uma variável global com um inicializador e marque-a como privada.

Essa maneira de criar um singleton é segura, rápida, preguiçosa e também é conectada ao ObjC gratuitamente.

O Swift 1.2 ou posterior agora suporta variáveis ​​estáticas / constantes nas classes. Então você pode simplesmente usar uma constante estática:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Existe uma maneira melhor de fazer isso. Você pode declarar uma variável global em sua classe acima da declaração de classe desta forma:

var tpScopeManagerSharedInstance = TPScopeManager()

Isso apenas chama seu init padrão ou quaisquer variáveis ​​globais e init dispatch_oncepor padrão no Swift. Em qualquer classe que você deseja obter uma referência, basta fazer o seguinte:

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

Então, basicamente, você pode se livrar de todo o bloco de código de instância compartilhada.

Swift únicos estão expostos nos quadros de cacau como funções de classe, por exemplo NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). Portanto, faz mais sentido, como uma função de classe, espelhar esse comportamento, em vez de uma variável de classe, como algumas outras soluções. por exemplo:

class MyClass {

    private static let _sharedInstance = MyClass()

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

Recupere o singleton via MyClass.sharedInstance().

De acordo com a documentação da Apple , foi repetido várias vezes que a maneira mais fácil de fazer isso no Swift é com uma propriedade de tipo estático:

class Singleton {
    static let sharedInstance = Singleton()
}

No entanto, se você estiver procurando uma maneira de executar configurações adicionais além de uma simples chamada de construtor, o segredo é usar um fechamento imediatamente invocado:

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

Isso garante a segurança de threads e é inicializado preguiçosamente apenas uma vez.

Swift 4+

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

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

Olhando para o código de exemplo da Apple, me deparei com esse padrão. Não tenho certeza de como o Swift lida com estática, mas isso seria seguro para threads em C #. Incluo a propriedade e o método para interoperabilidade Objective-C.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

Em resumo,

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

Você pode querer ler Arquivos e Inicialização

O inicializador lento para uma variável global (também para membros estáticos de estruturas e enumerações) é executado na primeira vez que o global é acessado e é iniciado dispatch_oncepara garantir que a inicialização seja atômica.

Se você planeja usar sua classe de singleton Swift no Objective-C, essa configuração fará com que o compilador gere cabeçalhos apropriados do tipo Objective-C:

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

Em seguida, na classe Objective-C, você pode chamar seu singleton da maneira que fez nos dias pré-Swift:

[ImageStore sharedStore];

Esta é apenas minha implementação simples.

Primeira solução

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Posteriormente no seu código:

func someFunction() {        
    var socketManager = SocketManager        
}

Segunda solução

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

class SocketManagerSingleton {

}

E mais tarde no seu código, você será capaz de manter chaves para menos confusão:

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

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

Então chame;

let shared = MySingleton.shared

Usar:

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!
        }
    }
}

Como usar:

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

A melhor abordagem no Swift acima de 1,2 é um singleton de uma linha, pois -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Para saber mais detalhes sobre essa abordagem, visite este link .

No Apple Docs (Swift 3.0.1),

Você pode simplesmente usar uma propriedade de tipo estático, que garante a inicialização lenta apenas uma vez, mesmo quando acessado por vários threads simultaneamente:

class Singleton {
    static let sharedInstance = Singleton()
}

Se você precisar executar configurações adicionais além da inicialização, poderá atribuir o resultado da chamada de um fechamento à constante global:

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

Eu sugeriria um enum, como você usaria em Java, por exemplo

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

Apenas para referência, aqui está um exemplo de implementação Singleton da implementação Nested Struct de Jack Wu / hpique. A implementação também mostra como o arquivamento poderia funcionar, bem como algumas funções associadas. Não consegui encontrar este exemplo completo, por isso espero que ajude alguém!

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)
    }
}

E se você não reconheceu algumas dessas funções, aqui está um pequeno arquivo utilitário do Swift que estou 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()
    }
}

No swift, você pode criar uma classe singleton da seguinte maneira:

class AppSingleton: NSObject {

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

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

Eu prefiro esta implementação:

class APIClient {

}

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

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

Minha maneira de implementar no 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")   

}

Acesse o globalDic em qualquer tela do aplicativo abaixo.

Ler:

 println(ConfigurationManager.sharedInstance.globalDic)  

Escreva:

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

A única abordagem correta está abaixo.

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

    private init() {}
}

Acessar

let signleton = Singleton.sharedInstance

Razões:

• static A propriedade type é garantida para ser inicializada lentamente apenas uma vez, mesmo quando acessada por vários threads simultaneamente, portanto, não é necessário usar dispatch_once
• Privatizando o initmétodo para que a instância não possa ser criada por outras classes.
• final classe como você não deseja que outras classes herdem a classe Singleton.

Depois de ver a implementação de David, parece que não há necessidade de ter uma função de classe singleton, instanceMethodpois letestá fazendo praticamente a mesma coisa que um sharedInstancemétodo de classe. Tudo o que você precisa fazer é declará-lo como uma constante global e seria isso.

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!
}

Swift para perceber singleton no passado, nada mais é do que as três maneiras: variáveis ​​globais, variáveis ​​internas e expedição_ de uma maneira.

Aqui estão dois bons singleton. (Nota: não importa que tipo de escrita deve prestar atenção ao método init () de privatização.Por causa do Swift, todo o padrão de construtor do objeto é público, precisa ser reescrito init pode ser transformado em private , impeça outros objetos dessa classe '()' por método de inicialização padrão para criar o 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 é o mais simples, com recursos seguros para threads. Nenhum outro encadeamento pode acessar o mesmo objeto singleton, mesmo que deseje. 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!
        }
    }
}

Eu exigi que meu singleton permitisse a herança, e nenhuma dessas soluções permitia. Então, eu vim com isso:

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
    }
}

• Dessa forma, ao fazer o Singleton.sharedInstance()primeiro, retornará a instância deSingleton
• Ao fazer o SubSingleton.sharedInstance()primeiro, retornará a instância de SubSingletoncreated.
• Se o acima for feito, então SubSingleton.sharedInstance()é Singletoné verdadeira e a mesma instância é utilizada.

O problema com essa primeira abordagem suja é que não posso garantir que as subclasses implementem dispatch_once_te assegurem que isso sharedInstanceVarseja modificado apenas uma vez por classe.

Vou tentar refinar isso ainda mais, mas seria interessante ver se alguém tem fortes sentimentos contra isso (além do fato de que é detalhado e requer atualizá-lo manualmente).

Esta é a minha implementação. Também impede que o programador crie uma nova instância:

let TEST = Test()

class Test {

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

Eu uso a seguinte sintaxe:

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()
    }
}

Isso funciona do Swift 1.2 até o 4 e tem várias vantagens:

1. Lembra o usuário de não subclassificar a implementação
2. Impede a criação de instâncias adicionais
3. Garante criação lenta e instanciação única
4. Reduz a sintaxe (evita ()) permitindo acessar a instância como Singleton.instance