Mit einem dispatch_once singleton-Modell in Swift

Da Apple hat nun klargestellt, dass static struct-Variablen initialisiert sind beide faul und eingewickelt in dispatch_once (siehe die Anmerkung am Ende der post), ich glaube, dass meine endgültige Lösung sein wird:

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

        return Singleton.instance
    }
}

Dieser nutzt die automatische faul, thread-sichere Initialisierung von static struct-Elemente, sicher versteckt die eigentliche Implementierung Verbraucher aus, hält alles kompakt unterteilte für die Lesbarkeit und verhindert eine sichtbare Globale variable.

Apple hat klargestellt, dass die lazy-Initialisierung sind thread-sicher, so gibt es keine Notwendigkeit für dispatch_once oder ähnlichen Schutz

Lazy-Initialisierung für eine Globale variable (auch für statische member von structs und enums) zum ersten mal ausgeführt wird, die global zugegriffen wird, und startet dispatch_once, um sicherzustellen, dass die Initialisierung atomar ist. Dies ermöglicht es, eine Coole Art zu verwenden dispatch_once in deinem code: nur deklarieren Sie eine Globale variable mit Initialisierung und markieren Sie es als privat.

Vom hier

InformationsquelleAutor

Swift 1.2 oder höher unterstützt nun statische Variablen/Konstanten in Klassen. So können Sie einfach verwenden einen statischen Konstanten:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

InformationsquelleAutor Florian

Swift singletons ausgesetzt sind, in die Cocoa-frameworks Funktionen der Klasse, z.B. NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(), also ich finde es macht mehr Sinn, als eine Klasse Funktion zum spiegeln dieses Verhalten, anstatt eine Klasse variable, wie einige andere Lösungen, z.B. mit

class MyClass {

    private static let _sharedInstance = MyClass()

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

Abrufen der singleton über MyClass.sharedInstance().

InformationsquelleAutor Ryan

Swift 4+

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

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

InformationsquelleAutor Adam Smaka

In kurzen,

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

Möchten Sie vielleicht zu Lesen Dateien und Initialisierung

Lazy-Initialisierung für eine Globale variable (auch für statische Mitglieder
structs und enums) zum ersten mal ausgeführt wird, die global zugegriffen wird, und
ist gestartet als dispatch_once um sicherzustellen, dass die Initialisierung ist
atomic.

InformationsquelleAutor onmyway133

Erste Lösung

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Später im code:

func someFunction() {        
    var socketManager = SocketManager        
}

Zweite Lösung

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

class SocketManagerSingleton {

}

Und später im code werden Sie in der Lage zu halten, Klammern für weniger Verwirrung:

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

InformationsquelleAutor Nicolas Manzini

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 zu verwenden:

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

InformationsquelleAutor Kingiol

Ich würde vorschlagen, ein Enum, wie Sie in Java, z.B.:

enum SharedTPScopeManager: TPScopeManager {
  case Singleton
}

InformationsquelleAutor Howard Lovatt

Nur als Referenz, hier ist ein Beispiel Singleton-Implementierung von Jack Wu/hpique Verschachtelten Struct Umsetzung. Die Umsetzung zeigt auch, wie die Archivierung arbeiten konnte, sowie einige begleitende Funktionen. Ich konnte nicht finden, dass dieses komplette ein Beispiel, ich hoffe das hilft 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 nicht erkennen, einige jener Funktionen, hier ist eine kleine Wohn-Swift-utility-Datei, die ich benutzt 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()
    }
}

InformationsquelleAutor SchoonSauce

Ziehe ich diese Umsetzung:

class APIClient {

}

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

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

InformationsquelleAutor Viktor Radchenko

Sehen, nachdem David die Umsetzung, wie es scheint, gibt es keine Notwendigkeit zu haben, eine singleton-Klasse Funktion instanceMethod seit let ist schon ziemlich viel die gleiche Sache wie eine sharedInstance-Klasse-Methode. Alles, was Sie tun müssen, ist, deklarieren Sie Sie als Globale Konstante 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. 
}

InformationsquelleAutor Essa A. Haddad

Swift zu erkennen, singleton in der Vergangenheit, ist nichts anderes als die drei Möglichkeiten: Globale Variablen, interne Variablen und dispatch_once Möglichkeiten.

Hier sind zwei gute singleton.(Hinweis: egal, welche Art von schreiben müssen, achten Sie auf die init () - Methode der Privatisierung.Weil in Swift, alle Objekt-Konstruktor standardmäßig ist die öffentlichkeit, die neu geschrieben werden muss init kann sich in private, verhindern, dass andere Objekte von dieser Klasse '()' by default-Initialisierung-Methode 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

InformationsquelleAutor Tim

Dies ist die einfachste, die mit einer thread-safe-Funktionen. Kein anderer thread Zugriff auf die gleichen singleton-Objekt, auch wenn Sie wollen. 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!
        }
    }
}

InformationsquelleAutor Abhishek Biswas

Dies ist meine Umsetzung. Es verhindert auch, dass die Programmierer vom erstellen einer neuen Instanz:

let TEST = Test()

class Test {

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

InformationsquelleAutor Yedidya Reiss

Ich Neige dazu, verwenden Sie die folgende syntax, da die meisten komplett:

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

Diese Werke von Swift 1.2 bis zu 4, und bietet mehrere Tugenden:

1. Erinnert den Nutzer nicht zur Unterklasse Umsetzung
2. Verhindert die Schaffung zusätzlicher Instanzen
3. Sorgt faul Schöpfung und einmalige Instanziierung
4. Verkürzt syntax (vermeidet ()), indem für den Zugriff auf Instanz als Singleton.instance

InformationsquelleAutor Gonzalo Durañona