Craig Shoemaker

This Blog Has Moved

drazz75 — Thu, 06 Dec 2007 22:08:00 GMT

I have moved this blog over to a new account. Please update your aggregators to point to

http://feeds.feedburner.com/PolymorphicPodcastBlog

...and you will automatically be updated with any future changes to the this feed.

Thanks,

Craig Shoemaker

Why I Quit My Job: So I Can Podcast More for You

drazz75 — Wed, 14 Nov 2007 14:46:00 GMT

I Quit With a Smile on My Face

I recently quit my job for a much bigger and decidedly better opportunity. I am elated to announce that I have accepted a new position with Infragistics as a New Media Evangelist. This means that I get to spend my days doing the things I love in hopes that I can help bring the developer community closer to a great company.

What does this mean for the Polymorphic Podcast?

I see great things on the horizon. While I retain 100% control over the show, Infragistics is allowing me to spend time during my workday on development and production of the show. In the past I have always had to steal an hour here or an hour there to work on production, but now I have dedicated time to apply to the growth the Polymorphic Podcast.

What this does not mean is that the Polymorphic Podcast is now a corporate extension of Infragistics. You don’t need to worry that I will be dropping the URL of my employer all over the place. There is no veiled marketing going on here. Infragistics just realizes there is a lot of value to keeping me connected to an established community. I thank Jason Beres and Ambrose Little for their hard work in making this happen.

So When Do You Get a New Show?

How about three? I’ve been promising you a video on how to install Subversion on a Windows box. Wait no longer because that video is now here. I have also recorded a show demonstrating how to use a new utility I call MVP Commander (thanks Rob Conery!) that generates MVP stubs right in Visual Studio. This way you are not forced to go to the tools page on my website to generate this code. Please checkout the notes and download links for the code and video here. Finally I recorded an audio catch-up show to announce my affiliation with Infragistics, tell you about the video shows and answer some reader email. You can listen to the show on the MVP Commander show-notes page.

Get Ready!

Between the work I am doing on my blog and podcast, the new podcasts, videos and screen-casts coming from the Infragistics website, and some appearances I am making at user groups and conferences throughout the year - some of you might be regretting asking for more! ;)

Podcast: Architecting for Extensibility II : Interview with Miguel Castro on Extensibility Patterns in CodeBreeze

drazz75 — Fri, 05 Oct 2007 13:19:00 GMT

Listen to the show here

Craig Shoemaker sits down with Miguel Castro to follow up on the first show on Architecting for Extensibility. In the previous show, Miguel takes us through a number of the patterns that make it possible for you to design points of extensibility into your applications. In the sequel to part one, Miguel describes in detail how he uses this pattern in CodeBreeze.

Raising Money for Diabetes with Halo 3 on Oct 11

Join Scott Hanselman in his enduring fight against diabetes by playing Halo 3 in high-def! For details on the event check out Scott's blog (http://tinyurl.com/yue4qm). To sign up go to http://iammasterchief.com/

Thanks!

I want to send a warm greeting and a big thanks to:

Jeffrey Norris
Buddy Stein
Brian Deacon

Still an MVP

My ASP.NET MVP award was renewed this year!

Podcast: Subversion Quickstart for .NET Developers

drazz75 — Thu, 09 Aug 2007 13:58:00 GMT

Listen to the Show!

Subversion

Subversion, sometimes known as SVN, is an open source version control system. Subversion allows users to keep track of changes made over time to any type of electronic data. Typical uses are versioning source code, web pages or design documents.

Why Subversion over Visual Source Safe?

While Visual Source Safe (VSS) is fully integrated into the Visual Studio environment, there are many disadvantages that can not be ignored.

Reliability

Sam Gentile, in his blog post entitled "No More VSS, Its Subversion", is so bold to just link to the search terms "VSS+corrupt" on Google to make a case for the ubiquity of VSS problems.

Numerous accounts of crashing and corruption: See links above...
Not a client-server application: The current VSS setup makes it difficult to expose source code to developer's outside your network.
Database size restriction: Some say the limit is 2GB, others say 10GB. Even if it's 100GB - who want's to worry about a size restriction?

Preferential Issues

There are also a number of issues with VSS that are most fairly described as "preferential issues". I cite these issues because while they are not technically "bugs" they do represent limitations that many developers find as a hurdle to deal with in the real world. Examples of some of these issues are exclusive file locking and VSS's method of tagging and branching make it difficult at times to work with.

Operation

Subversion features the operations you would come to expect from any source control system. If you come from a VSS background, some of the terms may seem a bit awkward. Below is a list of the most common operations you encounter while using Subversion.

Trunk

The trunk is the main thread where you will often work on your source code. The trunk acts as the basis where you can branch off and make changes or create point-in-time copies of your code. The trunk, just like a tree, is what supports a source code project.

Checkout

As opposed to a "check out" in VSS, a Subversion checkout is when you contact the code repository for the first time and bring down the files on to your machine. When you do a checkout the file and directory structure is created on your computer and a hidden folder is created under each folder under source control that helps maintain the state of each file.

Add

When you want to add a new file to the source control repository, you must first mark the file as being added. This will signal to Subversion that the next time you synch up with the repository, the file must be copied from its location on your machine to a versioned state on the Subversion server.

Commit

Many changes that you make to files will require a two-step process to expose the changes to other users of the repository. After you have added or changed a file, you must commit the changes up to the Subversion server. This will allow you to make many changes, but submit all the changes to the repository in a single transaction. Changes to the repository are atomic actions.

The two-step process also enables Subversion to keep the code repository's integrity while not requiring a exclusive lock on files under source control.

Conflict Resolution

When multiple people are working on the same project, inevitably they will end up editing the same file at the same time. When this happens there is a conflict in file states that must be resolved. When you go to commit your changes to Subversion, if a conflict is detected you will have an opportunity to resolve the conflict. Some of the UI tools make the experience prettier, but the process is the same whether or not you are using a GUI tool or the command line. Conflict resolution will expect you to choose portions of a file or entire files all together as the file version of the file. You do have an opportunity to say, "give me this section from file 1 and this section from file two" in order to reliably keep everyones changes. Conflict resoution is usually a non-event as often two developers are not working on the same line of code in the same file. If the changes in question are on the same lines of code among what the developers changed, then a decision must be made as to who's changes to keep and the application must be tested or perhaps refactored to not break this build.

Branching

A feature that Subversion implements well is the branching feature. Rather than maintaing some huge change log off the main repository thread as to what a "branch" is, Subversion makes a copy of the trunk and allows you to make any changes necessary. To bring the changes back down to the trunk you will merge the changes down to the trunk.

Merging

Once you have created a branch that you need to bring down to the trunk you will run a merge operation. Merging a branch down to the trunk is equivalent to comitting a large-scale change to the repository. If there are any conflicts during a merge Subversion will give you a chance to resolve the conflicts.

Tagging

Tagging gives you a way to set aside the trunk at a point and "label" the state of the trunk.

Branching vs Tagging

Often people wonder what is the difference between branching and tagging. You use a branch when you want to make significant changes to the trunk and still need source control features of commiting changes to the server, but don't want those changes to effect the users of the trunk. Branching creates an isolated environment for someone to make changes to the code.

Tagging is best used as a point-in-time snapshot of the repository. For instance at each version release of your code you would want to tag the code base.

Integration

When someone says they have Subversion installed on thier machine, often they mean they have a Windows Exporer shell installed and not the server on the box. Subversion is a client-server application where the service, security and database all live on a single server and clients (developer machines) use a separate tool for accessing the repository. The most common tool on Windows is Tortoise SVN.

Tortoise SVN

File system integration is seamless. Tortoise SVN is a Windows Explorer shell extension that grants you access to the Subversion repository natively from Windows Explorer. If you right-click in a Windows Explorer window you immediately have access to the Subversion system. The greatest benefit from granting access from a shell extension is that the access is pervasive. Any window that grants you listing of the file system will expose the Tortoise menu (ex: File-> Open dialog boxes).

You may download Tortoise SVN here.

As a .NET developer, there is one issue that you must be aware of before you begin using Tortoise SVN for your Visual Studio projects. Tortoise SVN uses hidden folders within the file system to help maintain the link with the central repository. These hidden folders are by default named ".svn". You will find this folder under every folder that is under source control with Tortoise SVN.

For some reason, the ".svn" naming convention is nothing but trouble to the Visual Studio IDE. If you try to use Tortoise SVN using it's default settings you will eventually encounter the following error while trying to run your projects and solutions in Visual ] Studio:

Cannot load project information from server

While this is technically an error stemming from a problem in the Visual Studio IDE, the Tortoise development team seemed to concede that it was easier to make a small change in the Tortoise setup rather than wait for an update to Visual Studio.

Therefore before you begin using Tortoise SVN for the first time, be sure to change the settings for Tortoise to use a hidden folder named "_svn" rather than ".svn".The following section will walk you through the process.

Configuring Tortoise SVN for use with Visual Studio

Once Tortoise SVN is installed on your machine, open a Windows Explorer menu and right-click to open the context menu. From the menu do the following:

Select TortoiseSVN
Select Settings
Check the box labeled Use "_svn" instead of ".svn" directories
Click OK

Then you are prompted to reboot your machine. While the reboot is annoying, it is required.

Note: The change in directory setting is appropriate for all Visual Studio versions, not just for Visual Studio 2003.

Visual Studio

When you begin using Subversion, you will appreciate the ease-of-use and performance, if you do not have a way to integrate with Visual Studio you will find it hard to use. Particularly if you have to somehow keep track of which files were added to your project and so on.

There are at least two options available to you to integrate access to the Subversion repository from within the Solution Explorer inside Visual Studio.

AnkhSVN: AnkhSVN is free and provides the same types of services that you would expect from VSS integration with Visual Studio. The only downside to AnkhSVN is that the UI implementation sometimes feels a little clunky. Asethetics aside - AnkhSVN is a solid program which allows you to seamlessly integrate with the Subversion repository.
VisualSVN: VisualSVN is much like AnkhSVN, but the UI experince is cleaner. Also the icons used in the context menus are exactly the same as in Tortoise SVN. This little touch just makes it easier to keep track of what operations you are performing since the experience looks the same in and out of the exporer shell. Functionally though VisualSVN's capabilities are equivalent to AnkhSVN. VisualSVN is not free.

Continuous Integration

One of the great benefits of working with a source control sysetm that is open source and extensibile, is how it will interface with other components in the development lifecycle.

Subversion integrates with many of the open source continuous integration packages as well as with MSBuild.

Resources

Note: Opening up access to your repository over the web can prove difficult on a Windows machine. Many people setting up for remote access will configure the repository on a Linux box running Apache.

Books on Subversion

Version Control with Subversion (printed copy) | Free e-book!

Pragmatic Version Control: Using Subversion

Practical Subversion, Second Edition

References

Listen to the Show!

Life with Visual Studio 2008

drazz75 — Thu, 02 Aug 2007 14:07:00 GMT

For those of you who are digging into Visual Studio 2008, check out Wally's blog series he's started. He calls it "My Life with Visual Studio 2008". Check it out!

Video: Web Navigation Strategies: Creating Contracts for Your Web Pages

drazz75 — Sat, 30 Jun 2007 14:35:00 GMT

The video and code for download is now posted at http://polymorphicpodcast.com/shows/webnavigator/.

Learn an object oriented way to encapsulate the location of your web pages, shielding the physical location of the pages to your application and creating a programmatic contract for required resources.

[advertisement] Watch the show and learn how to get $100 off an Advisor Summit event in Sept 2007.

Podcast:: Web Navigation Strategies: Creating Contracts for Your Web Pages

drazz75 — Thu, 21 Jun 2007 18:09:00 GMT

Listen to the show

Watch the video

Download the code

Problem:

You and Joe are working on a sizable web application. Nasty-Coder Joe, who is on another team, creates a new page that requires 2 session variables and a query string parameter in order for his page to work properly. You now need to pass data to this page to finish your last feature before you leave for vacation in one hour. Without reading Nasty-Coder Joe's code to try and figure out what the necessary session variables and QueryString paramenters are, how do you use his page?

Introduction:

Controlling page flow on the web has a number of distinct problems. Since the web is literally a "web" often the entry points to any one page are numerous. Many developers have come up with solutions to addressing the problem of page-flow in a web application, but the solutions sometimes end up becoming a thick mire of XML structures that try to be predictive in page-flow rather than facilitate the choose-your-own-adventures style of navigation often found in a web app.

Web Navigator is a technique, or pattern or approach that I came up with when I was faced with the same problem as stated at the beginning of this show. I was working alongside a developer who was creating pages that I needed to use, but I had no idea how to pass the correct information to the page.

What I came up with I call "WebNavigator".

Yes, I know I was wearing my terribly-original-idea-hat that day...

Web Navigatior is:

A way for you to encapsulate the contract that each page has for required data
- If you change the contract, you experience compilation errors
Abstract the location to pages to support change
- Who really cares if the login page is under a login folder or at the root of the site? You just want to get your user there!
A way to organize and create a composable model of your site's navigation
- Once you have tens of pages, how will you know which pages relate to one another?
A way to allow simple was to weave in and out of secured areas of the site
- Using SSL can be tricky. There are rules about how you must enter and exit secure areas of your site. Having a object to manage the changes in SSL makes your life easier

What is its Structure?

The syntax is based around a fluent interface. For example if you wanted to navigate to the homepage of the website, you would use:

WebNavigator.GoTo(WebNavigator.URLFor.Home());

Important points:

Redirects are not done autmatically. The destination methods (ex: WebNavigator.URLFor.Home()) will always return strings. This is so you can still use the Web Navigator class to build URLs for you without requiring a post back to build the URL.
Redirection is done only when necessary. WebNavigator.GoTo() handles the redirection. You can overload the method to support Server.Transfers and instructions to use SSL
Composition helps the readability of the navigational structure of your code. For example, the following should give you a very good idea of where the user will end up: WebNavigator.GoTo(WebNavigator.URLFor.Membership.Login());
Often pages don't require data, but they do change locations. If you have the access to a page wrapped up in WebNavigator.URLFor.Login() and it's real URL is http://domain.com/login.aspx, but used to be http://domain.com/login/default.aspx your website will not experience any broken links. You will change the mapping to the new location in one place and the rest of the site will reflect this change.

Examples of Encapsulation

When using pages throughout the website, some pages will require simple QueryString values and other pages will need session variables set and perhaps other requirements. Web Navigator will encapsulate the requirements of a page. When you are a developer consuming the page all you care about is what the destination method contracts in it's method signature.

For example, the following listing will show you how to pass a user's email address to the login screen.

string userName;

// set userName to something... perhaps from the database

WebNavigator.GoTo(WebNavigator.URLFor.Membership.Login(userName));

Using QueryString Values

The most common use of a destination method is to encapsulate the use of a QueryString parameter. The following example will show you how to hide the QueryString requirements.

public class Membership
{
    public string Login(string userName)
    {
        return string.Format("~/login/default.aspx?userName={0}",userName);
    }
}

Using Session Variables and Other Resources

Sometimes you do not want to pass an item the QueryString, or a page requires a complex-type before you can use it. (Think of a page requiring an object collection in memory). In these types of cases you could pass the data around in a session variable. The following will show you how to use session variables.

public class Reports
{
    public string SalesReport(OrderCollection orders)
    {
        System.Web.HttpContext.Current.Session.Add("SalesReport",orders);
        
        return "~/reports/sales.aspx";
    }
}

Using this method will set aside anything you need into session and then return the destination URL for you to use whenever necessary. The fun doesn't have to stop at session variables. You can use the same technique for application variables, context items, etc.

The point is that what is inside the implementaton does (setup QueryString vales, add Session variables, etc..) is completely hidden from the developer who is using the page. The method signature of the URLFor method will establish a contract for any required information for the page.

Contract Changes

If the contract to a page changes, you will encounter compilation errors. If the page in the past did not require any external data, but then was changed to needing a piece of data, the updated destination method signature will cause the application to encounter compilation errors where ever the page is used. This will ensure the page is always getting what it needs.

For instance if your content editor page previously did not require a content ID the method might look something like this:

WebNavigator.URLFor.ContentEditor();

Now you have decided you want to pass in the content ID so the call would look like this:

int contentID; 

// get contentID from somewhere

WebNavigator.URLFor.ContentEditor(contentID);

Handling SSL

You can implement it in different ways. I have done it as follows in the past:

WebNavigator.GoTo(WebNavigator.Secure(WebNavigator.URLFor.Login()));

Conculsion

Web Navigator is a pattern that you can use to help manage navigation throughout your websites. The strengths of this technique are:

Encapsulation of page location
Public contract of page requirements
Single place of change for URLs (avoiding broken links)
Manage SSL "auto-magically"
Makes code easy to read and maintain

Model View Presenter Q and A

drazz75 — Fri, 08 Jun 2007 13:11:00 GMT

I’ve had some questions on the Model View Presenter series I produced recently building up in my inbox, so I thought I would make this post an opportunity to answer the questions.

In one of your recent videos you showed us how to implement a service layer. Would you normally have your service layer talking to a separate data layer with provider specific (sql, xml) or implement directly in the service layer classes to the required data source?

The service layer is a façade that sits on top of the various objects you have created the in the business layer. The purpose of the service layer is to “provide a service” of "something".

For instance if you need a collection of the Products class returned to you from the data base based on a specific query, then you might create a ProductService class that will take a criteria object as a parameter and return to you the collection. The point is that you are then shielded from having to worry about using your data layer to fill the collection and closing any database connections (if necessary).

The service layer keeps this all hidden for you.

I still haven’t answered your question specifically. I use SubSonic as my data layer or O/RM so all my tables have entity classes generated for them. Therefore I use the objects created against my tables to do all my database interaction and just use the service layer to glue together the appropriate objects to return what is necessary.

I am trying to move away from database mirroring in my objects. I light of this fact, if you have a model that had a relationship say the Product and Category classes, how would you represent that in the business layer and service layer?

This is a noble pursuit. The best way to do this is to approach it with a layered strategy. In order to keep some sanity in the development process you will still want to have objects in your application that map 1 to 1 to database tables. Having these classes available gives you the encapsulation of doing the work that no developer these days should be doing… CRUD (Create, Read, Update and Delete). There are just too many good O/R Mapping or code-generation frameworks available for you to be writing your own data access code.

That being said, you can generate the classes that talk to your database tables, but then encapsulate them into a larger object that has a rich behavior model. To build off your example perhaps you implement the Product class. The product class has a property off of it which is a collection of categories. While you may have individual tables for these classes your product class can have the interface of only what you want the then talk to the table objects behind the scenes.

I would like to apply paging on the database side as opposed to using the built-in paging mechanism of the ASP.NET. What's the best way to apply paging and sorting to grid/list controls without violating the MVP pattern?

This is a great question. The answer to just about everything in the MVP pattern is to add the required items as properties to your view interface. All you would need to do is add a SortExpression property and SortItems event to the interface. Then, when you SortItems event is raised you can do all your work in the presentation layer and when you are done, re-bind the data source to the UI control.

Have you looked at Microsoft's Web Client Software Factory? It seems to do some of what you have described in the podcast, and I'd just like to get your take on the project.

I have looked at the Web Client Software Factory. I wanted to dig into it deeper, but I found that there is a lot to learn in order to make significant use of it. I emailed someone at Microsoft a few months back to come on the show and talk about the Factory’s use, but I haven't heard back from anyone yet.

So right now I am holding off digging into the Factory just because of time constraints.

Add a Sub Header Row to GridViews or Repeaters

drazz75 — Tue, 05 Jun 2007 18:01:00 GMT

Have you ever wanted to add a sub header row in the middle of a series of rows in a GridView or Repeater? The easiest way I found was to add a literal control to build the HTML you need for the header row.

The first thing you need to do is determine you are on the data item that will represent the header. In the example below I am binding my repeater to a collection of objects. If the object I am looking at has a value SubHeaderText property then I will add a literal control to the current item’s parent.

Check it out!

protected void rptStoreDetail_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
    OSATStoreDetailItem item;
    Literal lit;
    try
    {
        if (e.Item.ItemType == ListItemType.AlternatingItem ||
            e.Item.ItemType == ListItemType.Item)
        {
            item = (OSATStoreDetailItem)e.Item.DataItem;

            if (!string.IsNullOrEmpty(item.SubLabelText))
            {
                lit = new Literal();
                lit.Text = string.Format(“{0}”,item.SubLabelText);
                e.Item.Parent.Controls.Add(lit);
            }
        }
    }
    catch (Exception ex)
    {
        //TODO: Publish Exception
        System.Diagnostics.Debug.WriteLine(ex.Message);
        throw;
    }
}

Model View * Patterns Series Complete

drazz75 — Fri, 27 Apr 2007 14:51:00 GMT

The Design Patterns Bootcamp : Model View * Patterns series is now complete!

The series features two audio pieces and five instructional videos. The audio portions take care of introducing the concepts and answering frequently asked questions, while the videos cover the following topics:

Good luck while you build your applications to last!

Video: Implementing User Messages with Model View Presenter

drazz75 — Tue, 03 Apr 2007 20:03:00 GMT

Check out the latest release in the video releases of the Design Patterns Bootcamp Series: Model View * Patterns. This video will show you how to report messages back to users in a web application written with MVP (Supervising Controller).

Video: Implementing WinForms with Model View Presenter

drazz75 — Tue, 03 Apr 2007 20:02:00 GMT

Check out the latest release in the video releases of the Design Patterns Bootcamp Series: Model View * Patterns. This video will show you how to take an existing web application written with MVP (Supervising Controller) and re-purpose the lower layers for use in a WinForms application.

Video: Implementing WebForms with Model View Presenter

drazz75 — Tue, 03 Apr 2007 20:01:00 GMT

Check out the latest release in the video releases of the Design Patterns Bootcamp Series: Model View * Patterns. This video will show you how to implement a web application using the Model View Presenter (Supervising Controller) design pattern.

Make sure to keep checking the show notes page as there will be more in this series of videos!

The Polymorphic Podcast is now on www.asp.net!

drazz75 — Sat, 10 Mar 2007 22:17:00 GMT

Every once in a while something happens that is really special. When you maintain a blog, podcast or a newsletter list - as much as a labor of love as it may be - at the end of the day you want people listening to what you have to say. Recently Microsoft's own Simon Muzio helped make that wish come true for me with a little more force. The Polymorphic Podcast is now listed under the podcasts section of the official ASP.NET website. It's nice to be in such good company as Scott Hanselman (Hanselminutes), Carl Franklin and Richard Campbell (.NET Rocks!), Wally McClure (ASP.NET Podcast) and Podcast Studio.NET.

Thanks, Simon!

Podcast:: Design Patterns Bootcamp: Model View * Patterns

drazz75 — Thu, 08 Mar 2007 16:16:00 GMT

Design Patterns Bootcamp: Model View * Patterns

Listen to the Show!

Thanks to Dave Bost for the intro!

What is the Purpose of These Patterns?

Put code in its proper place
Way to provide clean reuse of the domain model
Way to increase testablity

Rocky Lhotka wrote a blog post about a year ago that discusses where validation logic should live in an application. The entire post is great, but by the end of the post he make a point that reaches beyond the question of where validation should live... " There's nothing more expensive than a line of code in the UI - because you _know_ it has a half-life of about 1-2 years. Everyone is rewriting their ASP.NET 1.0 UI code to ASP.NET 2.0. Everyone is tweaking their Windows Forms 1.0 code for 2.0. And all of it is junk when WinFX comes out, since WPF is intended to replace both Windows and Web UI development in most cases. Thus code in the UI is expensive, because you'll need to rewrite it in less than 2 years in most cases."

Model View * Patterns... What are they?

The main drawback to these patterns is usually the learning curve... this show will hopefully remove that barrier-to-entry. The first on the scene and primary pattern to all each involved is the Model View Controller. This pattern is used throughout many of the modern development platforms. The quickest way to describe MVC in the terms a .NET developer will understand is that you code your pages in such a way that you place the code that would be in your code-behind, into a separate class. This class is called a "controller". The "model" are your domain objects (business objects or data access objects).

So your controller will tell your domain objects what to do. Once the work is done, then the user interface must be updated. The code in the user interface is known as the "view". So if you can picture that the code-behind in an ASPX file is no longer where you do any real work and can re-label that code the "view", and you can picture a new class that would act as a bucket for the code you would have written in your code behind to do the work (call that the "controller") and imagine the finaly peice of the puzzle as a class that talks to the database, to encapsulates some business logic or does something else completely unlreated to any user interace (and call that the "model"), then you, my friend have just understood the most difficult part of the Model View * patterns.

What's built into ASP.NET?

Some people say that ASP.NET has the MVC pattern implicitly implemented in the web forms architecture. The thinking goes like this... the ASPX markup constitues the view, the code behind plays the role of the controller and domain objects represent the model. While this seems to fit nicely into the formal definition of MVC you quickly run into problems.

Michael Hamrah makes the point that ASP.NET declarative controls don't break pattern, just limit your flexibility.

What is the Difference Between MVC and MVP?

in MVC view talks to Model
in MVP view can know about model, but won't send message

How is MVP Constructed?

Model View Presenter comes in two flavors:Supervising Controller and Passive View

Make sure to check out the MVP stub generator!

Supervising controller will has some logic in UI, such as databindingd, etc.
Passive view will have NO logic in UI
Supervising controller is less complex and less-testable
Passive view is more complex and more testable