jump to navigation

Winforms – Model-View-Presenter – A tutorial May 11, 2009

Posted by wesaday in Programming.
Tags: , , ,
4 comments

Introduction

Coming from a C/C++ and diving into the .NET, I am constantly surrounded by strange phrases, three letter acronyms and concepts that take a long time to get used to. One of those concepts is the Model-View-Presenter (MVP).  There are plenty of articles about MVP around the Web. Most are pointers to Martin Fowler (http://www.martinfowler.com/eaaDev/uiArchs.html) or the MSDN (http://msdn.microsoft.com/en-us/library/cc304760.aspx). There are also many articles on Code Project (www.codeproject.com). The problem that I have had in the reading of these articles is that most use big $.25 words and unfamiliar phrases that mean nothing to the beginner, along with diagrams that are just plain confusing. Nothing I found that was in plain simple English. After a lot of trial and error and study I think I finally have something that I can understand. I do not pretend that this is the “right way” or the only way but it works for me.

This is the first part of five. Links to the other parts are:

     Part II

     Part III

       Part IV

       Part V

 

MVP

The goal of using the MVP design pattern is to separate the responsibilities of the application in such a manner as to make the application code:

·         Testable in an automated manner

·         Make the application more maintainable

·         Make the application more extensible. 

The first bullet means that there are many tools out there in the world that can be used to test code in an automated manner, called “unit testing”. These tools cannot test code that is in form code-behind modules. So the aim is to take that code out of the form code and place it in a DLL that can be tested.

I do not know about anyone else, but for me application code is way more maintainable when it is separated out into modules that have a specific purpose. If some unexpected feature does make it through the unit testing, then you will have a pretty good idea where to look just based on knowing what the various classes’ responsibilities are.

The extensibility part comes in when you have this separation of concerns, adding additional functionality is made easier because the code modules are not closely tied together also known as “loose coupling”.

What does it all mean?

The first thing is to understand the meaning of what the terms mean.

View: A view is any form or window that is shown to the user of the application.

Presenter: The presenter is an entity that presents the data to the view that is to be shown to the user.

Model: The model is the actual data that the Presenter will request and gets displayed in the View. The Model is responsible for obtaining the data. So the Model is the one that reads files, or connects to a database or if you are really ambitious, gets the data from a data service object.

The pattern is typically drawn like this.

uml1 

Looks simple doesn’t it? Well what all those other articles, and examples, didn’t tell me was how to turn that simple diagram into a working application.

Get on with it already!

The first thing to do is to setup the solution. Open up Visual Studio and create a new Windows Forms Application.

 newproject1

 

Once Visual Studio is through creating your new project, add a class library to the solution to hold all of the various classes. Right click your solution object in the Solution Explorer, select Add then Add new project.

 addnew1

 

classlibrary 

 

I named mine Common.Lib.dll you can name yours whatever you want to. I have seen some people that create a class library to contain the business logic and another one to contain the data layer. I think is overkill for this simple example. Go ahead and delete the Class1.cs file that Visual Studio created for you.

I like to compartmentalize things so I group like classes together. Right click on the class library project; select Add then Select New Folder. Name the new folder, Interfaces. Repeat twice more and name the other two new folders Models and Presenters. Your project should now look like this.

solutionex

This is the end of Part 1. After starting the article it quickly grew to 14 pages and I was not done yet so I elected to post a series of pages.

 

This is the project skeleton so far. Change the extension from .doc to .zip before you open it. This is a workpress requirement. projectskeletonzip

Advertisements

Model-View-Presenter and Model-View-ViewModel in Prism March 23, 2009

Posted by wesaday in Programming.
Tags: , , , , , ,
5 comments

 Introduction

 One of the most valuable skills a developer can develop is the ability to seperate UI modules, business rules and data access modules so that they are more maintainable. This separation means that the modules can be developed independently of each other without the changes having any impact on other modules. After several years in the business you get kind of tired of making a change and then having to chase down a bug that made its way in your application affecting modules that you never thought your change would touch you will come to appreciate separating out the code into different modules. Prism actually makes this pretty simple.

The first design pattern that will be demonstrated is the Supervising Presenter pattern that most closely resembles the Model-View-Presenter pattern so if you understand the MVP pattern then you should have no problem understanding this. For more information on the Supervising Presenter pattern see the Supervising Presenter topic in the Prism documentation.

A simple diagram for the MVP pattern looks like this:

 

 

 

 

 

MVP diagram

MVP diagram

 

 

 

 

 

The second design pattern that will be demonstrated is the Presentation Model or Model-View-ViewModel pattern.  For more on the Presentation Model pattern see the Presentation Model topic in the Prism documentation.

A simple diagram of the Presentation Model pattern looks like this:

 

 

 

 

 

MVVM diagram

MVVM diagram

 

 

 

 

 

The foundation for this demonstration is the final project from the Getting Started article which you can get here.

First the MVP pattern

The first thing to do is to decide what kind of data that we are going to display in the view and how we are going to display it. For this simple example we are going to display some strings in a ListBox. So the final ChildOneView will look like this:

 

one

The second thing to do is to create some folders within the project to hold the various files that we are going to be creating. This helps to keep the clutter down.  Right click on the ChildOneModule project and add a NewFolder named “Interfaces”. Add two more folders and name them “Presenters” and “Services”. Now we are going to need to create three interfaces, one for the View, one for the Model and one for the Presenter.  After that your project will look something like this

struct1

The interfaces are very simple. The Model interface will expose a collection strings that the view will bind to.

 

 

 

    public interface IChildOneService

    {

        ObservableCollection<string> GetStrings();

    }

 

 

 

 

 

 

The Presenter interface will need to have a reference to the View:

 

 

 

    public interface IChildOnePresenter

    {

        IChildOneView View { get; set; }  

    }

 

 

 

 

 

 

And finally, the View will need to have a reference to the data that the Model is going to expose:

 

 

 

    public interface IChildOneView

    {

        ObservableCollection<string> Model { get; set; }

    }

 

 

 

 

 

 

That pretty much does it for the interfaces. The next thing to do is to create a class that will serve as the Model. Right click the Services folder and add a new class named “ChildOneService”. The service will need to implement the IChildOneService interface that we created earlier.

 

 

 

    public class ChildOneService : IChildOneService

    {

        public ObservableCollection<string> GetStrings()

        {

            ObservableCollection<string> strings = new ObservableCollection<string> { “one”, “two”, “three”};

            return strings;

        }

    }

 

 

 

 

 

 

The GetStrings method will return the string collection and that is what is going to be displayed in the View. It’s important to realize that the data that is displayed could come from anywhere, a file, a database, a web service, etc.

The Presenter class is also very simple. Create a ChildOnePresenter class in the “Presenters” folder and have it implement the presenter interface. The Presenter will need a reference to the view and the model passed to it in the class constructor.

 

 

 

    public class ChildOnePresenter : IChildOnePresenter

    {

        public IChildOneView View { get; set; }

 

        public ChildOnePresenter(IChildOneView view, IChildOneService model)

        {

            View = view;

            View.Model = model.GetStrings();

        }

    }

 

 

 

 

 

 

Open the view code-behind file. Modify the class definition to implement the IChildOneView interface. The view interface is implemented as a property that is used to data bind to. The data is transferred from the ChildOneService class to the View by the Presenter.

 

 

 

   public partial class ChildOneView : UserControl, IChildOneView

    {

        public ChildOneView()

        {

            InitializeComponent();

        }

 

        public ObservableCollection<string> Model

        {

            get

            {

                return DataContext as ObservableCollection<string>;

            }

            set

            {

                DataContext = value;

            }

        }

    }

 

 

 

 

 

 

Open the View XAML file and modify the view to include a listbox and bind the listbox item data source to the string collection.

 

 

 

    <StackPanel>

        <Label Content=”Child one” />

        <ListBox ItemsSource=”{Binding}” />

    </StackPanel>

 

 

 

 

 

 

The last step is to modify the module class. We need to include a reference to the container so that we can notify the container that we have additional classes for it to instantiate. Once that is done, then we register the Model, View and Presenter with the container

 

 

 

    public class ChildOne : IModule

    {

        private readonly IRegionManager _regionManager;

        private readonly IUnityContainer _container;

 

        public ChildOne(IUnityContainer container, IRegionManager regionManager)

        {

            _regionManager = regionManager;

            _container = container;

        }

 

        public void Initialize()

        {

            _container.RegisterType<IChildOneService, ChildOneService>();

            _container.RegisterType<IChildOnePresenter, ChildOnePresenter>();

            _container.RegisterType<IChildOneView, ChildOneView>();

 

            ChildOnePresenter presenter = _container.Resolve<ChildOnePresenter>();

            _regionManager.Regions[“LeftChild”].Add(presenter.View);

        }

    }

 

 

 

 

 

 

If you compile and run the application at this point, you should see a window like the picture up top. That is how to implement the MVP pattern in Prism.

Model-View-ViewModel

The MVVM pattern is implemented in almost the same way. The only real difference is the way the View displays its data. MVVM relies heavily on data binding and Commands to get things done. This article is not going to cover Commands. That is something for another time.

To begin, create folders in the ChildTwoModule project named Interfaces, Services and ViewModels. You should turn out with something that looks like this:

 

struct2

For this example we will need three interfaces, IChildTwoModel, IChildTwoView and IChildTwoViewModel. As in the previous example, the Model will export a list of strings so our interface for the Model will look like this:

 

 

 

    using System.Collections.ObjectModel;

 

    public interface IChildTwoModel

    {

        ObservableCollection<string> GetStrings();

    }

 

 

 

 

 

 

The interface for the ViewModel will need to have a Property that exposes the list of strings to the View. The ViewModel will also need a reference to the View so our interface for the ViewModel will look like this:

 

 

 

    public interface IChildTwoViewModel

    {

        ObservableCollection<string> ModelStrings { get; }

 

        IChildTwoView View { get; }

    }

 

 

 

 

 

 

 The interface for the View will need a way to set the data to display. Since the ViewModel is exposing the data, the View needs a way to data bind the ViewModel to the View:

 

 

 

    public interface IChildTwoView

    {

        void SetModel(IChildTwoViewModel model);

    }

 

 

 

 

 

 

Now, on to the implementation. The Model class needs to implement the IChildTwoModel interface so create a new class in the Services folder named ChildTwoModel and then implement the interface. Remember that the interface is a method named GetStrings and returns a collection of string objects. So your Model class will look like this:

 

 

 

    using Interfaces;

    using System.Collections.ObjectModel;

 

    public class ChildTwoModel : IChildTwoModel

    {

        public ObservableCollection<string> GetStrings()

        {

            ObservableCollection<string> strings = new ObservableCollection<string> { “one”, “two”, “three” };

            return strings;

        }

    }

 

 

 

 

 

 

For the moment, I am going to skip over the ViewModel class as it is the most involved. Open up the View class and modify it to implement the IChildView interface. That brings in a method SetModel that will setup the data binding:

 

 

 

    public partial class ChildTwoView : UserControl, IChildTwoView

    {

        public ChildTwoView()

        {

            InitializeComponent();

        }

 

        public void SetModel(IChildTwoViewModel model)

        {

            DataContext = model;

        }

    }

 

 

 

 

 

 

Now open up the ChildTwoView.xaml file. Change the Grid layout panel to a StackPanel, and then add a ListBox to the StackPanel. Set the ItemsSource to the bind to the ModelStrings.

 

 

 

    <StackPanel>

        <Label Content=”Child two” />

        <ListBox ItemsSource=”{Binding ModelStrings}” />

    </StackPanel>

 

 

 

 

 

 

Now we come to the ViewModel class. The ViewModel class in the MVVM pattern takes on a lot of responsibility. The ViewModel not only provides data to the View but it also keeps track of the View state and acting as a go-between to the Model. One thing that is a really nifty feature is that the ViewModel can automatically update the Views data just by raising a property changed event. Okay so our ViewModel class needs to implement the IChildTwoViewModel interface and the INotifyPropertyChanged interface. The class constructor will need a reference to the View and the Model and set the ViewModel in the View:

 

 

 

        private readonly IChildTwoView _view;

        private readonly IChildTwoModel _model;

        private ObservableCollection<string> _modelStrings;

 

        public ChildTwoViewModel(IChildTwoView view, IChildTwoModel model)

        {

            _view = view;

            _model = model;

            _modelStrings = new ObservableCollection<string>();

            _modelStrings = _model.GetStrings();

            View.SetModel(this);

        }

 

 

 

 

 

 

 The SetModel method sets the data binding to the ViewModel. Now if you remember the View data binds the ListBox to something called ModelStrings so we need to implement a Property to expose the model strings:

 

 

 

        public ObservableCollection<string> ModelStrings

        {

            get

            {

                return _modelStrings;

            }

 

            set

            {

                _modelStrings = value;

                OnPropertyChanged(“ModelStrings”);

            }

        }

 

 

 

 

 

 

The OnPropertyChanged event notifies the View that the data has changed (if it does) and to update the data in the View.

 

        public event PropertyChangedEventHandler PropertyChanged;

 

        private void OnPropertyChanged(string propertyName)

        {

            PropertyChangedEventHandler handler = PropertyChanged;

            if (handler != null)

            {

                handler(this, new PropertyChangedEventArgs(propertyName));

            }

        }

 

The final thing is to modify the ChildTwoModule class to register the interfaces and the classes with the container just like we modified the ChildOneModule class.

 

 

 

        public void Initialize()

        {

            _container.RegisterType<IChildTwoModel, ChildTwoModel>();

            _container.RegisterType<IChildTwoViewModel, ChildTwoViewModel>();

            _container.RegisterType<IChildTwoView, ChildTwoView>();

 

            IChildTwoViewModel view = _container.Resolve<IChildTwoViewModel>();

 

            _regionManager.Regions[“RightChild”].Add(view.View);

        }

 

 

 

 

 

 

Now you should be able to compile and run that application and get a window similar to this:

 

final1

This concludes out whirlwind (and simplistic) tour of the Model-View-Presenter pattern and the Model-View-ViewModel in Prism. Hopefully you have a foundation from which to build and explore more in Prism. The final demonstration project (VS2008) can be found here. Rename the doc to zip before you open the archive. This is a wordpress.com requirment.

Getting started with Prism 2, formerly known as the Composite Application Library March 17, 2009

Posted by wesaday in Programming.
Tags: , , , ,
4 comments

Introduction

Prism is a set of libraries that allow developers to compose applications from separate components into a composite application. Composite meaning that the application functionality is split up into different modules that do not necessarily know about each other and then brought together to create an application.

 From the Prism documentation: “Composite applications provide many benefits, including the following:

·         They allow modules to be individually developed, tested, and deployed by different individuals or sub-teams; they also allow them to be modified or extended with new functionality more easily, thereby allowing the application to be more easily extended and maintained. Note that even single-person projects experience benefits in creating more testable and maintainable applications using the composite approach.

·         They provide a common shell composed of UI components contributed from various modules that interact in a loosely coupled way. This reduces the contention that arises from multiple developers adding new functionality to the UI, and it promotes a common appearance.

·         They promote re-use and a clean separation of concerns between the application’s horizontal capabilities, such as logging and authentication, and the vertical capabilities, such as business functionality that is specific to your application.

·         They help maintain a separation of roles by allowing different individuals or sub-teams to focus on a specific task or piece of functionality according to their focus or expertise. In particular, it provides a cleaner separation between the user interface and the business logic of the application—this means the UI designer can focus on creating a richer user experience. ”

The Prism documentation is actually very good with showing you how to accomplish individual tasks. Where the documentation falls short is when you want to bring the differing concepts together. For example, the documentation does lead you through creating an application and showing a view, what it does not show you is how to create a view that possibly contains multiple “child” views

The goals for this article are

a.       Build the Prism library

b.      Setup an application shell that shows the main window

c.       Create a module that shows a view in the main window

d.      Create a module that shows a view in the first module

e.       Create a module that shows a second view in the first module

f.       Load the modules from a configuration file

But before we get to that we have to know;

How to get and setup Prism

Head on over to the Prism web site, http://www.codeplex.com/Prism, and download the Prism package. The site also serves as the community portal to ask questions of the Prism development team. Unzip the archive to the folder of your choice then open that folder up in explorer to view the files. The folder will contain several batch files that will conveniently open up several different sections of the Prism project. The two batch files that we are interested in at this time are named “Desktop & Silverlight – Open Composite Application Library” and “Desktop only – Open Composite Application Library”. The first batch file will open up a solution that will compile the libraries to use in WPF and Silverlight. If you are not doing any Silverlight application that you can use the second batch file. But you cannot use the libraries interchangeably (I think, I have not verified this as I do not do Silverlight development but otherwise there would be no need for separate projects). So, double click the batch file of your choice and the Prism solution will load up into Visual Studio 2008 (as of this writing). Then build the solution. The output libraries will be placed in <Prism root>CAL->Desktop

Creating the shell

I am going to assume that you know how to create an application solution, reference libraries and create class libraries in Visual Studio so I am not going to explain those details in depth. If you do not, you should study those items first. The first thing to do is to fire up Visual Studio 2008. Then create a new WPF application and name it whatever you want. For the purpose of this article I will name my solution “PrismArticle”. This is going to be the “shell” for our application. The shell is just a container to display the primary user interface. The shell can contain one of more views that are displayed to the user. Note that some of the code presented is more or less boilerplate code and copied from the Prism documentation.

1.      In the solution explorer, rename Window1.xaml to Shell.xaml.

2.      Then open the code behind file and rename the class name from Window1 to Shell

3.      Open Shell.xaml and change the Title attribute to “PrismArticle” or whatever you want.

4.      Add the CompositeWPF namespace to the Shell.xaml file, xmlns:cal=”http://www.codeplex.com/CompositeWPF&#8221;

5.      Remove the Grid tags from the XAML and add a ContentControl named “MainRegion” and set the region name to “MainRegion” for Prism:

a.        <ContentControl Name=”MainRegion” cal:RegionManager.RegionName=”MainRegion”/>.

6.      Add a new class to your project named Bootstrapper.cs.

7.      Add references to the Prism libraries:

a.        Microsoft.Practices.Composite

b.      Microsoft.Practices.Composite.UnityExtensions

c.       Microsoft.Practices.Composite.Presentation

8.      Add these using statements to the top of the Bootstrapper file.

a.  using Microsoft.Practices.Composite.Modularity;

b.  using Microsoft.Practices.Composite.UnityExtensions;

c.  using System.Windows;

9.      Change the Bootstrapper class to inherit from the UnityBootstrapper class.

class Bootstrapper : UnityBootstrapper

10.  Override the CreateShell method in the Bootstrapper class.

        protected override DependencyObject CreateShell()
        {
               Shell shell = new Shell();
               shell.Show();
               return shell;
        }

11.  Override the GetModuleCatalog method.

        protected override IModuleCatalog GetModuleCatalog()

        {

            ModuleCatalog catalog = new ConfigurationModuleCatalog();

            return catalog;

  }

12.  Open the App.xaml.cs and override the Startup event.

        protected override void OnStartup(StartupEventArgs e)

        {

            base.OnStartup(e);

            Bootstrapper bootstrapper = new Bootstrapper();

            bootstrapper.Run();

        }

13.  Open the App.xaml file and remove the StartupUri since we are manually starting up the window in the bootstrapper.

 

Solution skeleton

Solution skeleton

 

 

Your final solution should look something like this. If all went well you should be able to build and run the application. But…

What the heck did we just do?

Everything up to step 8 should be pretty much self explanatory except for step 5.

Step 5 is where we setup a ContentControl in the shell window and named it “MainRegion”. Prism uses a concept called a Region that defines an area where a view is going to be displayed. If we had a module that mapped itself to the MainRegion, then that view would appear in that region. We will be doing just that in the next section.

Step 9 is where the application main window is created and shown.

Step 10 is where a catalog of the modules that the application uses is created. There are several different ways to accomplish this but for our example we are going to use a ConfigurationModuleCatalog which reads a configuration file and loads the modules defined in that file.

Step 11 is where the application starts up and instantiates the Bootstrapper.

Creating the first module

Before we create our first module we need to do a bit of configuration. Remember that we wanted to load our modules at runtime. To do that we have to have a place for the modules to be. So, in the solution folder create a “bin” folder, and then inside that folder create a “modules” folder. The bin folder is where we will put the executable and the modules folder is where the modules are going to go. Open up the project properties and on the Build tab set the output path to the bin folder that we just created.

Now for our first module. One thing that I deviate from the Prism documentation is that the Prism docs describe creating the regions to show the views in the shell. What I am going to do is to create a module that is shown in the main window and defines the regions for the application. This way the shell application remains static and the modules define the application. So our first module is the view that is going to be shown in the MainRegion that we defined before.

Add a Class Library project to the solution. For the sake of this example, I named my module project “MainWindowModule”. Open the Project properties select the Build tab and then change the output path to the modules folder under the bin folder that we created earlier.

Rename the Class1.cs file to MainWindow.cs. This will also rename the class to MainWindow. Add a reference to the Microsoft.Practices.Composite.dll. Then add a using statement to the top of the file:

 using Microsoft.Practices.Composite.Modularity.

Add a private variable to the class named _regionManager of type IRegionManager. The RegionManager allows us to access the regions defined in the application. Add a constructor to the class that accepts an IRegionManager parameter. Inside the constructor, make the _regionManager equal to the IRegionManager passed in.

Edit the class definition so that the class inherits from IModule. IModule is the interface that Prism uses to discover and initialize the modules. The method that we need to implement is the Initialize method. Inside the Initialize method, add the MainWindowView to the MainRegion through the region manager:

            _regionManager.Regions[“MainRegion”].Add(new MainWindowView());

Now we need a MainWindowView to show in the MainRegion. Just to make things a bit tidy, add a new folder to our solution named “Views”. Inside the Views folder, add a new WPF user control named MainWindowView. To make everyone happy, you have to add another using statement to include the Views now.

using MainWindowModule.Views;

  Now, after all that what do you think will happen when you build and run the application now? Well, try it and see what happens. Go ahead. I will wait. Ready? What you should have seen is the same window we saw before we created the module and jumped through all those other hoops. If you set a break point in the Initialize method of the module you will find out that the method in not called. So what is up with that? Well before we can see the view in the main window we have to…

Configure the module

To configure the application to load our modules we have to add a configuration file to the executable project. So add a New Item -> Application Configuration File. I named my file App.config. This is the configuration file that the application is going to read to create the ConfigurationModuleCatalog in the Bootstrapper class. Add the following code to the app config file:

  <configSections>

    <section name=modules type=Microsoft.Practices.Composite.Modularity.ModulesConfigurationSection, Microsoft.Practices.Composite />

  </configSections>

  <modules>

    <module assemblyFile=Modules/MainWindowModule.dll moduleType=MainWindowModule.MainWindow, MainWindowModule moduleName=MainWindowModule />

  </modules>

The Modules section defines what module to load and where to load it from. The “assemblyFile” attribute defines from where to load the module from. In this case we are loading the module from the Modules folder. The “moduleType” attribute is the name of the class that we want to load. The Prism docs call this a “type” which might be misleading for a beginner. This is the namespace and name of the class that implements the IModule interface. The last attribute simply defines the module name. There are other attributes that I will leave for another time. This is sufficient to get us going.

Now if you run the application you show at least get a stop at the break point you set earlier. But, chances are that you will see a blank window. Unless you open up the MainWindowView XAML file and put something in the window you won’t see anything. Go ahead and experiment and when you are finished playing around we will go on to the next phase.

Child views

Now that we know how to create and load a module the next thing that we want to do is to create a couple of child windows that we will display in the MainWindowView. We are not going to do anything fancy. Adding child views to the MainWindow is relatively painless. It’s basically the same as what we did for the MainWindowModule expect that the regions that we are going to define are in the MainWindowView. So, open up the MainWindowView XAML file and delete any content that you might have put there to experiment with. If you did do any experimenting you might have noticed that the contents of the MainWindowView were confined to a specific size when you resized the window. This is because of the Width and Height attributes in the view being set to 300. Go ahead and delete those two settings so that the view will fill the parent window.

 Now add a Grid layout control and define two columns. Add a content control to column zero and add another content control to column 1. Being so imaginative I named the region in column 0 “LeftChild” and the region in column 1 “RightChild”. Of course you are free to improve on that design J

Add 2 more class libraries to the solution; name one “ChildOneModule” and the other “ChildTwoModule”. The setup for these modules pretty much mimics the steps we followed to create the MainWindowView. The code for both is about the same except for the region names.

Here is what I did. Feel free to experiment. The ChildOneView I simply changed the background color and added a label to identify the view. I did the same to the ChildTwoView except I made the color different.

·         Remember to change the output path for the two modules

·         Remember to add the Prism libraries to the module projects.

·         Remember to add the module definitions to the app.config file. Note that the order in which the modules are listed matters! If you list the child modules after the MainWindowModule , Prism will throw an exception saying that the RegionManager does not contain the <name of region> region. After running around in circles for about 2 hours, you will discover that the modules appear to be loaded from the bottom up. So the MainWindowView has to get initialized first so the other views have a region to get loaded into.

The final application will look like this when it’s all said and done.

Final result from all this

Final result from all this

 

Conclusion

There we have downloaded and complied the Prism Library. Created a project that created a shell window using Prism, added a module to serve as the main window view and then finally added two more modules that served as two child views and loaded into the application dynamically loaded at runtime. This allows the UI views for the application to be developed separately from each other and to be totally independent code. Hopefully this is just the beginning of an exploration of the Prism framework. Depending on my work load and motivation I may continue writing about this. Next I think that I will explore getting our two child views to communication with each without them having to know anything about each other.

Here are links to the code for this article. Rename the archive from .doc to .zip before opening, this is a wordpress requirement. The code is presented as is with no warranty implied or guaranteed.

prism-article-part-1 This is the code for the initial project

prism-article-part-2 This is the code for the second part of the article

prism-article-part-3 This is the final code solution

MVVM in WPF Part II February 13, 2009

Posted by wesaday in Programming.
Tags: , , ,
11 comments

This is the second part in a two part article on the Model-View-ViewModel design pattern in WPF.

The Model

Our friend the Model is responsible for getting and holding onto the data. The data could come from anywhere, a file, a database, thin air, etc. Our Model is the one that is going to read the data out of the file and store it in a DataTable so that the ViewModel can present it to the View. So add a Model class to the Model project. I called mine “MainModel” because it’s going to the MainWindow. We are going to need three things in our Model, a constructor, a method to get the data from the file, and a property to expose the data to the outside world. The method is easy as we are just going to copy the same code from the previous article and make minor modifications to it. So here is our GetFileData method.

        public bool GetFileData(string filename)

        {

            const string connectionString = @”Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\csvfiles\;Extended Properties=’text;HDR=Yes'”;

            string commandText = string.Format(“Select * from {0}”, filename);

            OleDbConnection conn = new OleDbConnection(connectionString);

 

            conn.Open();

 

            OleDbDataAdapter da = new OleDbDataAdapter(commandText, conn);

            DataSet temp = new DataSet();

            da.Fill(temp);

            FileData = temp.Tables[0];

            return true;

        }

Here we are opening a file from the C:\csvfiles directory and filling a DataTable with the results. FileData is the name of the property that is holding the data. So lets add that next.

        public DataTable FileData

        {

            get; set;

        }

Pretty simple. The only thing left to do is to add the constructor.

        public MainModel()

        {

            FileData = new DataTable();

        }

That’s it for the Model. Remember to reference the System.Data and OleDb namespaces for the GetFileData method. Here is the complete listing for the Model.

namespace Article.Model

{

    using System.Data;

    using System.Data.OleDb;

 

    public class MainModel

    {

        public MainModel()

        {

            FileData = new DataTable();

        }

 

        public DataTable FileData

        {

            get; set;

        }

 

        public bool GetFileData(string filename)

        {

            const string connectionString = @”Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\csvfiles\;Extended Properties=’text;HDR=Yes'”;

            string commandText = string.Format(“Select * from {0}”, filename);

            OleDbConnection conn = new OleDbConnection(connectionString);

 

            conn.Open();

 

            OleDbDataAdapter da = new OleDbDataAdapter(commandText, conn);

            DataSet temp = new DataSet();

            da.Fill(temp);

            FileData = temp.Tables[0];

            return true;

        }

    }

}

Nothing to it. That is it for the Model. Next we will move to the ViewModel.

The ViewModel

Most of the action happens in the ViewModel so it naturally follows that the ViewModel is the most complex which was my stumbling block. There is so much that can, and does, go on in there that it can quickly get confusing.  The very first thing to do is to create a base ViewModel class that we could use to base our ViewModels on. For this simple example it really is not necessary but it does serve as a good base to build from. So add a new class to the ViewModels folder in the project and call it BaseViewModel.  Make the base class abstract and implement the INotifyPropertyChanged and IDisposable interfaces. Implementing those interfaces in the base class saves us from having to implement them in each and every other ViewModel.  Some of this code is strictly for debugging purposes and those are commented. I believe that 99% of the base class code was Josh Smiths. I added some code comments but that was about it.  This is the code stripped down. Not much to it and should be pretty much self explanatory.

    public abstract class BaseViewModel : INotifyPropertyChanged, IDisposable

    {

        protected BaseViewModel()

        {

        }

 

        ~BaseViewModel()

        {

            string msg = string.Format(“{0} ({1}) ({2}) Finalized”, GetType().Name, DisplayName, GetHashCode());

            Debug.WriteLine(msg);

        }

 

        public event PropertyChangedEventHandler PropertyChanged;

 

        public virtual string DisplayName

        {

            get; protected set;

        }

 

        protected virtual bool ThrowOnInvalidPropertyName

        {

            get; private set;

        }

 

        public void Dispose()

        {

            OnDispose();

        }

 

        [Conditional(“DEBUG”)]

        [DebuggerStepThrough]

        public void VerifyPropertyName(string propertyName)

        {

            // Verify that the property name matches a real,

            // public, instance property on this object.

            if (TypeDescriptor.GetProperties(this)[propertyName] == null)

            {

                string msg = “Invalid property name: “ + propertyName;

 

                if (ThrowOnInvalidPropertyName)

                {

                    throw new Exception(msg);

                }

 

                Debug.Fail(msg);

            }

        }

 

        protected virtual void OnDispose()

        {

        }

 

        protected virtual void OnPropertyChanged(string propertyName)

        {

            VerifyPropertyName(propertyName);

 

            PropertyChangedEventHandler handler = PropertyChanged;

            if (handler == null)

            {

                return;

            }

 

            var e = new PropertyChangedEventArgs(propertyName);

            handler(this, e);

        }

    }

Now we are ready for the MainViewModel. Add a new class to the ViewModels and name it MainViewModel. Make sure to derive from the BaseViewModel class. Because there is a lot of stuff going on in here, we are going to take it nice and easy getting through this. This is the class definition.

    public class MainViewModel : BaseViewModel

    {

    }

The two things that we need right now is two private variables, one for the Model and one for the data that the View is going to display.

        private readonly MainModel _model;

 

        private DataTable _fileData;

 

Because I am simple minded, we are going to initialize the variables in the constructor:

        public MainViewModel()

        {

            _model = new MainModel();

            _fileData = new DataTable();

        }

 

Now we need a method to call to get the data from the model:

        public void GetData()

        {

            _model.GetFileData(“test.csv”);

            FileData = _model.FileData;

        }

We have hard code a file name here but, if you wanted to you could open a file browser and let the user select a file to open.

And then a property to expose the data to view:

        public DataTable FileData

        {

            get

            {

                return _fileData;

            }

 

            set

            {

                _fileData = value;

                OnPropertyChanged(“FileData”);

            }

        }

 

Notice that the property called OnPropertyChanged in the setter. When that happens the view is automatically updated with the changed information. Magic!

As long as we are here we are going to introduce a Command. The command that we are going to use is going to get used when the user clicks the Button on the main window.  The command will get routed to the ViewModel and the ViewModel will handle the command.  We are going to need another variable for the command:

private RelayCommand _getDataCommand;

We are going to use the RelayCommand class to encapsulate the RoutedCommand. The RelayCommand class was also written by Josh Smith. Now to expose the command to the View we do this:

        public ICommand GetDataCommand

        {

            get

            {

                if (_getDataCommand == null)

                {

                    _getDataCommand = new RelayCommand(param => GetData());

                }

 

                return _getDataCommand;

            }

        }

The main point of this is the initialization of the Command. The RelayCommand is passed the method that it is going to call when the button is clicked. In this case, the GetData method is going to be that method.

As hard as it is to believe, that is it for the hardest part. After the code listing we are off to the View. This is the complete listing for the MainViewModel:

    public class MainViewModel : BaseViewModel

    {

        private readonly MainModel _model;

 

        private DataTable _fileData;

 

        private RelayCommand _getDataCommand;

 

        public MainViewModel()

        {

            _model = new MainModel();

            _fileData = new DataTable();

        }

 

        public DataTable FileData

        {

            get

            {

                return _fileData;

            }

 

            set

            {

                _fileData = value;

                OnPropertyChanged(“FileData”);

            }

        }

 

        public ICommand GetDataCommand

        {

            get

            {

                if (_getDataCommand == null)

                {

                    _getDataCommand = new RelayCommand(param => GetData());

                }

 

                return _getDataCommand;

            }

        }

 

        public void GetData()

        {

            _model.GetFileData(“test.csv”);

            FileData = _model.FileData;

        }

    }

The View

The view is oh so simple, really. The first thing that you need to do is to go over to www.codeplex.com and get the WPFToolkit, http://www.codeplex.com/wpf. I used the data grid control for WPF for this example. So this will also show you how to use the data grid in a most basic fashion. So after you install the toolkit you will need to add a reference to the WPFToolkit.dll to the View project. Once you do that, you can add the namespace reference to the View XAML file. Open up the MainWindow.xaml file and add the namespace to the top of the file:

xmlns:dg=”clr-namespace:Microsoft.Windows.Controls;assembly=WpfToolkit”

This tells the program that we are going to be using the Microsoft.Windows.Controls namespace and we are going to reference in our code as “dg”. Once we have the namespace mapped in, we can include the data grid control and binding it to our data source:

<dg:DataGrid ItemsSource=”{Binding Path=FileData}” Margin=”0,30,0,0″ />

The ItemsSource property is binding to the FileData property of the ViewModel. And that is all you need to do here to get the data grid to show the data. Cool huh? The only other thing that we are going to do here is to add a button that we can use to tell the ViewModel to go get the data:

<Button Height=”22″HorizontalAlignment=”Left” Margin=”8,4,0,0″ Name=”button1″VerticalAlignment=”Top” Width=”48″ Command=”{Binding Path=GetDataCommand}”>Button</Button>

The important part of this is theCommand=”{Binding Path=GetDataCommand}”” part. This is the part that tells the program that when the button is clicked that it is to execute the GetDataCommand. If you recall the GetDataCommand is the command in the ViewModel that gets the data from the Model. There is not an event handler in the traditional sense. More of the magic of WPF. That is it for the XAML for the MainWindow. The XAML for the MainWindow now looks like this:

<Window x:Class=”Article.MainWindow”

    xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation&#8221;

    xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml&#8221;

    xmlns:dg=”clr-namespace:Microsoft.Windows.Controls;assembly=WpfToolkit”

    Title=”MainWindow” Height=”300″ Width=”300″>

    <Grid>

        <dg:DataGrid ItemsSource=”{Binding Path=FileData}” Margin=”0,30,0,0″ />

        <Button Height=”22″HorizontalAlignment=”Left” Margin=”8,4,0,0″ Name=”button1″VerticalAlignment=”Top” Width=”48″ Command=”{Binding Path=GetDataCommand}”>Button</Button>

    </Grid>

</Window>

Now, before we continue I have to say that this in not the only way to code this up. You caninstantiate the ViewModel in the XMAL and not do anything at all in the code behind however, I am going to save that for another time. That being said open up the MainWindow.cs file and find the constructor for the window. Right after the InitializeComponent method call, add the following:

DataContext = new MainViewModel();

 That is all you need to do to set the DataContext of the window which is where the data binding looks to find the data. You will also need to add a reference to the ViewModel assembly. This is the MainWindow code:

namespace Article

{

    using System.Windows;

    using ViewModel.ViewModels;

 

    public partial class MainWindow : Window

    {

        public MainWindow()

        {

            InitializeComponent();

            DataContext = new MainViewModel();

        }

    }

}

Conclusion

That completes the discussion of the basic architecture of a WPF MVVM application. We created a basic Model class that read a .csv file and exposed that data as a property of the class. We created a base ViewModel class to serve as a base from which to build upon and created a derived ViewModel to bind the data to the View raising a NotifyPropertyChanged event to update the data binding. We also included in our ViewModel a command using a RelayCommand that would be used from the View to go get the data and the View displayed the data in the WPF data grid control through data binding. Attached is a Visual Studio 2008 solution containing all of the code discussed in this article, including the .csv file used to display data in the data grid. Rename the .doc file to .zip before trying to open it. This is a wordpress.com requirement. articlezip

Model-View-ViewModel in WPF Part I February 12, 2009

Posted by wesaday in Programming.
Tags: , ,
4 comments

Introduction

The Model-View-ViewModel (MVVM) is the current “standard” for developing applications in Windows Presentation Foundation but there seems to be no hard and fast rules. It’s more like a guideline. It took me a long time to figure what was going on in this design pattern. I read the articles written by John Gossman, http://blogs.msdn.com/johngossman/archive/2005/10/08/478683.aspx, and Dan Crevier http://blogs.msdn.com/dancre/archive/2006/10/11/datamodel-view-viewmodel-pattern-series.aspx but for the absolute beginner I was not able, or smart enough, to understand the material. After looking at a huge amount of example code and research I was finally able to decompose one of the example applications and figure out how it worked. This code that I am presenting here is a derivative of the demo application written by Josh Smith, http://joshsmithonwpf.wordpress.com. Josh is a WPF God and you can learn a lot from his articles. Anyway, after much frustration the pieces fell together and I began to comprehend what was going on in the MVVM.

The MVVM design pattern is sort of a descendent of the Model-View-Presenter design pattern. I published a series of articles introducing that design pattern starting here, https://wesaday.wordpress.com/2009/01/27/winforms-model-view-presenter-a-tutorial. However, the MVVM pattern takes advantage of some advanced features of WPF. I fully expect that this article will evolve into several parts also. Actually, I am just going to make this a two parter.

Goals

The goal of this article is to explain the MVVM pattern in an easy to understand tutorial manner, exploring the various facets. We will redo the application presented in the MVP article series in WPF. To recap, the final application will read a CSV file and display the data in a data grid in the main view and will turn out to look something like this:

 

The goal

The goal

The players

I learn best in a tutorial fashion so in this section we will introduce the entities that make up the MVVM.  A simplified diagram of the design pattern might look something like this:

MVVM diagram

MVVM diagram

The View object pretty remains the same. This is the window and controls that the user sees and interacts with. The major goal in using this pattern is to move as much of the code to the ViewModel as possible making the View code-behind a desolate wasteland.

The ViewModel contains the properties that are used in databinding data to the View and handlers that respond to user input. The ViewModel assumes most of the responsibility of knowing what is going on in the View andhandling the Model. I would imagine that most of the code that you are going to write in a real world application would reside in the View Model. The ViewModel implements the INotifyPropertyChanged interface. This is really cool since when the data in the ViewModel changes, the INotifyPropertyChanged updates the databinding and the View magically gets updated with the updated information.

Our friend the Model does not change all that much. It is still responsible for obtaining the requested data and giving it to the ViewModel.

Setting up

The solution that I describe is what worked for me so that is what I am going to stick to. In no way should this be construed as production code. This is stripped down code that eliminated unnecessary code to get down to the guts of the method. To use this is production code; you would definitely want to implement error handling and checking. Also I will probably not describe how to add projects or classes to the solution as you should know that already.

The first thing to do is to create a new WPF application. Being the imaginative soul that I am, I named my solution “Article”. You, of course, are free to name it whatever you want. I habitually rename the generated window class to “MainWindow”.  Add to the solution two more projects. The first project I named Article.Model and the second I named Article.ViewModel. In the Article.ViewModel project, add two new folders name on “Commands” and name the other “ViewModels”.  When you get all that done, your solution should end up looking something like this:

Solution setup

Solution setup

 

That is it for Part I. In Part II we will explore the Model, the View and the ViewModel in depth. And will include a sample solution illustrating the concepts.

Winform – Model-View-Presenter – Part V the View January 30, 2009

Posted by wesaday in Programming.
Tags: , ,
39 comments

Finally we come to the conclusion. This the the final part to the Model-View-Presenter in Winforms series.

Open the MainForm in the designer. This is probably the easiest step of all. Drag and drop a DataGridView on to the form. To make it look semi-decent, you might want to set the Anchor property so that the control fills the form as this is the only thing that we are going to do.

Now, open up the code-behind file. The first thing to do is to reference the class library in the main project. Right click the references in the solution explorer and select Add Reference. Click the Project tab, Select the Common.Lib.dll and then click OK.

 

Add reference

To the usings statements, add a ‘using Common.Lib.Interfaces’ statement. Now we can go ahead and implement the IMainView interface.

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using Common.Lib.Interfaces;

 

namespace ProjectSkeleton

{

    public partial class Form1 : Form, IMainView

    {

        public Form1()

        {

            InitializeComponent();

        }

 

        #region IMainView Members

 

        public DataSet CSVData

        {

 

        }

 

        #endregion

    }

}

This gives us a property that we will be using to bind the data to the DataGridView. Which is exactly what we are going to do. Bind the DataSource property of the DataGridView to the value of the DataSet like this:

        public DataSet CSVData

        {

            set { dataGridView1.DataSource = value.Tables[0]; }

        }

Now we need to instantiate the Presenter and give is a file name to open. I hard coded a file name in this example. Of course you could implement a file browser and open any file that you can. Create a private member of the DataPresenter;

        private DataPresenter _presenter;

Then instantiate the presenter passing is the mainview so it can give us the data. Then finally tell the presenter to open the test file.

       _presenter = new DataPresenter(this);

       _presenter.Display(“test.csv”);

Now you can run the solution and you should be able to see the grid is filled with the data from the test.csv file. There you have a complete solution that demonstrates the Model-View-Presenter design pattern with Winforms. There is a link to the complete Visual Studio 2008 solution below. Rename the .doc filename to .zip before you open it. This is a wordpress requirement. finalzip This link is the document that contains the all 14 pages of the text. The caveat is that the document may or may not exactly match since I have had to do a lot of editing online 🙂 mvp-in-winforms Note that this is an Office 2007 document.

 

 

 

Winforms – Model-View-Presenter – Part IV the Presenter January 29, 2009

Posted by wesaday in Programming.
Tags: , ,
4 comments

This is the fourth in a series describing the MVP pattern in Winforms.

The Presenter

Add two classes to the Presenters folder. One named Presenter and the other named DataPresenter. We are going to implement the Presenter as a generic so in case you change the Model or the View we could use the same Presenter or interchange Presenter classes. This will make enhancing the example as a base application easier. So declare the Presenter class as a Generic class where the parameter implements the IBaseInterface interface:

    public class Presenter<T> where T : IBaseInterface

    {

 

    }

Now declare two class properties, one for the Model and one for the View. Since the Presenter, and derivations, is the only one that will be using these properties, make them protected.

        protected static IModel Model { get; private set; }

        protected T View { get; private set; }

Now we are going to create two contructors, a static constructor and an public constructor that takes a parameter. The static constructor is going to initialize the Model for us. The other constructor is going to set the view for us. There also other ways to do this. I have seen where the Model is set in the constructor when the class is instantitated. It’s a matter of style. This way seems “cleaner” to me as the view does not have to know about the Model so the Presenters can use different Models and the View does need to know anything about it.

So our base Presenter class now looks like this:

using Common.Lib.Interfaces;

using Common.Lib.Models;

 

namespace Common.Lib.Presenters

{

    public class Presenter<T> where T : IBaseInterface

    {

        protected static IModel Model { get; private set; }

        protected T View { get; private set; }

        static Presenter()

        {

            Model = new Model();

        }

 

        public Presenter(T view)

        {

            View = view;

        }

    }

}

Okay now. For the real Presenter class. Open up the DataPresenter class. The first thing to do is to modify the class definition to derive from the Presenter class and define what the interface for our view that we are going to handle.

    public class DataPresenter : Presenter<IMainView>

    {

    }

Then this class simply needs to define a constructor and a public method to call to get the data from the Model and give it to the View.

 

        public DataPresenter(IMainView view)

            : base(view)

        {         

        }

 

        public void Display(string filename)

        {

            if (View != null) View.CSVData= Model.GetData(filename);

        }

The constructor is passed a IMainView interface which is also passed along to the base class. This also give access to the Model that is instantiated in the base class. The method simply calls the Model’s GetData method passing along the filename to get the data from and giving that back to the View. This is it for the class library. All we need to do now to finish this up is to finish our main view.

This is the Visual Studio 2008 project so far. Change the name from .doc to .zip before you open it. This is a wordpress requirement. presenterzip

Winform – Model-View-Presenter – tutorial Part III the Model January 28, 2009

Posted by wesaday in Programming.
Tags: , , ,
2 comments

This is the third part of the MVP tutorial series. In this part we are going to discuss…

The Model

The Model provides a “model” for the data that is going to be exposed to the View. Add a new class and call it “Model”. Then have the class implement the IModel interface.

using Common.Lib.Interfaces;

namespace Common.Lib.Models

{

    public class Model : IModel

    {

       

    }

}

Now if you were to compile the project, you get an error because we said that we would implement the interface but have not yet. Right click on the IModel interface text in the editor then select Implement Interface, then select Implement Interface on the sub menu.

 

Implement  interface

Implement interface

Once you do that, Visual Studio will write a skeleton implementation for all of the methods in the IModel interface. In this case, Visual Studio will create a method named GetData taking a string as a parameter and returning a DataSet. Go ahead and delete the throwing of the not implemented exception. So you should end up with something like this:

using Common.Lib.Interfaces;

namespace Common.Lib.Models

{

    public class Model : IModel

    {

 

        #region IModel Members

 

        public System.Data.DataSet GetData(string filename)

        {

 

        }

 

        #endregion

    }

}

To fill the method in, we add the following code:

            string connectionString =

                @”Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\csvfiles\;Extended Properties=’text;HDR=Yes'”;

            string commandText = string.Format(“Select * from {0}”, filename);

            OleDbConnection conn = new OleDbConnection(connectionString);

            OleDbCommand cmd = new OleDbCommand(commandText, conn);

 

            conn.Open();

            OleDbDataAdapter da = new OleDbDataAdapter(commandText, conn);

            DataSet JobData = new DataSet();

            da.Fill(JobData);

            return JobData;

This is going to some of the hard work for us. Of course you are free to get the data from any source that you want to. Basically all we are doing here is using OLEDB to open a file in the csvfiles directory on the C drive and filling a DataSet with the data in the file. Of courses for production code you would check for errors and take appropriate action but this is just an example. That’s all there is to do for the Model.

This is a zip with the project so far. Rename the .doc to .zip before you open. This is a wordpress requirement.  modelszip

Winforms – Model-View-Presenter – Part II The interface January 27, 2009

Posted by wesaday in Programming.
Tags: , , ,
3 comments

This is part II of the MVP series for Winforms.

For this example we are going to create a very simple application. Our example is going to load a CSV file and display it in a data grid. But, it’s not what the application does that is important. The important thing is how the application does it. The final application will look like this:

 

app 

Interface this!

The key to the whole thing is the interface. Now the interface is kind of a strange animal to me.  An interface is declared in code like this:

    public interface IMyInterface

    {

       

    }

In my previous work, an interface was basically a set of functions that you could call on objects and get results back. In the .NET world and interface is an actual object. Not only can you pass an interface between other objects but you can assign the interface to a variable like any other data type!

    public class MyClass

    {

        private IMyInterface myInterface;

    }

The purpose of the interfaces is to allow the Presenters to communicate back to the View in a loosely coupled way. The Presenter uses the interface to update the data that the View is showing to the user.  And that is what we are going to do now. It is important to note that the interface defines a type of contract. It does not actually contain any code on its own but causes the class that inherits the interface to implement the contract. Right click on the Interfaces folder in the solution, then select Add, then New item.  Select Code File and name it IBaseInterface, then click Add,

interface

 

This interface will just serve as a base interface that all the other interfaces can inherit from. For this example this interface will not actually do anything. Define the interface,

namespace Common.Lib.Interfaces

{

    public interface IBaseInterface

    {

 

    }

}

The Main View interface

Save that file and repeat the process only name this interface IMainView. This class is going to serve as the interface the Presenter is going to use to communicate with the Main view. Define the interface and inherit from our base interface,

namespace Common.Lib.Interfaces

{

    public interface IMainView : IBaseInterface

    {

       

    }

}

Now what we are wanting to do is to display some data in a DataGridView on the main form. So since the main form is going to be implementing the interface. How that is going to be done is to databind the data to the grid. So, what we want the interface to do is to expose a property that will be used by the Presenter to supply the data. So, add a property to the interface that is a DataSet type with a property setter,

    public interface IMainView : IBaseInterface

    {

        DataSet CSVData { set; }

    }

 

To use the DataSet type you will have to add a using System.Data statement to the file. The entire file looks like this:

 

using System.Data;

 

namespace Common.Lib.Interfaces

{

    public interface IMainView : IBaseInterface

    {

        DataSet CSVData { set; }

    }

}

The Model interface

Now we are going to define an interface for the Model. Add a new code file and name it IModel. The Model interface is going to define the function that will be used to retrieve the data from the file (or where ever else you want to get it from). Since we defined that the data would be in a DataSet, we need a function that will return a DataSet. So add a function definition GetData that takes the name of the file as a string and returns a DataSet:

    public interface IModel

    {

        DataSet GetJobData(string filename);

    }

Remember to add the System.Data namespace to the top of the file.

using System.Data;

 

namespace Common.Lib.Interfaces

{

    public interface IModel : IBaseInterface

    {

        DataSet GetData(string filename);

    }

}

That’s it for the interfaces. This is a Visual Studio 2008 solution with our app so far. Rename the file from .doc to .zip, this is a wordpress requirement. interfaceszip

Winforms – Model-View-Presenter – A tutorial, the introduction January 27, 2009

Posted by wesaday in Programming.
Tags: , , , ,
4 comments

Introduction

Coming from a C/C++ and diving into the .NET, I am constantly surrounded by strange phrases, three letter acronyms and concepts that take a long time to get used to. One of those concepts is the Model-View-Presenter (MVP).  There are plenty of articles about MVP around the Web. Most are pointers to Martin Fowler (http://www.martinfowler.com/eaaDev/uiArchs.html) or the MSDN (http://msdn.microsoft.com/en-us/library/cc304760.aspx). There are also many articles on Code Project (www.codeproject.com). The problem that I have had in the reading of these articles is that most use big $.25 words and unfamiliar phrases that mean nothing to the beginner, along with diagrams that are just plain confusing. Nothing I found that was in plain simple English. After a lot of trial and error and study I think I finally have something that I can understand. I do not pretend that this is the “right way” or the only way but it works for me.

This is the first part of five. Links to the other parts are:

     Part II

     Part III

       Part IV

       Part V

 

MVP

The goal of using the MVP design pattern is to separate the responsibilities of the application in such a manner as to make the application code:

·         Testable in an automated manner

·         Make the application more maintainable

·         Make the application more extensible. 

The first bullet means that there are many tools out there in the world that can be used to test code in an automated manner, called “unit testing”. These tools cannot test code that is in form code-behind modules. So the aim is to take that code out of the form code and place it in a DLL that can be tested.

I do not know about anyone else, but for me application code is way more maintainable when it is separated out into modules that have a specific purpose. If something unexpected feature does make it through the unit testing, then you will have a pretty good idea where to look just based on knowing what the various classes’ responsibilities are.

The extensibility part comes in when you have this separation of concerns, adding additional functionality is made easier because the code modules are not closely tied together also known as “loose coupling”.

What does it all mean?

The first thing is to understand the meaning of what the terms mean.

View: A view is any form or window that is shown to the user of the application.

Presenter: The presenter is an entity that presents the data to the view that is to be shown to the user.

Model: The model is the actual data that the Presenter will request and gets displayed in the View. The Model is responsible for obtaining the data. So the Model is the one that reads files, or connects to a database or if you are really ambitious, gets the data from a data service object.

The pattern is typically drawn like this.

uml1 

Looks simple doesn’t it? Well what all those other articles, and examples, didn’t tell me was how to turn that simple diagram into a working application.

Get on with it already!

The first thing to do is to setup the solution. Open up Visual Studio and create a new Windows Forms Application.

 newproject1

 

Once Visual Studio is through creating your new project, add a class library to the solution to hold all of the various classes. Right click your solution object in the Solution Explorer, select Add then Add new project.

 addnew1

 

classlibrary 

 

I named mine Common.Lib.dll you can name yours whatever you want to. I have seen some people that create a class library to contain the business logic and another one to contain the data layer. I think is overkill for this simple example. Go ahead and delete the Class1.cs file that Visual Studio created for you.

I like to compartmentalize things so I group like classes together. Right click on the class library project; select Add then Select New Folder. Name the new folder, Interfaces. Repeat twice more and name the other two new folders Models and Presenters. Your project should now look like this.

solutionex

This is the end of Part 1. After starting the article it quickly grew to 14 pages and I was not done yet so I elected to post a series of pages.

 

This is the project skeleton so far. Change the extension from .doc to .zip before you open it. This is a workpress requirement. projectskeletonzip