Swift singleton design sample – The.Swift.Dev.

Everyone seems to be bullying on the poor singleton sample, the general public name it anti-pattern. However what precisely is a singleton class and why is it so unhealthy?

What’s a singleton?

It is a very fashionable and generally adopted sample due to simplicity. A singleton class can solely have precisely one occasion via the whole utility lifecycle. That single occasion is barely accessible via a static property and the initialized object is often shared globally. It is like a world variable. 🌏

International variables and states

Singletons have unhealthy popularity as a result of they share world mutable states. The worldwide key phrase is at all times feared even within the circle of skilled builders. International states & variables are the hotbed of negative effects. International variables will be accessed from anyplace of your program so your courses that use them will change into stateful, unsecure, tight coupled and laborious to debug. It is not a very good observe to share states alongside objects via this fashion for apparent causes. 🤮

Unwanted side effects

It’s best to scope and isolate your variables as a lot as you possibly can and reduce the statefullness of your code. This can get rid of negative effects, make your code safer to make use of. Think about the next instance:

var world = 0


func sq.(_ x: Int) -> Int {
    world = x
    return x * x
}

world = 1;
var end result = sq.(5)
end result += world 
print(end result) 

The sq. technique is written by another person, who needed to retailer the enter in the identical world variable for some cause. Now while you name that operate you will not be avare of this, till you have a look at his code. Think about this type of points within a venture with a lot of oop courses written by a number of code authors… good luck with the military of BUGS! 🐛🐛🐛

The key lifetime of a singleton object

Singletons are created as soon as and stay without end, they work nearly precisely like world variables and that is why you need to be extraordinarily cautious with them. It’s best to solely handle these states with singletons that lasts for the entire lifecycle of the app. For instance user-specific periods are often unhealthy practices and you need to rethink your design. Additionally Swift just isn’t thread secure by default, so in case you are working with singletons you need to be ready for multi-threading points as effectively. But when they’re so problematic, should not we merely keep away from them completely? The reply isn’t any. 🚫

When to make use of a singleton class?

For instance UIApplication is almost definitely a singleton as a result of there ought to be just one utility occasion, and it ought to stay till you shut it down. That makes simply the proper instance for a singleton. One other use case is usually a Logger class. It is secure to make use of a singleton as a result of your utility will not behave any completely different if a logger is turned on or not. Noone else will personal or handle the logger and you will solely go info into the logger, so states cannot be tousled. Conclusion: a console or a logger class is kind of a suitable situation for the utilization of the singleton sample. 👏

Console.default.discover("Whats up I am a singleton!")

There are a a lot of “singletonish” (not every part is a real singleton object) use circumstances in Apple frameworks, here’s a quick checklist, so you possibly can have slightly inspiration:

• HTTPCookieStorage.shared
• URLCredentialStorage.shared
• URLSessionConfiguration.default
• URLSession.shared
• FileManager.default
• Bundle.fundamental
• UserDefaults.customary
• NotificationCenter.default
• UIScreen.fundamental
• UIDevice.present
• UIApplication.shared
• MPMusicPlayerController.systemMusicPlayer
• GKLocalPlayer.localPlayer()
• SKPaymentQueue.default()
• WCSession.default
• CKContainer.default()
• and so on.

I’ve seen a lot of supervisor courses carried out as singletons, corresponding to community, location or core knowledge managers, however these objects often should not be singletons, just because it may be multiple of them. 💩

Singleton sample will be very helpful, nevertheless it ought to be used with warning

If you wish to flip one thing right into a singleton, ask your self these questions:

• Will anything personal, handle or be answerable for it?
• Is there going to be precisely one occasion?
• Will or not it’s a world state variable?
• Ought to I actually use a globally shared object?
• Ought to stay via the entire app lifecycle?
• Is there any options for it?

If the solutions is clearly a sure for every part above, then you possibly can “safely” use a singleton or a world variable to retailer your knowledge. 🎉🎉🎉

The best way to create a singleton in Swift?

It is very easy to make a singleton object in Swift, however please at all times suppose twice and think about options earlier than you apply this design sample.

class Singleton {

    static let shared = Singleton()

    non-public init() {
        
    }
}
let singleton = Singleton.shared

These days I am at all times creating one particular singleton object, that is known as App. This fashion I can hook up each utility associated world state properties into that one singleton. The naming conference additionally helps me to reevaluate what goes into it. 💡

The best way to get rid of singletons?

If there’s different manner you need to go along with that in ~90% of the circumstances. The most typical various resolution for singletons is dependency injection. First you need to summary the singleton strategies right into a protocol, then you need to use the singleton because the default implementation if it is nonetheless wanted. Now you possibly can inject the singleton or a refactored object into the fitting place. This fashion your code will be examined with mocked objects of the protocol, even ignoring the singleton itself. 😎

typealias DataCompletionBlock = (Information?) -> Void


protocol Session {
    func make(request: URLRequest, completionHandler: @escaping DataCompletionBlock)
}


extension URLSession: Session {

    func make(request: URLRequest, completionHandler: @escaping DataCompletionBlock) {
        let process = self.dataTask(with: request) { knowledge, _, _ in
            completionHandler(knowledge)
        }
        process.resume()
    }
}

class ApiService {

    var session: Session

    
    init(session: Session = URLSession.shared) {
        self.session = session
    }

    func load(_ request: URLRequest, completionHandler: @escaping DataCompletionBlock) {
        self.session.make(request: request, completionHandler: completionHandler)
    }
}



class MockedSession: Session {

    func make(request: URLRequest, completionHandler: @escaping DataCompletionBlock) {
        completionHandler("Mocked knowledge response".knowledge(utilizing: .utf8))
    }
}


func take a look at() {
    let api = ApiService(session: MockedSession())
    let request = URLRequest(url: URL(string: "https://localhost/")!)
    api.load(request) { knowledge in
        print(String(knowledge: knowledge!, encoding: .utf8)!)
    }
}
take a look at()

As you possibly can see the singleton sample could be very simple to implement, nevertheless it’s actually laborious to decide about it is utility kinds. I am not saying that it is an anti-pattern, as a result of it is clearly not, however take care in case you are planning to cope with singletons. 😉