Netzwerkstatus in SwiftUI überwachen mit NWPathMonitor

Warum Network Monitoring in jede App gehört

Keine Internetverbindung, und die App zeigt einen endlosen Spinner oder eine leere Seite. Für den Nutzer ist das frustrierend, für dich sind es verlorene Bewertungen. Network Monitoring fängt genau das ab: Du erkennst Verbindungsänderungen in Echtzeit und zeigst eine klare Meldung, bevor der Nutzer überhaupt merkt, dass etwas schiefläuft.

Apple stellt dafür die NWPathMonitor-Klasse im Network-Framework bereit. Zusammen mit SwiftUI und dem @Observable-Makro lässt sich das in wenigen Zeilen implementieren.

Die NetworkMonitor-Klasse

Erstelle eine neue Swift-Datei NetworkMonitor.swift:

import Foundation
import Network

@Observable
@MainActor
final class NetworkMonitor {
    private let monitor = NWPathMonitor()
    var isConnected = true

    init() {
        monitor.pathUpdateHandler = { [weak self] path in
            Task { @MainActor in
                self?.isConnected = path.status == .satisfied
            }
        }
        monitor.start(queue: .global(qos: .utility))
    }
}

Was passiert hier:

• NWPathMonitor() überwacht alle Verbindungstypen (WiFi, Mobilfunk, Ethernet)
• pathUpdateHandler wird bei jeder Statusänderung auf einem Background-Thread aufgerufen. Deshalb das Task { @MainActor in }, um den State-Update sicher auf den Main Actor zu bringen
• @Observable + @MainActor stellt sicher, dass SwiftUI Views sich automatisch updaten und alle Property-Zugriffe Thread-safe sind
• isConnected startet optimistisch mit true, damit die App beim Start nicht kurz eine Offline-Ansicht zeigt bevor der Monitor antwortet
• [weak self] verhindert einen Retain Cycle, da der Monitor eine starke Referenz auf den Closure hält

Offline-Ansicht mit ContentUnavailableView

Seit iOS 17 gibt es ContentUnavailableView, eine native Ansicht für leere oder fehlende Zustände. Perfekt für "Keine Verbindung":

import SwiftUI

struct NetworkUnavailableView: View {
    var body: some View {
        ContentUnavailableView(
            "Keine Internetverbindung",
            systemImage: "wifi.exclamationmark",
            description: Text("Bitte überprüfe deine Verbindung und versuche es erneut.")
        )
    }
}

Das rendert automatisch ein zentriertes Icon mit Titel und Beschreibung, konsistent mit Apples Design Guidelines.

Integration in deine Views

Variante 1: Lokal mit @State

Für einzelne Views:

struct ContentView: View {
    @State private var networkMonitor = NetworkMonitor()

    var body: some View {
        if networkMonitor.isConnected {
            Text("Verbindung steht")
        } else {
            ContentUnavailableView(
                "Keine Internetverbindung",
                systemImage: "wifi.exclamationmark",
                description: Text("Bitte überprüfe deine Verbindung.")
            )
        }
    }
}

Variante 2: App-weit mit Environment (empfohlen)

Wenn mehrere Views den Netzwerkstatus brauchen, injiziere den Monitor über die Environment:

@main
struct MyApp: App {
    @State private var networkMonitor = NetworkMonitor()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(networkMonitor)
        }
    }
}

In jeder View dann:

struct ContentView: View {
    @Environment(NetworkMonitor.self) private var networkMonitor

    var body: some View {
        if networkMonitor.isConnected {
            // Normaler Content
        } else {
            ContentUnavailableView(
                "Keine Internetverbindung",
                systemImage: "wifi.exclamationmark",
                description: Text("Bitte überprüfe deine Verbindung.")
            )
        }
    }
}

Hinweis: Mit @Observable nutze .environment() statt .environmentObject(). Die ältere API funktioniert nur mit ObservableObject, das seit Swift 5.9 nicht mehr empfohlen wird.

Erweitert: Verbindungstyp erkennen

Du kannst den Monitor erweitern um zwischen WiFi und Mobilfunk zu unterscheiden:

@Observable
@MainActor
final class NetworkMonitor {
    private let monitor = NWPathMonitor()
    var isConnected = true
    var connectionType: ConnectionType = .unknown

    enum ConnectionType {
        case wifi, cellular, ethernet, unknown
    }

    init() {
        monitor.pathUpdateHandler = { [weak self] path in
            Task { @MainActor in
                self?.isConnected = path.status == .satisfied

                if path.usesInterfaceType(.wifi) {
                    self?.connectionType = .wifi
                } else if path.usesInterfaceType(.cellular) {
                    self?.connectionType = .cellular
                } else if path.usesInterfaceType(.wiredEthernet) {
                    self?.connectionType = .ethernet
                } else {
                    self?.connectionType = .unknown
                }
            }
        }
        monitor.start(queue: .global(qos: .utility))
    }
}

Praktisch, wenn du z. B. große Downloads nur über WiFi starten willst.

Testen

Methode	Funktioniert?	Anmerkung
Echtes Gerät, Flugmodus umschalten	Ja	Zuverlässigste Methode
Simulator, WiFi am Mac deaktivieren	Teilweise	Nicht immer konsistent
Network Link Conditioner (Xcode)	Ja	Simuliert verschiedene Netzwerkbedingungen
Unit Tests mit Mock	Ja	Extrahiere ein Protocol aus NetworkMonitor

Empfehlung: Teste immer auf einem echten Gerät. Der Simulator erkennt Netzwerkänderungen nicht zuverlässig.

Fazit

Network Monitoring gehört in jede App die mit dem Internet kommuniziert. Mit NWPathMonitor, @Observable und ContentUnavailableView brauchst du weniger als 30 Zeilen Code für eine vollständige Lösung, inklusive automatischer UI-Updates und nativer Offline-Ansicht.

---

Dieser Artikel wurde zuletzt am 5. April 2026 aktualisiert. Getestet mit Xcode 26 / iOS 26 / Swift 6.