Saya mencoba mencari model tunggal yang sesuai untuk digunakan di Swift. Sejauh ini, saya sudah bisa mendapatkan model aman non-utas bekerja sebagai:

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

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

        return Static.instance!
    }
}

Membungkus instance singleton dalam Static struct harus memungkinkan satu instance yang tidak bertabrakan dengan instance singleton tanpa skema penamaan yang rumit, dan itu harus membuat semuanya menjadi sangat pribadi. Namun jelas, model ini tidak aman untuk thread. Jadi saya mencoba menambahkan dispatch_oncesemuanya:

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

Tapi saya mendapatkan kesalahan kompiler di dispatch_oncetelepon:

Tidak dapat mengonversi jenis ekspresi 'Void' ke mengetik '()'

Saya sudah mencoba beberapa varian sintaks yang berbeda, tetapi semuanya tampaknya memiliki hasil yang sama:

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

Apa penggunaan yang tepat dispatch_oncemenggunakan Swift? Saya awalnya berpikir masalahnya adalah dengan blok karena ()dalam pesan kesalahan, tetapi semakin saya melihatnya, semakin saya pikir itu mungkin masalah untuk mendapatkan dispatch_once_tdefinisi yang benar.

tl; dr: Gunakan pendekatan konstanta kelas jika Anda menggunakan Swift 1.2 atau lebih tinggi dan pendekatan struct bersarang jika Anda perlu mendukung versi sebelumnya.

Dari pengalaman saya dengan Swift ada tiga pendekatan untuk menerapkan pola Singleton yang mendukung inisialisasi malas dan keamanan utas.

Konstanta kelas

class Singleton  {
   static let sharedInstance = Singleton()
}

Pendekatan ini mendukung inisialisasi malas karena Swift malas menginisialisasi konstanta kelas (dan variabel), dan aman menurut definisi let. Ini sekarang secara resmi direkomendasikan untuk instantiate singleton.

Konstanta kelas diperkenalkan di Swift 1.2. Jika Anda perlu mendukung versi Swift sebelumnya, gunakan pendekatan struct bersarang di bawah ini atau konstanta global.

Bersarang struct

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

Di sini kita menggunakan konstanta statis dari struct bersarang sebagai konstanta kelas. Ini adalah solusi untuk kurangnya konstanta kelas statis di Swift 1.1 dan sebelumnya, dan masih berfungsi sebagai solusi untuk kurangnya konstanta statis dan variabel dalam fungsi.

dispatch_once

Pendekatan Objective-C tradisional porting ke Swift. Saya cukup yakin tidak ada keuntungan atas pendekatan struct bersarang tetapi saya tetap menempatkannya di sini karena saya menemukan perbedaan dalam sintaksis yang menarik.

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

Lihat proyek GitHub ini untuk pengujian unit.

Karena Apple sekarang telah mengklarifikasi bahwa variabel struct statis diinisialisasi baik malas dan dibungkus dispatch_once(lihat catatan di akhir posting), saya pikir solusi terakhir saya adalah:

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

        return Singleton.instance
    }
}

Ini mengambil keuntungan dari inisialisasi malas otomatis dari elemen struct statis, dengan aman menyembunyikan implementasi aktual dari konsumen, menjaga semuanya terkotak secara kompak untuk keterbacaan, dan menghilangkan variabel global yang terlihat.

Apple telah mengklarifikasi bahwa inisialisasi malas bersifat aman, jadi tidak perlu dispatch_onceatau perlindungan serupa

Inisialisasi lazy untuk variabel global (juga untuk anggota statis struct dan enums) dijalankan pertama kali global diakses, dan diluncurkan sebagai dispatch_once untuk memastikan bahwa inisialisasi adalah atom. Ini memungkinkan cara keren untuk menggunakan dispatch_once dalam kode Anda: cukup deklarasikan variabel global dengan penginisialisasi dan tandai sebagai pribadi.

Dari sini

Untuk Swift 1.2 dan lebih tinggi:

class Singleton  {
   static let sharedInstance = Singleton()
}

Dengan bukti kebenaran (semua kredit ada di sini ), sekarang tidak ada alasan untuk menggunakan metode sebelumnya untuk lajang.

Pembaruan : Sekarang ini adalah cara resmi untuk mendefinisikan lajang sebagaimana dijelaskan dalam dokumen resmi !

Adapun kekhawatiran tentang penggunaan staticvs class. staticharus menjadi orang yang digunakan bahkan ketika classvariabel tersedia. Lajang tidak dimaksudkan untuk disubklasifikasi karena itu akan menghasilkan beberapa contoh basis tunggal. Menggunakanstatic menegakkan ini dengan cara yang indah, Swifty.

Untuk Swift 1.0 dan 1.1:

Dengan perubahan baru-baru ini di Swift, sebagian besar metode kontrol akses baru, saya sekarang condong ke arah cara yang lebih bersih menggunakan variabel global untuk lajang.

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

Seperti yang disebutkan dalam artikel blog Swift di sini :

Inisialisasi lazy untuk variabel global (juga untuk anggota statis struct dan enums) dijalankan pertama kali global diakses, dan diluncurkan sebagai dispatch_once untuk memastikan bahwa inisialisasi adalah atom. Ini memungkinkan cara keren untuk menggunakan dispatch_once dalam kode Anda: cukup deklarasikan variabel global dengan penginisialisasi dan tandai sebagai pribadi.

Cara membuat singleton ini adalah utas yang aman, cepat, malas, dan juga dijembatani ke ObjC secara gratis.

Swift 1.2 atau yang lebih baru sekarang mendukung variabel / konstanta statis di kelas. Jadi Anda bisa menggunakan konstanta statis:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

Ada cara yang lebih baik untuk melakukannya. Anda bisa mendeklarasikan variabel global di kelas Anda di atas deklarasi kelas seperti ini:

var tpScopeManagerSharedInstance = TPScopeManager()

Ini hanya memanggil init default Anda atau variabel init dan global mana pun secara dispatch_oncedefault di Swift. Kemudian di kelas mana pun Anda ingin mendapatkan referensi, Anda cukup melakukan ini:

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

Jadi pada dasarnya Anda dapat menyingkirkan seluruh blok kode instance bersama.

Swift lajang yang terkena dalam kerangka Kakao sebagai fungsi kelas, misalnya NSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). Jadi lebih masuk akal sebagai fungsi kelas untuk mencerminkan perilaku ini, daripada variabel kelas seperti beberapa solusi lainnya. misalnya:

class MyClass {

    private static let _sharedInstance = MyClass()

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

Ambil singleton via MyClass.sharedInstance().

Per dokumentasi Apple , telah diulang berkali-kali bahwa cara termudah untuk melakukan ini di Swift adalah dengan properti tipe statis:

class Singleton {
    static let sharedInstance = Singleton()
}

Namun, jika Anda mencari cara untuk melakukan pengaturan tambahan di luar panggilan konstruktor sederhana, rahasianya adalah menggunakan penutupan yang segera dipanggil:

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

Ini dijamin aman-utas dan diinisialisasi dengan malas hanya sekali.

Swift 4+

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

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

Melihat kode sampel Apple, saya menemukan pola ini. Saya tidak yakin bagaimana Swift berurusan dengan statika, tetapi ini akan aman di C #. Saya menyertakan properti dan metode untuk Objective-C interop.

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

Secara singkat,

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

Anda mungkin ingin membaca File dan Inisialisasi

Inisialisasi lazy untuk variabel global (juga untuk anggota statis struct dan enum) dijalankan pertama kali ketika global diakses, dan diluncurkan dispatch_onceuntuk memastikan bahwa inisialisasi adalah atom.

Jika Anda berencana untuk menggunakan kelas Swift singleton Anda di Objective-C, setup ini akan membuat kompiler menghasilkan header Objective-C-like yang sesuai:

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

Kemudian di kelas Objective-C Anda dapat memanggil singleton Anda seperti yang Anda lakukan di masa pra-Swift:

[ImageStore sharedStore];

Ini hanya implementasi sederhana saya.

Solusi pertama

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

Kemudian dalam kode Anda:

func someFunction() {        
    var socketManager = SocketManager        
}

Solusi kedua

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

class SocketManagerSingleton {

}

Dan nanti dalam kode Anda, Anda akan dapat menjaga kawat gigi agar kurang kebingungan:

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

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

Kalau begitu sebut saja;

let shared = MySingleton.shared

Menggunakan:

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

Cara Penggunaan:

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

Pendekatan terbaik di Swift di atas 1.2 adalah singleton satu baris, karena -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

Untuk mengetahui lebih detail tentang pendekatan ini, Anda dapat mengunjungi tautan ini .

Dari Apple Documents (Swift 3.0.1),

Anda cukup menggunakan properti tipe statis, yang dijamin akan diinisialisasi malas hanya sekali, bahkan ketika diakses di banyak utas secara bersamaan:

class Singleton {
    static let sharedInstance = Singleton()
}

Jika Anda perlu melakukan pengaturan tambahan di luar inisialisasi, Anda dapat menetapkan hasil pemanggilan penutupan ke konstanta global:

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

Saya akan menyarankan enum, seperti yang akan Anda gunakan di Jawa, misalnya

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

Sekedar referensi, berikut ini adalah contoh implementasi Singleton dari implementasi Nested Struct Jack Wu / hpique. Implementasi juga menunjukkan bagaimana pengarsipan dapat bekerja, serta beberapa fungsi yang menyertainya. Saya tidak dapat menemukan contoh lengkap ini, jadi semoga ini membantu seseorang!

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

Dan jika Anda tidak mengenali beberapa fungsi-fungsi itu, berikut adalah file utilitas Swift kecil yang pernah saya gunakan:

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

Dengan cepat, Anda dapat membuat kelas singleton dengan cara berikut:

class AppSingleton: NSObject {

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

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

Saya lebih suka implementasi ini:

class APIClient {

}

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

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

Cara implementasi saya di 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")   

}

Akses globalDic dari layar aplikasi mana saja dengan cara di bawah ini.

Baca:

 println(ConfigurationManager.sharedInstance.globalDic)  

Menulis:

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

Satu-satunya pendekatan yang tepat di bawah ini.

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

    private init() {}
}

Untuk mengakses

let signleton = Singleton.sharedInstance

Alasan:

• static tipe properti dijamin akan diinisialisasi malas hanya sekali, bahkan ketika diakses di beberapa utas secara bersamaan, jadi tidak perlu menggunakan dispatch_once
• Privatisasi initmetode sehingga instance tidak dapat dibuat oleh kelas lain.
• final kelas karena Anda tidak ingin kelas lain mewarisi kelas Singleton.

Setelah melihat implementasi David, sepertinya tidak perlu memiliki fungsi kelas tunggal instanceMethodkarena letmelakukan hampir sama dengan sharedInstancemetode kelas. Yang perlu Anda lakukan adalah mendeklarasikannya sebagai konstanta global dan hanya itu.

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

Cepat untuk menyadari singleton di masa lalu, tidak lebih dari tiga cara: variabel global, variabel internal dan cara dispatch_once.

Berikut adalah dua singleton yang baik. (Catatan: tidak peduli apa jenis tulisan harus memperhatikan metode init () privatisasi. Karena di Swift, semua standar konstruktor objek adalah publik, perlu ditulis ulang init dapat diubah menjadi pribadi , cegah objek lain dari kelas ini '()' dengan metode inisialisasi default untuk membuat objek.)

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

Metode 2:

class AppManager {
    static let sharedInstance = AppManager()

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

// How to use?
AppManager.sharedInstance

Ini adalah yang paling sederhana dengan kemampuan aman thread. Tidak ada utas lain yang dapat mengakses objek tunggal yang sama bahkan jika mereka mau. Cepat 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!
        }
    }
}

Saya meminta singleton saya untuk mengizinkan warisan, dan tidak ada solusi yang benar-benar mengizinkannya. Jadi saya datang dengan ini:

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

• Dengan cara ini ketika melakukan Singleton.sharedInstance()pertama itu akan mengembalikan instance dariSingleton
• Ketika melakukan SubSingleton.sharedInstance()pertama itu akan mengembalikan instance yang SubSingletondibuat.
• Jika di atas dilakukan, maka SubSingleton.sharedInstance()ini Singletonadalah benar dan contoh yang sama digunakan.

Masalah dengan pendekatan kotor pertama ini adalah bahwa saya tidak dapat menjamin bahwa subclass akan mengimplementasikan dispatch_once_tdan memastikan bahwa sharedInstanceVarhanya dimodifikasi satu kali per kelas.

Saya akan mencoba untuk memperbaiki ini lebih lanjut, tetapi akan menarik untuk melihat apakah ada yang punya perasaan kuat terhadap ini (selain fakta bahwa itu adalah kata kerja dan perlu memperbaruinya secara manual).

Ini implementasi saya. Itu juga mencegah programmer membuat contoh baru:

let TEST = Test()

class Test {

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

Saya menggunakan sintaks berikut:

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

Ini berfungsi dari Swift 1.2 hingga 4, dan memiliki beberapa keunggulan:

1. Mengingatkan pengguna untuk tidak membuat subkelas implementasi
2. Mencegah pembuatan instance tambahan
3. Memastikan kreasi malas dan instantiasi unik
4. Mempersingkat sintaks (menghindari ()) dengan mengizinkan untuk mengakses contoh sebagai Singleton.instance