Ponieważ Apple wyjaśniło teraz, że statyczne zmienne struct są inicjalizowane zarówno leniwe, jak i zawinięte w dispatch_once( patrz notatka na końcu posta), myślę, że moim ostatecznym rozwiązaniem będzie:

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

        return Singleton.instance
    }
}

To wykorzystuje automatyczną leniwą, bezpieczną dla wątków inicjalizację statycznych elementów struktury, bezpiecznie ukrywa rzeczywistą implementację przed konsumentem, przechowuje wszystko w zwartym podziale dla czytelności i eliminuje widoczną zmienną globalną.

Jabłko wyjaśniono, że Lazy initializer są bezpieczne dla wątków, więc nie ma potrzeby stosowania dispatch_once lub podobnych zabezpieczeń

Leniwy inicjalizator zmiennej globalnej (również dla statycznych członków struktur i enum) jest uruchamiany przy pierwszym dostępie do zmiennej globalnej i jest uruchamiany jako dispatch_once, aby upewnić się, że inicjalizacja jest atomowa. Pozwala to na użycie dispatch_once w kodzie: wystarczy zadeklarować zmienną globalną za pomocą inicjatora i oznaczyć ją jako prywatną.

Od tutaj

Dla Swift 1.2 i nowszych:

class Singleton  {
   static let sharedInstance = Singleton()
}

Z dowodem poprawności (cała zasługa idzie tutaj ), nie ma powodu, aby używać żadnej z poprzednich metod dla singletonów.

Update : to jest teraz oficjalny sposób definiowania singletonów, jak opisano w official docs!

Jeśli chodzi o obawy dotyczące stosowania static vs class. static powinny być używane nawet wtedy, gdy zmienne class staną się dostępne. Singletony nie są miał być podklasowany, ponieważ skutkowałoby to wieloma instancjami bazowego Singletona. Użycie static wymusza to w piękny, szybki sposób.

Dla Swift 1.0 i 1.1:

W związku z ostatnimi zmianami w Swift, głównie nowymi metodami kontroli dostępu, skłaniam się teraz 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 Swift blog tutaj :

Leniwy inicjalizator zmiennej globalnej (także dla statycznych członków structs and enums) jest uruchamiany przy pierwszym dostępie do globalnej, a jest uruchamiany jako dispatch_once, aby upewnić się, że inicjalizacja jest atomic. Pozwala to na użycie dispatch_once w kodzie: wystarczy zadeklarować zmienną globalną za pomocą inicjatora i zaznaczyć ją szeregowy.

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

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

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Jest na to lepszy sposób. Możesz zadeklarować zmienną globalną w swojej klasie powyżej declection klasy w ten sposób

var tpScopeManagerSharedInstance = TPScopeManager()

Wywołanie domyślnego init lub dowolnej zmiennej INIT i globalnej dispatch_once domyślnie w języku Swift. Następnie w klasie, którą chcesz uzyskać referencję, po prostu zrób to:

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

Więc w zasadzie można pozbyć się całego bloku współdzielonego kodu instancji.

Singletony Swift są eksponowane w frameworkach Cocoa jako funkcje klasowe, np. NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(), wydaje mi się więc, że bardziej sensowne jest odzwierciedlenie tego zachowania jako funkcji klasy, a nie jako zmiennej klasy, jak używają niektóre inne rozwiązania, np.

class MyClass {

    private static let _sharedInstance = MyClass()

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

Pobierz singleton przez MyClass.sharedInstance().

Zgodnie z dokumentacją Apple , wielokrotnie powtarzano, że najprostszym sposobem na to jest użycie właściwości statycznych typu:

class Singleton {
    static let sharedInstance = Singleton()
}

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

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

Jest to gwarantowane, że wątek będzie bezpieczny i leniwie zainicjowany 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 ' a natknąłem się na ten wzór. Nie jestem pewien, jak Swift radzi sobie ze statyką, ale to byłoby bezpieczne w C#. I obejmują zarówno właściwość i metodę dla Objective-C interop.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

Jeśli planujesz użyć swojej klasy SWIFT singleton w Objective-C, Ta konfiguracja 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
}

Wtedy w klasie Objective-C możesz nazywać swój singleton tak, jak zrobiłeś to w przedświątecznych dniach:

[ImageStore sharedStore];

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 Twoim kodzie będziesz mógł zachować szelki dla mniej zamieszania:

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

Użycie:

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

W skrócie,

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

Możesz przeczytać Pliki i inicjalizację

Leniwy inicjalizator zmiennej globalnej (także dla statycznych członków structs and enums) jest uruchamiany przy pierwszym dostępie do globalnej, a jest uruchamiany jako dispatch_once, aby upewnić się, że inicjalizacja jest atomic.

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

To zadzwoń;

let shared = MySingleton.shared

Sugerowałbym Enum, jak byś użył w Javie, np.:

enum SharedTPScopeManager: TPScopeManager {
  case Singleton
}

Dla przypomnienia, oto przykładowa implementacja Singletona zagnieżdżonej implementacji struktury Jacka Wu / hpique. 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)
    }
}

I jeśli nie rozpoznałeś niektórych z tych funkcji, oto mały żywy plik narzędziowy 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()
    }
}

Najlepsze podejście w Swift powyżej 1.2 to jednowierszowy singleton, as -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

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

Wolę tę implementację:

class APIClient {

}

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

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

Mój sposób implementacji 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")   

}

Dostęp do globalDic z dowolnego ekranu aplikacji przez Poniżej.

Powinno być:

 println(ConfigurationManager.sharedInstance.globalDic)  

Napisz:

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

Z Apple Docs (Swift 3.0.1),

Można po prostu użyć właściwości static type, która jest gwarantowana leniwie zainicjowany tylko raz, nawet gdy dostęp do wielu wątki jednocześnie:

class Singleton {
    static let sharedInstance = Singleton()
}

Jeśli potrzebujesz wykonać dodatkową konfigurację poza inicjalizacją, możesz przypisanie wyniku wywołania zamknięcia do globalnego stała:

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

Po obejrzeniu implementacji Davida, wydaje się, że nie ma potrzeby posiadania funkcji klasy singleton instanceMethod, ponieważ let robi prawie to samo, co metoda klasy sharedInstance. Wszystko, co musisz zrobić, to zadeklarować ją jako stałą globalną 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!
}

Właśnie się na to natknąłem, ale wymagałem mojego Singletona, aby pozwolił na dziedziczenie, a żadne z tych rozwiązań nie pozwalało na to.

Więc wymyśliłem 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 wykonując Singleton.sharedInstance () najpierw zwróci instancję Singleton
• podczas wykonywania SubSingleton.sharedInstance () najpierw zwróci instancję utworzonego Subsingletona.
• Jeśli powyższe jest zrobione, to SubSingleton.sharedInstance () is Singleton is true and the ta sama instancja jest używana.

Problem z tym pierwszym brudnym podejściem polega na tym, że nie mogę zagwarantować, że podklasy zaimplementują dispatch_once_t i upewnią się, że sharedInstanceVar jest modyfikowany tylko raz na klasę...

Postaram się dopracować to dalej, ale interesujące byłoby zobaczyć, czy ktoś ma silne uczucia przeciwko temu (poza tym, że jest gadatliwy i wymaga ręcznej aktualizacji).

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

Swift do zrealizowania Singletona w przeszłości, to nic innego jak trzy sposoby: zmienne globalne, zmienne wewnętrzne i sposoby dispatch_once.

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

To moja realizacja. Uniemożliwia to również programiście tworzenie nowej instancji:

let TEST = Test()

class Test {

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

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

Zwykle używam następującej składni jako najbardziej kompletnej:

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

1. przypomina użytkownikowi, aby nie podklasował implementacji
2. zapobiega tworzeniu dodatkowych instancji
3. zapewnia leniwe tworzenie i unikalną instancję
4. skraca składnię (avoids ()) pozwalając na dostęp do instancji jako Singleton.instance

Użyj statycznej zmiennej i prywatnego inicjatora, aby utworzyć klasę singleton.

class MySingletonClass {

    static let sharedSingleton = MySingletonClass()

    private init() {}
}