Próbuję wypracować odpowiedni model singletonu do użytku w Swift. Do tej pory udało mi się uzyskać bezpieczny dla wątków model działający jako:

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

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

        return Static.instance!
    }
}

Zawijanie instancji singletonowej w strukturze statycznej powinno pozwolić jednej instancji, która nie koliduje z instancjami singletonowymi bez skomplikowanych schematów nazewnictwa, i powinna uczynić to dość prywatnym. Oczywiście ten model nie jest bezpieczny dla wątków. Próbowałem więc dodać dispatch_oncedo całości:

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

Ale pojawia się błąd kompilatora w dispatch_oncewierszu:

Nie można przekonwertować typu wyrażenia „Void” na typ „()”

Wypróbowałem kilka różnych wariantów składni, ale wszystkie wydają się mieć takie same wyniki:

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

Jakie jest właściwe użycie dispatch_onceSwift? Początkowo myślałem, że problem dotyczy bloku z powodu ()komunikatu o błędzie, ale im dłużej na niego patrzę, tym bardziej myślę, że może to być kwestia dispatch_once_tprawidłowego zdefiniowania.

tl; dr: Użyj metody stałej klasowej, jeśli używasz Swift 1.2 lub nowszej, i zagnieżdżonej struktury strukturalnej, jeśli potrzebujesz obsługi wcześniejszych wersji.

Z mojego doświadczenia ze Swiftem są trzy podejścia do implementacji wzorca Singleton, które wspierają leniwe inicjowanie i bezpieczeństwo wątków.

Stała klasy

class Singleton  {
   static let sharedInstance = Singleton()
}

To podejście obsługuje leniwe inicjowanie, ponieważ Swift leniwie inicjuje stałe klas (i zmienne) i jest wątkowo bezpieczny z definicji let. Jest to teraz oficjalnie zalecany sposób utworzenia singletonu.

Stałe klas zostały wprowadzone w Swift 1.2. Jeśli potrzebujesz obsługiwać wcześniejszą wersję Swift, użyj poniższego podejścia do struktury zagnieżdżonej lub stałej globalnej.

Struktura zagnieżdżona

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

Używamy tutaj stałej statycznej zagnieżdżonej struktury jako stałej klasy. Jest to obejście problemu braku stałych statycznych klas w Swift 1.1 i wcześniejszych wersjach, i nadal działa jako obejście braku stałych statycznych i zmiennych w funkcjach.

dispatch_once

Tradycyjne podejście do celu C przeniesiono do Swift. Jestem całkiem pewien, że nie ma przewagi nad zagnieżdżoną strukturą strukturalną, ale i tak ją tutaj umieszczam, ponieważ uważam różnice w składni za interesujące.

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

Zobacz ten projekt GitHub dla testów jednostkowych.

Ponieważ Apple wyjaśniło, że statyczne zmienne struktury są inicjowane zarówno leniwie, jak i zawinięte dispatch_once(patrz uwaga na końcu postu), myślę, że moim ostatecznym rozwiązaniem będzie:

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

        return Singleton.instance
    }
}

Wykorzystuje to automatyczną, leniwą, bezpieczną dla wątków inicjalizację statycznych elementów konstrukcyjnych, bezpiecznie ukrywa rzeczywistą implementację przed konsumentem, utrzymuje wszystko w kompaktowych przedziałach dla czytelności i eliminuje widoczną zmienną globalną.

Apple wyjaśniło, że leniwy inicjator jest bezpieczny dla wątków, więc nie ma potrzeby dispatch_onceani podobnych zabezpieczeń

Leniwy inicjator zmiennej globalnej (także dla statycznych elementów struktur i wyliczeń) jest uruchamiany przy pierwszym dostępie do globu i uruchamiany jako dispatch_once, aby upewnić się, że inicjalizacja jest atomowa. Umożliwia to fajny sposób użycia dispatch_once w kodzie: wystarczy zadeklarować zmienną globalną za pomocą inicjatora i oznaczyć ją jako prywatną.

od tutaj

W przypadku Swift 1.2 i nowszych wersji:

class Singleton  {
   static let sharedInstance = Singleton()
}

Z dowodem poprawności (wszystkie zasługi tutaj ), nie ma teraz żadnego powodu, aby używać dowolnej z poprzednich metod singletonów.

Aktualizacja : Jest to teraz oficjalny sposób definiowania singletonów, jak opisano w oficjalnych dokumentach !

Jeśli chodzi o obawy dotyczące korzystania staticvs class. staticpowinien być tym, którego należy używać, nawet gdy classzmienne stają się dostępne. Singletonów nie należy klasyfikować do podklas, ponieważ spowodowałoby to wiele wystąpień podstawowego singletonu. Używanie staticwymusza to w piękny, szybki sposób.

W przypadku Swift 1.0 i 1.1:

Dzięki ostatnim zmianom w Swift, głównie nowym metodom kontroli dostępu, teraz skłaniam się ku czystszemu sposobowi używania zmiennej globalnej dla singletonów.

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

Jak wspomniano w artykule na blogu Swift tutaj :

Leniwy inicjator zmiennej globalnej (także dla statycznych elementów struktur i wyliczeń) jest uruchamiany przy pierwszym dostępie do globu i uruchamiany jako dispatch_once, aby upewnić się, że inicjalizacja jest atomowa. Umożliwia to fajny sposób użycia dispatch_once w kodzie: wystarczy zadeklarować zmienną globalną za pomocą inicjatora i oznaczyć ją jako prywatną.

Ten sposób tworzenia singletonów jest bezpieczny, szybki, leniwy, a także połączony z ObjC za darmo.

Swift 1.2 lub nowszy obsługuje teraz zmienne statyczne / stałe w klasach. Możesz więc po prostu użyć stałej statycznej:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Jest lepszy sposób, aby to zrobić. Możesz zadeklarować zmienną globalną w swojej klasie powyżej deklaracji klasy w następujący sposób:

var tpScopeManagerSharedInstance = TPScopeManager()

To po prostu wywołuje domyślny init lub cokolwiek init, a zmienne globalne są dispatch_oncedomyślnie w Swift. Następnie w dowolnej klasie, w której chcesz uzyskać referencję, po prostu wykonaj następujące czynności:

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

Zasadniczo możesz więc pozbyć się całego bloku współdzielonego kodu instancji.

Singletons Swift są wystawione w ramach kakao jak funkcje klasy, na przykład NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). Dlatego bardziej sensowne jest, aby funkcja klasy odzwierciedlała to zachowanie, niż zmienna klasowa, jak niektóre inne rozwiązania. na przykład:

class MyClass {

    private static let _sharedInstance = MyClass()

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

Odzyskaj singletona przez MyClass.sharedInstance().

Zgodnie z dokumentacją Apple wiele razy powtarzano, że najłatwiejszym sposobem na to w Swift jest właściwość typu statycznego:

class Singleton {
    static let sharedInstance = Singleton()
}

Jeśli jednak szukasz sposobu na wykonanie dodatkowej konfiguracji poza prostym wywołaniem konstruktora, sekret polega na użyciu natychmiast wywołanego zamknięcia:

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

Gwarantuje to, że jest bezpieczny dla wątków i leniwie inicjowany tylko raz.

Swift 4+

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

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

Patrząc na przykładowy kod Apple, natknąłem się na ten wzorzec. Nie jestem pewien, jak Swift radzi sobie ze statyką, ale byłoby to bezpieczne dla wątków w C #. Podaję zarówno właściwość, jak i metodę dla współdziałania Objective-C.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

W skrócie,

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

Możesz przeczytać Pliki i inicjowanie

Leniwy inicjator dla zmiennej globalnej (także dla statycznych elementów struktur i wyliczeń) jest uruchamiany przy pierwszym dostępie do globalnej i jest uruchamiany, dispatch_onceaby upewnić się, że inicjalizacja jest atomowa.

Jeśli planujesz używać swojej klasy singleton Swift w Objective-C, to ustawienie spowoduje, że kompilator wygeneruje odpowiednie nagłówki podobne do Objective-C:

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

Następnie w klasie Objective-C możesz nazwać singletona tak, jak to robiłeś w dniach sprzed Swift:

[ImageStore sharedStore];

To tylko moja prosta implementacja.

Pierwsze rozwiązanie

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Później w kodzie:

func someFunction() {        
    var socketManager = SocketManager        
}

Drugie rozwiązanie

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

class SocketManagerSingleton {

}

A później w kodzie będziesz mógł przechowywać nawiasy klamrowe dla mniejszego zamieszania:

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

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

Nazwij to;

let shared = MySingleton.shared

Posługiwać się:

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

Jak używać:

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

Najlepszym podejściem w Swift powyżej 1.2 jest singleton jednowierszowy, ponieważ -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Aby dowiedzieć się więcej o tym podejściu, możesz odwiedzić ten link .

Z Apple Docs (Swift 3.0.1),

Możesz po prostu użyć właściwości typu statycznego, która jest gwarantowana leniwie zainicjowana tylko raz, nawet jeśli jest dostępna w wielu wątkach jednocześnie:

class Singleton {
    static let sharedInstance = Singleton()
}

Jeśli musisz wykonać dodatkową konfigurację poza inicjalizacją, możesz przypisać wynik wywołania zamknięcia do stałej globalnej:

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

Sugerowałbym enum, jak byście używali w Javie, np

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

Dla przykładu, oto przykładowa implementacja Nested Struct Jacka Wu / hpique Singleton. Implementacja pokazuje również, jak może działać archiwizacja, a także niektóre funkcje towarzyszące. Nie mogłem znaleźć tego pełnego przykładu, więc mam nadzieję, że to komuś pomoże!

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

A jeśli nie rozpoznałeś niektórych z tych funkcji, oto mały, żywy plik narzędzia Swift, którego używałem:

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

W trybie szybkiego możesz utworzyć klasę singleton w następujący sposób:

class AppSingleton: NSObject {

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

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

Wolę tę implementację:

class APIClient {

}

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

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

Mój sposób wdrożenia w 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")   

}

Uzyskaj dostęp do globalDic z dowolnego ekranu aplikacji poniżej.

Czytać:

 println(ConfigurationManager.sharedInstance.globalDic)  

Pisać:

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

Jedyne właściwe podejście znajduje się poniżej.

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

    private init() {}
}

Mieć dostęp

let signleton = Singleton.sharedInstance

Powody:

• static gwarantuje się, że właściwość type zostanie leniwie zainicjowana tylko raz, nawet jeśli jest dostępna dla wielu wątków jednocześnie, więc nie trzeba jej używać dispatch_once
• Prywatyzacja initmetody, więc instancja nie może zostać utworzona przez inne klasy.
• final klasa, ponieważ nie chcesz, aby inne klasy dziedziczyły klasę Singleton.

Po zobaczeniu implementacji Davida wydaje się, że nie ma potrzeby używania funkcji klasy singleton, instanceMethodponieważ letrobi ona prawie to samo, co sharedInstancemetoda klasowa. Wszystko, co musisz zrobić, to zadeklarować jako globalną stałą i to by było na tyle.

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

Szybka realizacja singletonu w przeszłości to nic innego jak trzy sposoby: zmienne globalne, zmienne wewnętrzne i sposoby dispatch_once.

Oto dwa dobre singletony. (Uwaga: bez względu na to, jaki rodzaj pisania będzie musiał zwrócić uwagę na metodę inicjalizacji metody init (), ponieważ w Swift wszystkie ustawienia domyślne konstruktora obiektu są publiczne, należy zmienić przepis na init, który można przekształcić w prywatny , zapobiegaj domyślnym metodom inicjowania innych obiektów tej klasy „()”, aby utworzyć obiekt).

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

Metoda 2:

class AppManager {
    static let sharedInstance = AppManager()

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

// How to use?
AppManager.sharedInstance

Jest to najprostszy z zabezpieczonymi wątkami. Żaden inny wątek nie może uzyskać dostępu do tego samego obiektu singleton, nawet jeśli tego chcą. Szybki 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!
        }
    }
}

Wymagałem, aby mój singleton zezwalał na dziedziczenie i żadne z tych rozwiązań nie pozwalało na to. Więc wpadłem na to:

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

• W ten sposób, robiąc Singleton.sharedInstance()pierwszy, zwróci instancjęSingleton
• Robiąc SubSingleton.sharedInstance()pierwszy zwróci instancję SubSingletonutworzonej.
• Jeśli powyższe zostanie wykonane, wówczas SubSingleton.sharedInstance()jest Singletonto prawda i używana jest ta sama instancja.

Problem z tym pierwszym nieprzyzwoitym podejściem polega na tym, że nie mogę zagwarantować, że podklasy zaimplementują dispatch_once_ti upewnią się, że sharedInstanceVarzostanie zmodyfikowany tylko raz na klasę.

Spróbuję to doprecyzować, ale byłoby interesujące sprawdzić, czy ktoś ma do tego silne uczucia (poza tym, że jest pełny i wymaga ręcznej aktualizacji).

To jest moja realizacja. Zapobiega także tworzeniu przez programistę nowej instancji:

let TEST = Test()

class Test {

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

Używam następującej składni:

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

Działa to od Swift 1.2 do 4 i ma kilka zalet:

1. Przypomina użytkownikowi, aby nie implementował podklasy
2. Zapobiega tworzeniu dodatkowych instancji
3. Zapewnia leniwe tworzenie i wyjątkową instancję
4. Skraca składnię (omija ()), umożliwiając dostęp do instancji jako Singleton.instance