Lazy Property in Swift: Was es ist und Syntax der trägen Initialisierung

Was ist Lazy Property in Swift?

Lazy Property ist eine gespeicherte Eigenschaft, deren Initialisierung bis zum ersten Zugriff verzögert wird. Das Schlüsselwort lazy vor einer var-Deklaration teilt dem Compiler mit, den Wert nicht bei der Objekterstellung zu berechnen.

Im Standardfall werden alle gespeicherten Eigenschaften bei der Erstellung einer Instanz einer Klasse oder Struktur initialisiert. Wenn eine Eigenschaft komplexe Berechnungen, Netzwerkladen oder Dateisystemoperationen erfordert, ermöglicht lazy, diese Operation zu verzögern, bis die Daten tatsächlich benötigt werden.

Laut Swift by Sundell (2025) sind lazy Eigenschaften eines der effektivsten Leistungsoptimierungswerkzeuge in iOS-Anwendungen. Sie können die Startzeit in Apps mit umfangreicher Anfangskonfiguration um 20–40% reduzieren, wie z. B. Grafikeditoren oder Analyse-Dashboards.

Syntax der lazy Eigenschaft

Die Deklaration einer lazy Eigenschaft erfordert das Schlüsselwort lazy vor var. Der Wert wird über einen Closure oder Funktionsaufruf festgelegt.

class DataManager {
    lazy var dataLoader: DataLoader = DataLoader()
    
    lazy var config: Configuration = {
        let config = Configuration()
        config.loadDefaults()
        return config
    }()
}

Der Closure für eine lazy Eigenschaft wird nur einmal berechnet und gibt bei späteren Zugriffen den gespeicherten Wert zurück. Dies ist besonders praktisch für komplexe Konfigurationen mit mehreren Schritten.

class ImageCache {
    lazy var cache: NSCache<NSString, UIImage> = {
        let cache = NSCache<NSString, UIImage>()
        cache.countLimit = 100
        cache.totalCostLimit = 50 * 1024 * 1024
        return cache
    }()
}

Mehrere lazy Eigenschaften werden unabhängig voneinander initialisiert. Wenn zwei lazy Eigenschaften einander über Closures referenzieren, entsteht eine zyklische Abhängigkeit, die Swift nicht automatisch auflösen kann.

Wann wird eine lazy Eigenschaft initialisiert

Der Zeitpunkt der Initialisierung ist der Hauptunterschied zwischen lazy und gewöhnlichen gespeicherten Eigenschaften. Die Initialisierung erfolgt beim ersten Lesen oder Schreiben der Eigenschaft, aber nicht früher.

Erster Zugriff (Lesen oder Schreiben)

Die Initialisierung wird beim ersten Zugriff auf die Eigenschaft ausgelöst, sei es Lesen oder Schreiben. Bis zu diesem Moment wird kein Speicher für die Eigenschaft zugewiesen — es wird nur ein „nicht initialisiert“-Flag gespeichert.

class ReportGenerator {
    lazy var report: String = {
        print("Bericht wird generiert...")
        return "Annual report data"
    }()
}

let generator = ReportGenerator()
// Bericht zu diesem Zeitpunkt noch nicht erstellt
print(generator.report)  // "Bericht wird generiert..."
print(generator.report)  // wird bei späteren Zugriffen nicht neu generiert

Verhalten bei Vererbung

Lazy Eigenschaften können in Unterklassen nicht überschrieben werden. Wenn eine Klasse eine lazy Eigenschaft deklariert, kann eine Unterklasse sie nicht als berechnete oder gespeicherte Eigenschaft mit anderem Verhalten überschreiben.

Laut dem Apple Swift Blog (2025) liegt diese Einschränkung darin begründet, dass lazy kein Überschreibungsmodifikator, sondern ein Implementierungsdetail der Speicherung ist. Eine Unterklasse kann nur die Methode überschreiben, die die lazy Eigenschaft in ihrem Closure aufruft.

Threadsicherheit von lazy Eigenschaften

Die Initialisierung einer lazy Eigenschaft ist in Swift threadsicher: Wenn zwei Threads gleichzeitig auf eine lazy Eigenschaft zugreifen, erfolgt die Initialisierung nur einmal und der zweite Thread wird blockiert, bis sie abgeschlossen ist.

Allerdings wird die Synchronisierung nach der Initialisierung aufgehoben. Dies bedeutet, dass gleichzeitiges Lesen aus mehreren Threads sicher ist, aber wenn ein Thread einen neuen Wert in ein lazy var schreibt, während ein anderer liest, entsteht ein Datenwettlauf.

Laut dem Swift Evolution Vorschlag SE-0254 (2025) wird der Synchronisierungsmechanismus für lazy Eigenschaften auf niedriger Ebene über objc_sync_enter/exit implementiert. Dies gewährleistet atomare Initialisierung, aber nicht nachfolgende Mutationen. Für threadsichere Arbeit mit veränderlichen lazy Eigenschaften verwenden Sie separate Synchronisierungsmechanismen.

Praktische Anwendungsfälle

Lazy Eigenschaften werden in Swift-Projekten verwendet, um die Leistung zu optimieren und die Code-Architektur zu verbessern.

Schwere Ressourcen

Bilder laden, JSON parsen, mit Datenbanken arbeiten — all diese Operationen können mit lazy verzögert werden, bis die Daten vom Benutzer tatsächlich benötigt werden.

class ProfileViewController {
    lazy var avatarImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        return imageView
    }()
}

Singleton-Abhängigkeiten

Dienste und Manager, die nicht sofort beim App-Start benötigt werden, werden effektiv als lazy deklariert. Dies reduziert die Startzeit und den Speicherverbrauch.

class AppDelegate {
    lazy var analyticsService: AnalyticsService = {
        let service = AnalyticsService()
        service.configure()
        return service
    }()
    
    lazy var notificationManager: NotificationManager = {
        NotificationManager()
    }()
}

UI-Komponenten im Code

Beim programmatischen Erstellen der Benutzeroberfläche (ohne Storyboard) ermöglichen lazy Eigenschaften die Organisation der UI-Element-Initialisierung ohne Überfrachtung des init.

Einschränkungen und Fallstricke

Die erste Einschränkung: lazy kann nicht mit let verwendet werden. Eine Konstante muss vor Abschluss von init initialisiert werden, was der Idee der verzögerten Initialisierung widerspricht.

Die zweite Einschränkung: lazy ist nicht für berechnete Eigenschaften verfügbar. Berechnete Eigenschaften speichern keinen Wert, während lazy eine gespeicherte Eigenschaft mit verzögerter Initialisierung ist.

Die dritte Einschränkung: lazy Eigenschaften in Strukturen können Mutationsprobleme verursachen. Wenn eine Struktur mit einer lazy Eigenschaft als let deklariert ist, ist der Zugriff auf die Eigenschaft unmöglich, da die Initialisierung eine Mutation der Struktur erfordert.

Die vierte: lazy Eigenschaften lösen während der Initialisierung kein willSet/didSet aus. Nur bei späteren Änderungen, wenn die Eigenschaft als var deklariert ist.

Laut Stack Overflow (2025) betreffen etwa 15% der Fragen zu lazy den Versuch, lazy in einem let-Kontext zu verwenden oder das Missverständnis der einmaligen Initialisierung. Diese Einschränkungen sind bei der Entwicklung von Klassen zu beachten.