À l'aide d'un dispatch_once singleton modèle Swift

tl;dr: Utiliser le constante de classe approche si vous utilisez Swift 1.2 ou supérieur et de la imbriquée struct approche si vous avez besoin de support des versions antérieures.

De mon expérience avec Swift il y a trois méthodes pour implémenter le pattern Singleton qui prennent en charge l'initialisation tardive et du fil de sécurité.

Constante de classe

class Singleton  {
   static let sharedInstance = Singleton()
}

Cette approche prend en charge l'initialisation tardive parce que Swift paresseusement initialise les constantes de classe (et variables), et est thread-safe par la définition de let. C'est maintenant officiellement recommandé pour instancier un singleton.

Des constantes de classe ont été introduites dans Swift 1.2. Si vous avez besoin de l'appui d'une version antérieure de Swift, utilisez le imbriquée struct approche ci-dessous ou à une constante globale.

Imbriquée struct

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

Nous voici à l'aide de la constante statique d'un imbriquée struct comme une constante de classe. C'est une solution de contournement pour le manque de classe statique constantes dans Swift 1.1 et versions antérieures, et travaille toujours comme une solution de contournement pour le manque de statique des constantes et des variables dans les fonctions.

dispatch_once

La traditionnelle Objective-C approche porté à Swift. Je suis assez certain que il n'y a aucun avantage sur le imbriquée struct approche, mais je suis en train de mettre ici de toute façon comme je l'ai trouver les différences dans la syntaxe intéressant.

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

Voir ce GitHub projet pour les tests unitaires.

OriginalL'auteur hpique

Pour Swift 1.2 et au-delà:

class Singleton  {
   static let sharedInstance = Singleton()
}

Avec une preuve de la justesse (tout le crédit va ici), il y a peu de raison maintenant utiliser une des méthodes précédentes pour les singletons.

Mise à jour: C'est maintenant la officiel façon de définir les singletons comme décrit dans la officiel docs!

Que pour des questions sur l'utilisation de static vs class. static devrait être le seul à utiliser même lorsque class variables deviennent disponibles. Les Singletons sont pas destinés à être sous-classé, car le résultat serait dans plusieurs instances de la base de singleton. À l'aide de static applique dans ce une belle, Swifty.

Pour Swift 1.0 et 1.1:

Avec les changements récents de la Swift, la plupart des nouvelles méthodes de contrôle d'accès, je suis maintenant penché vers le moyen le plus propre d'utiliser une variable globale pour les singletons.

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

Comme mentionné dans la Swift article du blog de ici:

Le paresseux initialiseur pour une variable globale (également pour les membres statiques de
les structures et les énumérations) est exécutée la première fois que le mondial est accessible, et
est lancé comme dispatch_once pour s'assurer que l'initialisation est
atomique. Cette mesure est une façon cool pour utiliser dispatch_once dans votre code:
il suffit de déclarer une variable globale avec un initialiseur et marquer
privé.

Cette façon de créer un singleton est thread-safe, rapide, paresseux, et également relié à ObjC gratuitement.

OriginalL'auteur Jack

Il y a une meilleure façon de le faire. Vous pouvez déclarer une variable globale dans votre classe au-dessus de la classe decleration comme

var tpScopeManagerSharedInstance = TPScopeManager()

- Ce juste des appels de votre init par défaut ou n'importe quel init et les variables globales sont dispatch_once par défaut dans Swift. Alors dans quelle catégorie vous souhaitez obtenir une référence, vous faites simplement ceci:

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

Donc, fondamentalement, vous pouvez vous débarrasser de la totalité du bloc de l'instance partagée code.

OriginalL'auteur Kris Gellci

Par la La documentation d'Apple, il a été répété à plusieurs reprises que la meilleure façon de le faire dans Swift est statique type de propriété:

class Singleton {
    static let sharedInstance = Singleton()
}

Toutefois, si vous êtes à la recherche d'un moyen d'effectuer des réglages supplémentaires au-delà d'un simple appel du constructeur, le secret est d'utiliser un immédiatement appelé fermeture:

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

Ceci est garanti pour être thread-safe et initialisées qu'une seule fois.

OriginalL'auteur Adrian Macneil

À la recherche d'Apple est un exemple de code, je suis tombé sur ce modèle. Je ne suis pas sûr de la façon de Swift traite de la statique, mais ce serait thread-safe en C#. - Je inclure à la fois la propriété et la méthode pour Objective-C interop.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

OriginalL'auteur user2485100

Si vous prévoyez sur l'utilisation de votre Swift classe singleton en Objective-C, ce programme d'installation du compilateur de générer de l'Objectif-C-comme en-tête(s):

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

Puis en Objective-C, classe, vous pouvez appeler votre singleton de la façon dont vous l'avez fait dans la pré-Swift jours:

[ImageStore sharedStore];

Ce n'est que mon simple mise en œuvre.

OriginalL'auteur Michael

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

Ensuite l'appeler;

let shared = MySingleton.shared

OriginalL'auteur Kemal Can Kaynak

La meilleure approche dans le Swift 1.2 ci-dessus est une ligne de singleton, -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

De savoir plus de détails sur cette approche, vous pouvez visiter ce lien.

OriginalL'auteur CodeCracker

D'Apple Docs (Swift 3.0.1),

Vous pouvez simplement utiliser un type statique de la propriété, qui est garanti pour être
paresseusement initialisé qu'une seule fois, même lorsque l'on y accède à travers de multiples
threads simultanément:

class Singleton {
    static let sharedInstance = Singleton()
}

Si vous devez effectuer des réglages supplémentaires au-delà de l'initialisation, vous pouvez
affecter le résultat de l'invocation d'une fermeture pour le mondial
constante:

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

OriginalL'auteur sleepwalkerfx

La seule bonne approche est ci-dessous

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

Pour Accéder À

let signleton = Singleton.sharedInstance

Raisons:

• statique type de propriété est garanti pour être initialisées qu'une seule fois, même lorsque l'on y accède à travers plusieurs threads simultanément, donc pas besoin de l'aide de dispatch_once
• De la privatisation de la méthode init de sorte instance ne peut pas être créé par les autres classes.
• classe finale que vous ne souhaitez pas que les autres classes héritent de classe Singleton

OriginalL'auteur applefreak

Ma façon de mise en œuvre de 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")   
}

Accéder à la globalDic à partir de n'importe quel écran de l'application ci-dessous.

Lire:

 println(ConfigurationManager.sharedInstance.globalDic)  

Écrire:

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

OriginalL'auteur user2737730

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

OriginalL'auteur DD.amor

Je suis tombé sur ça, mais j'ai tenu mon singleton pour permettre à l'héritage, et aucune de ces solutions réellement permis.

Alors je suis venu avec cette:

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 cette façon, lorsque vous faites Singleton.sharedInstance() tout d'abord il sera de retour l'instance du Singleton
• Lors SubSingleton.sharedInstance() tout d'abord il sera de retour l'instance de SubSingleton créé.
• Si le dessus est fait, alors SubSingleton.sharedInstance() est un Singleton est vrai et la même instance est utilisée.

Le problème avec ce sale première approche est que je ne peut pas garantir que les sous-classes de mettre en œuvre les dispatch_once_t et assurez-vous que sharedInstanceVar n'est modifié qu'une fois par classe...

Je vais essayer d'affiner encore ce que cela, mais il serait intéressant de voir si quelqu'un a des sentiments forts à l'encontre de ce (outre le fait que c'est verbeux et nécessite de mettre à jour manuellement).

OriginalL'auteur RicardoDuarte

utiliser une variable statique et privé de l'initialiseur de créer une classe singleton.

class MySingletonClass {
static let sharedSingleton = MySingletonClass()
private init() {}
}

OriginalL'auteur Prashant Bhayani

private var sharedURLCacheForRequestsKey:Void?
extension URLCache{
public static func sharedURLCacheForRequests()->URLCache{
var cache = objc_getAssociatedObject(OperationQueue.main, &sharedURLCacheForRequestsKey)
if cache is URLCache {
}else{
cache = URLCache(memoryCapacity: 0, diskCapacity: 1*1024*1024*1024, diskPath: "sharedURLCacheForRequestsKey")
objc_setAssociatedObject(OperationQueue.main, &sharedURLCacheForRequestsKey, cache, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
return cache as! URLCache
}}

OriginalL'auteur Mike