ฉันกำลังพยายามหาโมเดลซิงเกิลที่เหมาะสมสำหรับการใช้งานใน Swift จนถึงตอนนี้ฉันสามารถรับแบบจำลองความปลอดภัยที่ไม่มีเธรดทำงานเป็น:

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

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

        return Static.instance!
    }
}

การตัดอินสแตนซ์ซิงเกิลตันในโครงสร้างแบบคงที่ควรอนุญาตอินสแตนซ์เดี่ยวที่ไม่ขัดแย้งกับอินสแตนซ์ซิงเกิลโดยไม่มีแผนการตั้งชื่อที่ซับซ้อนและควรทำให้สิ่งต่างๆเป็นส่วนตัวอย่างเป็นธรรม แน่นอนว่ารุ่นนี้ไม่ปลอดภัยสำหรับเธรด ดังนั้นฉันจึงพยายามที่จะเพิ่มdispatch_onceสิ่งทั้งหมด:

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

แต่ฉันได้รับข้อผิดพลาดของคอมไพเลอร์ในdispatch_onceบรรทัด:

ไม่สามารถแปลงประเภทของนิพจน์ 'Void' เป็น type '()'

ฉันได้ลองใช้รูปแบบที่แตกต่างหลากหลายของไวยากรณ์ แต่พวกเขาดูเหมือนจะมีผลลัพธ์เดียวกัน:

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

การdispatch_onceใช้ Swift ที่เหมาะสมคืออะไร ตอนแรกฉันคิดว่าปัญหาเกิดขึ้นกับบล็อคเนื่องจาก()ในข้อความแสดงข้อผิดพลาด แต่ยิ่งฉันมองมันมากเท่าไรฉันก็ยิ่งคิดว่ามันอาจเป็นเรื่องของการได้รับการdispatch_once_tกำหนดอย่างถูกต้อง

tl; dr: ใช้วิธีการคงที่คลาสหากคุณใช้ Swift 1.2 หรือสูงกว่าและวิธีการซ้อนแบบซ้อนหากคุณต้องการสนับสนุนเวอร์ชันก่อนหน้า

จากประสบการณ์ของฉันกับ Swift มีสามวิธีในการใช้รูปแบบซิงเกิลตันที่รองรับการเริ่มต้นขี้เกียจและความปลอดภัย

คลาสคงที่

class Singleton  {
   static let sharedInstance = Singleton()
}

วิธีการนี้จะสนับสนุนการเริ่มต้นขี้เกียจเพราะสวิฟท์ซมต้นคงระดับ (และตัวแปร) letและมีความปลอดภัยหัวข้อโดยความหมายของ ตอนนี้เป็นวิธีที่แนะนำอย่างเป็นทางการในการสร้างอินตัน

ค่าคงที่คลาสได้รับการแนะนำใน Swift 1.2 หากคุณต้องการสนับสนุน Swift เวอร์ชันก่อนหน้าให้ใช้วิธีการซ้อนโครงสร้างด้านล่างหรือค่าคงที่ส่วนกลาง

ซ้อนโครงสร้าง

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

ที่นี่เรากำลังใช้ค่าคงที่แบบคงที่ของโครงสร้างแบบซ้อนเป็นค่าคงที่คลาส นี่เป็นวิธีแก้ปัญหาสำหรับการขาดค่าคงที่คลาสแบบคงที่ใน Swift 1.1 และรุ่นก่อนหน้าและยังคงทำงานเป็นวิธีแก้ปัญหาสำหรับการขาดค่าคงที่แบบคงที่และตัวแปรในฟังก์ชัน

dispatch_once

วิธีการแบบ Objective-C แบบดั้งเดิมถูกส่งไปยัง Swift ฉันค่อนข้างแน่ใจว่าไม่มีข้อได้เปรียบในการวางโครงสร้างซ้อนกัน แต่ฉันวางมันไว้ที่นี่เมื่อฉันพบความแตกต่างของไวยากรณ์ที่น่าสนใจ

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

ดูโครงการGitHubนี้สำหรับการทดสอบหน่วย

เนื่องจาก Apple ได้ชี้แจงว่าตัวแปร struct แบบคงที่นั้นเริ่มต้นได้ทั้งสันหลังยาวและล้อมรอบdispatch_once(ดูหมายเหตุท้ายโพสต์) ฉันคิดว่าคำตอบสุดท้ายของฉันจะเป็น:

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

        return Singleton.instance
    }
}

สิ่งนี้ใช้ประโยชน์จากการเริ่มต้นอัตโนมัติแบบขี้เกียจและปลอดภัยขององค์ประกอบอิลิเมนต์โครงสร้างแบบคงที่ซึ่งซ่อนการดำเนินการจริงจากผู้บริโภคอย่างปลอดภัยเก็บทุกอย่างไว้ในช่องว่างเล็ก ๆ เพื่อความชัดเจนและกำจัดตัวแปรส่วนกลางที่มองเห็นได้

Apple ได้ชี้แจงว่าผู้เริ่มต้นที่ขี้เกียจมีความปลอดภัยต่อเธรดจึงไม่จำเป็นต้องมีdispatch_onceหรือต้องการการปกป้องที่คล้ายกัน

lazy initializer สำหรับตัวแปรโกลบอล (เช่นสำหรับสมาชิกแบบคงที่ของ struct และ enums) ถูกเรียกใช้เป็นครั้งแรกที่มีการเข้าถึงโกลบอลและถูกเรียกใช้เป็น dispatch_once เพื่อให้แน่ใจว่าการเริ่มต้นนั้นเป็นอะตอมมิก สิ่งนี้ช่วยให้วิธีที่ยอดเยี่ยมในการใช้ dispatch_once ในรหัสของคุณ: เพียงประกาศตัวแปรทั่วโลกด้วยการเริ่มต้นและทำเครื่องหมายเป็นส่วนตัว

จากที่นี่

สำหรับ Swift 1.2 และสูงกว่า:

class Singleton  {
   static let sharedInstance = Singleton()
}

ด้วยหลักฐานความถูกต้อง (เครดิตทั้งหมดเข้าที่นี่ ) ตอนนี้ไม่มีเหตุผลที่จะใช้วิธีการใด ๆ ก่อนหน้านี้สำหรับซิงเกิล

อัปเดต : นี่เป็นวิธีที่เป็นทางการในการกำหนดซิงเกิลตันตามที่อธิบายไว้ในเอกสารอย่างเป็นทางการ !

ในฐานะที่เป็นความกังวลเกี่ยวกับการใช้VSstatic ควรเป็นอันที่ใช้แม้ในขณะที่ตัวแปรพร้อมใช้งาน Singletons ไม่ได้หมายถึง subclassed เนื่องจากจะส่งผลให้เกิด single instance หลายฐาน การใช้บังคับใช้สิ่งนี้ในวิธีที่สวยงามและรวดเร็วclassstaticclassstatic

สำหรับ Swift 1.0 และ 1.1:

ด้วยการเปลี่ยนแปลงล่าสุดใน Swift ซึ่งเป็นวิธีการควบคุมการเข้าถึงส่วนใหญ่ฉันได้เรียนรู้วิธีการใช้ตัวแปรระดับโลกสำหรับซิงเกิล

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

ดังที่ได้กล่าวไว้ในบทความบล็อกของ Swift ที่นี่ :

lazy initializer สำหรับตัวแปรโกลบอล (เช่นสำหรับสมาชิกแบบคงที่ของ struct และ enums) ถูกเรียกใช้เป็นครั้งแรกที่มีการเข้าถึงโกลบอลและถูกเรียกใช้เป็น dispatch_once เพื่อให้แน่ใจว่าการเริ่มต้นนั้นเป็นอะตอมมิก สิ่งนี้ช่วยให้วิธีที่ยอดเยี่ยมในการใช้ dispatch_once ในรหัสของคุณ: เพียงประกาศตัวแปรทั่วโลกด้วยการเริ่มต้นและทำเครื่องหมายเป็นส่วนตัว

วิธีการสร้างซิงเกิลตันนี้ปลอดภัยสำหรับเธรดเร็วขี้เกียจและเชื่อมต่อกับ ObjC ฟรี

Swift 1.2 หรือใหม่กว่ารองรับตัวแปร / ค่าคงที่ในคลาส ดังนั้นคุณสามารถใช้ค่าคงที่:

class MySingleton {

    static let sharedMySingleton = MySingleton()

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

มีวิธีที่ดีกว่าที่จะทำมัน คุณสามารถประกาศตัวแปรโกลบอลในคลาสของคุณเหนือการประกาศคลาสเช่นนี้:

var tpScopeManagerSharedInstance = TPScopeManager()

สิ่งนี้จะเรียกใช้ค่าเริ่มต้นของคุณหรือค่าเริ่มต้นใดและตัวแปรทั่วโลกเป็นdispatch_onceค่าเริ่มต้นใน Swift จากนั้นในชั้นเรียนใดที่คุณต้องการรับการอ้างอิงคุณเพียงแค่ทำสิ่งนี้:

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

ดังนั้นโดยทั่วไปคุณสามารถกำจัดบล็อคอินสแตนซ์ที่แชร์ทั้งหมดได้

Swift singletons ถูกเปิดเผยในกรอบ Cocoa เป็นฟังก์ชันคลาสเช่นNSFileManager.defaultManager(), NSNotificationCenter.defaultCenter(). ดังนั้นจึงเหมาะสมกว่าในฐานะฟังก์ชันคลาสเพื่อสะท้อนลักษณะการทำงานนี้แทนที่จะเป็นตัวแปรคลาสเป็นโซลูชันอื่น ๆ เช่น:

class MyClass {

    private static let _sharedInstance = MyClass()

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

MyClass.sharedInstance()เรียกเดี่ยวผ่าน

ตามเอกสารของ Appleมีการทำซ้ำหลายครั้งว่าวิธีที่ง่ายที่สุดใน Swift คือด้วยคุณสมบัติประเภทคงที่:

class Singleton {
    static let sharedInstance = Singleton()
}

อย่างไรก็ตามหากคุณกำลังมองหาวิธีการตั้งค่าเพิ่มเติมนอกเหนือจากการเรียก Constructor แบบธรรมดาความลับคือการปิดการเรียกใช้ทันที:

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

สิ่งนี้รับประกันได้ว่าปลอดภัยต่อเธรดและเริ่มต้นได้อย่างเกียจคร้านเพียงครั้งเดียว

Swift 4+

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

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

ดูโค้ดตัวอย่างของ Apple ฉันเจอรูปแบบนี้ ฉันไม่แน่ใจว่า Swift เกี่ยวข้องกับสถิตศาสตร์ได้อย่างไร แต่จะปลอดภัยในเธรดใน C # ฉันรวมทั้งคุณสมบัติและวิธีการสำหรับ Objective-C interop

struct StaticRank {
    static let shared = RankMapping()
}

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

class var shared:RankMapping {
    return StaticRank.shared
}

โดยสังเขป

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

คุณอาจต้องการอ่านไฟล์และการกำหนดค่าเริ่มต้น

lazy initializer สำหรับตัวแปรโกลบอล (สำหรับสมาชิกแบบคงที่ของ structs และ enums) ถูกเรียกใช้ในครั้งแรกที่เข้าถึงโกลบอลและถูกเรียกใช้dispatch_onceเพื่อให้แน่ใจว่าการกำหนดค่าเริ่มต้นนั้นเป็นอะตอมมิก

หากคุณวางแผนที่จะใช้คลาส Swift singleton ของคุณใน Objective-C การตั้งค่านี้จะมีคอมไพเลอร์สร้างส่วนหัวคล้าย C Objective-C ที่เหมาะสม:

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

จากนั้นในคลาส Objective-C คุณสามารถโทรหาซิงเกิลของคุณในแบบที่คุณเคยทำมาก่อนวันสวิฟต์:

[ImageStore sharedStore];

นี่เป็นเพียงการดำเนินการที่เรียบง่ายของฉัน

ทางออกแรก

let SocketManager = SocketManagerSingleton();

class SocketManagerSingleton {

}

ต่อมาในรหัสของคุณ:

func someFunction() {        
    var socketManager = SocketManager        
}

ทางออกที่สอง

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

class SocketManagerSingleton {

}

และในภายหลังในรหัสของคุณคุณจะสามารถจัดฟันเพื่อความสับสนน้อยลง:

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

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

จากนั้นเรียกมันว่า

let shared = MySingleton.shared

ใช้:

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

วิธีใช้:

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

แนวทางที่ดีที่สุดใน Swift above 1.2 คือ singleton หนึ่งบรรทัดเช่น -

class Shared: NSObject {

    static let sharedInstance = Shared()

    private override init() { }
}

หากต้องการทราบรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการนี้คุณสามารถเยี่ยมชมลิงค์นี้

จาก Apple Docs (Swift 3.0.1)

คุณสามารถใช้คุณสมบัติประเภทแบบคงที่ซึ่งรับประกันว่าจะเริ่มต้นได้อย่างเกียจคร้านเพียงครั้งเดียวแม้เมื่อเข้าถึงผ่านหลายเธรดพร้อมกัน:

class Singleton {
    static let sharedInstance = Singleton()
}

หากคุณต้องการดำเนินการตั้งค่าเพิ่มเติมนอกเหนือจากการเริ่มต้นคุณสามารถกำหนดผลลัพธ์ของการภาวนาให้กับค่าคงที่ส่วนกลาง:

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

ฉันอยากจะแนะนำenumอย่างที่คุณจะใช้ใน Java เช่น

enum SharedTPScopeManager: TPScopeManager {
    case Singleton
}

นี่เป็นตัวอย่างการใช้งาน Singleton ของการใช้งาน Nested Struct ของ Jack Wu / hpique การนำไปใช้ยังแสดงให้เห็นว่าการเก็บถาวรสามารถทำงานได้อย่างไรรวมถึงฟังก์ชั่นบางอย่างที่แนบมาด้วย ฉันไม่สามารถหาตัวอย่างที่สมบูรณ์ได้ดังนั้นหวังว่านี่จะช่วยใครซักคน!

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

และถ้าคุณไม่รู้จักฟังก์ชั่นเหล่านี้นี่คือไฟล์อรรถประโยชน์ Swift ที่ใช้งานอยู่ที่ฉันเคยใช้:

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

ใน swift คุณสามารถสร้างคลาส singleton ได้ดังต่อไปนี้:

class AppSingleton: NSObject {

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

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

ฉันชอบการนำไปใช้นี้:

class APIClient {

}

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

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

วิธีการใช้งานของฉันใน 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")   

}

เข้าถึง globalDic จากหน้าจอใด ๆ ของแอปพลิเคชันด้านล่าง

อ่าน:

 println(ConfigurationManager.sharedInstance.globalDic)  

เขียน:

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

แนวทางที่ถูกต้องอยู่ด้านล่าง

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

    private init() {}
}

ในการเข้าถึง

let signleton = Singleton.sharedInstance

เหตุผล:

• static คุณสมบัติ type รับประกันว่าจะเริ่มต้นได้อย่างเกียจคร้านเพียงครั้งเดียวแม้เมื่อเข้าถึงผ่านหลายเธรดพร้อมกันดังนั้นไม่จำเป็นต้องใช้ dispatch_once
• การแปรรูปinitวิธีการนั้นไม่สามารถสร้างอินสแตนซ์ของคลาสอื่นได้
• final คลาสที่คุณไม่ต้องการให้คลาสอื่น ๆ สืบทอดคลาส Singleton

หลังจากเห็นการนำดาวิดมาใช้ดูเหมือนว่าไม่จำเป็นต้องมีฟังก์ชั่นชั้นเดี่ยวinstanceMethodตั้งแต่letทำสิ่งเดียวกับsharedInstanceวิธีการเรียน สิ่งที่คุณต้องทำคือประกาศให้เป็นค่าคงที่ทั่วโลกและมันจะเป็นเช่นนั้น

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 ที่ดี (หมายเหตุ: ไม่ว่าชนิดของการเขียนจะต้องใส่ใจกับ init () วิธีการของความเป็นส่วนตัวเพราะใน Swift ค่าเริ่มต้นของตัวสร้างวัตถุทั้งหมดเป็นแบบสาธารณะ ป้องกันวัตถุอื่นของคลาสนี้ () โดยวิธีการกำหนดค่าเริ่มต้นเพื่อสร้างวัตถุ)

วิธีที่ 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()

วิธีที่ 2:

class AppManager {
    static let sharedInstance = AppManager()

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

// How to use?
AppManager.sharedInstance

นี่เป็นสิ่งที่ง่ายที่สุดที่มีความสามารถในการป้องกันเธรด ไม่มีเธรดอื่นสามารถเข้าถึงวัตถุซิงเกิลเดียวกันแม้ว่าพวกเขาต้องการ สวิฟท์ 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!
        }
    }
}

ฉันต้องการซิงเกิลของฉันเพื่ออนุญาตการสืบทอดและไม่มีวิธีแก้ปัญหาเหล่านี้ที่จริงอนุญาต ดังนั้นฉันมากับสิ่งนี้:

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

• วิธีนี้เมื่อทำSingleton.sharedInstance()ก่อนจะส่งคืนอินสแตนซ์ของSingleton
• เมื่อทำSubSingleton.sharedInstance()ครั้งแรกมันจะกลับตัวอย่างของการSubSingletonสร้าง
• หากทำตามข้างต้นแล้วSubSingleton.sharedInstance()จะSingletonเป็นจริงและใช้อินสแตนซ์เดียวกัน

ปัญหาเกี่ยวกับวิธีการที่สกปรกครั้งแรกนี้คือฉันไม่สามารถรับประกันได้ว่าคลาสย่อยจะใช้งานdispatch_once_tและตรวจสอบให้แน่ใจว่าsharedInstanceVarมีการแก้ไขเพียงครั้งเดียวต่อคลาส

ฉันจะพยายามปรับแต่งสิ่งนี้เพิ่มเติม แต่มันน่าสนใจที่จะดูว่าใครมีความรู้สึกรุนแรงกับเรื่องนี้ (นอกเหนือจากความจริงที่ว่ามันเป็น verbose และจำเป็นต้องปรับปรุงด้วยตนเอง)

นี่คือการดำเนินการของฉัน นอกจากนี้ยังป้องกันโปรแกรมเมอร์จากการสร้างอินสแตนซ์ใหม่:

let TEST = Test()

class Test {

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

ฉันใช้ไวยากรณ์ต่อไปนี้:

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

ใช้งานได้ตั้งแต่ Swift 1.2 ถึง 4 และมีข้อดีหลายประการ:

1. เตือนผู้ใช้ไม่ให้ใช้คลาสย่อย
2. ป้องกันการสร้างอินสแตนซ์เพิ่มเติม
3. สร้างความมั่นใจได้ว่าขี้เกียจและอินสแตนซ์ที่เป็นเอกลักษณ์
4. ลดขนาดไวยากรณ์ (avoids ()) โดยอนุญาตให้เข้าถึงอินสแตนซ์เป็น Singleton.instance