Radfahren mit Singletons in Swift

Question

Ich habe eine Singleton-Klasse:

class SomeManager { 
    static let sharedInstance = SomeManager() 

    let serverService = SomerServerService() 
    let musicService = SomeMusicService() 
} 

Ich versuche

class SomeMusicService 
{ 
    let serverService = SomeManager.sharedInstance.serverService //here seems I get cycle. 
} 

verwenden Sollte ich faul oder eine andere Initialisierung.

Wie Sie let musicService = SomeMusicService() initialisiert ein Objekt und dann in dem gleichen Objekt sehen SomeMusicService es versucht sharedInstance von SomeManager Singleton nennen einem anderen Dienst beim Start zu bekommen.

Das ist also eine vollständige Liste:

import Foundation 

class ServerService 
{ 
    func downloadMusic() 
    { 
    print("Download music and play it after that.") 
    } 
} 

class MusicService 
{ 
    let serverService = Singleton.shared.serverService 

    func playMusic() 
    { 
    serverService.downloadMusic() 
    } 
} 

class Singleton 
{ 
    static let shared = Singleton() 

    let serverService = ServerService() 
    let musicService = MusicService() 
} 


let s = Singleton.shared 
print("Hello, World!") 

Wir nie print("Hello, World!") Zeile aufgerufen werden lassen.

Answer 1

könnten Sie weak verwenden behalten Zyklus zu vermeiden, aber die bessere Antwort ist eine berechnete Eigenschaft:

class SomeMusicService { 
    var serverService: SomeService { return SomeManager.sharedInstance.serverService } 
} 

---

ich von Ihrem aktualisierten Code sehen, was der Zyklus ist. Hier ist, wie er sich abspielt:

• Anruf Singleton.shared
  • Begin Singleton zu konstruieren
    • Baukonstruktion ServerService (für serverService Eigenschaft)
    • Begin MusicService zu konstruieren (für musicService Eigenschaft)
      • Anruf Singleton.shared (für serverService-Eigenschaft)
      • Block für Singleton.shared warten vervollständigen

Das Programm wird nun auf sich selbst blockiert wartet.

Die richtige Antwort ist, eine berechnete Eigenschaft zu verwenden, so dass Singleton.shared während der Konstruktion nicht aufgerufen werden muss. Eine lazy Eigenschaft würde auch funktionieren, aber scheint eine Menge Ärger dafür zu sein (und riskiert das Erstellen von Retain-Schleifen zwischen den Diensten).