Czym jest ViewModel?

Cześć, czy moglibyście uświadomić mi do czego stosowany jest ViewModel? Bo moje rozumowanie kończy się na tym, że jest potrzebny do dostarczenia wielu danych do widoku? Czy istnieje jakaś inna potrzeba stosowania tego rodzaju metody? Analizując kod z domyslnego szablonu ASP.NET MVC 4:

 public class LoginModel
    {
        [Required]
        [Display(Name = "User name")]
        public string UserName { get; set; }

        [Required]
        [DataType(DataType.Password)]
        [Display(Name = "Password")]
        public string Password { get; set; }

        [Display(Name = "Remember me?")]
        public bool RememberMe { get; set; }
    }

    public class RegisterModel
    {
        [Required]
        [Display(Name = "User name")]
        public string UserName { get; set; }

        [Required]
        [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
        [DataType(DataType.Password)]
        [Display(Name = "Password")]
        public string Password { get; set; }

        [DataType(DataType.Password)]
        [Display(Name = "Confirm password")]
        [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
        public string ConfirmPassword { get; set; }
    }
 

Czy powyższe klasy zaliczają się do MODELI czy do VIEWMODELI??

Generalnie ViewModel to po prostu dane, z ktorych korzysta widok, jest to cos pomiedzy widokiem a modelem. W viewModelu dane pochodzace z modeli sie odpowiednio przygotowywuje, formatuje itd.

viewmodel zawiera propertiesy potrzebne dla widoku, tak żeby nie zaśmiecać nimi obiektów biznesowych
załóżmy że masz model w którym masz listę liczb - potrzebujesz na widoku wyświetlić średnią z ich wartości - tworzysz propert na viewmodelu który wyliczy średnią i do której będziesz mógł się zbindować

Najczęściej służy więc do agregacji, formatowania i przetwarzania "surowych" obiektów na obiekty gotowe do wyświetlenia użytkownikowi

Viewmodel odseparowuje warstwę widoku od warstwy danych. Jeśli zmienimy pola w modelu, albo pozmieniamy modele tak, że zamiast jednego dużego dostaniemy kilka mniejszych to widok w ogóle tego nie odczuje bo nadal będzie dostawał ten sam viewmodel, który po prostu będzie z innych danych budowany. Poza tym, tak jak już zostało wspomniane, pozwala przesyłać do/z widoku tylko te dane, które potrzebujemy, ewentualnie wstępnie przetworzone.

ViewModel to po prostu warstwa, w której znajduje się cała logika aplikacji pisanej w MVVM. Z pomocą ViewModelu obsługuje się właściwości widoku np. uzupełnianie datagridów czy zbieranie danych z textboksów. Dane w ViewModelu są przekazywane do obiektów, które są Modelami tzn. reprezentują pewną warstwę abstrakcji danych.

Tak przykład:

:: Widok ::
GUI z Textboksem i Datagridem (tabelą jednym słowem)

:: Model ::
Programistyczna reprezentacja danych, bez żadnej logiki czyli np. takie klasy (modele):

 

// Nazwa klasy może pogryźć się z System.Windows.Controls 
// ale to tylko pseudokod.
class TextBox{
	private string _daneTextboksa;

	public string daneTextboksa{
		get { return this._daneTextboxa; }
		set { this._daneTextboxa = value; }
	}

	public Okno(){
		this._daneTextboxa = "";
	}
}

class WierszDataGrida{
	private int _lp;
	private string _dane;

	public int lp{
		get { return this._lp; }
		set { this._lp= value; }
	}

	public string dane{
		get { return this._dane; }
		set { this._dane= value; }
	}

	public Okno(){
		this._lp = 0;
		this._dane = "";
	}
}

:: ViewModel ::
Czyli obsługa tych reprezentacji danych np: uzupełnienie danych w DataGridzie (logika aplikacji):

 
class ViewModel{
	public ViewModel(){
		this.tekst = new TextBox{daneTextboksa = "Cześć"};
		this.wierszeTabeli = new ObservableCollection<WierszDataGrida>();

		//	I np ładowanie danych do tabeli. Zasadniczo powinno być w osobnej funkcji.
		for(int i=0;i<10;i++)
			this.wierszeTabeli.Add(new WierszDataGrida{ 
				lp = (i+1),
				dane = "To jest wiersz: " + lp.toString()
			}
	}

	private TextBox tekst;

	// To jest właściwie lista obiektów typy 'WierszDataGrida' czyli lista wierszy.
	private ObservableCollection<WierszDataGrida> wierszeTabeli;
}

Teraz można w widoku powiązać kontrolki z obiektami 'tekst' i 'wierszeTabeli' za pomocą bindowania. Po takiej czynności kiedy coś zmienisz w ViewModelu widok automatycznie się zaktualizuje.

Oczywiście klasa ViewModel jest napisana w uproszczeniu. Prywatne pola powinny mieć swoje publiczne odpowiedniki żeby mógł je zobaczyć widok, który jest tak naprawdę osobną klasą. Poza tym ViewModel musi posiadać mechanizm, który poinformuje widok o zmianie danych. W C# jest to interfejs 'INotifyPropertyChanged', który za pomocą funkcji 'OnPropertyChange' informuje o zmianie wybranych pól klasy.

To tak w uproszczeniu. Chciałem przedstawić tylko sam mechanizm. To co jest na górze to w sumie pseudokod :)

Co do Twojego pytanie, to wygląda to na klasę modeli. W MVC rolę ViewModelu pełni Controler z tego co się orientuję ale sam nie piszę nic w MVC. Raczej w MVVM, które jest sumie czymś podobnym:)

Dziękuję za liczne odpowiedzi. Tak więc reasumując klasy które wymieniłem wyżej zaliczają się jednak do ViewModeli? Dane są przekazywane z widoku do kontrolera gdzie następnie są dokonywane zmiany w modelu, czy tak? :)

#Tak.
#Tak.