Wie viel sollte eine Ansicht über das Modell wissen?

Ich erstelle eine Anwendung in Python mit einem Python-Wrapper für WPF und mit DAG-Unterstützung. Ich bin derzeit an einem Punkt angelangt, an dem ich mich für eine konsistente Art der Interaktion zwischen den Daten und der Ansicht entscheiden muss.

Soweit ich sehe, gibt es derzeit zwei offensichtliche Lösungen.

Die erste ähnelt der Struktur von Android-Anwendungen. Sie haben einen Controller, der die Ansicht festlegt / auffüllt. Der Controller besitzt also die Ansicht und überträgt nur die primitiven Daten, die angezeigt werden. Die Ansicht ist nur eine blöde Ebene und hat keine Ahnung, was passiert und woher diese Daten stammen. Wenn der Benutzer dann mit der Ansicht interagiert, sendet er Rückrufe an den Controller (sofern dieser registriert ist).

UserInfoController.py

userInfoView = UserInfoView()
userInfoView.onGenderChangedCallback = self.onGenderChangedCallback 
userInfoView.setUserGenderValue(user.getGender())

UserInfoView.py

def setUserGenderValue(self, gender):
    self.userGender = gender

def getView(self):
    return ui.Label(self.userGender, onEditCallback=self.onGenderChangedCallback)

Zweitens übergibt ein (Referenz-) Modell an die Ansicht und lässt die Ansicht die Daten abrufen und aktualisieren. Die Ansicht enthält jetzt das Modell und kann daher ohne zusätzliche Rückrufe an die Steuerung aktualisiert werden.

UserInfoViewModel.py

self.gender = 'Male'

UserInfoView.py

def getView(self):
    return ui.Label(self.ViewModel().getGender(), onEdited=self.genderEdited)

def genderEdited(self, newValue):
    self.ViewModel().setGender(newValue)

Ich frage mich also, ob ich die sehr primitiven Daten übergeben und die Ansicht so allgemein wie möglich halten soll, dann mit Rückrufen arbeiten und die geschäftlichen Besonderheiten im Controller ausführen soll.

Oder sollte ich das gesamte Modell an die Ansicht übergeben und die Ansicht das Modell direkt aktualisieren lassen. Dies bedeutet, dass weniger Code eingegeben werden muss.

PS. Beurteilen Sie den Code nicht - er dient nur zur Visualisierung.

BEARBEITEN:

Auch hinzuzufügen - diese Anwendung wird in Python geschrieben, das ducktyping unterstützt. Dies bedeutet, dass beim zweiten Ansatz die Ansicht weiterhin wiederverwendbar ist, solange das Modell die erforderliche Schnittstelle erfüllt.

Die einzige "Logik", die eine Ansicht enthalten sollte, sollte der Code sein, der für die Änderung des sichtbaren Status der GUI für den Benutzer verantwortlich ist. Jeder Code, der Daten manipuliert oder einen Wert berechnet, sollte an einer anderen Stelle behandelt werden.

Ihre Ansicht sollte wissen, wie das Modell aussieht, sollte jedoch das Verhalten, das mit den vom Modell bereitgestellten Elementen verbunden ist, nicht kennen.

Wenn Sie einfache Datentypen an Ihre Ansicht übergeben, ist diese sowohl für die Bearbeitung der Benutzeroberfläche als auch für die Speicherung des Ansichtsstatus verantwortlich, was leicht unhandlich werden kann.

Sie sollten das Modell direkt an die Ansicht übergeben, wenn das Modell für die Bearbeitung durch die Ansicht erstellt wurde. Wenn Ihr Modell das gleiche ist, das von Ihrem Datenspeicherungsmechanismus verwendet wird, kann dies später zu Problemen führen, wenn Ihre interne Darstellung und Ansichtsdarstellung voneinander abweichen (wie dies häufig der Fall ist).

Grundsätzlich sollten Sie nur eine Ansicht, ein Ansichtsmodell, ein Datenmodell und etwas für die Geschäftslogik haben. Dann lassen sich alle Ihre Anliegen leicht trennen, Sie müssen sie nur noch zusammenkleben.

Dies ist eine verallgemeinerte Antwort, aber die IMO-Ansicht sollte so wenig Arbeit wie möglich leisten (z. B. Benutzereingaben validieren).

Auf diese Weise können Sie erwarten, dass sich Ihre gesamte Logik im Controller befindet. Dies macht es viel einfacher, das Prinzip der Einzelverantwortung und all das aufrechtzuerhalten.