Da ich mich nun nach Jahren der Java Quälerei endlich wieder im .Net Umfeld bewege versuche ich mich gerade in WPF und MVVM einzulesen und wie man damit am Besten eine Anwendung aufbaut welche auf einem WCF Service aufsetzt.

MVVM soll ja das Entwurfsmuster der Wahl für WPF sein, allerdings sind mir da ein paar Dinge noch nicht so ganz klar.

Mein Ansatz wäre jetzt der das ich abgesehen von der View ein ViewModel habe welche halt alle Daten für die View bereitstellt, die Clientseite Logik enthält und die Serviceaufrufe durchführt.

Mein Model wären dadurch ja dann die automatisch erstellten WCF Klassen welche an die Services übergeben werden. Plus evtl. dadurch das diese partial sind ein Gegenstück zu jeder welche Methoden zur Validierung enthält.

Allerdings sehe ich wenn ich es so mache keinen Unterschied zwischen einem ViewModel und einem PresentationModel weshalb ich vermute das mein Ansatz nicht wirklich MVVM entspricht.

Hat jemand Erfahrungen damit?

Hallo,

das ViewModel enthält bei mir die Logik für den View. Hier bspw. Commands und / oder die Properties, die für das Binding notwendig sind. Die Models bilden dann nochmals die Daten des Views ab. Des Weiteren enthält das ViewModel den Aufruf gegen den Service.

Das ViewModel / Model implementiert außerdem das Interface INotifyPropertyChanged, welches den View informiert, dass an bestimmten Properties Änderungen vorgenommen wurden. Die View aktualisiert sich dann je nach Einstellung.

Für das MVVM-Pattern würde ich sogar so weit gehen, dass der Client die DTO’s per Service nochmals mappt. Grund ist hier das angesprochene Interface.

Model:

    public class Customer : NotificationObject

    {

        private string _firstName;


        private string _lastName;


        public string FirstName

        {

            get { return _firstName; }

            set

            {

                if(value == _firstName)

                {

                    return;

                }


                _firstName = value;

                OnPropertyChanged("FirstName");

            }

        }


        public string LastName

        {

            get { return _lastName; }

            set

            {

                if(value == _lastName)

                {

                    return;

                }


                _lastName = value;

                OnPropertyChanged("LastName");

            }

        }

    }

ViewModel bspw. eine Listenansicht

    public class CustomerListViewModel : ViewModelBase

    {

        private readonly ICustomerService _customerService;


        public CustomerListViewModel(ICustomerService customerService)

        {

            _customerService = customerService;


            LoadListCommand = new RelayCommand(OnLoadCommand);

        }


        public ObservableCollection<Customer> Customers { get; private set; }


        public ICommand LoadListCommand { get; set; }


        private void OnLoadCommand()

        {

            LoadCustomers();

        }


        private void LoadCustomers()

        {

            // CustomerService kapselt den Zugriff auf den WCF-Service

            var customers = _customerService.GetAllCustomers();


            foreach (var customer in customers)

            {

                Customers.Add(customer);

            }

        }

    }

NotificationObject

    public abstract class NotificationObject : INotifyPropertyChanged

    {

        public event PropertyChangedEventHandler PropertyChanged;


        protected virtual void OnPropertyChanged(string propertyName)

        {

            PropertyChangedEventHandler handler = PropertyChanged;

            if(handler != null)

            {

                handler(this, new PropertyChangedEventArgs(propertyName));

            }

        }

    }

ViewModelBase enthält weitere Logik, bspw. den EventAggregator von PRISM oder Caliburn(.Micro)

Aber es gibt hier viele Ansätze.

Meist wird das Model nochmals als ViewModel abgebildet. Grund ist hier wohl die Validierung. Dafür gibt es aber in meine Augen andere Möglichkeiten (FluentValidation)

EDIT:

Eine nette Übersicht von Karl Shifflet:

http://karlshifflett.files.wordpress.com/2009/01/wpflobmvvm1.png

Dank dir.

Per PN hab ich auch noch folgendes erhalten

Ich habe den Artikel mal kurz überflogen.

Das PresentationModel entspricht im MVVM Muster dem ViewModel.

Kleines Zitat aus dem Text :

Das sind genau die Vorteile, die man aus dem ViewModel zieht.

• Trennung der Logik von der Oberfläche
  
• Entkopplung durch Interfaces
  
• Logik Unit-Test bereit machen
  
• ....
  

Meiner Meinung nach vermischen Sie mit diesen Schritt zwei Entwurfsmuster.

Ein Kollege meinte das auch so, also ist es wohl wirklich so das die beiden Entwurfsmuster so ziemlich das Selbe nur mit einem anderen Namen beschreiben.

Dann werd ich das jetzt mal mit ner kleinen Testanwendung ausprobieren