Действительно ли мне нужен общий экземпляр для синглета?

Question

Я написал вспомогательную структуру для сохранения и загрузки файлов до NSUserDefaults.

import UIKit 

struct Database { 

    static let defaults = NSUserDefaults.standardUserDefaults() 

    static var myVariable: AnyObject? 

    static func save() { 
     defaults.setObject(myVariable, forKey: "myVariable") 
    } 

    static func load() { 
     if let myVariable = defaults.objectForKey("myVariable") { 
      self.myVariable = myVariable 
     } 
    } 

    static func clear() { 
     defaults.removeObjectForKey("myVariable") 
    } 
} 

Теперь я могу просто использовать Database.load() для загрузки myVariable из NSUSerDefaults. Однако тот же достижимо с этим кодом:

struct Database2 { 

    static var sharedInstance = Database() 

    let defaults = NSUserDefaults.standardUserDefaults() 

    var myVariable: AnyObject? 

    func save() { 
     defaults.setObject(myVariable, forKey: "myVariable") 
    } 

    func load() { 
     if let myVariable = defaults.objectForKey("myVariable") { 
      self.myVariable = myVariable 
     } 
    } 

    func clear() { 
     defaults.removeObjectForKey("myVariable") 
    } 
} 

Теперь я хотел бы использовать Database2.sharedInstance.load().

Какой из них рассматривается как лучшая практика и почему? Какая польза от sharedInstance, если я могу сделать все, что я хочу, с объявлением static?

Answer 1

Общего случай рекомендуется, по крайней мере, по следующим причинам:

1. метода класса делает модульное тестирование труднее
2. вам нужны экземпляры классов для инъекции зависимостей
3. , если позже вы решите, что не -singleton более подходит - например вы решили иметь два сохраняемость хранилища для «MYVARIABLE», то вы застряли
4. и не в последнюю очередь, члены класса живут в глобальном пространстве, и мы должны избегать использования глобал

Реального вопрос, который вы должны спросить , если вам действительно нужен синглтон (с или без общего экземпляра) для вашей проблемы. Если единственная причина иметь одноэлементность - это простота доступа, тогда вам не нужен синглтон.

P.S. Существует очень хорошее article on objc.io о одиночных играх, и хотя оно было написано для Objective-C, многие концепции оттуда тоже применяются в Swift.

Answer 2

// with singleton pattern, there exist only one copy of the object 
// sigleton pattern can be applied for reference type only 
// let st1 = Singleton(); let st2 = Sigleton(); st1 === st2 

// in your example, S is value type. All instances of S share only type properties, here only i 

struct S { 
    static var i: Int = 100 
    var j: Int 
    func foo() { 
     //print(i) // error: static member 'i' cannot be used on instance of type 'S' 
     print(S.i) 
    } 
    init(_ j: Int) { 
     self.j = j 
    } 
} 

var s1 = S(1) 
var s2 = S(2) 
//s1.i // error: static member 'i' cannot be used on instance of type 'S' 
S.i // 100 
s1.foo() // 100 
s1.j // 1 
s2.foo() // 100 
s2.j // 2 
S.i = 200 
s1.foo() // 200 
s2.foo() // 200 

, кстати, этот (ваш) подход может быть очень полезным и может быть предпочтительным в некоторых ситуациях.