Property Wrapper: βασικές έννοιες, σύνταξη και παραδείγματα στο SwiftUI

Τι είναι το Property Wrapper;

Property Wrapper είναι μια γλωσσική κατασκευή της Swift που εμφανίστηκε στην έκδοση 5.1, η οποία επιτρέπει την ενθυλάκωση της λογικής πρόσβασης στην ιδιότητα σε ξεχωριστό τύπο. Αντί να γράφει επαναλαμβανόμενους getter και setter σε κάθε κλάση, ο προγραμματιστής δηλώνει το περιτύλιγμα μία φορά και το εφαρμόζει μέσω του σχολιασμού @ πριν από τον τύπο. Η Swift τυλίγει αυτόματα την ιδιότητα στον καθορισμένο τύπο, καλώντας τις μεθόδους wrappedValue και projectedValue κατά την ανάγνωση και εγγραφή. Σύμφωνα με την Apple (WWDC 2019), τα Property Wrappers έχουν γίνει η βασική αφαίρεση για το SwiftUI.

Το περιτύλιγμα ιδιότητας είναι μια δομή ή κλάση με το χαρακτηριστικό @propertyWrapper. Εσωτερικά, ένας τέτοιος τύπος πρέπει να υλοποιεί την ιδιότητα wrappedValue που επιστρέφει και ορίζει την τρέχουσα τιμή. Ο μεταγλωττιστής της Swift αντικαθιστά τις αναφορές στην αρχική ιδιότητα με κλήσεις wrappedValue, κρύβοντας εντελώς την υλοποίηση από τον καλούντα κώδικα. Επιπλέον, μπορεί να οριστεί το projectedValue — μια προβολή προσβάσιμη μέσω του συμβόλου $.

Το πλεονέκτημα των Property Wrappers έγκειται στην επαναχρησιμοποίηση της λογικής. Για παράδειγμα, μπορεί να δημιουργηθεί ένα περιτύλιγμα για επικύρωση email, προσωρινή αποθήκευση τιμών ή συγχρονισμό με αποθηκευτικό χώρο — και να εφαρμοστεί σε οποιαδήποτε ιδιότητα στο έργο. Στο SwiftUI, αυτή η έννοια χρησιμοποιείται παντού: κάθε μηχανισμός διαχείρισης κατάστασης υλοποιείται ως ξεχωριστό Property Wrapper.

Πώς λειτουργεί το Property Wrapper στη Swift;

Κατά τη δήλωση μιας ιδιότητας με σχολιασμό @WrapperType var value: T, ο μεταγλωττιστής της Swift μετασχηματίζει τον κώδικα. Δημιουργεί ένα στιγμιότυπο WrapperType και παράγει πρόσβαση στην ιδιότητα μέσω wrappedValue. Ο πηγαίος κώδικας let x = value μετατρέπεται σε let x = _value.wrappedValue, και value = newValue σε _value.wrappedValue = newValue. Αυτός ο μετασχηματισμός συμβαίνει στο στάδιο της μεταγλώττισης, χωρίς επιβάρυνση κατά το χρόνο εκτέλεσης.

@propertyWrapper
struct Capitalized {
    private var text: String

    var wrappedValue: String {
        get { text }
        set { text = newValue.capitalized }
    }

    init(initialValue: String) {
        text = initialValue.capitalized
    }
}

Στη λίστα εμφανίζεται το περιτύλιγμα Capitalized, το οποίο μορφοποιεί αυτόματα το κείμενο με κεφαλαίο γράμμα. Κατά την ανάθεση τιμής, ο setter καλεί την capitalized πριν από την αποθήκευση. Τώρα οποιαδήποτε ιδιότητα με σχολιασμό @Capitalized θα αποθηκεύει μόνο σωστά μορφοποιημένο κείμενο. Αυτή η προσέγγιση εξαλείφει εντελώς την αντιγραφή κώδικα επικύρωσης και μορφοποίησης.

Η προβολή (projectedValue) — ένα πρόσθετο κανάλι επικοινωνίας, προσβάσιμο μέσω του προθέματος $. Στο SwiftUI, αυτή η δυνατότητα χρησιμοποιείται παντού: το $state δίνει Binding και το $observedObject επιστρέφει Published.Publisher. Η προβολή επιτρέπει στο περιτύλιγμα να παρέχει μια εκτεταμένη διεπαφή χωρίς να αλλάζει την κύρια πρόσβαση στην τιμή.

Κύρια Property Wrappers στο SwiftUI

Το SwiftUI περιλαμβάνει πέντε ενσωματωμένα Property Wrappers για διαχείριση κατάστασης: @State, @Binding, @ObservedObject, @StateObject και @Environment. Κάθε ένα λύνει ένα συγκεκριμένο έργο και χρησιμοποιείται σε διαφορετικά σενάρια. Το @State προορίζεται για απλά τοπικά δεδομένα, το @Binding — για μετάδοση αναφοράς δεδομένων σε θυγατρικές προβολές, τα @ObservedObject και @StateObject — για σύνθετα αντικείμενα, το @Environment — για τιμές συστήματος από την ιεραρχία.

Η επιλογή ενός συγκεκριμένου Property Wrapper εξαρτάται από την πηγή δεδομένων και τον κύκλο ζωής τους. Εάν τα δεδομένα ανήκουν σε μία προβολή και δεν χρειάζονται σε θυγατρικά στοιχεία — χρησιμοποιήστε @State. Εάν η θυγατρική προβολή πρέπει να τροποποιήσει τα δεδομένα του γονέα — εφαρμόστε @Binding. Για αντικείμενα που χρησιμοποιούνται σε πολλές προβολές, τα @ObservedObject και @StateObject είναι κατάλληλα.

@State: τοπική κατάσταση προβολής

@State είναι ένα Property Wrapper για αποθήκευση τοπικής κατάστασης μέσα σε μία προβολή. Η SwiftUI διαχειρίζεται αυτόματα τη μνήμη για ιδιότητες @State και ανασχεδιάζει την προβολή σε κάθε αλλαγή. Το @State είναι κατάλληλο για απλούς τύπους (String, Int, Bool, enum) και δομές που ανήκουν αποκλειστικά στην τρέχουσα προβολή. Κατά την αλλαγή τιμής, η SwiftUI επανεκτελεί την ιδιότητα body.

struct CounterView: View {
    @State private var count: Int = 0

    var body: some View {
        VStack {
            Text("Αριθμός: \(count)")
            Button("Αύξηση") {
                count += 1
            }
        }
    }
}

Στο παράδειγμα, η ιδιότητα @State count αποθηκεύει την τρέχουσα τιμή του μετρητή. Η SwiftUI δημιουργεί μια περιοχή αποθήκευσης για αυτήν την ιδιότητα στο heap και τη συνδέει με τον κύκλο ζωής του CounterView. Κατά το πάτημα του κουμπιού, το count αυξάνεται κατά 1, η SwiftUI ανιχνεύει την αλλαγή και επανεκτελεί το body, εμφανίζοντας τη νέα τιμή. Σημαντικό: το @State δεν πρέπει να χρησιμοποιείται για σύνθετους τύπους αναφοράς — γι' αυτό προορίζονται τα @StateObject και @ObservedObject.

@Binding: αμφίδρομη σύνδεση μεταξύ προβολών

@Binding δημιουργεί μια αναφορά στην πηγή δεδομένων που ανήκει σε άλλη προβολή. Το Binding δεν αποθηκεύει την τιμή ανεξάρτητα — διαβάζει και γράφει δεδομένα μέσω @State, @StateObject ή άλλου Binding που μεταδίδεται από τον γονέα. Αυτό επιτρέπει στα θυγατρικά στοιχεία να τροποποιούν την κατάσταση του προγόνου χωρίς άμεση ιδιοκτησία δεδομένων και χωρίς callbacks.

struct ToggleSwitch: View {
    @Binding var isOn: Bool

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

Στη λίστα, το ToggleSwitch λαμβάνει ένα @BindingBool από τη γονική προβολή. Ο γονέας δημιουργεί @State var isToggleOn = false και μεταδίδει το $isToggleOn στον αρχικοποιητή του ToggleSwitch. Όταν ο χρήστης αλλάζει το Toggle μέσα στη θυγατρική προβολή, η αλλαγή αντικατοπτρίζεται αμέσως στο @State του γονέα. Ο μηχανισμός Binding εξαλείφει εντελώς την ανάγκη για delegates ή closures για τη μετάδοση αλλαγών προς τα πάνω στην ιεραρχία.

@ObservedObject και @StateObject: εξωτερικά δεδομένα

@ObservedObject είναι ένα Property Wrapper για παρατήρηση ενός στιγμιότυπου ObservableObject που μεταδίδεται από έξω. Η προβολή δεν είναι ιδιοκτήτης αυτού του αντικειμένου — δημιουργείται στο γονικό στοιχείο ή εισάγεται μέσω Environment. Όταν οποιαδήποτε ιδιότητα @Published μέσα στο ObservableObject αλλάζει, η SwiftUI ανασχεδιάζει όλες τις προβολές που είναι εγγεγραμμένες μέσω @ObservedObject.

@StateObject είναι ένα περιτύλιγμα για δημιουργία και ιδιοκτησία ObservableObject απευθείας στην προβολή. Σε αντίθεση με το @ObservedObject, το @StateObject εγγυάται ένα μοναδικό στιγμιότυπο του αντικειμένου σε όλο τον κύκλο ζωής της προβολής. Ακόμα κι αν η SwiftUI αναδημιουργήσει τη δομή της προβολής (που συμβαίνει συχνά), το @StateObject διατηρεί το υπάρχον αντικείμενο και δεν καλεί ξανά τον αρχικοποιητή.

class UserSettings: ObservableObject {
    @Published var username: String = "Guest"
}

struct ProfileView: View {
    @StateObject var settings = UserSettings()

    var body: some View {
        ChildProfileView(settings: settings)
    }
}

struct ChildProfileView: View {
    @ObservedObject var settings: UserSettings

    var body: some View {
        Text("Γεια, \(settings.username)")
    }
}

Στο παράδειγμα, το ProfileView δημιουργεί UserSettings μέσω @StateObject, γινόμενο ιδιοκτήτης του αντικειμένου. Το ChildProfileView λαμβάνει το ίδιο στιγμιότυπο μέσω @ObservedObject — παρατηρεί, αλλά δεν διαχειρίζεται τον κύκλο ζωής. Όταν το username αλλάζει, και οι δύο προβολές ενημερώνονται. Αν το ChildProfileView είχε χρησιμοποιήσει @StateObject αντί για @ObservedObject, σε κάθε απόδοση θα δημιουργούνταν ένα νέο στιγμιότυπο με αρχική τιμή.

Ο βασικός κανόνας: το @StateObject εφαρμόζεται στην προβολή που δημιουργεί το αντικείμενο (πηγή αλήθειας), και το @ObservedObject στην προβολή που λαμβάνει το έτοιμο αντικείμενο από τον γονέα. Η παραβίαση αυτού του κανόνα οδηγεί σε απώλεια κατάστασης ή απροσδόκητη αναδημιουργία δεδομένων.

Δημιουργία δικού σας Property Wrapper

Η Swift επιτρέπει τη δημιουργία προσαρμοσμένων Property Wrappers για οποιαδήποτε επαναλαμβανόμενη λογική πρόσβασης σε ιδιότητες. Αρκεί να δηλώσετε μια δομή ή κλάση με το χαρακτηριστικό @propertyWrapper και να υλοποιήσετε το wrappedValue. Παρακάτω εμφανίζεται το περιτύλιγμα UserDefaultsWrapper, το οποίο συγχρονίζει αυτόματα την τιμή με το UserDefaults.

@propertyWrapper
struct UserDefaultsWrapper<T> {
    let key: String
    let defaultValue: T

    var wrappedValue: T {
        get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue }
        set { UserDefaults.standard.set(newValue, forKey: key) }
    }
}

struct AppConfig {
    @UserDefaultsWrapper(key: "theme", defaultValue: "light")
    var theme: String
}

Το περιτύλιγμα UserDefaultsWrapper χρησιμοποιεί ένα generic T για να λειτουργεί με οποιονδήποτε τύπο δεδομένων υποστηρίζεται από το UserDefaults. Ο getter διαβάζει την τιμή με βάση το κλειδί, ο setter γράφει. Η εφαρμογή του @UserDefaultsWrapper(key:defaultValue:) στην ιδιότητα theme τη συνδέει αυτόματα με τον αποθηκευτικό χώρο — όλη η λογική εργασίας με το UserDefaults είναι κρυμμένη μέσα στο περιτύλιγμα. Αυτό είναι ένα τυπικό παράδειγμα μείωσης του επαναλαμβανόμενου κώδικα με Property Wrappers.

Κατά τη δημιουργία προσαρμοσμένων περιτυλιγμάτων, είναι σημαντικό να λαμβάνεται υπόψη η απόδοση. Δεδομένου ότι ο getter και ο setter καλούνται σε κάθε πρόσβαση στην ιδιότητα, δεν πρέπει να τοποθετούνται βαριές λειτουργίες I/O στο wrappedValue. Για ασύγχρονη αποθήκευση δεδομένων, είναι καλύτερο να συνδυάζονται τα Property Wrappers με ObservableObject και @Published.