Quanto dovrebbe sapere una vista sul modello?

Sto creando un'applicazione in Python con un wrapper Python per WPF e con supporto DAG. Attualmente sono a un punto in cui devo decidere un modo coerente di interagire tra i dati e la vista.

Per quanto vedo ci sono attualmente due soluzioni ovvie.

Il primo è simile a come sono strutturate le applicazioni Android. Hai un controller che imposta / popola la vista. Quindi il controller possiede la vista e invia solo i dati primitivi che verranno visualizzati. La vista è solo un livello stupido e non ha idea di cosa sta succedendo e da dove provengano quei dati. Quindi, se l'utente interagisce con la vista, invierà richiamate al controller (se registrato).

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)

Il secondo è passare un modello (di riferimento) alla vista e consentire alla vista di recuperare e aggiornare i dati. La vista ora contiene il modello e quindi può aggiornarlo senza ulteriori callback al controller.

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)

Quindi suppongo che sia quello che sto chiedendo, dovrei passare i dati molto primitivi e mantenere la vista il più generica possibile, quindi lavorare con i callback e fare le specifiche aziendali nel controller.

O dovrei passare l'intero modello alla vista e consentire alla vista di aggiornare direttamente il modello. Ciò significa che ci sarà meno codice da digitare.

PS. Non giudicare il codice: è solo per la visualizzazione.

MODIFICARE:

Inoltre , questa applicazione verrà scritta in Python che supporta il ducktyping. Ciò significa che con il secondo approccio, la vista è ancora riutilizzabile purché il modello soddisfi l'interfaccia richiesta.

L'unica "logica" che una vista dovrebbe contenere, dovrebbe essere il codice responsabile della modifica dello stato visibile della GUI per l'utente. Qualsiasi codice che manipola i dati o calcola un valore dovrebbe essere gestito altrove.

Il tuo punto di vista dovrebbe sapere come appare il modello, ma dovrebbe essere ignaro del comportamento associato a qualsiasi cosa il modello esponga.

Passare semplici tipi di dati alla vista lo rende responsabile sia della manipolazione della GUI sia della memorizzazione dello stato della vista, che può facilmente diventare ingombrante.

È necessario passare il modello direttamente alla vista se il modello è stato creato per essere manipolato dalla vista. Se il modello è lo stesso utilizzato dal meccanismo di archiviazione dei dati, ciò può causare problemi lungo la strada se la rappresentazione interna e la rappresentazione della vista divergono (come spesso accade).

Fondamentalmente, dovresti avere solo una vista, un modello di visualizzazione, un modello di dati e qualcosa per gestire la logica aziendale. Quindi tutte le tue preoccupazioni si separano facilmente, devi solo incollarle insieme.

Questa è in qualche modo una risposta generalizzata, ma la vista IMO dovrebbe fare il minor lavoro possibile (ad es. Convalidare gli input dell'utente).

In questo modo puoi aspettarti che tutta la tua logica sia nel controller. Questo rende molto più facile mantenere la strada, il principio della responsabilità singola e tutto il resto.