Ich versuche, ein geeignetes Singleton-Modell für die Verwendung in Swift zu erarbeiten. Bisher konnte ich ein nicht threadsicheres Modell wie folgt zum Laufen bringen:

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

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

        return Static.instance!
    }
}

Das Umschließen der Singleton-Instanz in die statische Struktur sollte eine einzelne Instanz ermöglichen, die ohne komplexe Namensschemata nicht mit Singleton-Instanzen kollidiert, und die Dinge ziemlich privat machen. Offensichtlich ist dieses Modell jedoch nicht threadsicher. Also habe ich versucht dispatch_once, das Ganze zu ergänzen :

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

Aber ich bekomme einen Compilerfehler in der dispatch_onceZeile:

Der Ausdruckstyp 'Void' kann nicht in den Typ '()' konvertiert werden.

Ich habe verschiedene Varianten der Syntax ausprobiert, aber alle scheinen die gleichen Ergebnisse zu erzielen:

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

Was ist die richtige Verwendung von dispatch_onceSwift? Ich dachte anfangs, das Problem liege am Block aufgrund ()der Fehlermeldung, aber je mehr ich es mir anschaue, desto mehr denke ich, dass es darum geht, die dispatch_once_trichtige Definition zu erhalten.

tl; dr: Verwenden Sie den Klassenkonstantenansatz, wenn Sie Swift 1.2 oder höher verwenden, und den verschachtelten Strukturansatz , wenn Sie frühere Versionen unterstützen müssen.

Aus meiner Erfahrung mit Swift gibt es drei Ansätze zur Implementierung des Singleton-Musters, die eine verzögerte Initialisierung und Thread-Sicherheit unterstützen.

Klassenkonstante

class Singleton  {
   static let sharedInstance = Singleton()
}

Dieser Ansatz unterstützt die verzögerte Initialisierung, da Swift Klassenkonstanten (und Variablen) träge initialisiert und nach der Definition von threadsicher ist let. Dies ist jetzt offiziell empfohlen, um einen Singleton zu instanziieren.

Klassenkonstanten wurden in Swift 1.2 eingeführt. Wenn Sie eine frühere Version von Swift unterstützen müssen, verwenden Sie den folgenden Ansatz für verschachtelte Strukturen oder eine globale Konstante.

Verschachtelte Struktur

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

Hier verwenden wir die statische Konstante einer verschachtelten Struktur als Klassenkonstante. Dies ist eine Problemumgehung für das Fehlen statischer Klassenkonstanten in Swift 1.1 und früheren Versionen und funktioniert weiterhin als Problemumgehung für das Fehlen statischer Konstanten und Variablen in Funktionen.

dispatch_once

Der traditionelle Objective-C-Ansatz wurde auf Swift portiert. Ich bin mir ziemlich sicher, dass es keinen Vorteil gegenüber dem verschachtelten Strukturansatz gibt, aber ich stelle ihn trotzdem hier, da ich die Unterschiede in der Syntax interessant finde.

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

In diesem GitHub- Projekt finden Sie Unit-Tests.

Da Apple jetzt klargestellt hat, dass statische Strukturvariablen sowohl faul als auch eingewickelt initialisiert werden dispatch_once(siehe Hinweis am Ende des Beitrags), denke ich, dass meine endgültige Lösung sein wird:

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

        return Singleton.instance
    }
}

Dies nutzt die automatische verzögerte, thread-sichere Initialisierung statischer Strukturelemente, verbirgt die tatsächliche Implementierung sicher vor dem Verbraucher, hält alles kompakt für die Lesbarkeit unterteilt und eliminiert eine sichtbare globale Variable.

Apple hat klargestellt, dass Lazy Initialisierer threadsicher sind, sodass keine dispatch_onceoder ähnliche Schutzmaßnahmen erforderlich sind

Der verzögerte Initialisierer für eine globale Variable (auch für statische Elemente von Strukturen und Aufzählungen) wird beim ersten Zugriff auf global ausgeführt und als dispatch_once gestartet, um sicherzustellen, dass die Initialisierung atomar ist. Dies ermöglicht eine coole Möglichkeit, dispatch_once in Ihrem Code zu verwenden: Deklarieren Sie einfach eine globale Variable mit einem Initialisierer und markieren Sie sie als privat.

Von hier aus

Für Swift 1.2 und höher:

class Singleton  {
   static let sharedInstance = Singleton()
}

Mit einem Korrektheitsnachweis (alle Gutschriften gehen hier ) gibt es jetzt kaum einen Grund, eine der vorherigen Methoden für Singletons zu verwenden.

Update : Dies ist jetzt die offizielle Methode, um Singletons zu definieren, wie in den offiziellen Dokumenten beschrieben !

Was Bedenken über die Verwendung staticvs class. staticsollte auch dann verwendet werden, wenn classVariablen verfügbar werden. Singletons sind nicht als Unterklassen gedacht, da dies zu mehreren Instanzen des Basis-Singletons führen würde. Die Verwendung staticerzwingt dies auf eine schöne, schnelle Art und Weise.

Für Swift 1.0 und 1.1:

Mit den jüngsten Änderungen in Swift, den meist neuen Zugriffskontrollmethoden, neige ich jetzt zu einer saubereren Methode, eine globale Variable für Singletons zu verwenden.

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

Wie im Swift-Blog-Artikel hier erwähnt :

Der verzögerte Initialisierer für eine globale Variable (auch für statische Elemente von Strukturen und Aufzählungen) wird beim ersten Zugriff auf global ausgeführt und als dispatch_once gestartet, um sicherzustellen, dass die Initialisierung atomar ist. Dies ermöglicht eine coole Möglichkeit, dispatch_once in Ihrem Code zu verwenden: Deklarieren Sie einfach eine globale Variable mit einem Initialisierer und markieren Sie sie als privat.

Diese Art, einen Singleton zu erstellen, ist threadsicher, schnell, faul und wird auch kostenlos mit ObjC verbunden.

Swift 1.2 oder höher unterstützt jetzt statische Variablen / Konstanten in Klassen. Sie können also einfach eine statische Konstante verwenden:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Es gibt einen besseren Weg, dies zu tun. Sie können eine globale Variable in Ihrer Klasse über der Klassendeklaration wie folgt deklarieren:

var tpScopeManagerSharedInstance = TPScopeManager()

Dies ruft nur Ihren Standard-Init auf oder welche Init- und globalen Variablen dispatch_oncein Swift standardmäßig sind. Dann tun Sie in der Klasse, in der Sie eine Referenz erhalten möchten, einfach Folgendes:

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

Grundsätzlich können Sie also den gesamten Block des gemeinsam genutzten Instanzcodes entfernen.

Swift Singletons sind in dem Cocoa - Frameworks als Klassenfunktionen ausgesetzt, zum Beispiel NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). Daher ist es als Klassenfunktion sinnvoller, dieses Verhalten zu spiegeln, als als Klassenvariable wie bei einigen anderen Lösungen. z.B:

class MyClass {

    private static let _sharedInstance = MyClass()

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

Rufen Sie den Singleton über ab MyClass.sharedInstance().

Gemäß der Apple-Dokumentation wurde mehrfach wiederholt, dass der einfachste Weg, dies in Swift zu tun, eine statische Typ-Eigenschaft ist:

class Singleton {
    static let sharedInstance = Singleton()
}

Wenn Sie jedoch nach einer Möglichkeit suchen, über einen einfachen Konstruktoraufruf hinaus zusätzliche Einstellungen vorzunehmen, besteht das Geheimnis darin, einen sofort aufgerufenen Abschluss zu verwenden:

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

Dies ist garantiert threadsicher und wird nur einmal träge initialisiert.

Swift 4+

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

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

Beim Betrachten des Beispielcodes von Apple bin ich auf dieses Muster gestoßen. Ich bin nicht sicher, wie Swift mit Statik umgeht, aber dies wäre in C # threadsicher. Ich füge sowohl die Eigenschaft als auch die Methode für Objective-C Interop hinzu.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

In Kürze,

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

Möglicherweise möchten Sie Dateien und Initialisierung lesen

Der verzögerte Initialisierer für eine globale Variable (auch für statische Elemente von Strukturen und Aufzählungen) wird beim ersten Zugriff auf global ausgeführt und gestartet dispatch_once, um sicherzustellen, dass die Initialisierung atomar ist.

Wenn Sie planen, Ihre Swift-Singleton-Klasse in Objective-C zu verwenden, generiert der Compiler bei diesem Setup die entsprechenden Objective-C-ähnlichen Header:

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

Dann können Sie in der Objective-C-Klasse Ihren Singleton so nennen, wie Sie es in Tagen vor Swift getan haben:

[ImageStore sharedStore];

Dies ist nur meine einfache Implementierung.

Erste Lösung

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Später in Ihrem Code:

func someFunction() {        
    var socketManager = SocketManager        
}

Zweite Lösung

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

class SocketManagerSingleton {

}

Und später in Ihrem Code können Sie Klammern für weniger Verwirrung behalten:

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

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

Dann nenne es;

let shared = MySingleton.shared

Verwenden:

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

Wie benutzt man:

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

Der beste Ansatz in Swift über 1.2 ist ein einzeiliger Singleton, da -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Um mehr über diesen Ansatz zu erfahren, können Sie diesen Link besuchen .

Aus Apple Docs (Swift 3.0.1),

Sie können einfach eine statische Typ-Eigenschaft verwenden, die garantiert nur einmal träge initialisiert wird, selbst wenn über mehrere Threads gleichzeitig zugegriffen wird:

class Singleton {
    static let sharedInstance = Singleton()
}

Wenn Sie über die Initialisierung hinaus zusätzliche Einstellungen vornehmen müssen, können Sie das Ergebnis des Aufrufs eines Abschlusses der globalen Konstante zuordnen:

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

Ich würde ein vorschlagen enum, wie Sie es in Java verwenden würden, z

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

Nur als Referenz, hier ist ein Beispiel für eine Singleton-Implementierung der Nested Struct-Implementierung von Jack Wu / hpique. Die Implementierung zeigt auch, wie die Archivierung funktionieren könnte, sowie einige begleitende Funktionen. Ich konnte kein vollständiges Beispiel finden, also hilft das hoffentlich jemandem!

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

Und wenn Sie einige dieser Funktionen nicht erkannt haben, finden Sie hier eine kleine lebende Swift-Dienstprogrammdatei, die ich verwendet habe:

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

In Swift können Sie eine Singleton-Klasse folgendermaßen erstellen:

class AppSingleton: NSObject {

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

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

Ich bevorzuge diese Implementierung:

class APIClient {

}

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

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

Meine Art der Implementierung in 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")   

}

Greifen Sie von jedem Bildschirm der Anwendung aus wie folgt auf globalDic zu.

Lesen:

 println(ConfigurationManager.sharedInstance.globalDic)  

Schreiben:

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

Der einzig richtige Ansatz ist unten.

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

    private init() {}
}

Zugreifen

let signleton = Singleton.sharedInstance

Gründe dafür:

• static Die type-Eigenschaft wird garantiert nur einmal träge initialisiert, selbst wenn über mehrere Threads gleichzeitig zugegriffen wird, sodass keine Verwendung erforderlich ist dispatch_once
• Durch die Privatisierung der initMethode kann keine Instanz von anderen Klassen erstellt werden.
• final Klasse, da Sie nicht möchten, dass andere Klassen die Singleton-Klasse erben.

Nachdem Sie Davids Implementierung gesehen haben, scheint es nicht erforderlich zu sein, eine Singleton-Klassenfunktion zu haben, instanceMethodda letdies fast dasselbe tut wie eine sharedInstanceKlassenmethode. Alles was Sie tun müssen, ist es als globale Konstante zu deklarieren und das wäre es.

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

Singleton in der Vergangenheit schnell zu realisieren, ist nichts anderes als die drei Möglichkeiten: globale Variablen, interne Variablen und dispatch_once-Möglichkeiten.

Hier sind zwei gute Singleton. (Hinweis: Unabhängig von der Art des Schreibens muss die Privatisierungsmethode init () beachtet werden. In Swift ist der Konstruktorstandard des Objekts öffentlich, muss neu geschrieben werden. Init kann in privat umgewandelt werden Verhindern Sie standardmäßig andere Objekte dieser Klasse '()', um das Objekt zu erstellen.)

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

Methode 2:

class AppManager {
    static let sharedInstance = AppManager()

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

// How to use?
AppManager.sharedInstance

Dies ist die einfachste mit thread-sicheren Funktionen. Kein anderer Thread kann auf dasselbe Singleton-Objekt zugreifen, selbst wenn er dies wünscht. 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!
        }
    }
}

Ich verlangte von meinem Singleton, dass er die Vererbung zulässt, und keine dieser Lösungen erlaubte dies tatsächlich. Also habe ich mir Folgendes ausgedacht:

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

• Auf diese Weise wird beim Singleton.sharedInstance()ersten Ausführen die Instanz von zurückgegebenSingleton
• Wenn Sie dies SubSingleton.sharedInstance()zuerst tun , wird die Instanz von zurückgegebenSubSingleton .
• Wenn das oben genannte getan wird, SubSingleton.sharedInstance()ist Singletones wahr und es wird dieselbe Instanz verwendet.

Das Problem bei diesem ersten schmutzigen Ansatz ist, dass ich nicht garantieren kann, dass Unterklassen das implementieren dispatch_once_tund sicherstellen, dasssharedInstanceVar es nur einmal pro Klasse geändert wird.

Ich werde versuchen, dies weiter zu verfeinern, aber es wäre interessant zu sehen, ob jemand starke Gefühle dagegen hat (abgesehen von der Tatsache, dass es ausführlich ist und manuell aktualisiert werden muss).

Dies ist meine Implementierung. Außerdem wird verhindert, dass der Programmierer eine neue Instanz erstellt:

let TEST = Test()

class Test {

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

Ich benutze die folgende Syntax:

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

Dies funktioniert von Swift 1.2 bis 4 und hat mehrere Vorteile:

1. Erinnert den Benutzer daran, die Implementierung nicht zu unterklassifizieren
2. Verhindert die Erstellung zusätzlicher Instanzen
3. Gewährleistet eine verzögerte Erstellung und eine einzigartige Instanziierung
4. Verkürzt die Syntax (vermeidet ()), indem der Zugriff auf die Instanz als ermöglicht wird Singleton.instance