ASP.NET

RockNUG IoC Container Presentation Wrapup

Matthew Podwysocki — Thu, 10 Apr 2008 23:10:21 GMT

I want to thank the fine folks at the Rockville .NET Users Group (RockNUG) and Dean Fiala for giving me the opportunity to speak last night. It was a record crowd last night, so I'm glad that people were interested in Loose Coupling, Design Patterns, Test Driven Development, Behavior Driven Development and Inversion of Control containers. I hope everyone got some good information, and if not interested in using containers, design patterns and such, at least know they exist and have their use. Based on the feedback I've already received, it was warming and why I like presenting at user groups, so that both of us can learn.

Once again, I'd like to plug my DC ALT.NET group that I run. Our next meeting is scheduled for April 23rd and the topic will be Continuous Integration with Jay Flowers. We'll announce the location shortly for our group. You can go ahead and sign up for our mailing list here.

Anyhow, here are some resources that can help point you in the right direction. This includes articles, blogs and such that I find will be useful in your journey to better understand these things:

After my CMAP Code Camp session over the weekend, I will go ahead and post my slides and code samples for your enjoyment. So, if you're in the Columbia, MD area this weekend and haven't signed up, go ahead and do so. Hope to see a great crowd there!

ASP.NET MVC Source Code Now Available

Matthew Podwysocki — Fri, 21 Mar 2008 18:34:49 GMT

As of yesterday, the ASP.NET MVC Release 2 source code has been made available on CodePlex. ScottGu made the source drop announcement earlier this morning. Congrats to Phil Haack and the ASP.NET MVC Team for shipping the source code. It's worth noting, it's not Open Source in the way that it's just a zip file and no outside patches are to be accepted, unlike IronRuby. The plan going forward is to make incremental drops of the source code going forward.

As always, check out Jeffrey Palermo's MVCContrib project for contributions to the code base, which is open source.

Videos and Interviews from MIX08

Matthew Podwysocki — Tue, 11 Mar 2008 00:21:46 GMT

Well, I've had the urge to find all the videos I could and watch them to find out all the goodies I missed while not at MIX08. If you missed any of the main sessions, you can find out more about them here. Note that there are 88 sessions recorded here, so it's a lot of good viewing material.

Best of all are Scott Hanselman's MVC Videos can be seen here. He also covers the MVC Mock Helpers which better allow for unit tests using various Mock frameworks including Rhino Mocks, TypeMock.NET and Moq.

Dave Laribee was great on Twitter to make sure we were all kept up to date with all the good things that were happening. Brendan Tompkins supplied Dave with a video phone so that he could capture impromptu videos and such. But, best of all they were broadcasted live. He was able to talk to guys like Rob Conery, Phil Haack, Steve Harman, Miguel, John Lam, Scott Hanselman and Josh Holmes. Very cool stuff! They were pretty good and entertaining, although the video wasn't always superb and sometimes you needed motion sickness pills. But, the sessions of note are:

More of them can be found here. And it's enough to make Phil think that he has enough of a fidgeting problem... Well, enjoy!

ASP.NET Team Releases for Mix 2008

Matthew Podwysocki — Fri, 07 Mar 2008 00:46:00 GMT

For all those interested in the information and the latest bits from the ASP.NET Team, here are the latest links.

Downloads:

ASP.NET Updates:

Jeffrey Palermo, the founder of MVCContrib and CodeCampServer has posted the changes from what he can gather here. As noted, you must uninstall the old bits first before installing the new ones.

I've been playing with the bits for a little bit lately and I must admit it's a lot better now. But, I'm noticing that it seems that the ASP.NET team wants us to use more of the Supervising Controller/Presenter Pattern and less of the Passive View Pattern. Brad Wilson also notes that here. It hasn't dampened my usage of it yet as I have adapted my designs since then. After all, you have to be a little flexible when using a CTP.

RockNUG Meeting - ASP.NET MVC + Updates

Matthew Podwysocki — Thu, 14 Feb 2008 00:54:37 GMT

Tonight, put on the DVR and come out to the Rockville .NET Users Group (RockNUG) for a presentation by Jeff Schoolcraft on ASP.NET MVC.

The timing of course couldn't be more appropriate as ScottGu has recently posted about the ASP.NET MVC Framework Update in which he talks about a few pain points I know I've been having as well as others such as:

Can be deployed in partial trust in the \bin directory
Improved routing features and infrastructure
Test wizard now supports and probably one of my favorite features
- MSTest
- NUnit
- MbUnit
- XUnit.NET
Removing ControllerAction Attribute requirement from controllers, instead all public members will be controller actions. Another nice thing to remove a pain point
Filter Support for Controllers and Action methods
HTML Helpers now built in
And so on...

The plan is to release a new preview at MIX08, so it should be pretty exciting to get the hands on the new bits.

Phil Haack has also covered this with his comments on ASP.NET MVC Update and Blocking Direct Access to Views in ASP.NET MVC.

Anyhow, back to the original intent of the post, the details are as follows:

An Introduction to ASP.NET MVC
presented by Jeff Schoolcraft

Come walk with me as I lead you on a gentle, relaxed tour of the ASP.NET MVC Framework. I'll demystify the forest of three letter acronyms. Then we'll take a journey through the hall of ancestors--and cousins--to discuss some influences and other players in the MVC space. We'll end up at the Grove of Hello World and, like habitat for softwarity, we'll build a demo application. Along the way we might run into some tangential trolls, but we'll cross that bridge when we come to it.

Jeff Schoolcraft is the founder of The Queue, Incorporated; a consulting shop that writes software and helps write software better. He has been in the .NET space from nearly the beginning and is still, mostly, writing web applications in C#. He tries to organize a couple Code Camps a year and is hoping to find a developer community that isn't over an hour away. When he's not immersed in code he enjoys spending time with his wife and two daughters.

Time:
Wednesday, February 13, 2007 6:30-9:00 PM

Location:
Montgomery College, Rockville
Humanities Building - Room 103
Rockville, MD
Click here for details....

Come and support the organization if you're in the area! Should be a great session!

RockNUG Meeting 2/13 - ASP.NET MVC

Matthew Podwysocki — Fri, 01 Feb 2008 23:11:24 GMT

The Rockville .NET Users Group (RockNUG) will be holding their Februrary meeting on the 13th at 6:30PM-9PM. This month, Jeff Schoolcraft will give an introduction to ASP.NET MVC that we have all come to know and love, to a point of course...

The details are as follows:

An Introduction to ASP.NET MVC
presented by Jeff Schoolcraft

Come walk with me as I lead you on a gentle, relaxed tour of the ASP.NET MVC Framework. I'll demystify the forest of three letter acronyms. Then we'll take a journey through the hall of ancestors--and cousins--to discuss some influences and other players in the MVC space. We'll end up at the Grove of Hello World and, like habitat for softwarity, we'll build a demo application. Along the way we might run into some tangential trolls, but we'll cross that bridge when we come to it.

Jeff Schoolcraft is the founder of The Queue, Incorporated; a consulting shop that writes software and helps write software better. He has been in the .NET space from nearly the beginning and is still, mostly, writing web applications in C#. He tries to organize a couple Code Camps a year and is hoping to find a developer community that isn't over an hour away. When he's not immersed in code he enjoys spending time with his wife and two daughters.

Time:
Wednesday, February 13, 2007 6:30-9:00 PM

Location:
Montgomery College, Rockville
Humanities Building - Room 103
Rockville, MD
Click here for details....

Come and support the organization if you're in the area! Should be a great session!

Grokking the Model View Presenter (MVP) Variations

Matthew Podwysocki — Wed, 23 Jan 2008 06:38:46 GMT

For many of my current ASP.NET projects, I've been using the Model View Presenter (MVP) for this. However, there are many ways to implement this and if you ask someone, you'll likely get a differing opinion each and every time. Such as the case with the Model View Presenter. I've covered this before, but in the context of SharePoint, so now I'm just going to stick with ASP.NET and the concepts itself.

The Model View Presenter

Martin Fowler came up with the concept for the Model View Presenter back in 2004. The Model View Presenter is a slight variation of the Model View Controller that we've heard so much about with such frameworks as ASP.NET MVC, MonoRail, Struts and of course Ruby on Rails. The basic idea is that the model stores the data, the view shows a representation of the model, and the presenter handles the interaction between the two. The main reason for the use of this framework is that you can use the existing ASP.NET infrastructure to support this without any additional libraries unlike ASP.NET MVC and MonoRail.

The key benefits of course is testability and separation of concerns. The view is basically dumb and does nothing but what the presenter tells it to do. This allows for easy testing with mock views or test doubles. Now questions arise when you start handling events in these presenters. Billy McAfferty has a good writeup on the subject which is still a great reference.

But since then, Martin Fowler split the Model View Presenter into two, the Passive View and the Supervising Controller (Presenter).

The Passive View

The intent of the Passive View is that it is a rather dumb view. This means the majority of the code used for setting up the view and all the logic is moved into the presenter. The view is just a thin wrapper around the presenter with no behaviors defined. Basically, it just defines the contract of the data to display, and no real concept of what the model is. Jeremy Miller has a great writeup of this in his series "Build Your Own Cab" with Part #4 covering the Passive View.

So, to put it succinctly, the main points of the Passive View are:

The view should not know about the model
The view should be simple as possible
The view should implement an interface so you can mock it
If the view needs to use a complex type, then use an adapter to break it down

Below is a basic example of a search screen for a given employee to return employee information for the given employee ID.

public interface IEmployeeSearchView
{
     string EmployeeId { get; }

     string FirstName { set; }

     string Lastname { set; }

     int Level { set; }
}

And then we can define the presenter with just a stub so that we can test our interaction. Note that our model is defined through the IEmployeeTasks interface and I'm not really going to cover what that does.

public class EmployeeSearchPresenter
{
     private IEmployeeTasks tasks;
     private IEmployeeSearchView view;

     public EmployeeSearchPresenter(IEmployeeSearchView view, IEmployeeTasks tasks)
     {
          this.view = view;
          this.tasks = tasks;
     }

     public void InitializeView()
     {
          Employee employee = tasks.GetEmployee(view.EmployeeId);
          view.FirstName = employee.GivenName;
          view.Lastname = employee.Surname;
          view.Level = employee.Rank;
     }
}

Well, if we were truly doing TDD, we would have just left InitializeView to do nothing, then made it fail, then put in the code to make it pass, but that's a bit much for a blog post and more for a webcast and so on. As you can note from our presenter, it has no idea about events or when it gets invoked. In other words, the presenter gets invoked at certain times during the page such as an Click event.

Now, I'm not happy with the above code, because I'm setting the Employee object and doing that mapping of the view from the employee object and it just has a code smell to it. So, where can we move that logic? How about into the view itself? Let's modify the view to include more things.

public interface IEmployeeSearchView
{
     // Same as above plus this
     void SetEmployee(Employee employee);
}

Now, this makes the view have some logic in it, or does it? We'll use an adapter approach to fix that.

public static class EmployeeAdapter
{
     public static void SetEmployee(IEmployeeSearchView view, Employee employee)
     {
          view.FirstName = employee.GivenName;
          view.LastName = employee.Surname;
          view.Level = employee.Rank;
     }
}

Now, the implementing view must do this for the SetEmployee method.

public void SetEmployee(Employee employee)
{
     EmployeeAdapter.SetEmployee(this, employee);
}

And in turn, we modify our InitializeView method to incorporate this change as well:

public void InitializeView()
{
     Employee employee = tasks.GetEmployee(view.EmployeeId);
     view.SetEmployee(employee);
}

So, as you can see, it's made our mapper code a bit more clearer and it's a better approach when tackling the Passive View.

Now, let's move onto the Supervising Controller.

Supervising Controller

Now in more complicated scenarios where you need to handle events, that's where the Supervising Controller comes into play. Both Phil Haack and Jeremy Miller have great writeups on this. Phil's approach uses the ASP.NET Event Model to control this through defining a base view that can be applicable to all views and then implementing a custom view on top of this.

public interface IView
{
     event EventHandler Init;

     event EventHandler Load;

     bool IsPostBack { get; }

     void DataBind();

     bool IsValid { get;}
}

public class IEmployeeEditView : IView
{
     string EmployeeId { get; }

     string FirstName { get; set; }

     string LastName { get; set; }

     int Level { get; set; }

     event EventHandler EmployeeSaved;
}

So, as you can see, the real differences start to emerge when you start handling the events and such and you subscribe through the presenter itself. We'' stub out what the presenter will look like.

public class EmployeeEditPresenter
{
     private IEmployeeEditView view;
     private IEmployeeTasks tasks;

     public EmployeeEditPresenter(IEmployeeEditView view, IEmployeeTasks tasks)
     {
          this.view = view;
          this.tasks = tasks;
          SubscribeToEvents();
     }

     private void SubscribeToEvents()
     {
          view.EmployeeSaved += OnEmployeeSaved;
     }

     private void OnEmployeeSaved(object sender, EventArgs e)
     {
          Employee employee = new Employee(view.EmployeeId);
          employee.GivenName = view.FirstName;
          employee.Surname = view.LastName;
          employee.Rank = view.Level;
          tasks.SaveEmployee(employee);
         DataBind();
     }

     // More code here
}

Once again, I went ahead and wrote the code before the tests because once again, this is a blog post and not a web cast. Anyhow, so we've seen two basic ways of defining your views and presenters.

Variations on the Theme

So, basically we have two ways of attacking the problem:

Expose events off the view to which the presenter can subscribe. This of course ties it to the event model as defined in ASP.NET or your UI of choice. This is using the Supervising Controller approach.
Have the presenter methods called within the events in your UI as noted in the Passive View approach.

Some might object to the Supervising Controller approach as it ties you to the ASP.NET event model. They criticize this approach because they may want to substitute a Web UI with a Windows Forms application, with a WPF application, etc. But, how realistic is that scenario where you want both options for a UI to use the same logic and so on?

Let's take another approach as well. Jim Bolla posted about what he calls the Observable View Pattern. This uses the observer pattern and it very much like the Passive View but with events on the view. Let's walk through a simple example:

Note that we're using the IView interface from above.

public class IEmployeeEditView : IView
{
     string EmployeeId { get; }

     string FirstName { get; set; }

     string LastName { get; set; }

     int Level { get; set; }

     event EventHandler EmployeeSaved;
}

Now, let's see what the page might look like.

public class EditEmployee : Page, IEmployeeEditView
{
       protected void OnSaveButtonClick(object sender, EventArgs e)
       {
           if (EmployeeSaved != null)
               EmployeeSaved(this, EventArgs.Empty);
       }

      protected override void OnInit(EventArgs e)
      {
           new EditEmployeeViewObserver().Observe(this);

           if (Init != null)
               Init (this, EventArgs.Empty);
      }
}

And in turn, our EditEmployeeViewObserver would look like this:

public class EditEmployeeViewObserver
{
       public void Observe(IEmployeeEditView view)
       {
           view.Init += delegate
           {
               new EditEmployeeViewInitializationProcess(view).Execute();
           };

           view.EmployeeSaved += delegate
           {
                new EditEmployeeSavedProcess(view).Execute();
           };
       }
}

The key to this approach is using events. This has the view creating the observer and then forgetting about it after the Observe method. It shouldn't fall out of scope during the setup here after that. The observer then forwards to the process class which in turn implements the Command pattern. It's a pretty interesting approach I must say.

Conclusion

So, the question then arises, which to use and when? Well, Martin Fowler gives the answers in his links from above, but it's down to personal preference. I've followed more of Phil Haack's approach to the Supervising Controller. Mostly the view doesn't do anything, as the presenter subscribes to the view's events. Jeremy Miller thinks a different way as well as noted here. But, at the end of the day it's down to preference. Each approach works and has its pluses and minuses.

CMAP Meeting 1/2/2008 - ASP.NET MVC

Matthew Podwysocki — Wed, 02 Jan 2008 07:21:33 GMT

Today, the CMAP user group will hold their first meeting of 2008. This meeting will be a Visual Studio 2008 InstallFest. If you hadn't registered already, too late, it's already booked up, but feel free to attend the ASP.NET MVC portion of this event.

Also, DC ALT.NET is announcing our meeting for January at this event. I will have a writeup of this later on today and post here. Tentatively it is scheduled for January 15th, so sign up at our site and participate!

Anyhow, the topic this month is ASP.NET MVC presented by a great guy and member of DC ALT.NET, Scott Allen.

Below are the details:
CMAP January 2nd Meeting

Topic:
The ASP.NET MVC Framework
By: Scott Allen

The ASP.NET MVC framework is an alternative framework for building web applications with ASP.NET. In this introduction to the new framework, we will see how the Model View Controller design pattern helps us to maintain a separation of concerns and produce testable, maintainable software. We will also look at the URL routing system and discuss the implications of the new framework for .NET web developers.

Time:
1/2/2008 – 6:30PM

Location:
HCC Business Training Center
6751 Columbia Gateway Drive
Columbia, MD 21046

Hope to see a great crowd there!

ASP.NET Extensions and MVC Code Samples

Matthew Podwysocki — Tue, 18 Dec 2007 19:35:11 GMT

As noted in some of my previous posts, there is a lot of excitement around the ASP.NET 3.5 extensions including MVC, Dynamic Data, Silverlight and so on. I have a few samples I'll be posting within the week using ASP.NET MVC with such things as Spring.NET, Castle Windsor, Object Builder and so on. In the mean time, I'm still working on the Spec# posts and some SharePoint Model View Presenter I hope to get out soon.

Anyhow, there are some great links out there for doing cool stuff with ASP.NET MVC:

ASP.NET Dynamic Data Support - ScottGu builds dynamic web pages using LINQ to SQL object model without having to create any pages manuall
Using jQuery with ASP.NET MVC - Chad Myers uses jQuery to demo the Edit in Place demo using ASP.NET MVC.
Using script.aculo.us with ASP.NET MVC - Chad Myers once again tries to get script.aculo.us to work with ASP.NET MVC.
ASP.NET MVC Choose Your Data Access - Rob Conery, an ASP.NET team member discusses using LinqToSql, NHibernate, and Subsonic as the data access models for ASP.NET MVC.
ASP.NET MVC Mailing List
ASP.NET MVC Forum
ASP.NET MVC RouteBuilder HTTPModule released - Jonathan Holland with the help of Elion Lipton worked on createing an HTTPModule to allow storing of routing rules in the web.config instead of the Route using an anonymous class. RouteBuilder is availble on Codeplex.
Routing Revisited - Sean Lynch talks about new routing scenarios and where the current Route object falls short.

Develop, mentor and inspire!

MVC Contrib Progress

Matthew Podwysocki — Fri, 14 Dec 2007 19:10:35 GMT

In a previous post, I mentioned that Jeffrey Palermo launched MVCContrib to serve as community contributions to the ASP.NET MVC ASP.NET extensions. Since that time, there has been a lot of activity on that front.

Current contributions include:

IoC container controller factories for containers: StructureMap, Windsor, Spring.Net and ObjectBuilder
Extra View Helpers
Generic Test Doubles for Unit Testing

Very cool stuff and let's see more contributions on that front. Develop with passion!