Andrew Siemer's Blog

Review: ASP.NET MVC in Action by Jeffrey Palermo, Ben Scheirman, and Jimmy Bogard

Andrew Siemer - www.andrewsiemer.com — Tue, 23 Jun 2009 20:41:31 GMT

The ASP.NET MVC framework was just released as a preview when I started to write my first book (ASP.NET 3.5 Social Networking). In the early days of design decisions for my book I was faced with the problem of building with the MVP pattern or the new MVC pattern/framework. At that time there was next to nothing regarding the use of (proper or improper) the ASP.NET MVC framework.

Shortly after I got started with my project (which I chose to do in MVP) I was asked to do a review for the ASP.NET MVC in Action book. I gladly accepted and started to read as Jeffrey Palermo, Ben Scheirman, and Jimmy Bogard explored the world of the ASP.NET MVC offerings. I thought that they did a very good job of describing how Microsoft meant you to use the new framework and a better job of describing how to break beyond the limitations of the current offerings.

I must say that this is one of the few books that I have ever read cover to cover so many times! With each review of the book I went through each chapter to find any updates. As this book was being written several new CTP’s of the ASP.NET MVC framework were released. With each of the CTP releases came a new rendering of the book. It was quite fun to see how quickly things changed of the year that this book was written in.

Finally having the final review in my hands and being so very familiar with it’s content, I have to say that of all the books on the ASP.NET MVC framework the ASP.NET MVC in Action book should be at the top of your list for things to purchase in the upcoming months. At a quick glance this book covers all things relating to ASP.NET MVC and then some. This book is not just a regurgitation of MSDN or other resource as so many books are these days. Here are the chapter titles for this book:

Getting started with the ASP.NET MVC Framework
The Model in depth
The Controller in depth
Views in depth
Routing
Customizing and extending the ASP.NET MVC Framework
Scaling the architecture to more complex sites
Leveraging existing ASP.NET features
AJAX in ASP.NET MVC (which includes coverage of jQuery!)
Hosting and Deployment
Exploring MonoRail and Ruby on Rails
Best Practices
Recipes

As you can clearly see from the above this is more than just the XYZ of ASP.NET MVC. I highly recommend this book for anyone interested in breaking away from the pains of ASP.NET WebForms. This framework, especially with the help of this new book, makes programming for the web fun again!

Andrew Siemer
Teacher, Author, Engineer, Architect, Build Master, Scrum Master, Father of 6, Husband, ex Army Ranger

My Book

ASP.NET 3.5 Social Networking: An Expert Guide to Building Enterprise-ready Social Networking and Community Applications with ASP.NET 3.5

Links

Blog.AndrewSiemer.com
AndrewSiemer.com
PictFresh.com
Linked In
My Space
Face Book
Twitter AndrewSiemer.GymEd.com
GymEd.com

NDepend review – code evolution achieved by following NDepend metrics

Andrew Siemer - www.andrewsiemer.com — Thu, 28 May 2009 21:07:19 GMT

The people behind the NDepend software recently provided me with their latest version of NDepend to see what I thought. I initially ran the package over one of my recent projects and found that the reporting offered in the latest version of NDepend was infinitely better than the previous version (1.0) that I worked with. I found the reports that NDepend was offering would be most valuable while building my latest project. For this reason I started my latest project in a manner that would leave much room for improvement.

My application in the beginning

The project that I am going to run NDepend over to help me catch mistakes as I develop is built in ASP.NET MVC, LINQ to SQL, and following Domain Driven Design. I specifically didn’t follow most of the SOLID principles to see how well NDepend would allow me to catch and correct my deficiencies. To start off I am using the standard Model View Controller concepts and have stuffed all of my business and data access layer into a separate assembly project. I am building a services layer, have specific domain objects (generated by LINQ to SQL), and am using the Repository pattern. Beyond that I am new’ing up class references, not creating interfaces for anything, and am lumping generic concepts into generic classes.

With that in mind I ran NDepend over my initial code base and was given the following reports (there is a lot more information offered…but we will start here):

What does all of this mean? I took a look at this cheat sheet (http://www.hanselman.com/blog/content/binary/NDepend%20metrics%20placemats%201.1.pdf) to begin to decipher all of this information. On our abstractness and instability chart my code is currently showing as being very concrete and very stable! This is not a bad zone to be in (my code is neither painful or useless). <GRIN> Also, when looking at my dependency graph you will notice that for the most part (MOST PART) my presentation layer is only communicating with the sub system through my business layer. Some of my code is generated (LINQ to SQL) or part of a framework (ASP.NET MVC) which means that there is not a whole lot I can do in some regards. And we can clearly see in the metrics section (all the gradient squares) that some areas have a lot more code dedicated to them than others. Finally we have a list of high level warnings (yellow sections of the CQL) that may benefit from closer inspection.

Since I have a nice baseline of my application built in a standard tiered manner but not following my normal development avenues (SOLID), I am going to first avoid the direct output of these reports and add in a couple of my normal design decisions to see how it affects these reports. I am first most curious to see how implementing StructureMap will help me here as it will force me to generate interfaces for all of my classes as well as remove all the static dependencies in my code. Also, once I have StructureMap implemented it will be easier to do things like Inversion of Control and Test Driven Development. Implementing StructureMap will help us get closer to the concept of the Interface Segregation Principle. Once that is done I will rerun the reports to see where we are. Then I will implement Inversion of Control (IoC) to see how that impacts things. My next step would be to refactor my code so that it follows the Single Responsibility Principle (but in the effort to get this post done…I may push that to another article!).

Application after StructureMap

Once I added StructureMap into my source code for all the references that I could I started to find myself moving up the scale of “uselessness” but no closer to “abstractness” (which makes sense). The change that was made was that rather than saying Object o = new Object() I am now generating an interface (with ReSharper) for the Object and then declaring an instance of the object using StructureMap using syntax like IObject o = ObjectFactory.GetInstance<IObject>(). This basically means that pretty much everything has an interface defining it’s usage. Also, with StructureMap I can swap in mocks when testing. This makes my code much more flexible down the road (more flexible apparently equals more useless). An example of this flexibility is that if I want to use the standard .NET Cache initially I can. Then later I can swap in a new MemCache object simply by injecting the new object everywhere that ICache is called for via StructureMap. This is done with a couple of lines of configuration code in the StructureMap.config file…lots of power here!

Before (StructureMap and interfaces not used):

After (StructureMap implemented where possible, interfaces used where appropriate):

Here are the other items to look at.

Having done my best to start following the Interface Segregation Principle I am now going to turn to my next favorite pattern/principal by implementing Inversion of Control (or the Dependency Inversion Principle) and see what improvements that gives us.

My application with Inversion of Control

In order to apply inversion of control to my application I will be taking all of the instantiations out of my methods and moving them out to parameters of a method or passed in via the constructor. Now that I have StructureMap sewn into the application I can take advantage of some of its power in that if it sees an interface being specified in the constructor of an object that it is instantiating, it will go ahead and pass in the appropriate instance of that required object.

For example, prior to doing IoC I had a repository class that would work with accounts (AccountRepository). It would instantiate an instance of the Connection class internally and then do the work it needed to do to connect to the database and grab the appropriate account related data. This means that the Connection class and the AccountRepository class were very strongly coupled to one another. Some of this coupling in the same layer is not horrible…but in this case every single repository in my application would be coupled to my Connection object which over time would rapidly become a very large number.

We can easily fix this scenario using StructureMap in that we can require IConnection be passed in via the constructor of each repository class. Then when we instantiate a repository object StructureMap will take care of passing the appropriate Connection to the Repository and we are off and running. This removes the need for users of the Repository to be aware of which Connection object to use and reduces coupling considerably.

I will apply this concept to the entire application and see how that affects things in NDepend’s eyes.

Argh! There was no physical change to my NDepend reports simply by implementing IoC! NDepend looks at coupling across assemblies but not inside the assembly (at least I don’t see that anywhere). No worries! This addition will help down the road when it is time to start implementing our unit tests. Not a total loss.

Addressing the canned CQL Queries and Constraints

Ok, let’s dig into some of the CQL Queries and Constraints to see if we can affect change that way. The yellow sections of this report are the areas that need attention.

Lets start off with the Encapsulation warnings (section in red above). In the Visual NDepend interface I can see the following warnings.

By double clicking on the first item “Methods” I see the following list.

Here you see specific suggestions to make my code more compliant with rules of encapsulation! Double clicking the first problem area “Methods that could be declared as…” I am presented with this list.

Double clicking on any of these method names takes me directly to the code (in Visual Studio) that needs help. From there I can dig around to see about making the suggested changes. In some cases I see where I could indeed mark something as “internal”…however the suggestions that are being made are simply because nothing external to the assembly is calling the specific method. Unfortunately for me I frequently import libraries and tools from past projects knowing that I will need to use them eventually. In my case most of the suggested items that need to be fixed are items that are waiting to be used rather than items that need to be marked as internal!

I continued to poke through their list of suggestions and found that while the suggestions are good, they are not always 100% appropriate. This means that I will have to learn to live with some of these yellow cautionary sections as I can’t get them to go away (without mangling their CQL queries…which may apply at a later date)!

NDepend is super flexible!

Now that I have been using this product for a while, and have started to bump my head against it a bit, I am starting to find that this product is actually very flexible! For example there is a query for for naming standards I have started to bump my head against. I like to use an underscore to denote my private fields in a class. NDepend would prefer that I use m_ instead. To change this is quick and easy. I simply locate the rule that bugs me, double click on it, make the change in the CQL query editor, and save the changes.

I made the changes to the query above so that it now looks like this:

This goes for all of the rules that are in this product which means that I can add and remove rules as I see fit!

Social Networking in .NET

Andrew Siemer - www.andrewsiemer.com — Mon, 11 May 2009 23:09:23 GMT

I finally posted the code from my book ASP.NET 3.5 Social Networking on CodePlex at http://community.codeplex.com/. Several people have asked for this so that we can make changes to the code and improve/expand the code base. I think I may also take the time to convert it from the MVP pattern to the latest ASP.NET MVC pattern/template as well as add test coverage the project. I also set up a forum for this at forum.socialnetworkingin.net and a separate blog at blog.socialnetworkinging.net.

SOLID principles explained in a visual manner

Andrew Siemer - www.andrewsiemer.com — Fri, 08 May 2009 02:29:21 GMT

If you followed any of the banter regarding the SOLID principles between “uncle” Bob Martin and Joel Spolsky you may have also already seen the SOLID development principles in motivational pictures. If not follow through all the links listed here. The last one has the pictures.

Simple podcast outlining the SOLID principles: http://www.hanselminutes.com/default.aspx?showID=163

Jeff Atwood, Joel Spolsky, and “uncle” Bob Martin discuss SOLID: http://itc.conversationsnetwork.org/shows/detail4012.html

Hanselman’s follow on interview with “uncle” Bob Martin: http://www.hanselminutes.com/default.aspx?showID=168

The best thing that came from all of this is the following pictures from LosTechies:

http://www.lostechies.com/blogs/derickbailey/archive/2009/02/11/solid-development-principles-in-motivational-pictures.aspx

Huagati DBML/EDMX Tools

Andrew Siemer - www.andrewsiemer.com — Wed, 22 Apr 2009 19:52:37 GMT

Anyone that is working frequently with either LINQ to SQL or the Entity Framework needs to go get a copy of the Huagati DBML/EDMX tools. They plug right into Visual Studio (2008) and allow you to perform many of the tasks that you would think VS would do for you. I just recently had a new dev db get corrupted. I had no backups for it. I also had no scripts generated for it. Argh! What to do? With this tool I was able to reverse engineer my EDMX file and spit out all the SQL I needed to generate the database. There are many other features provided with this tool that I am sure you will love too.

This tool is offered in a free 30 day trial. Then there are a few paid versions. I think that the professional version is worth the $120 price tag but there is a $50 version and a $12/mo subscription option. Very good stuff! Go grab a copy.

Susan Boyle – not geeky…but WOW! Must watch.

Andrew Siemer - www.andrewsiemer.com — Thu, 16 Apr 2009 17:49:24 GMT

Word Press Tag Cloud to be reused across other tag-able systems – WP Cumulous

Andrew Siemer - www.andrewsiemer.com — Fri, 03 Apr 2009 15:36:53 GMT

I was scooting about the net the other day and landed on someone’s site that had the most fascinating tag cloud I have seen so far. The tags in this cloud revolve as though they are in a 3d sphere. When you mouse over the sphere you can move the words up down and around. Very interesting. This is a flash based control that you can feed with an XML file. Also, the source for it is readily available which makes it a tool that can be ported to just about any tab based platform. Very nice! See the home page for this widget here or get the developer (source) version here.

ILOG Rules for .NET 3.0 – quick overview

Andrew Siemer - www.andrewsiemer.com — Mon, 30 Mar 2009 20:14:10 GMT

I have been working on a project for the past year or so. This project was originally decided to be implemented in a BizTalk environment. Although most of us were new to this form of SOA development we went ahead with the understanding that we would eventually learn enough to stand up, manage, and develop for BizTalk. With this in mind we developed our entire application in such a way that we thought the app would simply plug in to the BizTalk environment (from an orchestration point of view any ways).

Some of the reasons that we decided to go with BizTalk was that it was very scalable, configurable, flexible, and that it had many components that we could easily use in our application. Some of these components were the Business Rules Engine (BRE), various reporting tools (BAM), built in queue integration, etc. We liked the idea of using already built and tested components. Why recreate the wheel after all? After we played with BizTalk for quite some time, took several classes, and spent many months with our BizTalk consultants, we eventually heard one statement that summed up BizTalk in every way:

“BizTalk can do anything you want it too, it just can’t do anything out of the box!”

Whaaaaa?

Any ways…again…a year later I am still working on an application that needs some of these BizTalk style components. One of which we have found is needed more and more. We needed an external program to manage the flow of our application. One might immediately jump to Windows Workflow Foundation and the Rules Engine that comes with WWF. However, one of the marching orders of this application is that the business users can make changes to the logic of the application in such a way that it doesn’t require a code push and is not restricted by the length of a development cycle. We had looked into several rules engines along the way to see if any were capable of addressing this need. All of the rules engines that we came across were Java based and forced you to integrate with them via web services. Yuck.

We eventually came across ILOG Rules for .NET. This is a program (now owned by IBM and a Microsoft Gold partner) that integrates into a .NET developers world in a very seamless manner. It plugs right into Visual Studio allowing the developer to define flows, express facts to rule editors, verbalize those facts in a more business friendly manner, and call into the execution server to run the rules all without any headache at all.

In addition to that the rules, decision tables, and flows can be edited externally in Microsoft Word or Excel.

And for those in a real Microsoft shop you probably have a SharePoint installation to manage all of your documents. SharePoint is also fully integrated into this suite for rule doc management, workflow management, etc. (sorry, no screen shot of this yet)

The best part of this application in my mind is that ILOG gives you a 6 month free trial of the fully functional suite! This means that you can easily knock together a proof of concept before you purchase their (very reasonably priced) program. http://www.ilog.com/dev/brms/rfdntrial/ And another benefit to their free trial is that they provide you will full access to their support forum. I had a few issues during my POC development that I got pretty quick help with through this online help format!

In future posts I will show my proof of concept and address some of the gotchas that I ran into.

I am going to assume that you can get through their registration and free trial download process. I am also going to assume that you can get all of their programs installed and running (they cover that pretty well).

One word to the wise – do be sure to install the execution server first so that you don’t have to mess with any configuration files down the road! This should be pretty easy as it is the first installer you come across.

Also, be sure to read through their various documents and white papers (with the QuickStart being the most helpful!):

Quick Start	C:\Program Files\ILOG\ILOG Rules for .NET Quick Start 3.0\Documentation\QuickStart.pdf
White papers	http://www.ilog.com/products/rulesnet/whitepapers/
Online help	http://docs.ilog.com/brms/documentation/rulesnet30/

Entity Framework : An entity object cannot be referenced by multiple instances of IEntityChangeTracker.

Andrew Siemer - www.andrewsiemer.com — Fri, 27 Mar 2009 19:12:42 GMT

I just had this error where entity framework was complaining about my object already being referenced by the data context that I originally got the object from. In LINQ to SQL I guess this was just taken care of for me. I would get the object in a using statement so that the data context was cleared when I was through with the context. Then I could do what ever I wanted to with the object after that – to include throwing it back to the database.

I came across the fix to this issue here: http://social.msdn.microsoft.com/Forums/en-US/adodotnetentityframework/thread/501d7b99-0cb9-44b6-b2cd-16275a151b31 which simply suggests detaching the object from the original context before I kill that context. Then I can re-attach the object to a new context later on. This solved the issue…but uncovered more issues.

Here is my post to the MS forum:

-----------------------------------------------------------------------------------

Working in a web app I am very fond of the Repository approach. I generally create a new context inside a using statement which then kills the context for me once my snippet of work is complete. So for an AccountsRepository I might have a Save(Account account) method which would have something like the following:

using (RanchBuddyDataContext dc = new Connection().GetContext())

{

if(account.AccountID > 0)

{

dc.Accounts.Attach(account, true);

}

else

{

dc.Accounts.InsertOnSubmit(account);

}

dc.SaveChanges();

}

While this worked great in LINQ to SQL I am finding that it doesn't work so well with the Entity Framework. I am now getting the error that started this thread. In order to address this problem I have to do a few things and am not liking the work that goes into this. Hopefully someone can adjust my way of thinking on this.

For my particular issue I have a person that logs into the system. Once the log in is correct I stash their account object (fairly light) into their current session. I then refer to that now and then as needed. This works great. However, when the user goes to the edit account screen, I would normally load the screen with their session held Account object. Allow the user to edit their data and then throw it at a repository method as descibed above.

Not any more!

Up to the point where the user logs in is unchanged. However, the object that is returned to me by my login method now has to be detached from the context - a step that I must remember any time that I want to keep and object out of the db, fiddle with it (edit it), and then eventually persist it back to the db. Then it is put in the session for later use. Once the user edits their account I have to get an original copy of the object (I am guessing so that the context is aware of it???) and then attempt to persist my object (with changes) back to the db.

I now have this code for getting the Account by username:

public Account GetAccountByUsername(string Username)

{

Account result = null;

using (RanchBuddyEntities dc = connection.GetContext())

{

result = dc.AccountSet.Where(a => a.Username == Username).FirstOrDefault();

dc.Detach(result);

}

return result;

}

If the account that is returned from a username search matches the supplied password then the account object here goes into my session. Notice that at the bottom of my query above I have a dc.Detach(result) statement to remove it from the context. From what I have read so far I have to do this so that I can re-attach it later on or keep a copy of the original object with me everywhere I go.

Then comes my save code.

using (RanchBuddyEntities dc = connection.GetContext())

{

if(account.AccountID > 0)

{

Account original = dc.AccountSet.Where(a => a.AccountID == account.AccountID).FirstOrDefault();

dc.ApplyPropertyChanges("AccountSet",account);

}

else

{

dc.AddToAccountSet(account);

}

dc.SaveChanges();

}

In this code I now have to get the original object into the context (as I don't carry the original object around with me just in case I need it and I guess the context is not aware of it if I don't manually load it??), then ApplyPropertyChanges of my updated object, and finally SaveChanges() on the context.

I would love to hear if anyone has a better way of working with this. I much prefer the way I was able to do this in LINQ to SQL as there were less steps to remember and I didn't need to litter various methods with snippets so that one method would work correctly with another (when they shouldn't care about each other at all).

-----------------------------------------------------------------------------------

I would love to hear of a better solution to this problem that shouldn’t be a problem.

Entity Framework : At first glance the LINQ to SQL team didn’t transition fast enough!

Andrew Siemer - www.andrewsiemer.com — Tue, 03 Mar 2009 19:52:27 GMT

I started looking at the latest the EF team had to offer and while things have progressed immensely over the years it appears that there is still some room for improvement. Given the turmoil over the possible demise of LINQ to SQL I know that the use of Entity Framework is inevitable for me and probably just around the corner.

With my newest project I have started to plug in an ADO.NET Entity Data Model (EDMX) where I would normally plug in LINQ to SQL Classes (DBML). I still dropped the file into my Domain directory so that all the classes that are generated show up where I would expect them. I then connect to my database in the Server Explorer, expand my database, then expand tables, and drag over all of my tables unto the new Entity design surface. This creates a bunch of classes for me named exactly as my tables are named? ARGH! This is the first pain point. I rename each and every table from a plural form to a single form. With this corrected I can then go in and edit my Connection() helper class to return Entities instead of a DataContext.

From this…
0:      public class Connection
1:     {
2:         public RanchBuddyDataContext GetContext()
3:          {
4:             string connString = ConfigurationService.GetRanchBuddyEntitiesConnectionString();

5:              RanchBuddyDataContext dc =new RanchBuddyDataContext(connString);
6:              dc.CommandTimeout = 60;
7:             return dc;
8:          }
9:      }

To this…
0:   public class Connection
1:      {
2:   public RanchBuddyEntities GetContext()
3:   {
4:   string connString = ConfigurationService.GetRanchBuddyEntitiesConnectionString();

5:   RanchBuddyEntities dc = new RanchBuddyEntities(connString);
6:   dc.CommandTimeout = 60;
7:   return dc;
8:   }
9:   }

That was pretty easy! I can now start to create my repository layer which connects to my database through the Entity Framework. The syntax is a little different but mostly the same. And once you get the hang of it it is very easy to get to work. Where I used to select directly from DataContext.TableCollection I now have to do something like this to select a record:


0:   public Account GetAccountByUsername(string Username)
1:   {
2:   Account result = null;
3:   using (RanchBuddyEntities dc = connection.GetContext())
4:   {
5:   result = dc.AccountSet.Where(a => a.Username == Username).FirstOrDefault();
6:   }
7:   return result;
8:   }

Something like this to save a record:


0:   public RepositoryStatus SaveAccount(Account account)
1:   {
2:   RepositoryStatus rs = new RepositoryStatus();
3:   try
4:              {
5:   using (RanchBuddyEntities dc = connection.GetContext())
6:   {
7:   if(account.AccountID > 0)
8:   {
9:   dc.Attach(account);
10:   }
11:   else
12:                      {
13:   dc.AddToAccountSet(account);
14:   }
15:   dc.SaveChanges();
16:   }
17:   rs.SetObject(account);
18:   rs.AddMessage("Your account was successfully saved!");
19:   rs.StatusType = Status.StatusTypes.Success;
20:   }
21:   catch(Exception e)
22:   {
23:   rs.SetObject(account);
24:   rs.AddMessage(e.Message + e.StackTrace);
25:   rs.StatusType = Status.StatusTypes.Failure;
26:   }
27:   return rs;
28:   }

And something like this to delete a record:

0:          public RepositoryStatus DeleteAccount(Account account)
1:          {
2:             RepositoryStatus rs =new RepositoryStatus();
3:             try
4:             {
5:                 using (RanchBuddyEntities dc = connection.GetContext())
6:                  {
7:                      dc.Attach(account);
8:                      dc.DeleteObject(account);
9:                      dc.SaveChanges();
10:                  }
11:                  rs.SetObject(new object());
12:                  rs.AddMessage("Your account was successfully deleted!");
13:                  rs.StatusType =Status.StatusTypes.Success;
14:              }
15:             catch(Exception e)
16:              {
17:                  rs.SetObject(new object());
18:                  rs.AddMessage(e.Message + e.StackTrace);
19:                  rs.StatusType =Status.StatusTypes.Failure;
20:              }
21:             return rs;
22:          }

In some ways this is actually easier than working with LINQ to SQL. Let’s continue on.

Ok, I added a column to one of my previously included tables. In LINQ to SQL I would just delete the entity and re-drag it to the design surface. Let’s do that here for EF. Deleting the entity works great. Now let’s re-add the table. Wait…it won’t let me? What is that about. Apparently there are issues with the designer that don’t quite clean every thing out as one might expect. Deleting the entity only removed it from the view. As far as EF is concerned the entity is still in play! To really delete the table so that you can re-add it you have to dig into the EDMX and remove all references to that table! FUN FUN FUN.

With the table deleted, then all references to the table deleted, I am now able to add my table back to the design surface. Cool. Close the design surface and let’s do something else. (this only happens now and then…but bare with me!) Oh wait…re-open the design surface real quick and let’s do a bit more work there. Wait…what’s this…Visual Studio periodically forgets how to open an EDMX file you say? Guess what…the only way to correct this issue is to close your solution and reload it! The other stuff I can live with. But this particular issue is sort of lame!

All in all and especially since I have no choice – working with the Entity Framework doesn’t seem like brain surgery just yet. I am hoping that all the issues I had working with disconnected contexts and many to many tables is rectified. Also, I am hoping that having all the relationships left intact doesn’t cause me the same pains as LINQ to SQL did…guess I can always turn them off like I tend to do in LINQ to SQL.

MVC Attributes via ActionFilterAttribute

Andrew Siemer - www.andrewsiemer.com — Tue, 18 Nov 2008 05:27:07 GMT

I needed an attribute to decorate methods/controllers to protect them from being accessed by users that are not logged in. If I were using a .net provider for authentication I could use the [Authorize] attribute that is provided in the MVC framework. However, in this case I chose to create my own security. This means that I need to also create my own [Authorize] attribute (as I love it’s simplicity!). Finding the way to do this is not that straight forward. So here is the custom attribute.

Code Snippet


0:  public class MustBeLoggedInAttribute : ActionFilterAttribute 
1:  {
2:   private WebContext _webContext;
3:   public MustBeLoggedInAttribute()
4:   {
5:   _webContext = new WebContext();
6:   }

7:   public override void OnActionExecuting(ActionExecutingContext filterContext)
8:   {
9:   if(_webContext.Account == null)
10:   {
11:   string loginUrl = "~/Account/Login";

12:   filterContext.HttpContext.Response.Redirect(loginUrl);
13:   }

14:   base.OnActionExecuting(filterContext);
15:   }
16:  }

/pre>

And to use this new attribute simply decorate the method you want protect.

Code Snippet


0:  [MustBeLoggedIn]
1:  public ActionResult ChangePassword(string currentPassword, string newPassword, string confirmPassword)
2:  {

3:   ViewData["Title"] = "Change Password";

4:   // Non-POST requests should just display the ChangePassword form 
5:      if (Request.HttpMethod != "POST")
6:   {
7:   return View();
8:   }

/pre>

Notice that the name of the custom attribute is MustBeLoggedInAttribute but the usage of the attribute only shows MustBeLoggedIn – no Attribute!

I saw several hits of not using a hard coded Redirect path by specifying the controller and action. If someone knows this answer for the current release of MVC please post it! For now I can stick it in a config value or something.

LINQ to SQL possibly being dropped by Microsoft?

Andrew Siemer - www.andrewsiemer.com — Mon, 03 Nov 2008 17:31:59 GMT

Is anyone out there close to this subject? My editor at RedGate sent me a link to someone’s blog post that basically took me to this link where I found a beat around the bush statement eluding to the possibility of MS dropping LINQ to SQL.

http://blogs.msdn.com/adonet/archive/2008/10/29/update-on-linq-to-sql-and-linq-to-entities-roadmap.aspx

As I have several applications running on LINQ to SQL I was wondering what people’s thoughts were on this subject. What do you think the odds are of them actually removing support and future updates to this product? I don’t think that LINQ to Entities is quite ready to be adopted in the same way that LINQ to SQL was (and it was only sort of ready). So what are you plans to migrate too if LINQ to SQL is to be dropped? NHibernate?

ASP.NET 3.5 Social Networking: An expert guide to building enterprise-ready social networking and community applications with ASP.NET 3.5

Andrew Siemer - www.andrewsiemer.com — Thu, 30 Oct 2008 23:11:53 GMT

My first book is finally starting to show up on the Internet!

http://www.amazon.com/ASP-NET-3-5-Social-Networking-Enterprise-ready/dp/1847194788/ref=sr_1_1?ie=UTF8&s=books&qid=1225408005&sr=8-1

This book explores the creation of a social networking site or community site from the ASP.NET/C# developers point of view. The application that is built follows an enterprise approach to building a web site and utilizes concepts such as domain driven design, repository pattern, structure map, inversion of control, test driven development, model view presenter, and ajax. It also explores the non-technical side of a community which covers topics such as tag clouds, blogs, forums, profile and account management, etc.

jQuery Visual Studio Intellisense released

Andrew Siemer - www.andrewsiemer.com — Thu, 30 Oct 2008 22:55:51 GMT

http://code.google.com/p/jqueryjs/downloads/detail?name=jquery-1.2.6-vsdoc.js&can=2&q=

If you are a jQuery fanatic, an ASP.NET developer, and a Visual Studio user take a look at the link above for excellent Intellisense integration. If you are not yet a jQuery fanatic but meet the other requirements take a look at the link above as jQuery has been adopted by Microsoft and will be published with Visual Studio moving forward. Good stuff.

StructureMap users - great article (Using the StructureMap Container independently of ObjectFactory)

Andrew Siemer - www.andrewsiemer.com — Mon, 15 Sep 2008 17:28:34 GMT

The developer of StructureMap (Jeremey Miller) posted a great article (to defend the product) regarding the use of StructureMap outside of the ObjectFactory:

http://codebetter.com/blogs/jeremy.miller/archive/2008/09/10/using-the-structuremap-container-independently-of-objectfactory.aspx

Great article comparing MVC and MVP - at a high level

Andrew Siemer - www.andrewsiemer.com — Mon, 15 Sep 2008 17:16:01 GMT

http://codebetter.com/blogs/kyle.baley/archive/2008/09/10/mvc-vs-mvp-a-hillbilly-s-journey.aspx

I felt that a pointer to this article is worth while. I have spent a fair bit of time trying to determine what my preference was between MVP and MVC. I tend to lean more towards the MVP side and this article mentions directly why I like it so much more. MVC tears out the state awareness that the standard ASP.NET web forms come with. I spent so many years in ASP classic wiring up form and query string variables and attempting to keep track of who a user was and what they were up too. Once ASP.NET was launched all that work mostly went away. I would rather keep the state awareness simple and do some plumbing to achieve MVP which allows me to do TDD than go back to an environment that forces me to provide plumbing for one task (state) just to remove plumbing for another (decoupled presentation layer). In my mind as long as you are achieving TDD and a fairly decoupled front end you are headed in the right direction.

I like this last statement from the referenced post above:

"So my ultimate understanding of the difference is that it is based on how intimate the View and Presenter/Controller are. In MVP, they are cosy and familiar, like cousins. In MVC, they are cold and distant, like lawyers."

That sums it up for me!

Manning .NET Daily Drawing

Andrew Siemer - www.andrewsiemer.com — Wed, 18 Jun 2008 20:15:58 GMT

Join the Manning .NET Daily Drawing!
Until July 17, click here to win a free .NET Ebook every day,
and then win the Complete Manning .NET Library!

UTC DateTime format and BizTalk

Andrew Siemer - www.andrewsiemer.com — Wed, 11 Jun 2008 16:02:48 GMT

We came across an odd little issue where our message schema requires a DateTime value. Using System.DateTime.Now does not come out in the proper format as BizTalk requires the UTC format. UTC format follows something like this: YYYY-MM-DDThhmmss (e.g. 1997-07-12T103508)

If you are working with your dates pragmatically as we currently are you can simply use System.DateTime.Now.ToString("o")

We are currently working in a message assignment shape to send a response value in the form of a DateTime just to let the consumer of our web service know that BizTalk received the request.

In the message assignment...

Notice the System.DateTime.Now.ToString("o")...

(this assignment should go in one continuous line)

Accepting XmlDocuments from BizTalk, de-serializing them to XSD generated Serializable Classes, and back again!

Andrew Siemer - www.andrewsiemer.com — Thu, 01 May 2008 02:58:44 GMT

Introduction

So I find myself working in a BizTalk world these days. So most of what I am dealing with is WCF, SOA, bus, etc. related. However, there are times when I need to write an assembly that BizTalk can use to communicate with the outside world. The best way for BizTalk to interact with my assembly is with XmlDocuments that conform to an strongly typed XSD generated schema. After a bit of research across many sites, several colleagues interacting with one another over this issue, and finally locating my answer after the dust settled, I decided that this topic would make a great blog post.

So in this post I am going to walk you through the following processes:

Define an XML structure
Generate an XSD schema
Generate a serializable class with the XML Schema Definition Tool (XSD.exe)
Create a class/method that accepts an XmlDocument (as you would from BizTalk)
De-serialize the XmlDocument to the strongly typed serializable class
Work with the strongly typed serializable class
Serialize the strongly typed serializable class into an XmlDocument (to act as BizTalk would so that you can test your assembly)
Create a test harness to interact with our functionality

To get us started I have created two projects. One to act as a ClassLibrary that would simulate what BizTalk would interact with. The other project is a console application that will act on behalf of BizTalk itself and pass an XmlDocument into the class library project for manipulation.

Define an XML structure

Defining an XML structure is pretty simple. We will add an XML file to our class library project. Right click on the "Class Library" project and select Add>New Item.

Select the XML file option. Change the name to Person.xml and click Add.

This will then open your new Person.xml file in the main window of Visual Studio. Lets build up the XML to represent a person with contact information, address information, etc.

XML Structure for our Person entity


0:  <?xml version="1.0" encoding="utf-8" ?>
1:  <Person FirstName="Andrew" MiddleName="Tobias" LastName="Siemer">
2:   <Emails>
3:   <Email Type="Primary">asiemer@hotmail.com</Email>
4:   <Email Type="Secondary">andrewsiemer@gmail.com</Email>
5:   </Emails>
6:   <Phones>
7:   <Phone Type="Cell">661-600-0000</Phone>
8:   <Phone Type="Home">661-722-0000</Phone>
9:   <Phone Type="Fax">661-123-0000</Phone>
10:   </Phones>
11:   <Addresses>
12:   <Address Type="Home">
13:   <Street1>1234 Some Street</Street1>
14:   <Street2></Street2>
15:   <City>Lancaster</City>
16:   <State>Ca</State>
17:   <Zip>93536</Zip>
18:   </Address>
19:   <Address Type="Work">
20:   <Street1>1234 Some Street</Street1>
21:   <Street2></Street2>
22:   <City>Culver City</City>
23:   <State>Ca</State>
24:   <Zip>93536</Zip>
25:   </Address>
26:   </Addresses>
27:  </Person>

It is important to notice that I have not only defined the structure here, I have added test data as well. An in cases where I want repeating nodes I have added more than one set of demo data. This will help us in the next step when we generate our schema as the code generator is smart enough to see these differences.

Once we have our demo structure and data in place we can move to the next step to generate the XSD schema.

Generate an XSD schema

I don't know if this section really warrants a whole heading by itself or not... (but Google will appreciate it if no one else does!)

In the XML Editor tool bar you will see a button (the furthest left button on my bar) that will generate the schema for us.

With the Person.xml file open, click the "Create Schema" button. Once you have done this you will have the generate schema pop up in a Person.xsd tab.

Generated Schema for the Person entity


0:  <?xml version="1.0" encoding="utf-8"?>
1:  <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
2:   <xs:element name="Person">
3:   <xs:complexType>
4:   <xs:sequence>
5:   <xs:element name="Emails">
6:   <xs:complexType>
7:   <xs:sequence>
8:   <xs:element maxOccurs="unbounded" name="Email">
9:   <xs:complexType>
10:   <xs:simpleContent>
11:   <xs:extension base="xs:string">
12:   <xs:attribute name="Type" type="xs:string" use="required" />
13:   </xs:extension>
14:   </xs:simpleContent>
15:   </xs:complexType>
16:   </xs:element>
17:   </xs:sequence>
18:   </xs:complexType>
19:   </xs:element>
20:   <xs:element name="Phones">
21:   <xs:complexType>
22:   <xs:sequence>
23:   <xs:element maxOccurs="unbounded" name="Phone">
24:   <xs:complexType>
25:   <xs:simpleContent>
26:   <xs:extension base="xs:string">
27:   <xs:attribute name="Type" type="xs:string" use="required" />
28:   </xs:extension>
29:   </xs:simpleContent>
30:   </xs:complexType>
31:   </xs:element>
32:   </xs:sequence>
33:   </xs:complexType>
34:   </xs:element>
35:   <xs:element name="Addresses">
36:   <xs:complexType>
37:   <xs:sequence>
38:   <xs:element maxOccurs="unbounded" name="Address">
39:   <xs:complexType>
40:   <xs:sequence>
41:   <xs:element name="Street1" type="xs:string" />
42:   <xs:element name="Street2" />
43:   <xs:element name="City" type="xs:string" />
44:   <xs:element name="State" type="xs:string" />
45:   <xs:element name="Zip" type="xs:unsignedInt" />
46:   </xs:sequence>
47:   <xs:attribute name="Type" type="xs:string" use="required" />
48:   </xs:complexType>
49:   </xs:element>
50:   </xs:sequence>
51:   </xs:complexType>
52:   </xs:element>
53:   </xs:sequence>
54:   <xs:attribute name="FirstName" type="xs:string" use="required" />
55:   <xs:attribute name="MiddleName" type="xs:string" use="required" />
56:   <xs:attribute name="LastName" type="xs:string" use="required" />
57:   </xs:complexType>
58:   </xs:element>
59:  </xs:schema>

Make sure you save this new file into your Class Library project. Then click the "Show All Files" button.

Then right click on the ghosted Person.xsd and choose to include that file in the project.

Once we have the XSD defined we can use the XSD.exe tool to generate a serializable class for us!

Generate a serializable class with XML Schema Definition Tool (XSD.exe)

The MSDN page (http://msdn.microsoft.com/en-us/library/x6c1kb0s(VS.71).aspx) states this best: The XML Schema Definition tool generates XML schema or common language runtime classes from XDR, XML, and XSD files, or from classes in a runtime assembly.

We generated our schema from a button in Visual Studio. You could have also done it with this tool. What we can't do in Visual Studio (perhaps yet?) is take the schema one step further and generate a class. So, we will turn to the XSD.exe tool to generate a class from our schema.

To do this we first need to locate our XSD.exe tool. Mine is in this directory on my machine: C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\ If you don't have that directory (do you have Visual Studio installed?) you can search for it.

This is a command line tool so we will need to interact with it in one of a few possible ways. The easiest way is to open a command window and navigate to the location of the XSD.exe's directory. That being said, we need to make sure that the class that we generate is always in sync with our schema. So to do this we will create a batch file to performs the generation for us in a repeatable fashion. Then we can hook that batch file into our build process so that it generates the class first, and then builds the projects code.

To do this add a text file to our Class Library project.

Rename the file to GenerateClasses.bat and click Add.

We then need to add three lines to our new batch file. One to navigate the command prompt to the location of the XSD.exe file. The next line to call the XSD file with a few parameters. And the next line so that we can see the output when we run the batch file interactively.

Batch file to generate class in a repeatable fashion


0:  cd "C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\"
1:  xsd "C:\Projects\BlogPosts\XsdDemo\ClassLibrary\Person.xsd" /classes /o:C:\Projects\BlogPosts\XsdDemo\ClassLibrary\
2:  pause

CD makes the current directory the directory that is specified. In our case we specified the location of the XSD.exe file. Once at this location we tell the XSD executable to generate a class (with the /classes switch) from the Person XSD (with the path to the Person.xsd) that we created earlier. We also tell XSD to place the output in our Class Library project root directory. We then specify the pause command to see the output of XSD when in interactive mode.

Once we have this batch file created we can navigate to the file and run it by double clicking on it.

If you see the command prompt with some gibberish in it odds are there are extra characters in your file.

This seems to be caused by Visual Studio inserting some random characters that are not seen in the editor. Not sure exactly what it is.

To fix it I delete the .bat file I created in Visual Studio and create a new text file. I then copy my commands over to the clean .bat file. Now it works!

Now you can double click your .bat file again and all should be good.

Back in Visual Studio, make sure you still have show all files selected and click on the refresh button. You should now see a plus next to your Person.xsd. Expand this and you should also see a newly created Person.cs file. This is your generated serializable class that represents the Person XML we started out with.

Automagically Generated Serializable Class


0:  //------------------------------------------------------------------------------
1:  // <auto-generated>
2:  //     This code was generated by a tool.
3:  //     Runtime Version:2.0.50727.1434
4:  //
5:  //     Changes to this file may cause incorrect behavior and will be lost if
6:  //     the code is regenerated.
7:  // </auto-generated>
8:  //------------------------------------------------------------------------------

9:  using System.Xml.Serialization;

10:  // 
11:  // This source code was auto-generated by xsd, Version=2.0.50727.1432.
12:  // 


13:  /// <remarks/>
14:  [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.1432")]
15:  [System.SerializableAttribute()]
16:  [System.Diagnostics.DebuggerStepThroughAttribute()]
17:  [System.ComponentModel.DesignerCategoryAttribute("code")]
18:  [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
19:  [System.Xml.Serialization.XmlRootAttribute(Namespace="", IsNullable=false)]
20:  public partial class Person {

21:   private PersonEmail[] emailsField;

22:   private PersonPhone[] phonesField;

23:   private PersonAddress[] addressesField;

24:   private string firstNameField;

25:   private string middleNameField;

26:   private string lastNameField;

27:   /// <remarks/>
28:      [System.Xml.Serialization.XmlArrayItemAttribute("Email", IsNullable=false)]
29:   public PersonEmail[] Emails {
30:   get {
31:   return this.emailsField;
32:   }
33:   set {
34:   this.emailsField = value;
35:   }
36:   }

37:   /// <remarks/>
38:      [System.Xml.Serialization.XmlArrayItemAttribute("Phone", IsNullable=false)]
39:   public PersonPhone[] Phones {
40:   get {
41:   return this.phonesField;
42:   }
43:   set {
44:   this.phonesField = value;
45:   }
46:   }

47:   /// <remarks/>
48:      [System.Xml.Serialization.XmlArrayItemAttribute("Address", IsNullable=false)]
49:   public PersonAddress[] Addresses {
50:   get {
51:   return this.addressesField;
52:   }
53:   set {
54:   this.addressesField = value;
55:   }
56:   }

57:   /// <remarks/>
58:      [System.Xml.Serialization.XmlAttributeAttribute()]
59:   public string FirstName {
60:   get {
61:   return this.firstNameField;
62:   }
63:   set {
64:   this.firstNameField = value;
65:   }
66:   }

67:   /// <remarks/>
68:      [System.Xml.Serialization.XmlAttributeAttribute()]
69:   public string MiddleName {
70:   get {
71:   return this.middleNameField;
72:   }
73:   set {
74:   this.middleNameField = value;
75:   }
76:   }

77:   /// <remarks/>
78:      [System.Xml.Serialization.XmlAttributeAttribute()]
79:   public string LastName {
80:   get {
81:   return this.lastNameField;
82:   }
83:   set {
84:   this.lastNameField = value;
85:   }
86:   }
87:  }

88:  /// <remarks/>
89:  [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.1432")]
90:  [System.SerializableAttribute()]
91:  [System.Diagnostics.DebuggerStepThroughAttribute()]
92:  [System.ComponentModel.DesignerCategoryAttribute("code")]
93:  [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
94:  public partial class PersonEmail {

95:   private string typeField;

96:   private string valueField;

97:   /// <remarks/>
98:      [System.Xml.Serialization.XmlAttributeAttribute()]
99:   public string Type {
100:   get {
101:   return this.typeField;
102:   }
103:   set {
104:   this.typeField = value;
105:   }
106:   }

107:   /// <remarks/>
108:      [System.Xml.Serialization.XmlTextAttribute()]
109:   public string Value {
110:   get {
111:   return this.valueField;
112:   }
113:   set {
114:   this.valueField = value;
115:   }
116:   }
117:  }

118:  /// <remarks/>
119:  [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.1432")]
120:  [System.SerializableAttribute()]
121:  [System.Diagnostics.DebuggerStepThroughAttribute()]
122:  [System.ComponentModel.DesignerCategoryAttribute("code")]
123:  [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
124:  public partial class PersonPhone {

125:   private string typeField;

126:   private string valueField;

127:   /// <remarks/>
128:      [System.Xml.Serialization.XmlAttributeAttribute()]
129:   public string Type {
130:   get {
131:   return this.typeField;
132:   }
133:   set {
134:   this.typeField = value;
135:   }
136:   }

137:   /// <remarks/>
138:      [System.Xml.Serialization.XmlTextAttribute()]
139:   public string Value {
140:   get {
141:   return this.valueField;
142:   }
143:   set {
144:   this.valueField = value;
145:   }
146:   }
147:  }

148:  /// <remarks/>
149:  [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.1432")]
150:  [System.SerializableAttribute()]
151:  [System.Diagnostics.DebuggerStepThroughAttribute()]
152:  [System.ComponentModel.DesignerCategoryAttribute("code")]
153:  [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
154:  public partial class PersonAddress {

155:   private string street1Field;

156:   private object street2Field;

157:   private string cityField;

158:   private string stateField;

159:   private uint zipField;

160:   private string typeField;

161:   /// <remarks/>
162:      public string Street1 {
163:   get {
164:   return this.street1Field;
165:   }
166:   set {
167:   this.street1Field = value;
168:   }
169:   }

170:   /// <remarks/>
171:      public object Street2 {
172:   get {
173:   return this.street2Field;
174:   }
175:   set {
176:   this.street2Field = value;
177:   }
178:   }

179:   /// <remarks/>
180:      public string City {
181:   get {
182:   return this.cityField;
183:   }
184:   set {
185:   this.cityField = value;
186:   }
187:   }

188:   /// <remarks/>
189:      public string State {
190:   get {
191:   return this.stateField;
192:   }
193:   set {
194:   this.stateField = value;
195:   }
196:   }

197:   /// <remarks/>
198:      public uint Zip {
199:   get {
200:   return this.zipField;
201:   }
202:   set {
203:   this.zipField = value;
204:   }
205:   }

206:   /// <remarks/>
207:      [System.Xml.Serialization.XmlAttributeAttribute()]
208:   public string Type {
209:   get {
210:   return this.typeField;
211:   }
212:   set {
213:   this.typeField = value;
214:   }
215:   }
216:  }

Knowing that our schema may change we need to hook up our batch file to our build process so that each time we build the class library we have the most up to date class that represents our schema. To do this right click on your Class Library project and select properties. Select the Build Event tab.

In the Pre-build event command line section enter the full path to your batch file.

C:\Projects\BlogPosts\XsdDemo\ClassLibrary\GenerateClasses.bat

Save that and we are ready. Delete the class that we generated earlier. Then build your solution. Then refresh the solution explorer window. Your Person.cs file should now be back!

Now that we have all the right tools in place let's build some sample code.

Create a class/method that accepts an XmlDocument

In this section we are going to create a class that exposes methods that will simulate something that BizTalk would use. We are going to create a method that accepts an XmlDocument representing our person schema. We will create a method that takes in a Person and loads the phone numbers for that person. We will also create a method that takes in a Person and loads the addresses.

If you still have a class1 class in your project rename it to Worker. Then enter the code as you see it below.

Our Worker Class


0:  using System;
1:  using System.Collections.Generic;
2:  using System.IO;
3:  using System.Linq;
4:  using System.Text;
5:  using System.Xml;
6:  using System.Xml.Serialization;

7:  namespace ClassLibrary
8:  {
9:   public class Worker
10:      {
11:   public XmlDocument LoadEmails(XmlDocument Person)
12:   {
13:   return null;
14:   }

15:   public XmlDocument LoadPhones(XmlDocument Person)
16:   {
17:   return null;
18:   }

19:   public XmlDocument LoadAddresses(XmlDocument Person)
20:   {
21:   return null;
22:   }
23:   }
24:  }

Now that we have the method signatures in place we can start to work with the XmlDocument.

De-serialize the XmlDocument to the strongly typed serializable class

Inside of our methods we are accepting the XmlDocument that our test harness (which simulates BizTalk) is going to pass into us. Now we technically could work with this document in many ways but in our case we want to de-serialize that XmlDocument into the class that we generated with XSD. To do this we need to make a method that we can use from all of our Load... methods.

In order to make this the most flexible I will create a Generic method that allows us to specify the Type that we expect the XmlDocument to be de-serialized into.

Deserialize method


0:  public T Deserialize<T>(XmlDocument document)
1:   {
2:   T obj = default(T);
3:   using (MemoryStream ms = new MemoryStream())
4:   {
5:   document.Save(ms);
6:   ms.Flush();
7:   ms.Seek(0, SeekOrigin.Begin);
8:   XmlSerializer serializer = new XmlSerializer(typeof(T));
9:   obj = (T)serializer.Deserialize(ms);
10:   }

11:   return obj;
12:   }

This method starts with the generic signature of public T Deserialize<T>(XmlDocument document). The T provides me with a way to specify the type that I will expect my XmlDocument to be converted too. Also, since T is specified as the return type, I am also expressing that the specified type is what I expect the method to pass back to me.

I then define an object of type T. Since I don't know the type that I will be working with in my method I have to specify that my obj instance can be the object itself or the default instance of type T. This allows me to handle the fact that T might be a class or a struct. That is to say that T might be on the stack or the heap.

I then step into the using statement where I instantiate an instance of MemoryStream. I will be using the MemoryStream object to hold my XmlDocuments data. I then Flush the memory stream to make the XmlDocument present in the MemoryStream. Because I have flushed the stream I then have to reset the stream back to the beginning so the next time that I call into the stream the XmlDocument will be accessible.

With the XmlDocument ready and waiting in memory I can now turn my attention to the next step - XmlSerializer. I create an instance of XmlSerializer and specify the type using the generic T reference. I then pass the stream into the serailzier's Deserialize method and cast the object that is returned to my generic type T.

Once this is complete I leave the scope of the using statement which means that the MemoryStream is set for destruction.

I can now safely return my de-serialized object of type T.

Work with the strongly typed serializable class

Now that I have a way to take in the XmlDocument and cast it to my serialized class I can now freely work with the passed in object as I would any other class. I will explain what I am doing in one method knowing that the other two methods do very similar tasks.

LoadEmails


0:   public XmlDocument LoadEmails(XmlDocument Person)
1:   {
2:   Person p = Deserialize<Person>(Person);
3:   List<PersonEmail> emails = new List<PersonEmail>();

4:   for (int i = 1; i < 4; i++)
5:   {
6:   PersonEmail pe = new PersonEmail();
7:   switch (i)
8:   {
9:   case 1:
10:   pe.Type = "Primary";
11:   pe.Value = "asiemer@hotmail.com";
12:   break;

13:   case 2:
14:   pe.Type = "Secondary";
15:   pe.Value = "andrewsiemer@gmail.com";
16:   break;

17:   case 3:
18:   pe.Type = "Secondary";
19:   pe.Value = "andrewsiemer@yahoo.com";
20:   break;
21:   }
22:   emails.Add(pe);
23:   }

24:   p.Emails = emails.ToArray();

25:   return Serialize(p);
26:   }

/pre>

In the LoadEmails method we are taking in the XmlDocument that represents the Person class. We then de-serialize the XmlDocument so that we can work with the Person class directly. I then create a generic List of type PersonEmail (another class that was generated by XSD.exe). I then create a for loop that will create 3 instances of PersonEmail and then based on the value of the int i variable will load the PersonEmail with varying data. At the bottom of each iteration I then add the instance of the PersonEmail to my generic list of PersonEmails. At the end of the loop I then convert the generic List to an array with the ToArray method and add that array to the Person objects Emails collection.

Here are the other two methods we will work with.

LoadPhones and LoadAddresses methods


0:   public XmlDocument LoadPhones(XmlDocument Person)
1:   {
2:   Person p = Deserialize<Person>(Person);
3:   List<PersonPhone> phones = new List<PersonPhone>();

4:   for (int i = 1; i < 4; i++)
5:   {
6:   PersonPhone pp = new PersonPhone();
7:   switch(i)
8:   {
9:   case 1:
10:   pp.Type = "Home";
11:   pp.Value = "661-600-1234";
12:   break;

13:   case 2:
14:   pp.Type = "Cell";
15:   pp.Value = "661-555-7894";
16:   break;

17:   case 3:
18:   pp.Type = "Fax";
19:   pp.Value = "661-222-7854";
20:   break;
21:   }
22:   phones.Add(pp);
23:   }

24:   p.Phones = phones.ToArray();

25:   return Serialize(p);
26:   }

27:   public XmlDocument LoadAddresses(XmlDocument Person)
28:   {
29:   Person p = Deserialize<Person>(Person);
30:   List<PersonAddress> addresses = new List<PersonAddress>();

31:   for (int i = 1; i < 4;i++)
32:   {
33:   PersonAddress pa = new PersonAddress();
34:   switch(i)
35:   {
36:   case 1:
37:   pa.Type = "Home";
38:   pa.Street1 = "1234 Some Street";
39:   pa.Street2 = "Apt B";
40:   pa.City = "Lancaster";
41:   pa.State = "California";
42:   pa.Zip = 93536;
43:   break;

44:   case 2:
45:   pa.Type = "Work";
46:   pa.Street1 = "1234 Some Street";
47:   pa.Street2 = "Suite 102";
48:   pa.City = "Culver City";
49:   pa.State = "California";
50:   pa.Zip = 90210;
51:   break;

52:   case 3:
53:   pa.Type = "Vacation";
54:   pa.Street1 = "1234 Some Street";
55:   pa.Street2 = "Hut B";
56:   pa.City = "Honolulu";
57:   pa.State = "Hawaii";
58:   pa.Zip = 12345;
59:   break;
60:   }
61:   addresses.Add(pa);
62:   }

63:   p.Addresses = addresses.ToArray();

64:   return Serialize(p);
65:   }

/pre>

This then brings us to the next section where we serialize the Person object back to an XmlDocument.

Serialize the strongly typed serializable class into an XmlDocument

Now that we are successfully converting XmlDocuments to a format that we can easily work we need to discuss getting the serializable classes back to their XmlDocument format. To do this we will create another generic method that doesn't care what we are serializing.

Serialize method


0:   public XmlDocument Serialize<T>(T ObjectToSerialize)
1:   {
2:   XmlDocument xd = new XmlDocument();
3:   using (MemoryStream stream = new MemoryStream())
4:   {
5:   XmlSerializer xs = new XmlSerializer(typeof(T));
6:   xs.Serialize(XmlWriter.Create(stream), ObjectToSerialize);
7:   stream.Flush();
8:   stream.Seek(0, SeekOrigin.Begin);
9:   xd.Load(stream);
10:   }
11:   return xd;
12:   }

This method also allows us to specify the type that we will be working with via T. The first thing we do inside the method is to create a new XmlDocument. We then specify another MemoryStream inside of a using statement (so that once we are out of the using statement the MemoryStream will be released). Next comes an instance of the XmlSerializer. Notice that we specify the type using the typeof method on the T variable. We then call the Serialize method of the XmlSerializer and pass the ObjectToSerialize into the MemoryStream via a call to the XmlWriter.Create() method. Now that we have the object waiting in the MemoryStream we again call the Flush method to save the object into the MemoryStream. Now the Seek method is called to reset the index of the MemoryStream so that the object is accessible in the MemoryStream. We can finally load the object from the MemoryStream into the XmlDocument via a call to the Load method. We then exit the using statement to release the MemoryStream. Finally we can return the XmlDocument.

With all of this new functionality we can finally create a test harness to make sure that it all works.

Create a test harness to interact with our functionality

Now that we have all these cool new tools to play with lets create a test harness to verify that everything is working! Let's get started by opening up the program.cs file in the ConsoleApplication that we created. Now let's add a reference to your TestHarness project that references the ClassLibrary project. Do this by right clicking on the TestHarness project and selecting add reference. Then select the projects tab in the window that opens.

Select the ClassLibrary project and select ok.

Now we can get to work. In the Program class add the following logic:

Main method of the Program class


0:   static void Main(string[] args)
1:   {
2:   Worker worker = new Worker();
3:   XmlDocument xd = new XmlDocument();
4:   Person p = new Person();

5:   p.FirstName = "Andrew";
6:   p.MiddleName = "Tobias";
7:   p.LastName = "Siemer";

8:   xd = worker.LoadPhones(worker.Serialize(p));
9:   p = worker.Deserialize<Person>(xd);

10:   xd = worker.LoadEmails(worker.Serialize(p));
11:   p = worker.Deserialize<Person>(xd);

12:   xd = worker.LoadAddresses(worker.Serialize(p));
13:   p = worker.Deserialize<Person>(xd);

14:   Console.Read();

15:   }

You will notice that I have created an instance of the Worker class. I then created an instance of the XmlDocument that we will be passing back and forth between the worker and this method. And then comes an instance of the serializeable Person class.

I then add some values to the Person class. Then comes the calls into the Load... methods of the Worker class. Notice that with each call into a Load method I am calling the Serialize method of the Worker class to convert my Person class to an XmlDocument. Technically BizTalk would do this serialization on its own and would present an XmlDocument to my class library. The response of the Load methods is then assigned to the XmlDocument instance that we have. I then call the Deserialize method of the Worker class and assign it back to the Person class. With each call to a new Load method I am adding more and more data to my Person class.

As you can see in the image above all of our properties and collections are full!

StructureMap 101 - dynamically swapping objects

Andrew Siemer - www.andrewsiemer.com — Mon, 03 Mar 2008 21:44:34 GMT

I recently wrote this in an email to my co-workers. This makes it a bit out of context here...but hopefully it will make sense!

I had to refresh my mind a little bit to figure out how to programatically swap out instance momentos in StructureMap...so I figured I would send this out to you all too.
In case you were wondering why we are using StructureMap for newing up objects rather than just instantiating them directly (other than good design with decoupling :) )... up to this point I have not been able to produce any good reasons in this project for being able to swap out objects but just came across an instance. I am currently working on porting our caching via .net httpcontext to caching with memcached (distributed server cloud).

As a result of this we now have two objects that perform the same tasks...but with different implementation. One that uses the cache facility with .net's HttpContext and one that uses the MemCached implementation. The interface for both of these objects is the same. The interface is called ICache.

We have a Cache object that inherits from ICache. We also have a MemcachedCache object that inherits from the same ICache. We then have pluggable attributes defined for both caching classes [Pluggable("Cache")] and [Pluggable("MemCached")]. The plugin family for ICache is [PluginFamily("MemCached")]. This means that the default object to be returned by StructureMap is the MemcachedCache class as the default value for the interface's PluginFamily attribute matches the Pluggable attribute of the MemcachedCache object.

However, in our tests (and possibly while performing local dev work), we would want to use the HttpContext cache to remove dependencies as much as possible and to speed along the tests. That being said we would also want the ability to test our MemCache installations from time to time too!

This can be done with the same set of unit tests with the InjectStub method that the StructureMap.ObjectFactory presents us with.

ICache cache1 = ObjectFactory.GetInstance<ICache>(); //MemcachedCache caching

ObjectFactory.InjectStub(typeof (ICache), new Cache());

ICache cache2 = ObjectFactory.GetInstance<ICache>(); //HttpContext caching

ObjectFactory.ResetDefaults();

ICache cache3 = ObjectFactory.GetInstance<ICache>(); //back to the MemcachedCache caching

Setting the default class can also be done in the StructureMap.Config file:

<?xml version="1.0" encoding="utf-8" ?>
<StructureMap>
<Assembly Name="[assembly name]" />
<PluginFamily
      Assembly="[assembly name]"
      Type="[namespace.interface name]"
      DefaultKey="[MemCached or Cache]" />
</StructureMap>

Let me know if there are any questions!

Converting a System.Data.Linq.Binary (or timestamp) to a string and back again to avoid LINQ concurrency issues

Andrew Siemer - www.andrewsiemer.com — Mon, 11 Feb 2008 18:04:38 GMT

I have been working on getting around the concurrency issues that LINQ has while working with disconnected DataContext's in an nTier environment. I currently have a Timestamp field in all of my tables to act as a row version number to help LINQ keep track of what is going on with my data. Up to this point I haven't had any issues as I have been working with objects that were either stored in session/cache as whole objects or I have been reconstituting the object from a new DataContext prior to updating it. In both of these scenarios I have the current timestamp to pass back to LINQ so that LINQ is happy.

This morning I found myself in a position where I didn't have the data stored in session (and didn't want to put it there either) and I didn't want to get a fresh copy from the database to update. These two scenarios just don't work for this situation. In reality, they don't work more often than not! How can I get around around this Timestamp concurrency issue?

After a great deal of research on some very cool ways to do things. And some more research regarding methods that just don't work. And after spending my whole morning trying to resolve this. I finally stepped back from the project and took a look at the easiest approach. What do you know - KISS worked to my advantage.

Using extension methods in C# 3.0 I created two methods, TimestampToString(), and StringToTimestamp(). This allowed me to easily store the timestamp as an attribute, in a hidden field, etc. so that I could easily work with it just as I would a record ID. Here's the code:

   1:          public static string TimestampToString(this System.Data.Linq.Binary binary)

   2:          {

   3:              byte[] binarybytes = binary.ToArray();

   4:              string result = "";

   5:              foreach (byte b in binarybytes)

   6:              {

   7:                  result += b.ToString() + "|";

   8:              }

   9:              result = result.Substring(0, result.Length - 1);

  10:              return result;

  11:          }

12:

  13:          public static System.Data.Linq.Binary StringToTimestamp(this string s)

  14:          {

  15:              string[] arr = s.Split('|');

  16:              byte[] result = new byte[arr.Length];

  17:              for (int i = 0; i < arr.Length; i++)

  18:              {

  19:                  result[i] = Convert.ToByte(arr[i]);

  20:              }

  21:              return result;

  22:          }

If you haven't worked with extension methods yet, you should be able to copy the above code into a static class (I called mine extensions <GRIN>). Then you can call the new methods off of the matching data type. So when working with a Class generated by LINQ that has a timestamp property (System.Data.Linq.Binary) you could say something along the lines of Account.Timestamp.TimestampToString(); And for any string that has a TimestampToString() generated value in it you can conversely call string.StringToTimestamp().

Now I will be the first to admit that this code could be cleaned up and refined. At this point I was just happy to get it to work. I have seen so many examples of things that just didn't work for this scenario so I felt the need to post something that did!

LINQ .First() method throws an error if there are no records!

Andrew Siemer - www.andrewsiemer.com — Wed, 06 Feb 2008 21:01:44 GMT

Egad! So I have used the .First() method in many of my LINQ queries to make sure that my query only returns one record. I thought this would be a great way to insure isolation of one record. Very similar to a TOP 1 statement in SQL. However, there is an issue with this concept. If your TOP 1 SQL statement doesn't find any records it returns nothing. I guess I sort of hoped that the .First() method would do something similar - say return NULL or something like that. It doesn't! Instead it throws an error stating "sequence contains no elements". Not what I had hoped for.

No worries though! There apparently was a reason for this method to find 1 or flip out as the LINQ team also provides the FirstOrDefault() method which will return NULL if no records were found. Their documentation on the 101 LINQ Samples page doesn't state anything about throwing an error. It doesn't really state anything at all about what would happen if the First() item wasn't found. It does state however that the FirstOrDefault() method will return the default value for the requested type - IE NULL!

LINQ to SQL - Implementing the Repository pattern

Andrew Siemer - www.andrewsiemer.com — Tue, 05 Feb 2008 20:52:11 GMT

I have been working for the past few days to try and figure out how to get LINQ to SQL integrated into my normal nTier environment. I have also been trying to follow along with the general principles of Domain Driven Design but am finding that there are some deficiencies in the current LINQ to SQL implementation that force a few restrictions on how I do things.

Let's first look at some of the restrictions

Disconnected DataContext

My understanding of the LINQ to SQL DataContext is that it prefers to remain open. The primary reason for this is that its sole purpose in life is to track the state of it's objects. As you add new objects into your collections, modify existing objects, or delete objects, the DataContext is tracking everything. Then you can all DataContext.SubmitChanges() and it will persist all of those changes into the database.

Keeping a DataContext around for the life of a web application though just doesn't sound realistic to me! I am very much used to the idea of opening a connection to the database, getting in, getting my job done, and getting out. As soon as I start down the standard tiered way of thinking where I open my DataContext, get an object, close the DataContext, do some work on my object, open a new DataContext, persist my object, and finally close that DataContext - LINQ to SQL is very unhappy with me!

This is just not the way that LINQ to SQL is currently designed to work! There are many work around's to get it to work the way it was intended, but it seems to add a level of complexity to the system that I think is inappropriate.

Interesting reading:

LINQ to SQL DataContext Lifetime Management

LINQ to SQL and attaching Entities

Simple object relationships

When I think about LINQ to SQL I am thinking that I have a whole ORM system similar to NHibernate that allows me to fetch an object and it's children, make some changes, push that back into the database, etc. All seamlessly! That has not been the case so far.

I am finding that LINQ to SQL doesn't like working with complex relationships. This is primarily due to my working in a disconnected environment of course. I am told that if I were to just use one DataContext that I keep alive forever - all would be fine. I am a web developer though - not a desktop guy! This just isn't possible.

This leaves me to managing my own relationships between my objects.

Persisting child objects

In the same way that I would think LINQ to SQL would allow me to fetch and play with child objects I would think it would allow me to easily persist them. This too doesn't appear to be the case. When spinning up a new DataContext I have to first detach all my children objects from the parent object, then attach the parent to the DataContext, then attach the children object to the parent object, and then SubmitChanges(). This is not always 100% though!

Value Objects

Entities and Value Objects are a very important part of Domain Driven Design. A value object is basically an object that can't exist without a parent object (or Entity). It doesn't have any unique identifier by itself. Where as an Entity object can exist without any help from other objects. As far as LINQ to SQL is concerned, all objects are to be Entity objects. This makes sense considering that LINQ needs a unique identifier in order for it to do it's job efficiently. However, this breaks some of the concepts of Domain Driven Design!

Now let's look at how we can get around these issues

Disconnected DataContext

When working with a disconnected nTier environment we need to be able to spin up a connection to the database, do some work, and disconnect - freeing up resources and going on our marry way. LINQ to SQL provides some features that allows you to do this as long as you are aware of the surrounding issues with making this decision. LINQ to SQL provides you with the Attach() method. There are various overrides of Attach(), but the one we are most concerned with is the one that allows you to specify that the object you are attaching already exists and that you are attaching a modified version of it.

dc.Respondents.Attach(respondent, true);
dc.SubmitChanges();

Simple object relationships

To be totally honest with you, the easiest way I have found to work with LINQ to SQL and how it manages relationships regarding my objects is to simply remove all knowledge of my relationships. At first this may sound a bit off, but it really does work out quite well in a Domain Driven Design where my repositories are responsible for simple fetching and persistence functionality and my services are more concerned with managing the relationships of my objects. As soon as I decided to use LINQ to SQL in this manner, everything started to work without any problem. No more hacked work around's to try and get it to perform as advertised!

Persisting child objects

As stated above, now that LINQ knows nothing about how my objects are related to one another, I no longer have to worry about this as an issue. I can now directly handle my relationships at the service layer above my repositories. If I need to save a complex object with child objects, I can pass it to a service layer which will break it apart and save out the underlying objects. This gives me total control at this point.

Value Objects

I have yet to find a fix for this issue! LINQ requires that our objects are unique in the system on their own merit! I doubt this will ever change.

Putting it all together?

Now that we know about the pros and cons of LINQ to SQL in a tiered environment and understanding my suggested work around's, lets see it in action.

Connection Wrapper

My connection wrapper may be a bit more complex than you might need. It is set up to work in an automated building/testing environment where NAnt is in control of which connection string to use.

using System;
using System.Xml;
using Company.Project.Core.Domain;
using Company.Project.Core.Properties;

namespace Company.Project.Core.DataAccess.Impl
{
    public class Connection
    {
        public ProjectDataContext GetContext()
        {
            string connString = "";
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load("ConnectionStringToUse.xml");

                XmlNodeList xnl = doc.GetElementsByTagName("environment");
                XmlElement xe = (XmlElement)xnl[0];

                switch (xe.InnerText.ToString().ToLower())
                {
                    case "local":
                        connString = Settings.Default.ProjectConnectionStringLocal;
                        break;

                    case "development":
                        connString = Settings.Default.ProjectConnectionStringDevelopment;
                        break;

                    case "production":
                        connString = Settings.Default.ProjectConnectionStringProduction;
                        break;

                    default:
                        throw new Exception("No connection string defined in app.config!");
                }
            }
            catch
            {
                connString = Settings.Default.ProjectConnectionStringLocal;
            }

            ProjectDataContext fdc = new ProjectDataContext(connString);
            return fdc;
        }
    }
}

This of course could be greatly simplified to just return the default DataContext!

Once we have this in place we can start creating a repository. A basic repository should provide ways to get an object by ID, save an object (inserting and updating), and delete an object. It might look something like this.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Company.Project.Core.Domain;
using Company.Project.Core.Properties;
using StructureMap;

namespace Company.Project.Core.DataAccess.Impl
{
    [Pluggable("Default")]
    public class RespondentRepository
    {
        private Connection conn;
        public RespondentRepository()
        {
            conn = new Connection();
        }

        public Respondent GetRespondentByID(Int32 RespondentID)
        {
            Respondent result;
            using (ProjectDataContext dc = conn.GetContext())
            {
                result = dc.Respondents.Where(r => r.RespondentID == RespondentID).First();
            }
            return result;
        }

        public void SaveRespondent(Respondent respondent)
        {
            using (ProjectDataContext dc = conn.GetContext())
            {
                if (respondent.RespondentID > 0)
                {
                    dc.Respondents.Attach(respondent, true);
                }
                else
                {
                    dc.Respondents.InsertOnSubmit(respondent);
                }
                dc.SubmitChanges();
            }
        }

        public void DeleteRespondent(Respondent respondent)
        {
            if (Settings.Default.PerformActualDeletes)
            {
                using (ProjectDataContext dc = conn.GetContext())
                {
                    dc.Respondents.DeleteOnSubmit(respondent);
                    dc.SubmitChanges();
                }
            }
            else
            {
                respondent.FlaggedForDelete = true;
                SaveRespondent(respondent);
            }
        }
    }
}

The only thing that is not standard C# code here is the reference to StructureMap and the attribute of [Pluggable("Default")]. For more on what StructureMap is look here:

http://structuremap.sourceforge.net/Default.htm

To get started with our repository you will first notice the constructor for this class is spinning up a new instance of our Connection object. This is important as each method will need to be able to speak with the database and they use the Connection object to do so.

From there we have a GetObjectByID method. This will perform the basic fetch functionality that all systems need.

public Respondent GetRespondentByID(Int32 RespondentID)
        {
            Respondent result;
            using (ProjectDataContext dc = conn.GetContext())
            {
                result = dc.Respondents.Where(r => r.RespondentID == RespondentID).First();
            }
            return result;
        }

One thing to notice here is that we are spinning up our DataContext inside of a using statement. This means that the DataContext will only exist in that using statement and will be disposed of when we are through with our work. We then call conn.GetContext() to get an instance of our DataContext. As this is a simple selection operation I have used a Lambda to grab the record with a corresponding ID and then called .First() to insure that we will only be returning one object. Since we are using a unique ID I should only be returning one object anyways...but better safe than sorry! Keep in mind that when working with LINQ, some methods are deferred and the scope of the DataContext is local to the using statement. This means that if you want to return a result set or an object you may need to create a variable that is a bit farther reaching. In our case we declared a Respondent object which is then passed out of the method.

We then get to our SaveRespondent method.

public void SaveRespondent(Respondent respondent)
{
    using (ProjectDataContext dc = conn.GetContext())
    {
        if (respondent.RespondentID > 0)
        {
            dc.Respondents.Attach(respondent, true);
        }
        else
        {
            dc.Respondents.InsertOnSubmit(respondent);
        }
        dc.SubmitChanges();
    }
}

This method is responsible for both inserting new objects and saving existing ones. The make up of how we retrieve an DataContext is the same as before. In this case though we want to test the passed in object to see if it has an ID already or not. If it doesn't have an ID then we will insert the item into the database. Otherwise we will save it to the database. We then SubmitChanges() to actually perform the persistence.

The only thing left is to provide a way for us to easily delete an object.

public void DeleteRespondent(Respondent respondent)
{
    if (Settings.Default.PerformActualDeletes)
    {
        using (ProjectDataContext dc = conn.GetContext())
        {
            dc.Respondents.DeleteOnSubmit(respondent);
            dc.SubmitChanges();
        }
    }
    else
    {
        respondent.FlaggedForDelete = true;
        SaveRespondent(respondent);
    }
}

Again, the make up of how we obtain a DataContext is the same. There is a bit more code here than is necessary. Technically all you need is what you see in the using statement. However, I have baked in some extra logic here that asks are we performing real time deletes or system/batch deletes later. The basic real time delete logic is this:

using (ProjectDataContext dc = conn.GetContext())
{
    dc.Respondents.DeleteOnSubmit(respondent);
    dc.SubmitChanges();
}

The Settings.Default.PerformActualDeletes is simply a flag to determine where we are going to do the real time deletes or not. If we are not doing real time deletes then we update the FlaggedForDelete property to true. Then a custom process would clean out the FlaggedForDelete objects later in the evening.

Once all of these methods are in place you can then start building services on top of the repository if you feel you need to. For the most part these simple repository methods should meet your needs. But in the case that you have a complex object, you may need a service to assemble it or disassemble it and persist it's children to the database via the repository.

Windows Live Writer - know of a better blog authoring tool?

Andrew Siemer - www.andrewsiemer.com — Tue, 05 Feb 2008 17:40:12 GMT

Up until today I have always made my posts via the web interface that is provided to me at the geekswithblogs.net site. One of my new years resolutions was that I would start to blog more with better and more article oriented content. I have come to an understanding with myself that if I want to do this I will need to find a way that is more efficient with regards to writing my blog posts. Something more WORD like would be great!

This has led me to this application - Windows Live Writer. It seems to be integrated with my blog provider (SubText). That is a bonus. Lets see how it handles publishing this simple post!

My favorite anonymous avatar! (spell check is working great)

My web site avatar. (adjusting the aspect ratio in this environment is easy enough!)

My very first avatar from when I first got started! I know I know...pretty funny looking. (working with tables is easy enough!)

Now lets post this sucker and see if it sticks?

I would love to hear your opinion regarding Live Writer vs. other blog authoring environments.

Andy

ASP.NET MVC - opinions?

Andrew Siemer - www.andrewsiemer.com — Tue, 05 Feb 2008 17:09:41 GMT

Hello all! I find myself looking at design patterns to see if there is anything new floating about. Of course the new MVC framework keeps popping up everywhere. While I have been aware that MS released the new MVC framework for ASP.NET a while ago, each time I have read about it I have found myself shying away from it in favor of MVP. I primarily didn't like the concept of ViewState being removed or the fact that we had to go back to the old ways of tossing variables into the sky via a post or get hoping for them to come back down to us via a request. Does anyone out there have much experience using this new framework? Do you prefer it over MVP? What has been your experience with it? Do you find that any newb off the street can easily work in this new MVC environment (not that a newb can easily get around in MVP!!!)?