Beyond This Point

GeeTasks Pro

2010-04-21T09:56:00.001-05:00

I’m a bit of a personal productivity junky and it seems I’m always trying out the latest time-management apps on computers and my iPhone. Well, I think I’ve finally settled on one I really like: GeeTasks Pro.

GeeTasks is basically a rich GUI for Google Tasks, a TO-DO list in the Google cloud that integrates with GMail. So the nice thing is you can manage your tasks on any computer with a web browser and then use GeeTasks when you’re on your iPhone (or iPod Touch). Google also has an iPhone web interface for Google Tasks, but GeeTasks is much more functional and, since it caches all your task data locally, it works when you’re not connected to the internet!

The really cool thing about GeeTasks is it’s so easy to use (in some ways, more so than the Google Tasks web app). The developer is also actively improving it and even added features based on my personal suggestions!

So if you’re looking for a nice anywhere TO-DO app solution, I highly suggest you check it out!

First Snow

2009-10-16T15:57:00.002-05:00

This picture was just too cute not to post. Here’s Brinna, my 1-year old daughter about a week ago when we had our first snow of the year. This is her first experience with snow, at least as a walking human being. I’m sure she doesn’t remember it from last winter. You just have to wonder what’s going through her mind right at this moment.

Probably something like: “Why the heck are we getting snow in early October?!?”

Using a Mobile Source Code Repository

2009-08-23T23:59:00.000-05:00

If you’re a consultant or just do a lot of coding on the side either for profit or to keep your skills sharp, it’s often nice to be able to store your code in a source code repository. The benefits of a personal repository are almost the same as what you get with a repository shared by a team of developers (history-tracking of your code, the ability to branch and merge, easy roll-back of uncommitted changes), the only different is that you’re the only user.

But setting up a reliable source code repository is not trivial, especially if you want to be able to access it while on the go. The easy route is to pay for a hosted solution, but that requires an internet connection (at least for doing source code operations) and they usually cost money if you want something decent.

I’ve come up with a couple simple approaches that allow you to have a personal repository that you control, that can be accessed from anywhere whether you have an internet connection or not, and that can get backed up in the event of data corruption.

Virtualization

Before I jump into the details, I’d like to say a couple things about virtualization since it is a big component of the solutions I came up with (especially the second). While you can easily code using tools installed directly on your host OS, I highly recommend isolating your software development environments on one or more virtual machines (VM’s). There are several reasons for this:

It allows you to develop on operating systems that are more comparable to what your application may be running on in production. Most workstation OS’s (like Windows Vista or Windows 7) do not come with all of the server-side components or are just not quite configured the same as the server OS your app may be running on in production (Windows 2000 Server, Windows Server 2003, Windows Server 2008, etc). Some server-side application services (like SharePoint) won’t even run on a non-server OS.
It allows you to have multiple different development environments. If you have one project or client that uses Visual Studio 2005 and another that uses 2008, it’s safer to run them on separate operating systems to prevent interference.
It allows you to easily play with new beta development tools without hosing up your working development environments. Nothing like installing the latest beta of VS2010 and finding out VS2008 no longer loads your paying customer’s solution.
If your host OS is not Windows (ex: Mac OSX) and you want to develop Windows applications, you don’t have much of a choice!

Which virtualization option you go with is pretty irrelevant. For the longest time, I was a big user of Microsoft’s Virtual PC. It was free and it worked great. Since then I’ve moved to VMWare’s Workstation and Player on Windows and Fusion on the Mac. VMWare seems to have a slightly more superior product at the moment, but Microsoft’s virtualization offering is not too far behind, especially when you consider the new functionality available in Windows 7.

Source Control System

There are a few good choices out there for source control. Personally, I like Subversion (SVN) the best. It’s free (open source) and a lot of very useful third-party tools are out there. TortoiseSVN is an excellent Windows GUI client and is free. AnkhSVN (now being developed by Collabnet, the company that hosts the SVN source control itself) provides source control integration into Visual Studio and is also free. Finally, there’s VisualSVN. They make a free server application called VisualSVN Server that allows you to get a Subversion repository up and running in minutes on a Windows server, complete with HTTPS access over Apache. VisualSVN also makes a Visual Studio source control add-in that’s comparable to AnkhSVN, although arguably more robust.

The two solutions I came up with (Method 1 and Method 2 below) both use VMWare Workstation for the virtualization platform and Subversion for source control. I’m sure one could adapt these steps fairly easily to work with other systems since the concepts behind them are what are important.

Method 1: Single VM with a Local Repository

When I first had the need to manage my own source control, I had a single VM I used to work on my code.

The source control solution in this case was quite simple since I could pretty much put everything on that VM.

Install a local repository

First I used TortoiseSVN to create a local file-based repository. You can use the command-line Subversion tool to do this as well, but TortoiseSVN makes it easy:

I usually put the repository itself in a standard location (like C:\SVN) so the repository URL in my Working Copy becomes something like file:///C:/SVN/my-repository:

Configure repository backup

You can do this a number of ways, but you want to make sure that whatever is backing up the repository is doing it automatically on a scheduled basis, so you don’t have to think about it. An online backup service (like Mozy.com) works well, but there’s a monthly service charge. I do all my backups on my wife’s computer, which is a MacBook. Therefore I can use TimeMachine, which is integrated into Mac OS, to backup everything important, including my source code repository.

However, my repository is still sitting in the file system of my VM which isn’t hosted on the MacBook – it’s on my laptop, which is running Windows. To sync the repository files to the MacBook so they can get backed up I use Windows Live Sync (used to be called FolderShare). It’s a free file syncing tool from Microsoft that can sync between multiple PC’s and Mac’s via your local network or over the internet and even through firewalls. All you need is a Windows Live ID to get started.

So as long as all my source code is developed on a single VM, I can keep the source control repository locally on that VM as a simple file-based SVN repository and use Live Sync and TimeMachine to keep my repository files backed up. Also, if I go mobile and/or the MacBook isn’t connected to the internet (so Live Sync can’t sync) I still have access to the repository so I can do all the source control operations I may need to keep developing code. Then the next time my VM is able to connect the Mac, it will sync the repository files so they can be included in the next backup.

Method 2: Multiple VM’s with a Shared Repository

The above solution works great until you decide to write your code on more than one VM. Perhaps you have a couple projects going that require different development stacks. Maybe one is an ASP.NET application running on IIS6 (Windows Server 2003) and another is on IIS7 (Windows Server 2008). In that case you really should develop your applications on separate VM’s, each running the correct version of Windows.

Of course, now the problem is accessing the file-based source control repository across multiple VM’s. One option is to move the SVN repository files to the host OS. Most virtualization solutions like Microsoft Virtual PC and VMWare Workstation have a file sharing feature where a VM can access files on the host OS. While this works, there’s a very noticeable performance hit. The other drawback to putting the SVN repository on the host OS itself is that it’s mixing a part of your development environment infrastructure into the host, which conflicts with why you moved everything to virtual machines in the first place.

A better approach is to move the repository to a dedicated VM that can act as a light-weight server and handle source control operation requests from all the client VM’s. Subversion can be run as a server in this way. It uses Apache to handle HTTP requests from clients and it seems perform nearly as well as with the local file-based repository.

Let’s take a look at how to set all this up.

Create a source control server VM

The first step is to create this server VM which will host our shared repository and handle client SVN requests from the other VM’s. This VM won’t require a lot of RAM since it’s primarily just going to serve up request for source control operations. I created mine using Windows Server 2008, which has a minimum memory requirement of 512MB, so that’s what I went with.

Before we move on to installing additional software on the source server VM, we need to take care of some necessary networking infrastructure.

Create a private virtual network to connect all the VM’s

One of the other advantages of most virtualization systems out there is the ability to create virtual networks. If you have multiple VM’s that need to communicate with one another and especially if that communication needs to be private (or doesn’t need to occur over a public network), you can create a virtual network.

In my situation, I ended up using one of the available custom networks installed by VMWare Workstation (vmnet2 in my case). You don’t want to use the Host-Only, Bridge, or NAT networks as we need something that’s private that we can dedicate to these VM’s. In my case, to turn this on, I just added a network adapter to all the VM’s, including the server VM, and connected it to the vmnet2 virtual network:

This new network adapter showed up in the OS (Windows) of all the VM’s. To make them easier to manager, I renamed them from “Local Area Connection” and “Local Area Connection 2” to “Public LAN” and “Private LAN” in each VM:

Set up DNS and DHCP services on the server VM

Simply connecting the VM’s together with our new private network connection doesn’t make it so they can communicate (at least not very well) over the private network. It’s the equivalent to connecting a bunch of computers to a Ethernet hub or switch with network cables. Each host will default to a 169.254.x.x address and name resolution won’t work at all if each OS has their default firewalls turned on.

Ideally, we need some way of handing out IP’s and ideally having DNS name resolution to those IP’s (the most important one being the server). To do that we first need to pick an IP subnet and a static IP for the server VM. In my case I went with 192.168.76.x for the subnet and 192.168.76.1 for the static IP. I then set the IP address of the “Private LAN” network adapter on the server VM to that static IP, which is done in Windows itself:

Next we need to turn on DNS services on the server VM so it can resolve DNS names local to our virtual network. After installing the service, I created a forward lookup zone for a private DNS domain called “ts-local”. You can use whatever private DNS domain name you want as long as it isn’t something that might conflict with domain names on the internet or any other network you may connected to.

Then I added an A-host for the server VM itself whose hostname is “MCP”:

Next we need to enabled the DHCP server service on the server VM so we can hand out the IP’s in our subnet. Once you install the service, configure it to hand out IP’s to our subnet as well as specify the DNS server IP (same as the server VM) and the domain name (in my case “ts-local”):

Finally, we should be able to release and renew the IP address on each of the client VM’s and get an IP in our subnet. We should also be able to resolve the IP address of the server VM from the client VM’s using PING:

Install VisualSVN Server on the server VM

Now for the real reason we created this server VM in the first place. Setting up a Subversion server that uses Apache (the web server that SVN uses) by hand is no easy task (trust me, I’ve done it). VisualSVN Server makes this a snap. It will install Apache, configure HTTPS, and create a location for the repositories. By default, VisualSVN Server creates the repositories directory at C:\Repositories. I prefer C:\SVN.

After the install is complete, all you have to do is create a username for your client VM’s to use to access the repositories.

Move the repository

If you started with Method 1 like I did, you need to move the file-based repository from the single VM to our shiny new Subversion server VM. VisualSVN Server makes this easy with it’s import option:

Simply browse to where the repository files are and perform the import. You may want to copy them over to a temporary directory on the server VM first to make them easily accessible from the server’s file system.

Once the repository has been imported, you’ll want to set assign the user account you created earlier to have read/write access to the repository:

Your server is now ready to service source control requests!

Point the Working Copies to the new repository

If you already have Working Copies (the term Subversion uses for directories that are under source control) on your original development VM, you can point them at the new URL using TortoiseSVN’s Relocate function. For example, if you had a working copy connected to file:///C:/SVN/my-repository, you can now point it to http://mcp.ts-local/SVN/my-repository:

Configure repository backup

The final step to getting the multiple-VM source code repository operational is to configure the backup. The approach is the same as with the single-VM approach – you just have to back up the repository files on the server VM instead. In my case, that directory is C:\SVN. I point Live Sync there which syncs the files to my MacBook which in turn backs everything up via TimeMachine. Very nice!

The multi-VM solution also has the same disconnected benefits that the single-VM solution does. You can perform all your source code operations anytime you want, even if your host machine is disconnected from the network. The next time you are connected, Live Sync will sync any repository file changes to the MacBook so they can be backed up.

Turn off Push with a Jailbroken iPhone 2G on T-Mobile with no Data Plan

2009-07-25T08:56:00.006-05:00

So this tip probably applies to about 3 people out there besides me, but the road to a solution was about three days of pain, so I feel compelled to post something.

I've been a happy iPhone user since the beginning of 2009 when my manager at work sold me his 2G. A buddy of mine showed me the ropes of jailbreaking and unlocking the iPhone and before I knew it I was running iPhone OS 2.2.1 via QuickPwn on the T-Mobile network. Better yet, I didn't have to have a data plan (yes, I'm cheap), like you do with AT&T. I just hopped on an available WiFi network whenever I needed to use data - life was good.

Until I decided it would be a fun idea to upgrade my iPhone to the new 3.0 OS.

The actual install itself (I used redsn0w) was quite painless and relatively easy. After I got all my apps re-installed and my settings back to what I had before, I had a sweet phone that couldn't receive incoming calls or text messages. After several re-installs of the OS, attempting to use trial and error to narrow down the source of the problem, I finally stumbled upon the answer. And, yes, I tried googling the heck out of the internet and could not find another poor soul out there who was in my same predicament (hence the first sentence of this post).

The source of the problem was that I had Push turned on (which is the default when you install OS 3.0). Push is a technology that allows applications like email and calendar to receive updates from the server without having to continuously poll the sever. Polling like this is also called Pull, the opposite of Push. Push requires a data plan to work. I don't have a data plan with T-Mobile. I guess Push doesn't behave well without one. Kinda makes sense since I'm sure the iPhone developers didn't really think about this scenario since I think you're required to have a data plan with your iPhone if you're with AT&T.

Anyway, to turn Push off, here's where you go in the iPhone settings:

Settings > Mail, Contacts, Calendars > Fetch New Data > Push > Off

After I did that, everything works! And I have to say the 3.0 version of the iPhone OS is a nice upgrade, even on a 2G.

Using the Repository Pattern with CSLA.NET, Part 2

2009-02-18T00:17:00.001-06:00

In my last post, we built an abstraction for a data access layer used by CSLA.NET business objects based on the Repository Pattern. We started by creating two base interfaces, IRepository<TContext> and IContext and then used them to define a set interfaces that abstracted the data access for a simple order entry system. Those interfaces were:

IOrderRepository - represented the repository for orders and line items; a factory object that can create the other repository objects
IOrderContext - the context that the IOrderRepository creates that performs the actual data access
IOrderInfoDto - a DTO for order summary entities
IOrderDto - a DTO for orders
ILineItemDto - a DTO for order line items

We then demonstrated how objects based on those interfaces would be called from the data access areas within actual CSLA.NET business objects (in the DataPortal_* methods). We also showed how the repository object was injected in via dependency injection. In our case, we used the Unity IOC Container but any IOC Container or dependency injection framework would do.

In this post we're going to build a concrete implementation of our abstract data access layer. In other words, we'll build classes that implement the above interfaces. In this case, we'll use LINQ to SQL as our actual data access technology. However, given the high level of abstraction of our repository pattern implementation, we could conceivable build concrete implementations in many other technologies such as LINQ to Entities, <insert your favorite ORM here>, or even plain old ADO.NET.

LINQ to SQL Classes

Before we jump into the implementation of our interfaces, we need to first build our LINQ to SQL classes. These classes will play an integral role in our concrete implementation.

LINQ to SQL requires that a physical database exist, so assume that we've started with a simple SQL Server database that contains an Orders table and a LineItem table with a one-to-many relationship between them. We can then add an Orders.dbml file (LINQ to SQL Classes item) to a Visual Studio 2008 project and drag both tables onto the design surface:

Visual Studio (actually LINQ to SQL) does a lot of work behind the scenes when we do this. It code generates a LINQ to SQL DataContext class called OrdersDataContext and two entity classes called Order and LineItem that map to the database tables.

You may also notice is the screen shot above that we've added a set of stored procedures to our database that perform all the inserts, updates, and deletes, and they show up as methods on the OrdersDataContext class. While LINQ to SQL entity classes have the ability to perform these operations on their own, they have a limitation that forces us to use a alternative mechanism, like stored procedures, instead. We'll investigate this issue further a little later on in the post.

At this point, the OrdersDataContext, Order, and LineItem classes could be used by a set of CSLA.NET business objects to perform all the required data access. However, the business objects would be be tightly coupled to the LINQ to SQL code and therefore there would be no easy way to abstract the LINQ to SQL code so it could be mocked for unit testing purposes. Let's see how we can migrate this code into a concrete implementation of our repository pattern abstraction.

Concrete DTO's

Before we jump into the concrete repository and context objects, let's take a quick look at how we implement the DTO's. LINQ to SQL makes this relatively easy since the entity classes code generated by LINQ to SQL are the DTO's. All we need to do is make them implement our DTO interfaces. Since the LINQ to SQL code generation is done using partial classes, this is quite easy.

First the, concrete IOrderDto class:

partial class Order
    : IOrderDto
{

    byte[] IOrderDto.Timestamp
    {
        get
        {
            return this.Timestamp.ToArray();
        }
        set
        {
            this.Timestamp = new Binary(value);
        }
    }

    IEnumerable<ILineItemDto> IOrderDto.LineItems
    {
        get
        {
            return this.LineItems.Cast<ILineItemDto>();
        }
    }

}

At a minimum, we need to define the partial class Order (which binds to the code-generated Order class at compile time) that implements the IOrderDto interface. But we also need to add a couple explicit IOrderDto property implementations.

The first is due to the fact that the Order class that was code-generated by LINQ to SQL has a Timestamp property that is of the LINQ to SQL-specific type Binary. However, the IOrderDto interface defines the Timestamp property as a byte array, which is not specific to a data access technology. Therefore we need to add the IOrderDto.Timestamp property explicitly and marshal the Binary and byte array values back and forth.

The second explicit property implementation is IOrderDto.LineItems. The Order class code-generated by LINQ to SQL also defines a LineItems property, but it's of type EntitySet<LineItem>. Therefore, we need to convert between the two and a handy way to do it is to use the Cast extension method.

The concrete ILineItemDto class is very similar, but we only have to add an explicit implementation of its the ILineItemDto.Property:

partial class LineItem
    : ILineItemDto
{

    byte[] ILineItemDto.Timestamp
    {
        get
        {
            return this.Timestamp.ToArray();
        }
        set
        {
            this.Timestamp = new Binary(value);
        }
    }

}

Now, with the concrete DTO's defined, let's move onto the concrete repository and context classes.

Concrete Order Repository

You may recall the role of the repository object is to be a factory for all of the other objects needed by the data access layer. It's main job is to create the associated context. Therefore our order repository will need to create an order context. It will also need to be able to create any DTO's required by data access methods that require DTO's as inputs.

Given that, here's our concrete OrderRepository class:

public sealed class OrderRepository
    : IOrderRepository
{

    IOrderContext IRepository<IOrderContext>.CreateContext(bool isTransactional)
    {
        return new OrderContext(isTransactional);
    }

    IOrderDto IOrderRepository.CreateOrderDto()
    {
        return new Order();
    }

    ILineItemDto IOrderRepository.CreateLineItemDto()
    {
        return new LineItem();
    }

}

A fairly simple implementation of a factory. The CreateContext method creates a new instance of our concrete OrderContext (which we'll see its implementation just ahead), passing a value to its constructor, telling it whether or not it needs to be transactional. Then we have two methods for creating DTO's: CreateOrderDto and CreateLineItemDto. Notice that what we're actually returning are instances of the two entity classes code generated by LINQ to SQL since they implement the required DTO interfaces.

Concrete Order Context

While the repository object is the factory that creates all the data access objects, the context object plays the star role in actually performing the data access operations. Therefore, the OrderContext class is going to have the most meat of any of our concrete repository pattern classes. Let's examine the OrderContext class in chunks since there's a lot going on.

Basic Implementation of OrderContext

First, let's take a look at the class definition itself and its constructor that we know takes a isTransactional boolean parameter:

public sealed class OrderContext
    : IOrderContext
{

    private OrdersDataContext _db;
    private TransactionScope _ts;

    public OrderContext(bool isTransactional)
    {
        _db = new OrdersDataContext();
        if (isTransactional)
            _ts = new TransactionScope();
    }

}

As you can see, our OrderContext object wraps an instance of an OrdersDataContext object (via the _db field) which is a LINQ to SQL DataContext. Therefore, our OrderContext object is essentially an abstraction of a LINQ to SQL data context. When it implements the remaining IOrderContext interface members, it does this by making calls against that LINQ to SQL DataContext instance.

The OrderContext also wraps a TransactionScope object, which it only creates if the calling OrderRepository object specified that the context is transactional. That transaction is committed in the CompleteTransaction method, which is required by the IContext base interface:

    void IContext.CompleteTransaction()
    {
        if (_ts != null)
            _ts.Complete();
    }

The last place we interact with this transaction is at the end of the order context object's lifecycle during the IDispose.Dispose implementation:

    void IDisposable.Dispose()
    {
        if (_ts != null)
            _ts.Dispose();
        _db.Dispose();
    }

We also dispose the OrdersDataContext which closes up the database connection.

So far with the OrderContext class we've implemented the creation and clean-up of the object. Now we need to implement the methods defined by the IOrderContext interface that actually do the data access.

IOrderContext.FetchInfoList Implementation

First, let's take a look at the implementation of the IOrderContext interface's FetchInfoList method:

    IEnumerable<IOrderInfoDto> IOrderContext.FetchInfoList()
    {
        var query =
            from o in _db.Orders
            orderby o.Date
            select new OrderInfoData
            {
                Id = o.Id,
                Customer = o.Customer,
                Date = o.Date
            };
        return query.Cast<IOrderInfoDto>();
    }

    private class OrderInfoData
        : IOrderInfoDto
    {
        public int Id { get; set; }
        public string Customer { get; set; }
        public DateTime Date { get; set; }
    }

The purpose of this method is to return a list of all the orders in the database. They come back as the light-weight IOrderInfoDto objects. Our implementation of this method performs a standard LINQ to SQL query against the Order entity objects in the OrdersDataContext. However, we don't want to return all the data of each order. The IOrderInfoDto object is only a subset of that data. An easy solution is to perform a LINQ projection of Order objects to IOrderInfoDto objects. This will generate only the T-SQL necessary to populate the data required by the IOrderInfoDto objects. And of course we need a concrete IOrderInfoDto class to create and return; an easy approach is just to declare a private OrderInfoData class shown above just below the FetchInfoList method.

IOrderContext.FetchSingleWithLineItems Implementation

The next data access method required by the IOrderContext interface is FetchSingleWithLineItems:

    IOrderDto IOrderContext.FetchSingleWithLineItems(int id)
    {
        var options = new DataLoadOptions();
        options.LoadWith<Order>(o => o.LineItems);
        _db.LoadOptions = options;
        var query =
            from o in _db.Orders
            where o.Id == id
            select o;
        return query.Single();
    }

This method is similar to the previous in that it is another LINQ to SQL query. However, it returns a single DTO (instead of a collection) and that DTO is an instance of the full Order entity class, which happens to implement the IOrderDto interface.

But we don't want to return just the data of the order itself. We also want to return all of it's child line item data as well (which will be accessible via the LineItems property), and preferably all with one call to the database. We can do this with a little LINQ to SQL magic by configuring the LoadOptions property of the OrdersDataContext, telling it that when it loads the data of an Order object, go ahead and load its child LineItem objects contained within the LineItems property.

The FetchInfoList and FetchSingleWithLineItems methods pretty much take care of all the data access querying. Now we need to implement the insert, update, and delete operations.

Insert, Update, and Delete Method Implementations

While the query method implementations simply took advantage of the built-in LINQ capabilities of the entity classes, we can't quite do the same with the insert, update, and delete methods. Normally, with LINQ to SQL you can make whatever state changes you want to those objects and when you're ready to persist those changes back to the database, you just call the SubmitChanges method on the DataContext object, which keeps track of which entity objects have changed.

While this approach could work in our situation, it requires us to maintain references to all of these objects between data access operations performed by our CSLA.NET business objects and this is a problem. All CSLA.NET business objects need to be serializable so they can function properly in the CSLA.NET DataPortal. This means that any objects contained within a CSLA.NET business object must also be serializable. Unfortunately, LINQ to SQL objects are not.

There are some potential workarounds like one where you create a new LINQ to SQL entity object, load it with data, and then attach it to a DataContext as if it were previously fetched by the DataContext, but this is not using LINQ to SQL as it was intended and in many cases produces unexpected behavior. The only reliable solution is to use a different mechanism than the LINQ to SQL entity objects and the DataContext to persist changes back to the database. One of the easiest is the use of stored procedures. This, in fact, is the same approach that Rocky uses with his LINQ to SQL data access code in his sample ProjectTracker application. In the Orders.dbml file in our project, we simply drag those stored procedures over from the database and LINQ to SQL adds them as methods to the OrdersDataContext.

The last thing we should mention about the insert, update, and delete methods is that, unlike the query methods which returned DTO's (or collections of them), these methods take DTO's as parameters (except for delete which typically only takes an ID). Therefore, the caller (in this case the CSLA.NET business object) needs to be able to create an empty DTO and populate it. Which is why the OrderRepository class has the DTO creation methods.

So, without further delay, here are the insert, update, and delete method implementations for the order entities:

    void IOrderContext.InsertOrder(IOrderDto newOrder)
    {
        int? id = null;
        Binary timestamp = null;
        _db.insert_order(
            ref id,
            newOrder.Customer,
            newOrder.Date,
            newOrder.ShippingCost, 
            ref timestamp);
        newOrder.Id = id.Value;
        newOrder.Timestamp = timestamp.ToArray();
    }

    void IOrderContext.UpdateOrder(IOrderDto existingOrder)
    {
        Binary newTimestamp = null;
        _db.update_order(
            existingOrder.Id,
            existingOrder.Customer,
            existingOrder.Date,
            existingOrder.ShippingCost,
            existingOrder.Timestamp, 
            ref newTimestamp);
        existingOrder.Timestamp = newTimestamp.ToArray();
    }

    void IOrderContext.DeleteOrder(int id)
    {
        _db.delete_order(id);
    }

We also have insert, update, and deletes for the line item entities as well, but they are very similar, so I'll save them for the sample code download at the end.

Sample Application

To make all of this really gel, I wanted to include a fairly extensive sample application that demonstrates everything we've been talking about in the last three posts: dependency injection and the Repository pattern with CSLA.NET. However, this sample goes a bit further than what we've talked about so far so I wanted to briefly discuss it but save the details for an upcoming post.

A lot of what we've been building here are mechanisms to abstract each layer of our application so they are more loosely-coupled and more testable. This is why dependency injection is so useful and why patterns like Repository really help. But the Repository pattern is really just a means to abstract the data access layer. What if you wanted to abstract the business layer? What if you wanted to write unit tests that tested the functionality in your UI layer in isolation so that you wouldn't have to build concrete business objects in your tests? That's the one big additional thing that the sample application sets out to do. In short, it does this by defining abstractions (in the form of interfaces) for each business class and pulls out the static factor methods into separate factory interfaces and classes.

So here's a quick rundown of the projects that are included in the sample application solution, which is called CslaRepositoryTest:

DataAccess - contains the abstract data access layer interfaces
DataAccess.SqlServerRepository - a concrete implementation of the types in DataAccess
BusinessLayer - CSLA.NET business layer objects
BusinessLayer.Test - unit tests that test the business layer, mocking out the data access layer
Gui - a Windows Forms GUI that uses the business objects in BusinessLayer. The GUI uses a Model/View/Presenter-style architecture so it can be more easily tested.
Gui.Test - unit tests that test the GUI layer, mocking out the business objects
Core - contains common types not necessarily specific to a particular layer

Some other notes:

The BusinessLayer is compiled against CSLA.NET 3.5.
The sample application uses v1.2 of the Unity Application Block as an IOC Container. The Gui project configures uses a file called Unity.config to configure Unity.
The DataAccess.SqlServerRepository project uses SQL Server Express to attach to a file instance of the database, just like the CSLA.NET ProjectTracker sample application does. The database file is Orders.mdf and is located in the same directory as the solution.
Both test projects use NUnit as their unit testing framework. You should be able to run all of the unit tests in the NUnit-GUI application.
Both test projects use Rhino Mocks v3.5 for mocking objects.
The binaries for all of the 3rd party dependencies mentioned above are included in a lib folder in the download. The only thing you need to have installed is Visual Studio 2008 and SQL Server 2005 Express (which usual comes with Visual Studio 2008).

Finally, here's the sample application.

Conclusion

In this post we walked through a concrete implementation of our abstract data access layer that uses the Repository pattern. Our implementation used LINQ to SQL, but we could have easily created one that used any other data access technology. In an upcoming post, we'll dig a little further into how to abstract the business layer itself.

Using the Repository Pattern with CSLA.NET, Part 1

2009-01-28T23:59:00.001-06:00

In a previous post I showed a way to use dependency injection with CSLA.NET. In this post, I'll show a practical example of how to use that technique to abstract the data access layer used by your business objects using the Repository pattern. This post is part 1. At the end of part 2, I'll include a link to a fully-functional demo application that even includes a fully functional business layer, data access layer, UI layer, and unit tests.

Background

The default approach for data access in CSLA.NET is to write your data access code right in the business class in the DataPortal_* or Child_* methods. These methods have direct access to the internal state of the business object so they can easily persist that state to your data store without breaking encapsulation. While this approach obviously works, there are several reasons why one might want to move this code out of the business object and into its own layer. Here are few good ones:

Testability: If you want to be able to write tests for your business objects that test isolated units of code (i.e. unit tests), your business object shouldn't be talking to a real database at test-time. Therefore some kind of abstraction needs to be implemented that allows the real database to be called at run-time and a mocked database to be called at test-time.
Maintainability: It's never good when you cram too much code into one class. Arguably, data access logic is very different than business logic, and therefore has a different set of concerns and pressures for change. Moving it out to its own layer allows both the business logic and the data access logic to change independently with minimal impact on each other. For example, an abstracted data access layer, if designed at a high enough level, might allow you to change the underlying database platform (ex: from SQL Server to Oracle) or technology (ADO.NET to LINQ to SQL) without having to alter and recompile your business layer. Abstracting data access into its own layer also jives with SRP (Single Responsibility Principal) which states that every object should only have one reason to change. While CSLA.NET business objects may never only have just one reason to change, it's always good when you can reduce the number of reasons.
Security: Some application architectures require that the data access code itself cannot exist on any public-facing machine (the client workstation in the case of a Rich UI application like WinForms, WPF, or Silverlight or the web server in the case of a web app). The idea being if a hacker is able to compromise a public-facing machine, and that machine has the data access code on it, they then potentially have the information to access the database itself (i.e. via the connection string). Moving the data access code to a separate layer means you have the flexibility to only deploy the data access layer to an application server, which stands in between the public-facing machine(s) and the database, behind its own firewall.

Problem

Unfortunately, abstracting the data access layer is no easy task. There are a lot of choices and options, so you have to be careful that you don't end up limiting yourself. Here are a few things we need to consider:

We want a data access layer that is called and consumed by the business layer and not one that populates the business objects for us. If your data access layer populates your business objects it either has to set public properties on your business objects (which fires validation rules unnecessarily) or it has to have access to the internal state of your business objects, which violates encapsulation.
We need to determine what level we want to do our abstraction. We could create a low-level abstraction that represents a specific data access technology. For example, you could abstract ADO.NET by only working with the various ADO.NET interfaces (IDbConnection, IDbCommand, IDataReader, etc.). But this approach prevents you from easily switching data access technologies, since, by doing so, you would have to alter your business layer code. Another approach to consider is making your data access layer abstraction generalized enough so it doesn't pin you to a specific technology.

Solution

The solution I chose to pursue was to follow the relatively well-known data access pattern called the Repository Pattern. Repository is a high-level abstraction of your data access layer that allows the caller to perform any necessary data access (queries, CRUD, etc) and get back a structured set of objects that represent the data. I like to call these objects DTO's (data transfer objects) since they are nothing more than strongly-typed data structures (just data, no logic). And since the Repository is a high-level abstraction, you gain the flexibility of being able to change the underlying data access technology in the future as well as do other fun tricks like data caching.

Given that description of Repository, there still are a lot of ways to implement it. Just do a Google search on "Repository Pattern" and you'll see what I mean. I've come up with what I think is a relatively simple approach that seems to work well with CSLA.NET. Let's take a closer look.

Repository and Context

There are two key components to my Repository design: the repository and the context.

The repository represents the gateway to the data access layer. The repository will create all the necessary data access objects we need to perform our data access. Essentially it is a factory object and it can be injected into our business object via dependency injection.

When you want to actually perform data access operations, you usually want this to be done in a context of some sort that you can dispose of when you're done. Maybe you need to execute one or more calls atomically within a transaction or maybe you just need to do some querying and you want to ensure that the connection is closed when you're done, even if the query fails. This is what a context is for.

The repository's primary job is to create a context when the business object needs to perform data access. It can also create other data access objects, like DTO's, that may be needed to assist in performing data access.

So, let's take a look at what the repository and context might look like in code:

public interface IRepository<TContext>
    where TContext : IContext
{
    TContext CreateContext(bool isTransactional);
}


public interface IContext
    : IDisposable
{
    void CompleteTransaction();
}

Pretty simple. An IRepository object can create a specific type of IContext object, and when it does, you have to specify whether or not the IContext is transactional. If an IContext is transactional, it has a method called CompleteTransaction that is called by the business object to indicate that the transaction has succeeded and should be committed. And regardless if the IContext object is transactional or not, it is disposable which makes it easy for the calling business object to close things like database connections.

And by the way, I personally prefer to use interfaces for my abstractions (vs abstract classes) because they're much easier to mock in a testing scenario.

Notice that neither of these interfaces has any methods that perform specific database operation (ex: CRUD). I prefer to move those down into more specialized interfaces that abstract a specific set of entities in your data access layer. For example, here's a repository and a context for a simple order-entry system that contains order and line item entities:

public interface IOrderRepository
    : IRepository<IOrderContext>
{
    IOrderDto CreateOrderDto();
    ILineItemDto CreateLineItemDto();
}

public interface IOrderContext
    : IContext
{
    IEnumerable<IOrderInfoDto> FetchInfoList();
    IOrderDto FetchSingleWithLineItems(int id);
    void InsertOrder(IOrderDto newOrder);
    void UpdateOrder(IOrderDto existingOrder);
    void DeleteOrder(int id);
    void InsertLineItem(ILineItemDto newLineItem);
    void UpdateLineItem(ILineItemDto existingLineItem);
    void DeleteLineItem(int id, int orderId);
}

Most of the action is down in the IOrderContext object; it contains all of the data access methods that involve interacting with the database. There are two methods for querying and retrieving order data. The remaining methods perform the inserts, updates, and deletes.

Notice that my query methods are explicit: "fetch info list" and "fetch single order with line items". I've seen some Repository Pattern implementations out there that provide more generic query methods that allow you to harness the power of LINQ by returning an IQueryable<T> object. While there's nothing wrong with this approach, it does lock you into using data access technologies in your concrete implementation that only support LINQ. Some do, some don't (like ADO.NET). To be flexible, I chose to not lock myself into LINQ, so my query methods return simple IEnumerable<T> results. And even if you are confident that any data access technology you will use is LINQ-friendly, not all LINQ implementations are the same. For example: LINQ syntax for LINQ to SQL is a little different than LINQ syntax for LINQ to Entities.

The DTO's

Notice that all data is transferred to and from these data access methods via DTO's. The only issue is that these DTO's are interfaces so if the business object has to pass them to the context (say to the InsertOrder method), it needs a way to create one first. That's where the DTO factory methods on the IOrderRepository object come into play. This further cements the concept that the repository is really an object factory.

Before we move on, let's take a look at the definition of the DTO interfaces in my example.

First, the IOrderInfoDto which is returned by the FetchInfoList method:

public interface IOrderInfoDto
{
    int Id { get; set; }
    string Customer { get; set; }
    DateTime Date { get; set; }
}

This is giving us only a portion of the fields that may be defined by the order entity in the database. The purpose of this DTO (and the ReadOnlyBase<T> business object it populates, is to provide a simplified view of order data, perhaps to populate a list in the GUI.

When we need a single entire order, the FetchSingleWithLineItems method returns the IOrderDto object:

public interface IOrderDto
{
    int Id { get; set;  }
    string Customer { get; set; }
    DateTime Date { get; set; }
    decimal ShippingCost { get; set; }
    byte[] Timestamp { get; set; }
    IEnumerable<ILineItemDto> LineItems { get; }
}

It contains pretty much the same data as IOrderInfoDto plus the remaining order entity data and also a collection of child line items. Those line item objects are of type ILineItemDto:

public interface ILineItemDto
{
    int Id { get; set; }
    int OrderId { get; set; }
    string ProductName { get; set; }
    decimal Price { get; set; }
    int Quantity { get; set; }
    byte[] Timestamp { get; set; }
}

By the way, both the IOrderDto and ILineItemDto interfaces contain a Timestamp property which is used to manage data concurrency. This timestamp has to be persisted into the business object itself. I'll show how this is done in the sample code, but Rocky also does it in his ProjectTracker sample application.

Calling the Repository from the Business Object

I think to really see how this implementation of the Repository Pattern works, we should take a look at how a business object would call these data access objects. Let's examine the simplest case of a root-level collection of read-only order business objects (we'll name it OrderInfoCollection) performing its data access while fetching the collection.

private void DataPortal_Fetch()
{
    RaiseListChangedEvents = false;
    using (var context = EnsureDependency(_repository).CreateContext(false))
    {
        IsReadOnly = false;
        foreach (var dto in context.FetchInfoList())
        {
            var child = DataPortal.FetchChild<OrderInfo>(dto);
            this.Add(child);
        }
        IsReadOnly = true;
    }
    RaiseListChangedEvents = true;
}

The code follows the standard pattern for the implementation of the DataPortal_Fetch method of a business object that inherits from ReadOnlyListBase<T,C> where we turn off list-changed events and make the collection temporarily writable while we load it. But instead of opening up an ADO.NET database connection or creating a LINQ to SQL data context, we talk to an abstract repository instance instead and call CreateContext which returns us a IOrderContext instance. All context objects implement IDisposable so we wrap it in a using statement which guarantees things like database connections and transactions will be closed up at the end.

Within our using block is where we make all the data access method calls against the context. In this case, we're calling FetchInfoList, enumerating the IOrderInfoDto objects returned, and using each to create an associated child OrderInfo business object for the collection.

Dependency Injection

You may be asking: where does the instance of the _repository field get created and what's this EnsureDependency method? This goes back to how I implement dependency injection with CSLA.NET which I detail in the previous post. Here's the definition of that field and the method that Unity (my dependency-injection/IOC Container framework of choice) uses to inject it:

[NonSerialized]
[NotUndoable]
private IOrderRepository _repository;

[InjectionMethod]
public void Inject(IOrderRepository repository)
{
    if (repository == null)
        throw new ArgumentNullException("repository");
    _repository = repository;
}

This is the magic that allows us to easily mock out the data access layer at test-time and use a real concrete implementation at run-time. Showing how you would mock these objects is a bit more than we have time for now. However, I will provide unit tests that show it in the downloadable sample code at the end of part 2.

Transactional Data Access Code

So we showed the simple example of how a read-only collection would call the data access layer to query the database and populate itself. Let's also show an example of some data access code in a business object that's transactional.

Let's jump over to a full BusinessBase<T> business object for an order (we'll call it Order) and take a look at what the DataPortal_Insert method implementation might look like for inserting an order:

protected override void DataPortal_Insert()
{
    using (var context = EnsureDependency(_repository).CreateContext(true))
    {
        var dto = EnsureDependency(_repository).CreateOrderDto();
        dto.Customer = ReadProperty<string>(CustomerProperty);
        dto.Date = ReadProperty<DateTime>(DateProperty);
        dto.ShippingCost = ReadProperty<decimal>(ShippingCostProperty);
        context.InsertOrder(dto);
        LoadProperty<int>(IdProperty, dto.Id);
        _timestamp = dto.Timestamp;
        DataPortal.UpdateChild(ReadProperty<LineItemCollection>(LineItemsProperty), this, context);
        context.CompleteTransaction();
    }            
}

A little more complicated, but the pattern is very similar. We create a context (this time specifying that it's transactional) and we perform our data access operations against it. In this case we to first create an empty IOrderDto so we can populate it with the business object state and pass it into the InsertOrder data access method. When that's done we load the ID and timestamp of the newly inserted order entity back into the business object. Finally, we cascade the update call down to any child line item business objects.

Conclusion

So this is all great and fun and with just the code we've written so far we could get our business layer up and running with passing unit tests. But with all of that we still haven't actually hit a real database! We need to code up a concrete implementation of our repository interfaces to get there. I'm going to save that for the next post and with that post will come the promised full set of sample code.

Using Dependency Injection with CSLA.NET

2008-12-22T10:32:00.001-06:00

In this post, I'm going to talk about one way to implement Dependency Injection with CSLA.NET.

NOTE: My discussions and code samples are using CSLA.NET 3.5.

Background

CSLA.NET. I'm a big fan. I have been even back before it went .NET in the VB5 and VB6 days.

I don't know actual statistics, but I would wager that CSLA.NET is probably the most popular framework for creating object-oriented business objects in .NET. If you're building even a moderately complex line-of-business application where you want your business logic to live in one place (instead of spread all over the place, the worst being in your UI), you want a middle tier that takes advantage of object-oriented design (not just a set of classes that mimic the structure of the database), and optionally have everything just work in a distributed environment, then you should definitely take a close look at CSLA.NET.

I'm also a big fan of automated tests around my business layer. And when I say tests, I'm referring to unit tests, where I want to validate just the behavior of my business object and nothing else. In other words, I'm not interested in testing the other layers that my business object may interact with (like the database or a logging component). Those would be integration or regression tests. Those are good too, by the way, but unit tests should come first.

Since business objects almost always have to communicate with other layers, your unit tests need the ability to fake those layers out in order to test your business logic in isolation. There are variety of ways to do this, but a popular one is to abstract calls to these layers using Dependency Injection and then use a mocking framework to inject a fake version of that layer. To really do Dependency Injection, you need to use a framework of some kind (typically called an IOC Container) to handle your dependency instances and automatically perform injections on your objects.

Problem

So, like I said, I really love the CSLA.NET framework. But with all of its awesome excellence, I've always been challenged writing true unit tests against business objects that use it. This is because CSLA.NET makes it difficult to implement Dependency Injection. Why? In short: CSLA.NET creates your business object instances for you. This happens in the servers-side portion of the DataPortal. Dependency Injection works best if it can have some kind of access to the object creation process so an object's dependencies can be injected. Unfortunately, the DataPortal does not provide any sort of hook where you can create your object. The DataPortal does this all behind the scenes as a black box and then gives you your object instance after creation, letting you then execute your data-access code in the DataPortal_* methods.

To be fair, the latest version of CSLA.NET, 3.6 which just released, does give you access into the creation of your business objects via the new object factory feature. However, there are two challenges with going down this road:

You end up having to write a lot more than just object creation into your object factory classes since the object factory is also responsible for performing all data access including the state population of your business objects.
You have to write a factory class for every business object that requires dependency injection. Couple this with the first point, and that adds up to a lot more coding just so you can have control over the creation of your business objects.

There is also another challenge, and that is that the creation of objects on the server-side of the DataPortal isn't the only place business objects in CSLA.NET are being created! One of the great features of CSLA.NET is this idea of mobile objects: your business objects have the ability to be transported from one physical tier to another. However, every time an object goes mobile it needs to be serialized. When it gets to the destination tier, it needs to be deserialized and deserialization involves recreating the object instance except this time its done within the bowels of the .NET Framework. Yuck! Even more difficult to hook into. And by the way, as of CSLA.NET 3.5, for consistency this serialization/deserialization process even occurs when everything happens in-process on one physical tier.

Solution

The solution I finally stumbled upon essentially gave up on the idea of trying to hijack the object creation process either in the DataPortal or worse yet in the .NET Framework itself during deserialization.

The good news is that most IOC Container frameworks out there allow you to perform dependency inject with an existing object instance. In my case, I'm using Unity, the IOC Container from Microsoft, which is a member of their Application Blocks family. Unity's container object has a method called BuildUp that let's you do exactly this.

And the other piece of good news is that CSLA.NET allows very easy access to an object instance just after it is created either by the server-side DataPortal or by deserialization. All you have to do is override a couple virtual methods and you're done!

Implementation

My implementation of this was to create a set of base classes that all inherit from main CSLA.NET base classes that do the necessary overrides and perform the dependency injection. Let's build the base class for BusinessBase<T>, probably the most used CSLA.NET base class.

First, let's get the basics out of the way. We'll declare an abstract class called InjectableBusinessBase<T> that inherits from BusinessBase<T> and contains a protected constructor, which all abstract classes should have:

[Serializable]
public abstract class InjectableBusinessBase<T>
    : BusinessBase<T>
    where T : BusinessBase<T>
{

    protected InjectableBusinessBase() { }

}

Now, let's add the necessary overrides to hook into post-object creation so we can kick off our dependency injection:

    protected override void DataPortal_OnDataPortalInvoke(DataPortalEventArgs e)
    {
        Inject();
        base.DataPortal_OnDataPortalInvoke(e);
    }

    protected override void Child_OnDataPortalInvoke(DataPortalEventArgs e)
    {
        Inject();
        base.Child_OnDataPortalInvoke(e);
    }

    protected override void OnDeserialized(StreamingContext context)
    {
        Inject();
        base.OnDeserialized(context);
    }

First we overrode DataPortal_OnDataPortalInvoke. This gets called by the server-side DataPortal when a root level business object is created. Then we overrode Child_OnDataPortalInvoke which gets called by the server-side DataPortal whenever a child object is created by the DataPortal (a new feature as of CSLA.NET 3.5 that I highly recommend). Finally, we overrode OnDeserialized, which, through the help of BusinessBase<T>, gets called by the deserialization process of .NET.

In all three cases, we're calling an Inject method, which is a private method declared in our base class. It looks like this:

    private void Inject()
    {
        var type = this.GetType();
        Ioc.Container.BuildUp(type, this);
    }

Nothing too fancy here. We're essentially calling the Unity BuildUp method which requires the type of our business object and the business object instance itself.

What is a little exotic, if you're familiar with Unity, is the Ioc.Container code. Our base class needs some way to access the Unity container instance against which to call BuildUp. I've created a utility class called Ioc that has a static Container property that returns this. I'll include the code for this class as well as all the code for the various base classes at the end of this post. For now, just know that the code Ioc.Container returns our IOC container.

That pretty much is all that's required to make dependency injection work with CLSA.NET and Unity! However, I do have one more method I want to include in my base class:

    protected TDependency EnsureDependency<TDependency>(TDependency dependency) 
        where TDependency : class
    {
        if (dependency == null)
            throw new MissingDependencyInjectionException(this.GetType(), typeof(TDependency));
        return dependency;
    }

The purpose of this method will become a little more clear when we take a look at an example concrete business object class that inherits from InjectableBusinessBase<T>. Essentially all this method does is return the same object that gets passed in. However, before it returns it, the method checks to make sure the object is null; if so, it throws a custom exception that basically says a required dependency instance is missing that it's of a certain type and is contained within the object of this type. I'll include the source code for this exception class at the end of the post as well.

Sample Concrete Class

To make all this gel, let's code up a concrete business object class that inherits from our base class. I'm going to code up a very simple Customer class that has two properties, ID and Name, and a single Fetch factory method. Here's the code so far:

[Serializable]
public sealed class Customer
    : InjectableBusinessBase<Customer>
{

    private static PropertyInfo<int> IdProperty = 
        RegisterProperty<int>(new PropertyInfo<int>("Id"));
    public int Id
    {
        get { return GetProperty<int>(IdProperty); }
    }

    private static PropertyInfo<string> NameProperty = 
        RegisterProperty<string>(new PropertyInfo<string>("Name"));
    public string Name
    {
        get { return GetProperty<string>(NameProperty); }
        set { SetProperty<string>(NameProperty, value); }
    }

    private Customer() { }

    public static Customer Fetch(int id)
    {
        var criteria = new SingleCriteria<Customer, int>(id);
        return DataPortal.Fetch<Customer>(criteria);
    }
    
}

Nothing new here other than the class inherits from InjectableBusinessBase<Customer>. We have two properties declared using the new CSLA.NET 3.5 managed property syntax. Then we have the standard private constructor and the static factory method which uses the DataPortal to create and fetch our business object from the database.

Now I want to introduce a dependency into my class that performs the actual data access necessary to fetch the customer, which will be performed in a standard DataPortal_Fetch method. This data access object will implement a custom interface called ICustomerDataAccess and will have a method called FetchData that takes a customer ID and returns a DTO that contains my customer data. Here's what my ICustomerDataAccess interface might look like:

public interface ICustomerDataAccess
{
    ICustomerDto FetchData(int id);
}

By the way, a DTO (data transfer object) is just an object that contains nothing but data. For mocking purposes, my DTO is an interface (called ICustomerDto).

In an upcoming post, I'll show a more elegant way to abstract away the data access layer in CSLA.NET using dependency injection and the Repository pattern.

Let's add a field to my class that will contain this dependency:

    [NonSerialized]
    [NotUndoable]
    private ICustomerDataAccess _dataAccess;

Notice that I've added two attributes to this field. The first, NonSerializedAttribute, is important because we don't want this dependency (or probably any dependency) to be serialized if the business object were to become mobile and transferred from one physical tier to another. In the case of data access, it really only needs to occur on the tier that performs data access (i.e. an application server).

The second attribute, NotUndoableAttribute, comes from the CSLA.NET framework. It tells CSLA.NET that this field is not to participate in the undo functionality provided by the BusinessBase<T> class. This is because the dependency does not contain any business object state that would need to be rolled back if the users were to perform an Undo.

Having both of these attributes in place essentially relieves us of the need to make our dependency serializable. The actual implementation class of ICustomerDataAccess can be just a plain old object.

Now we need a way to inject this dependency into our business object. Unity gives you three ways: constructor, set-able property, or method. We can't use the Customer constructor since we're performing the dependency injection after the instance has been created by the DataPortal or deserialization. We could use the set-able property. However, I personally like the method approach since, if you have multiple dependencies, you can inject all of them in a single call.

We just have one in our example, so here's the code:

    [InjectionMethod]
    public void Inject(ICustomerDataAccess dataAccess)
    {
        if (dataAccess == null)
            throw new ArgumentNullException("dataAccess");
        _dataAccess = dataAccess;
    }

My method can be named anything, but it needs to be decorated with the special Unity InjectionMethodAttribute and it needs a parameter for each of my dependencies so I can set the fields. Notice I also throw an ArgumentNullException if whatever is doing the injection passes in a null. We want to fail if this ever happens.

Finally, we need to add the DataPortal_Fetch method that will use our data access dependency:

    private void DataPortal_Fetch(SingleCriteria<Customer, int> criteria)
    {
        var customerData = EnsureDependency(_dataAccess).FetchData(criteria.Value);
        LoadProperty<int>(IdProperty, customerData.Id);
        LoadProperty<string>(NameProperty, customerData.Name);
    }

The first thing we do is call the FetchData method of my ICustomerDataAccess object to obtain the customer DTO. Here is where you can see the EnsureDependency method in action that we coded earlier in the base class. If we wrap the _dataAccess dependency in a call to EnsureDependency, we know we're not going to get a NullReferenceException, which is non-descriptive and hard to debug. Rather we'll get a more descriptive exception that explains exactly what dependency is missing from what object.

Once we have the DTO, we can simply populate our business object in the standard CSLA.NET 3.5 way.

Conclusion

There you have it! Dependency Injection and CSLA.NET living peacefully side-by-side.

If you'd like to take a look at the complete set of source code for this, which includes all the Injectable* base classes, the MissingDependencyInjectionException class, the Ioc helper class, and the sample Customer business object code, you can download it here. Before the sample code will compile, you will also need to download CSLA.NET 3.5 and Unity 1.2 and update the assembly references accordingly.

Now I'm not pretending that this is the only way to make this work. If there are other people out there who've made Dependency Injection and CSLA.NET work better, perhaps with a different IOC Container like StructureMap or Castle Windsor, write a comment and let me know!

Trying out PreCode and SyntaxHighlighter

2008-12-15T22:43:00.001-06:00

Per Scott Hanselman's recent blog post on the best code syntax highlighter for your blog, I'm giving his suggestion a try, which is to use the PreCode plug-in for Live Writer (a free blog writing GUI from Microsoft), which renders your code snippets so they use the SyntaxHighlighter JavaScript library.

I host my blog on Google's Blogger and so I don't have an easy way to host the necessary JavaScript files to make SyntaxHighlighter work. But I do have a Google Pages account, so I was able to upload them there and modify my blog's HTML Template in Blogger to include the necessary <link> and <script> tags to make the magic happen. I used tips from this blog post to get it working.

I wanted to get this set up since I'm about to post three (yes three!) blog entries on CSLA.NET which will probably contain a fair amount of code.

Anyway, without further adieu, here's my first SyntaxHighlighter code snippet, generated by the PreCode plug-in:

public interface IFoo
{
  void Bar();
}

public class MyFoo
  : IFoo
{
  public Bar()
  {
      //do something
  }
}

NOTE: If you're using a feed reader like Google Reader, this code won't look like anything special. You'll have to open the blog page directly to see the full effect.

Where's Pete?

2008-11-17T08:57:00.003-06:00

Wow, it's been ages since I've posted anything here. Pretty lame. I have a laundry list of stuff I actually want to write about, but I just haven't found the time. Maybe it's cuz we had another baby back in September? Still, no excuse.

Hopefully this will post will kick me in the pants. Feel free to comment and do the same.

More than one way to not drive to work

2008-06-10T10:33:00.001-05:00

Saw this on my ride into work today on the Gateway Trail. I think I've seen a maybe two Segways ever in my life. This guy rocks!

2008 MS150 - Sunday

2008-06-08T20:00:00.000-05:00

Today we finished the second half of the MS150. Hit the road at about 7:30am and crossed the finish line in Blaine at about 12:20pm.

Today's pace was a little faster than yesterdays, probably due to the slight tail wind instead of a head wind. We averaged over 20mph for the day and we had one 22 mile run in the morning (where we skipped a rest stop) where we averaged over 22mph! That was a lot of fun!

I took a lot of really cool pictures (with my phone), including one over my shoulder while my group was in formation, but somehow (and I'm still perplexed as to how this happened) I lost the memory card in my phone. Fortunately, I have this one, which my wife Kris took just after the finish with my kids. This was the highlight of my weekend anyway! It was great seeing my family cheering me on when I crossed the finish!

Well, it was a great event this year. I'm so glad I decided to join a team and even more glad that I joined the Backdrafters. What an awesome group (115 riders!) led by a great team captain, Doug.

I've already signed up for next year (got my complimentary MS150 socks). I'm definitely going to keep riding with the Backdrafters.

Thanks for everyone who supported me this year. I increased my donations from last year and brought in over $600! Next year I want to raise over $1000, which puts you into the Golden Gears Club. Also, anyone reading this who would want to experience the MS150 for themselves is more then welcomed to do so! Just let me know. You can contact me via email which you can get by viewing the homepage of my blog here.

2008 MS150 - Saturday Evening

2008-06-07T22:31:00.003-05:00

That is a kiddie pool full of beer (with a mini-keg of Heineken in the middle). This was the first thing I saw when we entered the Backdrafters tent. Man, that first beer tasted good!

There was all the beer, water, and snacks you could consume! What a refreshing end to the day. Even Cap'n Doug took a few minutes and enjoyed a cold one.

At 5pm they served a catered diner and we ate like kings and queens!

Now we and the bikes rest until tomorrow where we do the second half. The weather report looks great: No rain and 10-15 mph NW tail wind!

2008 MS150 - Saturday Ride

2008-06-07T12:00:00.000-05:00

We left Carlton this morning at about 7:30 am. I was very excited to ride, but nervous to see if I'd be able to keep up with my partners. Landon (far right) is a biking freak and claims to have drafted many a semi truck doing 50+ mph!

So we hit the road and in about 36 minutes and 10.17 miles later we hit our first rest stop (which was actually rest stop #2 since we started in Carlton instead of Proctor). Our average speed was 17 mph. Not too bad for the warm-up ride. Cory (right, below) decided it was wise to put some air in his tires at this point.

After the first rest stop we picked up the pace and averaged 18.6 to rest stop #3, biking 11.34 miles. Also I did some pulling (led our group) and was actually able to maintain a decent pace!

At 8:50 we reached rest stop #3 and took a quick breather. The next stop would be lunch!

With our 10.05 mile run to lunch our average speed increased again to 18.7 mph! The Subways were great!

And a bit filling. Our 9.13 mile run from lunch to rest stop #5 was a little slower (17.4 mph). It was definitely getting warmer. Landon (right, below) was tired of my camera phone.

Our last run was the going to be the longest (15.6 miles). Amazingly we all hit a major second wind! At one point we were consistently holding 24 mph, all of taking our turn pulling, and still doing that with a head wind!

And finally, the finish:

Overall we averaged about 19 mph and arrived in Hinckley at about 11:45am (I think I arrived at Hinckley last year about 3pm)! And I kept pace the entire day! I owe most of that to the awesome bike that my boss, Kerry, borrowed me for the event: A 2005 (I think) Bianchi Cross Concept.

Now it was time to check into the hotel, relax a bit, and check out the infamous Backdrafters tent...

2008 MS150 - Friday

2008-06-07T05:45:00.000-05:00

Loaded the bikes in our own rental truck, hopped on the bus, and made it up to Carlton, MN last night with the Backdrafters.

Spent the night in the Black Bear Casino Hotel, and now I sit in the hotel lobby with my laptop mentally gearing up for the first day of riding with a cup of coffee.

Our team has a bit of a unique situation in that they're not starting in Proctor like the rest of the 3500 MS150 bikers. Doug, the team captain, wasn't able to book enough hotel rooms in Proctor for the team and so switches us over to Carlton, which is about 15 miles down the trail, making today's ride a little shorter than 75 miles (this is one reason why I chose to bike from home to National Sports Center yesterday, which was about 16 miles).

I've already met a lot of great people on the team. I met Doug (above) right away; he's a great guy.

There was also someone practicing their accordion in the parking lot yesterday afternoon before we left Blaine (I'm assuming that's going to be used tonight in Hinckley for the festivities).

I also met my roommates: Landin (our room captain), Cory, John, and Dillan. The cool thing is that it sounds like all of us want to try to ride together. Ladin is a pretty aggressive rider; he's done both the Minnesota Iron Man and the MS TRAM (Trek Across Minnesota).

It should be a fun day of biking!

Starting the 2008 MS150

2008-06-06T13:17:00.001-05:00

Well, it's that time of year again! Last year was so much fun I had to do it again. This will be my second Minnesota MS150 bike ride. I took this photo this morning before I left the house just before I biked to the National Sports Center in Blaine where everything starts.

I've been fortunate enough to join a team this year (Jeff wasn't able to attend due to his new kid!) called the Backdrafters. Instead of tenting I'm going to be doing the hotel thing Friday (tonight) and Saturday, which means I was able to pack a lot less stuff. I got it all in that gray backpack.

Well, I hope to do some actual blogging of the event over the weekend with some pictures from my phone. Right now I'm sitting at a Caribou right next to the National Sports Center. In about an hour I head over to get registered, meet up with my team (none of whom I've physically met yet), and hop on the bus for Duluth. And then it's an early rise to start turnin' pedals (as Doug, the team leader, sez) on Saturday.

And a huge thanks to everyone who's contributed to this event!

Upgraded to Vista

2008-05-12T22:37:00.001-05:00

This may come as a surprise to many people, but I've just now upgraded my main laptop from Windows XP to Windows Vista. Why the wait? Two things: First, I wanted to wait until SP1. Second, I wanted to wait until I had more RAM.

Regarding that second point, my laptop had 2GB RAM, which seems like plenty. However, I was maxing it out pretty easily with XP when running a 1GB Virtual PC (which is how I do all of my software development). So I upgraded to 3GB, which seems to give me just enough breathing room, even with Vista. I would have gone to 4 (which my ThinkPad T60 supports), but discovered that the extra 1GB was pretty much a waste with 32-bit Vista given issues with hardware memory mapping. 64-bit Vista apparently doesn't suffer as bad from this issue, but, alas I do not have a 64-bit processor, yet.

The good news is that on the same machine I was running XP Pro, Vista seems to perform just fine. In fact, it seems noticeably faster than XP was, which is a bit counter to popular opinion. Of course a clean install of any OS always seems to run fast. We'll see how things go.

Code Camp Presentation Posted - Tapping the Power of LINQ

2008-04-14T22:52:00.002-05:00

Well, I had the opportunity to present again at the Twin Cities Code Camp, this time #4, which was for Spring 2008. I did a general talk on LINQ including LINQ to Objects, LINQ to XML, and LINQ to SQL.

Anyway, thanks again to Jason Bock of Magenic Technologies for organization this event. From what I heard, we had a record turn out!

If you want to download the presentation and/or check out the sample code, you can do so here.

Managing Unhandled Exceptions in ASP.NET Web Services

2008-04-10T14:01:00.006-05:00

We've been working on building a web services at my current project at work for quite some time now and we're finally wrapping things up. One of the items to unfortunately get addressed toward the end of the project was error handling and logging (doesn't it always). And to my dismay the error handling scenario for ASP.NET Web Services (even in .NET 3.5) is not as pretty as it is with a standard ASP.NET Web Forms website.

Specifically, you can't just add a few lines of code to the Global.aspx.cs file in the Application_Error event handler method to log unhandled exceptions because the ASP.NET Web Services pipeline bypasses this event so it can return all the exceptions back to the caller. It does this by wrapping the unhandled exception in a SoapException, which ultimately gets deserialized as a SOAP fault. Out of the box, there is very little you can do with these unhandled exceptions before they are sent to the client. For example, there is no quick and easy way to log them like you can with .aspx pages.

The SoapExtension Solution

The most popular approach to solving this problem (that I've found so far) is to code up a custom SoapExtension subclass, which privodes you low-level access to the SoapMessage at different stages of the web service request and response. When the unhandled exception occurs, the SoapException can be captured in the response SoapMessage (via the Exception property). The SoapException's InnerException property then contains the actual unhandled exception. At this point you can at log the exception on its way out the door so when you get that email from your tech support department, you've got something to go on.

But if you've ever developed a real public-facing web service (like ours is), you'll quickly agree that simply logging the exception isn't enough. Often times you want a little more control over the contents of the SoapException itself that gets sent back to the caller. The SoapExtension subclass approach gives you the ability to modify the SoapException, but at a very low level. Specifically, it's already been deserialized into its representative SOAP fault XML and you have to do some fancy stream manipulation to insert any custom content into that fault (ex: add a detail element). In my opinion, this is a hack and not a very ellegant solution. Instead we should have more control of the SoapException before it gets thrown. Ideally if we could create and throw the SoapException ourselves, we could have much more control over the contents of the resuling SOAP fault (like the fault code and detail). Then we wouldn't have to bother with intercepting and manipulating the raw SOAP messages themselves.

Client-Caused vs. Server-Caused Errors

A great example of this is when you want to return a client-caused SOAP fault vs. a server-caused SOAP fault. A client-caused SOAP fault is one caused because the client sent invalid data in their request. For example, they're not authenticated or they sent a null for a value of a required web method parameter or data transfer object (DTO) property. The SOAP fault infrastructure allows you to classify this kind of error by throwing a SOAP fault with a Code = Client (or Sender in SOAP 1.2). It's also helpful to send information in the detail section of the SOAP fault about what is invalid and how to fix it. It's up to the client to then fix their request before sending it again; otherwise, they'll get another client-caused SOAP fault.

A server-caused SOAP fault is one where something actually bad happenned on the server. In this case the client is really helpless to fix the issue. Operations or an engineer on the development team needs to determine the issue and fix it on the server side. When this kind of error occurs, you want very little detail to be sent to the client, certainly not a full stack trace! Rather you want a simple error message like "An unexpected error has occurred on the server." Optionally you could also send some kind of error identifier, which the client could use when communicating with customer support so that the error can easily be referened in the server logs. Like the client-caused SOAP fault, the server-caused SOAP fault has a special fault Code = Server (or Receiver in SOAP1.2).

The Try/Catch Solution

The best way to implement catching all exceptions and throwing your own SoapException is with a try/catch around the code that can cause the unhandled exception, which essentially is every web method in your web service. Unfortunately, since there's no single place in code you can do this, you're faced with putting try/catch statements around the logic of every single web method. The code for one particular web method might look like this:

[WebMethod]
public string WebMethod1(int arg1, int arg2)
{
  try
  {
    //web method logic
  }
  catch (ExceptionType1 ex)
  {
    //handle ExceptionType1
  }
  catch (ExceptionType2 ex)
  {
    //handle ExceptionType2
  }
  catch (Exception ex)
  {
    //handle all other exceptions
  }
}

While this works, it's a ton of duplicated code, especially all the logic in the catch statements. Wouldn't it be nice if there was a way to add a little bit of code to each web method but put the bulk of the error handling logic in a single method somewhere else?

Well, there is!

The Try/Catch Using Anonymous Methods Solution

The trick is to put all of your even handling logic (including the try/catch) into a separate utility method and then invoke that method by passing it a delegate to your web method logic. This utility method might look something like this:

private T Execute<T>(Func<T> body)
{
    //wrap everything in common try/catch
    try
    {
        return body();
    }
    catch (SoapException)
    {
        //rethrow any pre-generated SOAP faults
        throw;
    }
    catch (ValidationException ex)
    {
        //validation error caused by client
        ClientError innerError = new ClientError();
        //TODO: populate client error as needed
        //throw SOAP fault
        throw this.GenerateSoapException(
            "An error occurred while validating the client request.",
            SoapException.ClientFaultCode,
            innerError);
    }
    catch (Exception ex)
    {
        //everything else is treated as an error caused by server
        ServerError innerError = new ServerError();
        //TODO: populate server error as needed
        //TODO: log error
        //throw SOAP fault
        throw this.GenerateSoapException(
            "An unexpected error occurred on the server.",
            SoapException.ServerFaultCode,
            innerError);
    }
}

A few things to note about the Execute method above:

The delegate type being passed in is the generic Func<TResult> delegate, which is new to .NET 3.5 (Visual Studio 2008/C# 3.0). It works with any method that has no arguments and returns a value of the generic type TResult. If you're coding this in .NET 2.0 you could simply declare your own delegate that has the same signature like this

private delegate TResult Func<TResult>();

The same generic type is also specific in the Execute method and is also the return type of the Execute method. And since we execute the delegate and return its result, everything is done in a strongly-typed fashion with no casting. It's even more elegant since the caller doesn't have to explicitly specify the type T since it can be derrived from the actual parameters of the method this is passed (which we'll see in a moment).
The error-handling logic expcitly catches and rethrows SoapExceptions. The assumption here is that if something lower down threw an actual SoapException, they probably want that exception to drive the resulting SOAP fault generated by ASP.NET instead of the one we're going to create (in the catch statements that follow).
The error-handling logic explicitly catches an exception type that represents all client-caused errors (in this case a made-up exception class called ValidationException). If there are multiple exception types that represent this, then you'd have multiple catches.
The final catch (Exception) is a catch-all for everything else, which is, by definition, an unexpected server error. It has a TODO placeholder for logging the error.
The last two catch statements employ another utility method that generates the SoapException itself (which I will show shortly). This method uses XML serialization to serialize a custom error object DTO and put it in the SoapException Detail.

So, what would a web method look like that's using this Execute method? Back to our first web method example:

[WebMethod]
public string WebMethod1(int agr1, arg2)
{
    return this.Execute(delegate
    {
        string result;
        //do something with arg1 and arg2 and generate a string result
        return result;
    });
}

Notice how by putting the web method logic within an anonymous method, the call to the Execute method is nothing more than a thin wrapper. Also notice that we don't have to call the Execute method with a string type parameter (i.e. Execute(...)) because it's inferred from the return type of the anonymous method.

The beauty is that now you've got a single place where you can do all of your plumbing-related coding. Error handling is one thing you can do (which was the original focus of this blog post), but you can also do logging, add instrumentation code, or whatever, all in one spot!

And here's the handy code for the GenerateSoapException utility method referenced before:

private SoapException GenerateSoapException(string message, XmlQualifiedName faultCode, object detailError)
{
    using (Stream stream = new MemoryStream())
    {
        using (XmlWriter writer = new XmlTextWriter(stream, Encoding.Default))
        {
            //build detail XML by serializing detailError object
            XmlSerializer serializer = new XmlSerializer(detailError.GetType(), "your-webservice-namespace-here");
            serializer.Serialize(writer, detailError);
            stream.Position = 0;
            XmlDocument doc = new XmlDocument();
            XmlElement detail = this.SoapVersion == SoapProtocolVersion.Soap12
                ? doc.CreateElement("soap", "Detail", "http://www.w3.org/2003/05/soap-envelope")
                : doc.CreateElement("detail");
            doc.Load(stream);
            detail.AppendChild(doc.DocumentElement);
            //build exception
            return new SoapException(
                message,
                faultCode,
                this.Context.Request.Url.AbsoluteUri,
                detail);
        }
    }
}

Enjoy!

~pete

Code Camp Presentation Posted - LINQ to XML

2007-10-31T20:28:00.000-05:00

Twin Cities Code Camp 3 was a blast and I had a lot of fun presenting this time on LINQ to XML. Hats off to Jason Bock who did a fantastic job pulling all this together (as did everyone else who helped out). All the presenters were first class, many of them Microsoft MVP's. It was an honor working along side them.

If you missed my talk or just have a general interest in LINQ or LINQ to XML, feel free to download my Powerpoint presentation. If you have any questions, shoot me an email at: peter at twistedstream dot com.

Fall 2007 Code Camp

2007-10-08T09:52:00.000-05:00

One of the more recent really cool tech events to hit the Twin Cities is the Twin Cities Code Camp. They happen usually every 6 months and #3 is occurring at the end of the month on October 27th. Code Camp is organized by Jason Bock, a Microsoft MVP and a good friend of mine from Magenic Technologies. It is sponsored by a number of area technology businesses including Magenic, Microsoft and New Horizons, which is where its held.

The event is free to attend (plus they feed you breakfast and lunch). You get to choose from a number of sessions where you can learn about new technologies and chum with a lot of really smart people.

Also, I've been given the privilege to present one of these sessions. I'll be talking about LINQ to XML, Microsoft's new XML API. If you're interested in LINQ (which you really should be since its the main feature add for the next version of .NET), there are two others sessions before mine that talk about LINQ to SQL and LINQ to objects. Very cool stuff! Check out the schedule to see all the topics.

Google Maps API Weirdness in IE6

2007-07-19T10:02:00.000-05:00

For the past few months I've integrating the Google Maps API into an existing website. Last month we finally released the new version of the site and everything seemed to be working fine, except in IE6.

Specifically, the map marker icons (you know, the little red teardrops) were not rendering properly. Here's how they looked in IE7 and Firefox:

and here's how they looked in IE6:

Yuck! Now, it's a well-known fact that IE6 can't render PNG files properly (specifically if they have any transparency to them, which these icons do). However, the Google Maps API is aware of this and employs the AlphaImageLoader filter to compensate. Go to http://maps.google.com/ on IE6 and the icons look just fine.

So why were my icons turning out so crumby?

Well, my scenario was a bit more complex than all the standard 'hello world' samples out there. First, I was using custom icons. But on top of that I wasn't simply slapping some static JavaScript code on my page to display the Google Maps API objects. Rather, I was generating all of the JavaScript code dynamically in my .aspx page on the server side. However, the final HTML output of my page (specifically the JavaScript code rendering the GIcon objects) looked right.

Except for one difference. Like I said, I was using custom icons. Just about all of my custom icons were the same shape; they really only differed in color, which meant the only real difference was the GIcon.image property (all the other properties were pretty much identical). In my inifinite wisdome I thought it would be clever to consolidate all of the other image URL properties associated with each GIcon (shadow, transparent, etc) and I would do this by storing those images as embedded resources within my assembly and referencing them via WebResource.axd.

The end result was that instead of the GIcon JavaScript code looking like this:

icon.shadow = "my-shadow.png";

it looked like this:

icon.shadow =
"/WebResource.axd?d=some-long-key&t=timestamp";

And what was tripping up IE6 was the fact that the image URL wasn't ending in ".png". Really what was being tripped up was the Google Maps API JavaScript code running in IE6. Perhaps the version of their code that runs in IE7 is able to automatically detect PNG files without requiring a .png file extension. Who knows. But the bottom line is that the image URL must end in a .png file extension, ruling out any standard dynamic image URL resource (like WebResource.axd).

This took me a fair amount of effort to solve. Hopefully, I'll save someone else the time.

First MS150 a Success

2007-06-11T10:00:00.000-05:00

I've had way too busy of a summer. So much so that one of the biggest events, the MS150, came and went, and I never even bothered blogging about it. Well, here it is, better late than never.

In short: we (Jeff and I) had a blast. 150 miles of fun... and soreness. My butt got pretty sore and at the final 10 miles of the tour my left knee was giving me problems. Jeff had been drafting behind me most of the way and, at the end, was able to take the lead, which was nice. Jeff had weird gloves and one of his hands was numb for about 3 weeks afterward!

But the benefits definitely outweighed the costs! I will do this event next year.

Here were some lessons learned:

Stretching is very important (lack of is what caused my knee injury).
Get on the trail earlier in the morning next year to beat the heat.
Get more power with higher RPM's instead pedalling harder; this is much easier on your joints.
Hang with a group to take advantage of drafting. I would struggle to maintain 15mph (with a head wind), but it a group could do 18mph with ease.

No more room in my VHD

2007-05-22T23:14:00.000-05:00

UPDATE #2:
Hold the phone. A reader just tried the procedure described in the UPDATE section below and found out that when you finally go to convert from the fixed back to a dynamically expanding disk, you never get prompted for a new disk size. If this is true, this handy workaround is pretty much worthless. Has anyone else attempted this that could confirm? Yes, I'm too lazy to do it myself.

UPDATE:
The information in the original post is pretty much obsolete, or perhaps more accurately put, incompetent. Thanks to a recent anonymous comment, all I had to do was convert the VHD to a fixed disk and then back to dynamically expanding. Read on if you'd like to learn how to do it the hard way.
:)

So, you may or may not know that I'm a huge fan and user of Virtual PC and Virtual Server. For over two years, I've been using virtualization exclusively for software development. Sure, there's a slight performance hit, but you can't beet the flexibility you gain from having one (or more) isolated development environments. Before using Virtual PC, it was common for me to be wiping my laptop once every 4 to 6 months. Now, since I don't run any development tool software on my host OS, it's rare that I have to rebuild my host machine. And, of course, creating new virtual PC's is a snap.

Virtual PC, Virtual Server, and VMWare all use the concept of virtual hard drives (or VHD's). These are nothing more than files on your physical host OS's drive that represent a virtual drive. They can be fixed in size (like a physical drive) or dynamically expand. The later option is handy in that such a VHD only takes up as much physical space as it needs, gradually growing over time. The benefit is it saves a lot on physical drive space, especially if you manage multiple virtual machines.

When you create a virtually expanding VHD you have to specify its maximum size; for Virtual PC the default max size is 16MB. The kicker is when you're using that VHD and all of the sudden one day you run out of room. It's the same experience you have when you run out of room with a physical drive - you immediately try to free up space by deleting unnecessary files and uninstalling unused apps.

However, I recently ran into a scenario where making more room wasn't enough. I was installing Visual Studio 2005 Service Pack 1, which requires a ton of free disk space (over 2GB I think) and I couldn't make it happen. Since you can't change the max size of an existing VHD, I only had two options:

Rebuild my virtual machine with a larger VHD.
Somehow transfer the contents of my existing VHD to a new empty VHD.

The second option was much more appealing since it would require minimal effort. I just needed a tool that could do it. Transferring or cloning a disk is more involved that simply copying files since you need to transfer boot record, partition, as well as other information.

Doing a little digging, I found there are several utilities out there. Norton Ghost is one. The one I chose was Acronis True Image Server (I installed the Server version since my OS was Windows Server 2003). Neither of these are free, so you have to either buy them or use their trial edition. The process I used was the following:

Create a new empty dynamically expanding VHD (with a more desirable max size) and mount it to the virtual machine.
Install Acronis True Image Server on the virtual machine.
Start True Image and run the Clone Disk wizard.
Unmount the old VHD.
Mount the new VHD as drive 0.

I think there are free disk cloning utilities out there, but I'm not sure how trustworthy they are. Disk cloning isn't something you want to mess up.

AN IMPORTANT NOTE:
Before you perform this operation, make sure you have plenty of room on the physical drive that contains the new VHD. Running out of physical drive space as the new VHD is getting filled (and expanded) can cause the clone to fail. Learned that one the hard way :).

Back in the saddle

2007-05-03T10:05:00.000-05:00

It's been over two weeks since I've biked (to work)!!! I've been slacking and am running out of excuses. Most of it has to do with over-busy-ness. Blah, blah, blah...

Tomorrow I AM biking in and the rest of the blogging world can hold me to it.

Looks like we're going to get some rain too. Perfect.

Converting the primary key type in a SQL Server database from int to GUID

2007-04-01T14:43:00.000-05:00

I maintain and develop a database for a web application that I've worked on for several years now. The application and the database have evolved significantly, and as things got larger and more complex, I've had to employ more advanced techniques and tools to perform database updates from development to production.

One of the "mistakes" I made when I originally designed the database was to use primary keys with the int data type (along with setting the primary key column as an identity column) for all of the tables. I have nothing against int's or identity columns and, in fact, that simple, tried-and-true configuration has worked well for this application... except for one, unfortunately very painful side-effect. When it comes time for me to push a major update from development to production, sorting out duplicate columns between both development and production database can be a real pain in the undercarriage.

The reason for this is often times in development I'm added new rows to tables that exist in both development and production to test and/or enable a new feature. If the primary key for that table is an int that is auto-generated by the database (since its an identity column) then there's a VERY good chance that same ID has been duplicated in a row in the production database. Things get even more complicated when that primary key ID is referenced by other columns in other tables via foreign key relationships. I tried a few production push sessions where I pretty much took the production database offline (which meant I pretty much took the website offline), pulled down the entire production database, integrated the development data into production by hand (I use RedGate products), and finally pushed the whole thing back up to production. Not pretty, but it worked... until recently. Within the last few months, for various reasons the production database has nearly tripled in size, making the whole pulling of the entire production database, and, worse yet, the pushing of it back up, ridiculously impractical. My last push took over 12 hours! Now, granted, I'm restricted by the limits of a cable Internet connection, but I came to the realization that I needed another solution.

Well, the solution is simple: switch to GUID primary keys. They never duplicate (in theory) so I can create rows in development that will never interfere with new rows in production. Unfortunately the road to this solution is not so simple. However, I was able to finally get there, so I thought I would share how I did it.

How to do the conversion

The main issue with a conversion of primary key columns from int/identity to GUID is the fact that you can't simply do a TABLE ALTER to remove the identity status of a column. You actually have to drop the column and re-add it!

Following are the steps I took. In this example, we'll call the starting database db and the final database db_new-schema.

Create db_new-schema as an empty database with new schema (i.e. everything the same as the old schema except the primary and foreign key columns are all of type UNIQUEIDENTIFIER).
Create another empty database called db_load whose schema is identical to db's except all the primary and foreign key columns are of type NVARCHAR(36) and contains only tables (views, stored procedures, functions are unnecessary). Also, there should be no foreign key constraints between tables.
Use an ETL tool (like DTS or SSIS) to copy the raw table data from db to db_load.
Create a SQL script that uses a cursor to enumerate the rows of a given table in db_load, updating each row's primary key with a new GUID value (using the NEWID function), and updates the rows in all foreign key tables with the same GUID value (selecting them using the old INT id). This script needed to modified and run for each table in the database until all of them were updated. In the end, all INT values were converted to new GUID's (although all primary and foreign key columns were still typed as VARCHAR).
Convert all primary and foreign key columns from VARCHAR to UNIQUEIDENTIFIER.
Use an ETL tool (or RedGate Data Compare) to load the db_new-schema database with all the data in db_load.

Good luck!

MS150

2007-03-03T18:16:00.000-06:00

This June I'm going to be riding in the MS150 Bike Tour, which is an anual fund raising event for multiple sclerosis. It's 150 mile trek from Duluth to the Twin Cities that lasts 3 days (2 days of actual biking).

Anyway, I'm very excited as this is the first real long-distance bike trip I've ever taken. And it's for a good cause!

If you'd like more information about the event or would like to donate, check out my personal MS150 page.

(In the words of Kip) "That's what I'm talkin' about."

2007-02-25T17:03:00.000-06:00

We got snow!

For once the weather man didn't cry wolf. I opened up my back door and here's what I saw: beautiful, white, fluffy snow!

It's been several years since we'd had a dump like this one. I know where we live, we got at least 12" and we're due for more.

And the coolest part is the kids and I built a snow hut. I haven't built one of these since I was in Boy Scouts!

Radical Islam

2007-01-24T09:08:00.000-06:00

I watched a very interesting documentary last night called Obsession: Radical Islam's War Against the West.

I think since 9/11 everyone has been aware of a link between Islam Extremism and terrorism, but I'm not sure everyone is aware of the gravity of this movement. What I liked about the film was that just about everyone interviewed was a Muslim (one person was a former PLO agent). This diminished the notion that the movie was a biased message from non-Muslim groups (i.e. Jedeo-Christian). And, of course, the first point made was that Islam Extremism is a view only held by a small percentage of practicing Muslims (something like 10 to 15%). However, that number is getting bigger as the "movement" is being very effective in recruiting non-Extremists to their cause - especially the youth.

The scary thing is the end goal of Radical Islam: to take over the world (by force) and make everyone Islam, killing everyone who apposes. A lot of people, including myself, questioned why Al Qaeda attacked the World Trade Center. Why do they hate us so much? Why were they willing to kill Americans, including Muslims? The answer, according to the film, is that they will kill anyone who apposes their mission of world domination. Right now, Western Civilization, is a huge target since it apposes this world view.

The movie also drew a very interesting parallel between Islam Extremism and the Nazi movement in WWII. Hitler's end goal was similar: to take over the world and eradicate anyone who didn't fit his world view, his primary target being the Jews. An interesting point was made that the current Radical Islam movement is potentially more dangerous than the Nazi movement because the Nazis fought because Hitler told them to; Islam Extremists fight because they believe God is telling them too.

Taking all this into account, puts a new spin on the War in Iraq, at least for me. Like most Americans right now, I'm getting weary of this conflict: the money being spent, the lives lost, yada yada. Up until the last few years, I've considered myself a conservative. I voted for Bush. However, these days its been tough to understand and support what he's doing. After all, wasn't it Osama bin Laden who attacked us, not Iraq? There were no WMD's. It just seems like we're there now because we opened a can of worms and can't get out.

Well, if what this movie says is true, then there is some logic for being in Iraq. Assuming the US government realized the real threat of Islam Extremism (world take-over), they had two options: build US defenses and just wait for the movement to grow and attack us or be proactive and attempt to stabilize the region where most of the Islam Extremism was coming from. At the time we invaded Iraq, everyone, left and right was certain that Saddam Hussein had WMD's. And if he was in on this movement, there was a huge threat here. Well, he didn't (at least we didn't find any). So we finally took him out only to find that removing him destabilized the country even more. But given the threat of Radical Islam, did we have any choice? Had we just sat back and let the movement take over the rest of world, we would have had very little chance of effectively defending ourselves in the future. Tough call. I'm glad I'm not the President of the Unites States.

As a Christian, I'm still not sure where I stand on the War in Iraq. I guess from a strategic standpoint, it makes sense. But as far as showing the love of Christ, I'm not so sure. War is never a black and white issue.

A final point. About a month ago I watched Al Gore's An Inconvenient Truth. This movie openned my eyes as well. I find it interesting that both the left and right have a doomsday prophecy: the left thinks the polar ice caps will melt within 50 years and the right thinks a global Jehad will take over the world. Both sides say we need to take action now to prevent the end of the world as we know it.

Wouldn't it be ironic if both sides were true.

January Bike Ride

2007-01-23T10:41:00.000-06:00

This will be a true test to see if my wife reads my blog.

I biked into work today. In me defense, it wasn't totally planned. The plan was to drop off my car at the shop and bike to the bus stop, which is only about .5 mile away. However, the problem with the bus, I've found, is that you have to get to the bus stop on time. So I missed the bus and my inspiring bus schedule said the next one would show up in about 50 minutes. The decision was easy: wait 50 minutes at a cold bus stop or bike to work in 35.

The good news was that I was fairly well dressed. I had assumed before this that I really didn't have the right clothing for anything below 30°F (this morning it was about 20°F). The only thing that got a little cold were my toes. The roads were fairly clear and the Gateway Trail, which I rode for about half the trip, was mostly plowed. As long as I didn't make any sudden turns, everything was smooth.

Overall, I enjoyed it and it's getting my more excitied about biking. Spring could not come soon enough.

Will Google take over the world?

2007-01-22T22:47:00.000-06:00

For years I've had to endure Microsoft-bashing. I call it bashing because for the past 8 years I've made a living off of the success of Microsoft and knocking Microsoft (or M$ as the affectionate abbreviation goes), meant you were knocking the entity that ultimate allowed me to get a pay check. But don't get me wrong, it's fun to bash large corporations, and I'll admit I've made an occasional M$ jab from time to time. Microsoft has done some cool stuff and some not so cool stuff. And, ironically, many of the sins they were accused of back in the day have been committed by many of their competitors since then. I guess it's the game of business.

I remember something Bill Gates said a few years ago when Microsoft was at its peak. And that was that at any given moment, Microsoft Corporation was 12 months away from going under. What he meant was that even a software giant like Microsoft could never stand still or the competition would eat it alive.

Well, I think Microsoft has met it's match: Google. It's no secret that Google has quietly become a huge player in the technology world. They are the standard search engine. I love many of their free services, including Gmail, Google Maps, and Google Reader. But I've always found it a bit odd that they offer so much stuff for free.

What exactly is G$ up too? Check this out.

Why I HATE Cingular

2007-01-03T00:15:00.000-06:00

Ya, harsh subject line. And for people who know me, I'm not one to start flaming people or companies. But I've had it. And I need to vent this somehow.

About a year and a half ago I switched from T-Mobile to Cingular because I wanted a phone that only Cingular offered. Dumbest mistake of my life. The very second my 2 year contract is up, I'm switching back. Now, granted, Cingular has been better than AT&T, but not by much. And just an FYI - my biggest annoyance with Cingular is that they claim to have the fewest number of dropped calls; I get a dropped call about once a day.

Anyway, I open up my cell phone bill today expecting it to be around the normal $75. Not this time. Today it was 498.54! Holy crap! So I scrambled to figure it what the heck happenned. Of course, disciphering the billing charges requires a PhD and a half, but I finally found the issue. The bill claimed that I had done a 39,578KB data transfer. I don't have a data plan. I haven't done any data transfers since the first month I had service after which I cancelled their $20/mo data plan.

I called customer care and the rep did a little research and found out the transfer occurred at 3:52pm on Tuesday 11/28/06. I was at work at that time and to my knowledge was not using my phone to transfer megabytes of data (I did a quick calculation and discovered it would take at least 2 hours to transfer that much data with my phone). So I told them that and they claimed there was nothing they could do. Ha! I asked to speak with a manager. After sitting on hold for 10 minutes, a manager came on and said the best they could do was credit my account $150. When I proceded to explain to them that I wasn't going to pay any of the erroneous data charge, the connection went dead. Cingular - network with the fewest dropped calls. That was the moment that I almost ate my cellphone while tearing the countertop off my kitchen cabinets.

There is a happy ending. I called back, sat on hold for a while, and finally spoke with a rep who was able to credit me half of the charge and fill out a form that would supposedly credit the rest back within 30 days. I pray that happens; God have mercy on the poor customer care person who answers my call if it doesn't.

There, I feel much better now. :)

UPDATE 9/4/07:

I'm happy to report that Cingular did manage to completely reverse the charges. It took a month, but at least it was taken care of. Why I had to go through so much pain is still irritating to think about. The conspiracy theorist in me thinks they sprinkle little fees like this all the time to customers and bank on the hopes that the customer won't go through the hassle to reverse them.

Anyway, in the end, I got even. The very day after my 2 year contract was up I switched to T-Mobile. And, like the comment of one of the readers, I haven't had to think about my wireless provider ever since.

One more funny thing. Just after I switched, T-Mobile put up some billboards in the Minneapolis/St. Paul area stating "Don't drop dad! T-Mobile, fewest drop calls in the Twin Cities". I knew it wasn't just me!

Power lines, KSTP, and DSL filters

2006-11-28T21:27:00.001-06:00

We've been living in our current house for a little over two years now. The house is nice, but it's less than a block from some really big power lines. Not the normal residential kind, but the big industrial, 1.21 Gigawatt, make-the-air-buzz-when-it's-raning kind, like this:

Other than the fear of aquiring gradual brain cancer, this was a non-issue. Until we picked up the phone. When you used any land-line phone in the house, regardless of the brand of phone (believe me, we tried many) or the carrier (we tried of few of those as well), you could always hear a local talk AM radio station, loud and clear.

I tried everything I could think of to fix the problem. I even installed new phone wiring between my Vonage box in the basement (Vonage is our phone company du jour) and the phone base unit in the kitchen upstairs. I orginally did this with new standard 4-conductor telephone wire; didn't help a bit. A few days ago I redid the entire run using plenum-grade CAT-5e cable, figuring that the non-twisted telephone wire was picking up lots of interference. That help, a little.

About 6 months ago my neighbor told me he had the same problem and solved it by installing a DSL filter between the phone jack and his phone. By chance I remembered that about a month ago and picked one up, but sort of forgot about it. Well, just tonight after feeling the frustration of my not-so-successful wire replacement project, I remembered the filter I bought, and decided to give it a shot.

It worked!

And here's the little bugger that did the trick.

Being somewhat of a die-hard cable internet subscriber, I guess I've gained a new respect for DSL. :)

Subversion on Windows

2006-10-23T11:46:00.000-05:00

Source control has always been a bit problematic in the Microsoft world. Most of us have used Visual SourceSafe quite extensively and don't have to be convinced that it pretty much sucks rocks. The good news is that the souce control story has gotten better in recent years and months. The most notable event was the launch of Team Foundation Server, which comes with Team Source Control, a huge improvement in the Microsoft offering for source control.

However, TFS is not very ideal for single-man shops like myself (yes, I do some software side projects from time to time). It's ideal for teams (even small ones) where collaboration of source code with the software development process is important (this should be the case with any shop). It's also not very free. I'm a bit of a cheap skate, so all-free was definitely more appealing.

In the past I've played with CVS and liked it. It's been around for a long time and has a decent Windows implementation that installs an easy-to-manage Windows service. However, CVS has its well-known shortcomings. These shortcomings are the primary reason for the creation of Subversion (SVN), which is very CVS-like, but better in many ways.

The only down side to SVN, it seemed, was that it didn't have a very good Windows implementation. Specifically, the server install did not include a Windows service. You had to come up with some other way of keeping your SVN process (or daemon as they call it) running using a 3rd party Windows service wrapper or the like.

Well, digging further, I recently discovered that it's not too difficult to use SVN with Apache, which is an open source web server that has a very nice Windows implementation. Accessing SVN via Apache (i.e. HTTP) is ideal because it allows you to easily browse your repository, and it works great with TortoiseSVN (my preferred SVN client) which uses WebDAV to communicate with SVN via HTTP. In fact I found the best resource for setting all this up was in the TortoiseSVN documentation itself.

Very cool! Now, I'm a die-hard SVN fan.

Lovin' GMail

2006-10-23T10:16:00.001-05:00

It's probably safe to say I switch email providers as often as blog engines, perhaps even more often. However, I think I've finally found one I can stick with for a while: Gmail.

My email story goes something like this:

Way back in the day, used whatever email address my ISP gave me. I quickly gave this up for a free Yahoo Mail account, which allowed me to check my mail from anywhere and not give up the address if I changed ISP's.
Purchased a domain name (twistedstream.com) and thought it would be cool to host my own mail server at home! I think I played with some 3rd party POP3 server at first. Then I switched to what all the cool Microsoft kids were using: Exchange.
I finally got tired of my home server either going down (which, in all honesty, didn't happen very often) or my ever-reliable Internet connection dropping and consequently people complaining about not being able to send/receive email to/from me. So I switched back to a hosted solution called Everyone.net that would work with my domain name. I believe was able to access my email via POP3 and IMAP. I liked the IMAP capability because it was more like Exchange.
Unfortunately Everyone.net only did email. All my calendar and contact data was still local to one machine. Then I decided to switch back (yes, back) to Yahoo Mail. Yahoo was also able to host my domain name as well as sync calendar and contacts with Outlook (this worked most of the time).
Then a coworker turned me onto a hosted Exchange service at 1and1. Man, this had to be the Holy Grail of email (for Outlook users)! And, for the most part, it was. But then I took a new job where the OWA (Outlook Web Access) didn't play well with the corporate firewall; essentially it made checking my personal email next to impossible while at work.

Then enters Gmail.

I've actually had an account for some time (I picked one up back when it first came out and it was the latest rave). However, besides some of its different ways of organizing mail, it just seemed like another web mail client. However, two things peaked my interest and eventually made me switch:

The ability to send email from any email address (not just your @gmail.com account). Yes, via a slick validation email, Gmail will allow you to send email from any account. Couple this with aliases set up in my MX record, and Gmail now becomes the center of my email universe.
The ability to import all of my old email. Granted, this feature isn't provided out of the box by Gmail. You have to do some digging, but a free tool called the Gmail Loader allows you to import all of your old mail. And when I say all, I mean all. I was able to suck in email as far back as 2000 (which is all I had archived). The beauty of this is all of that email (over 1GB) is now labelled and searchable with Gmail's awesome search engine. And since Gmail gives you over 2.5GB of storage, I still have plenty of room.

One more feature that Gmail has that I like, but don't necessary use, is their POP3 access. Like many other hosted email services, you can use a rich email client (Outlook, Outlook Express, Thunderbird, etc) to pull down your email via the POP3 protocol. Gmail makes that experience better with the following added capabilities:

More choices on how messages are stored on the server.
The ability to send email from any email address that you've validated on the Gmail site.
Having a copy of any email sent from your rich email client stored in the Sent Mail folder on the server (as long as you use the Gmail SMTP server in your client-side configuration).

Very cool stuff. I now feel content with my email :).

ps
I have to say a big thanks to my friend Michael who's been using Gmail for some time now and got me re-interested.

My BPTBEC ratio is very low

2006-10-09T19:46:00.000-05:00

I have, once again, switched blog engines. I began by using LiveJounral, then I switched to hosting my own. That was cool, but I got tired of having to maintain the server and have friends complain that they couldn't read my blog because my internet connection was down (which is Comcastic!). Not that it really mattered anyway since it was a rare occasion to actually see a new post from my blog.

So, I've made the move back to a hosted blog. For kicks, I decided to go with Blogger. They've been around a long time, have a pretty slick interface that's free, and the Blogger account integrates with my Google ID, which is cool.

Finally, regarding the subject of this post. In all this silliness, I thought it would be fun to make up an acronym to describe my blogging behaviors. BPTBEC stands for Blog Posts To Blog Engine Changes. Right now that ratio for me is at about 3.7. Hehe, I think most average bloggers would have a value in the 100's or 1000's. Well, at least I've got something to shoot for.

Go ahead, blame the rear derailer

2006-09-22T01:15:00.000-05:00

After all that hoopla in my last post about my rear derailer, I came to realize that my original hunch was actually correct. I finally brought my bike into Erik's Bike Shop to get some tire fenders installed today. I mentioned my derailer issue and the tech examined the bike and determined the derailer was in fact out of adjustment.

Shows you what I know. :)

Don't Always Blame the Rear Derailer

2006-09-19T08:25:00.000-05:00

My first biking post! Biking (bycicling, not the motorized variety) has become my new favorite hobby. Good form of exercise. Lot's of scenery. And, as of yesturday, I can use it to get to work since I now work in downtown St. Paul. I suppose I should go more into that subject in a different post (stay tuned). Like most software developers, staying in shape is always a challenge, so if I can combine commuting with achieving that goal, I'm way ahead.

So, I haven't done a real bike ride (i.e. > 1 mile) in over two weeks due to my hectic schedule as of late. I took my bike out Sunday night to do a quick 5 miler around Garvais Lake. I get about 100 yards and begin to notice that my chain keeps slipping, as if it were hopping between gears. My immediate reaction was that my rear derailer was out of adjustment. So I start fiddling with my rear shifter to try to get it to settle on a gear. Same problem. I then try different gears to see if the issue only occurrs with the higher gears. Same problem.

Something was fishy. I'm finally biking along the lake and would really rather enjoy the scenery instead of fight with my transmission. In a puff of frustration, I hop off my bike, flip it upside down, and pedal it by hand so I could get a close look at the derailer. I notice that it seems to be inline with the sprokets. Looking closer I also notice that the skipping seems to be occuring at a regular pace as I turn the crank, and if I slow down the RPM's, the skipping slows down.

Finally I begin to see the problem. Some (not all) of the links in my chain were stiff. They weren't rusted, per se, just stiff. Stiff enough so they wouldn't quite twist around the small gear of the derailer, causing the chain to actually jump off, just for a split second. Hense the skipping.

I wasn't quite sure how to remedy the problem. So, I decided to just hop on my bike and take it easy for the rest of the ride (i.e. actually enjoy the scenery). As luck would have it, the continual motion of my ride eventually loosened up the chain (perhaps warmed it up?) so within a few minutes, the skipping went away!

I was a happy biker and learned something new that day!

Mobile Objects and Ice Cream

2006-06-30T00:35:00.000-05:00

So I've been taking the time lately to read through Rocky Lhotka's new CSLA.NET 2.0 book, Expert C# 2005 Business Objects. It's a great book and in it, among many other things, he talks about the concept of mobile objects. In short, mobile objects are objects that have the ability to move from one location (process or machine) to another. In each location they can behave in an object-oriented fashion, interacting with the services that that location has to offer. Essentially, the concept of mobile objects is one of the ways the CSLA.NET framework solves the age-old problem of doing OO within a distributed application.

Anyway, I caught myself thinking in mobile object terms the other night when I got a hankering for a bowl of ice cream. I found myself upstairs in the kitchen with an empty bowl and a spoon. The problem was that the ice cream was in our second refridgerator in the basement. Rather than bringing the ice cream container up to the kitchen (only to have to bring it back down again when I'm done), I decided to implement a mobile object. I was the end user and my bowl was the object (I suppose my spoon was the user interface). I wanted to make my bowl mobile and send it to the basement to be filled with ice cream. Since it happened to be father's day, I asked my son if he would be willing to execute the fetch. Being a good boy, he ran downstairs with my bowl, performed the data-centric operation of getting the ice cream out of the ice cream container (the data store) and filling the bowl. He then made the bowl mobile again by returning it back to me in the kitchen. With the filled ice cream bowl I performed some UI-centric business logic by pouring on a generous serving of Magic Shell. And then I ate it.

See, mobile objects really do work!

Setting up an IIS6 Application Pool Identity

2006-04-19T16:36:00.000-05:00

Often times it's necessary to run an ASP.NET application under a different user account than Network Service. Usually this is the case when Network Service doesn't have enough rights to access necessary application resources like a database or a file share on a different server.

Here's how to configure a different account (local account or domain account) so it has sufficient permissions to run an IIS6 Application Pool for ASP.NET applications:

Add the account to the local IIS_WPG security group.
Open the Group Policy Editor for the local computer (gpedit.msc)
Drill down to: Local Computer Policy/Computer Configuration/Windows Settings/Security Settings/Local Policies/User Rights Assignments
Add the new identity account to the following polices:
- Adjust memory quotas for a process
- Logon as a service
- Replace a process level token
If your web application is going to host any web services, you need to also give your account Delete access to the C:\WINDOWS\Temp directory. Note: this is done via the Advanced dialog in the Security page of the Explorer folder properties dialog box.

References:

Building a virtualized Team Foundation Server development environment

2005-11-19T01:55:00.000-06:00

Given the recent RTM release of Visual Studio 2005 and all the hype around Team Foundation Server, I wanted to build a development environment where I could play with both. So, I finally managed to do it using Virtual PC. I thought I’d share the knowledge of what took me several hours (days, rather) to complete.

My goal was to virtualize a development environment that contained a TFS server and one or more clients. I’d heard that one needed to install TFS within an Active Directory domain. However, after reading the install documentation, I found that to only be necessary if the data tier (SQL Server 2005) and the application tier (TFS) were to be run on separate machines; this is what the doc calls a Dual-Server Deployment. On the contrary, if both the data and application tiers are installed on the same machine (Single-Server Deployment), a domain is optional.

But since many development shops will have Active Directory running, I wanted to simulate it. So, one option would be to install all of TFS on a single machine that was also a Domain Controller. However, it is also common knowledge that installing TFS on the Domain Controller itself is problematic (at least it has been with previous TFS betas). Given all that, I decided to build three virtual machines:

A stand-alone Domain Controller – 256 MB RAM
The “TFS server” with SQL Server 2005, Windows Sharepoint Services SP2 (another prereq for TFS), and Team Foundation Server itself – 512 MB RAM
A client machine with a Team Edition of Visual Studio 2005 installed (in my case, I have access to a licensed copy of Team Edition for Software Developers) – 512 MB RAM

The total RAM requirement was 1.5 GB, which fit my memory budget since my host OS (Windows XP Pro on a Dell Latitude D600 laptop) has 2 GB.

To build all of this, I needed the following software “ingredients”:

A base VM image of Windows Server 2003 that had been Sysprep’d. Make sure this image either has a local copy of the Windows Server 2003 install CD’s I386 directory or you have the CD or an ISO handy. I’m going to use this base image for all three machines, even the client. However, one could just as easily build the client with Windows XP
A handy copy of the Team Foundation Server install documentation (TFSInstall.chm), which can be found on the CD/ISO
A SQL Server 2005 install CD/DVD or ISO (Standard or better). In my case I had Developer Edition
The install for Windows SharePoint Services 2.0 with SP2, which can be downloaded here
The Team Foundation Server, Beta 3 Refresh CD or ISO
A Microsoft Office 2003 CD or ISO that contains both Word and Excel.
The Microsoft Project 2003 Professional CD or ISO
A Team Edition Visual Studio 2005 install DVD or ISO

And, finally, here is the list of steps I took to cook it all up:

Build the Domain Controller VM
The domain controller will host a private Active Directory domain. As a bonus, it will also act as a gateway router to the outside world. If any of the machines in the local virtual network require outside (i.e. internet) access, the 2nd network adapter on this machine can be bound to a physical network interface on the host machine, and Routing and Remote Access will provide NAT access to the outside. This capability will actually be called upon when we build the client VM later in this post.

Create a new VM by copying the base Windows Server 2003 VM files.
In the VM Settings, set the memory to 256 MB.
Change the network adapter to Local only.
Add a second network adapter and bind it to one of the host OS’s network adapters.
Start the VM and let it run through all of the initial Sysprep setup stuff.
Log in as the local administrator.
Change the guest OS network connection bound to Network Adapter 1 so that it has a static IP address. I went with these settings:

IP: 192.168.100.1
Subnet Mask: 255.255.255.0
Default Gateway: 127.0.0.1
Change the VM’s computer name to something meaningful. I went with W2k3TFSB3R-DC. A side note: computer names should be limited to 15 characters or less since that’s the max length of a NetBios computer name.
Run the Configure Your Server Wizard (Administrative Tools). The wizard will automatically suggest that you make the server a domain controller, a DNS server, and a DHCP server. And, since you have two network adapters, it will also suggest installing Routing and Remote Access. Do all of this. I chose to use tfs.local as the Active Directory domain name. This will require a reboot.
In the VM Settings, change the binding of Network Adapter 2 to Not connected. This will keep the network of VM’s completely isolated from the outside world. If you need to connect them for any reason, you can always reconnect the adapter to a physical adapter.
Create the following domain accounts and allow them to remain in their default security group (Domain Users):

TFSSETUP – This will be used when running TFS setup on the TFS server and will also automatically be joined to the TFS Administrators Application Group
TFSSERVICE – Used as the identity for TFS Windows services
TFSREPORTS – Used by SQL Server Reporting Services
TeamDeveloper – User account of the developer on the client machine
Leave this VM running.

Build the TFS Server VM
The TFS server will host all of the Team Foundation Server server-side components (application tier) as well as the supporting database (data tier). It will also host Team Foundation Build, which enables automated builds. The kicker is that in order to perform testing and code analysis in the build, a Visual Studio Team SKU needs to also be installed on the server. Luckily, VS Team licensing is per-user, and not per-machine, so installing VS on the server won't break the budget. In our case, we will be installing the same VS SKU on the server as the client machine.

Create a new VM by copying the base Windows Server 2003 VM files.
In the VM Settings, set the memory to 512 MB.
Change the network adapter to Local only.
Log in as the local administrator.
Change the VM’s computer name to something meaningful. I went with W2k3TFSB3R-SVR. And while you’re doing this, join the computer to the tfs.local domain. This will require a reboot.
Log in as the domain administrator (TFS\Administrator) instead of the local administrator.
Add the TFSSETUP domain account to the local Administrators security group.
Run the Configure Your Server Wizard and turn on the Application Server role, which will enable IIS (make sure to allow ASP.NET).
Install your copy of Visual Studio 2005. You really only need to install the bare minimum since this VS install is solely there to support Team Foundation Build. Therefore, the only components necessary are the following:

Microsoft Visual Studio 2005 Team Edition >
Team System {your SKU} Tools >
- Code Analysis Tools
- Testing Tools

where {your SKU} is the version of Visual Studio Team Edition that you have (in my case, I have Team Developer).

And of couse, you don't need to install MSDN.
Install SQL Server 2005 using the instructions found here in the TFSInstall.chm file:

Overview of Team Foundation Server Single-Server Deployment >
Installing Team Foundation Server >
How to: Install Microsoft SQL Server 2005 for Team Foundation Server (Single-Server Deployment)

NOTE:
I would advise using the TFSQL2005AnswerFile.ini answer file approach, which is explained at the bottom of the doc page under the section: To install Microsoft SQL Server 2005 using an answer file.
Install Windows SharePoint Services 2.0 with SP2 using the instructions here in the TFSInstall.chm file:

Overview of Team Foundation Server Single-Server Deployment >
Installing Team Foundation Server >
How to: Install Microsoft Windows SharePoint Services for Team Foundation Server (Single-Server Deployment)
Log off and log back in as TFS\TFSSETUP.
Install Team Foundation Server using the instructions here in the TFSInstall.chm file:

Overview of Team Foundation Server Single-Server Deployment >
Installing Team Foundation Server >
How to: Install Team Foundation Server
Install Team Foundation Build using the instructions here in the TFSInstall.chm file:

Overview of Installing Team Foundation Build >
How to: Install Team Foundation Build
Leave this VM running.

Build the TFS Client VM

The TFS client will contain all client-side development tools as well as the client-side software for accessing Team Foundation Server, which is called Team Explorer. Team Explorer is not its own application, but rather a set of add-ins that integrate seemlessly with Visual Studio 2005. The TFS client machine will also host a local instance of SQL Server 2005 as well as all of the SQL Server developement tools that come along for the ride.

Create a new VM by copying the base Windows Server 2003 VM files.
In the VM Settings, set the memory to 512 MB.
Change the network adapter to Local only.
Log in as the local administrator.
Change the VM’s computer name to something meaningful. I went with W2k3TFSB3R-C-TD. And while you’re doing this, join the computer to the tfs.local domain. This will require a reboot.
Log in as the domain administrator (TFS\Administrator) instead of the local administrator.
Add the TeamDeveloper and TFSSETUP domain accounts to the local Administrators security group.
Log off and log back in as TFS\TeamDeveloper.
Install Microsoft Office 2003 from your Office CD/ISO. At a minimum you need to install Word and Excel (complete installs of each). This is a prerequisit for the upcoming Team Explorer install.
Install Microsoft Project 2003 Professional (complete install) from your Project CD/ISO. This is a prerequisit for the upcoming Team Explorer install.
On the domain controller VM (W2k3TFSB3R-DC), bind the Network Adapter 2 to one of your physical network adapters. This should allow all the VM’s access to your physical network (and presumably the internet) via Routing and Remote Access. If this doesn’t work, you can always set the Network Adapter of the TFS Client from Local only to one your physical network adapters.
Perform a Microsoft Office Update.
On the domain controller VM (W2k3TFSB3R-DC), set the Network Adapter 2 back to Local only.
Install your copy of Visual Studio 2005. Make sure you specify to install SQL Server Express. We’re going to also install the full version of SQL Server 2005 in the following steps. However, there are advantages to having both installed; one of them being many of the sample apps that come with Visual Studio only seem to work with Express.
Install the MSDN Documentation that comes with Visual Studio 2005.
Install SQL Server 2005. I have the Developer Edition and chose to install the following components:

- SQL Server Database Services
- Reporting Services
- Integration Services
- Client Tools, Books Online

You may be prompted that some of the components are already installed (since we installed SQL Server Express earlier via Visual Studio). Make sure to re-check any components that it asks for at this point.
Install Team Explorer using the instructions here in the TFSInstall.chm file:

Overview of Installing Team Explorer >
How to: Install Team Explorer
Open Visual Studio 2005 and connect Team Explorer to the server (W2k3TFSB3R-SVR) using the instructions here in the TFSInstall.chm file:

Overview of Installing Team Explorer >
How to: Connect Team Explorer to Team Foundation Server

That’s it! ;-)

Now you’ve got a handy virtualized Team Foundation Server development environment, complete with the build server (Team Foundation Build) that you can use to play around with, demo, and even develop real code using TFS.

Good luck!

Version Tolerant Serialization

2005-05-05T10:50:00.000-05:00

Sorry, I haven't posted anything to my blog in a while (not that anyone was holding their breath... well, except for maybe Jason :-) )...

I've done a thing or two with .NET Serialization and Remoting in the past and presently I'm doing some stuff where we're considering all of the transport options that come with .NET: Remoting, Web Services, Enterprise Services, and the soon-to-be new kid on the block, Indigo. Recently, I watched an MSDN TV show with Matt Tavis on the new features added to Remoting coming up in .NET 2.0. I think its great that their expanding the functionality of Remoting (especially since many were claiming that it was dead back when Indigo was first announced). The reality is that they're adding some really cool features. At a high level they are:

A new channel called the IPC Channel which is optimized for same-machine inter-process Remoting. It uses named pipes instead of TCP/IP for communication.
An option to secure the TCP Channel using SSPI-based security that is offered in the new System.Net.Security namespace.
Socket cache control
Generics support
IPv6 support
Version tolerant serialization

That last feature is the one I'd like to comment on. Technically this new feature isn't specific to Remoting, but is a part of .NET Serialization, which is broader technology used by Remoting.

VTS and Remoting
In .NET 1.x if you serialized an object of a given type and then deserialized using a newer version of that type and the new type had additional (or removed) fields, you would get seriaization errors. The only work around was to implement the ISerializable interface. However, this approach was crude as you were responsible for reading and writing directly to the serialization stream and things got worse when you wanted to serialize an object hierarchy. Microsoft's answer to this issue is Version Tolerance Serialization. VTS essentially adds 5 new attributes to the System.Runtime.Serialization namespace that allow you to mark fields as optional (these would be used with the new fields on the new type) as well as mark methods in your class for handling specific events in the serialization/deserialization process. In a Remoting scenario, what this lets you do is update a type on the server-side to a new version and let the client-side versions remain the same, without throwing serialization errors.

Now, in and of itself, this is pretty cool. But I think its worth it to take a moment to offer up a word of caution. There's a reason why the original serialization mechanism was version intolerant (and it wasn't just because the Microsoft developers were too lazy to add tolerance support). If the object you're serializating across the wire is nothing more than data, then this new feature is fairly safe. But if you're actually remoting objects that are more object-oriented (both data and logic together) then caution needs to exercised. While VTS may prevent serialization (i.e. schema) errors from occurring, it won't stop differences in logic between the two type versions from totally hosing up your application. In other words, when you code up version 2 of the serializable object, you better be thinking about version 1, version 1.5, and any other version between what the client was compiled against and what you've got sitting in your IDE. The question to ask when considering this new feature is this: is it more work to force clients to always get the latest binaries or to add backward-compatibility support to my new type? I think in many cases it's more complex to do the later. Especially when you consider many of tools we have today that allow client applications to automatically update their binaries.

So, in a Remoting scenario where you allow the client and server to version independently I think one needs to exercise caution (and a lot of good unit testing) before hailing this feature as the answer to all our versioning problems. Throwing a new version of a type onto a server with minimal effort to support backward compatibility will lead to a lot of very hard to debug application errors and may even lead to bad data getting persisted to the database. Rocky Lhotka talks more about this problem is a more generic scense in this article on TheServerSide.net.

Howerver...

VTS in General
I think there is a scenario where this new feature shines without the aforementioned caviat. I was on a project once where we used serialization to persist objects to disk instead of persisting them to a traditional RDBMS. The application was a desktop app similar to Microsoft Word where the user worked with "documents" and could save and load them as files. It seemed like a natural fit to have the document be some kind of object model that was persisted to and from disk via serialization. Everything worked fine until we started thinking about version 2 of our app. While there were ways to relax the versioning restrictions in in .NET 1.x serialization when the schema didn't change, the moment we added new fields to our types, the fated serialization errors occurred.

But this scenario was different than Remoting in that we only had to worry about the difference in type data (schema), not logic. This is because we were not interoperating with the older type. We just had to figure out a way to transform data serialized by an old type so that it would fit the schema of a new type. In the end, we ended up writing an elaborate upgrade system that would parse the serialized data itself (which in our case was SOAP XML) and transform it to a newer version, adding fields as necessary. This was not an ideal solution. First, it was very complex. Second, it essentially broke the rule of encapsulation, since the upgrader tool had to have intimate knowledge of the fields of the type is was upgrading. It would have been better to place the responsibility of managing new fields of a type within the type itself. I believe the new VTS features of .NET 2.0 allow us to do just that and with minimal effort.

Clearscreen CAPTCHA Control now supports CS 1.0!

2005-04-05T00:42:00.000-05:00

Wow, that didn't take long. Miguel Jiménez has updated his CAPTCHA control to version 1.4 and it now works with Community Server! And here I was all set to hack the source code myself so I could get something up and running. Oh well, I've got better things to do with my time anyway. ;-)

And the good news is that it actually works! Check it out; it's running on my site.

Evolution and creation in the classroom

2005-03-28T12:34:00.000-06:00

Check out this interesting discussion on a recent news article talking about a possible Florida mandate to force equal time in the college science classroom for both evolution and creation.

Feel free to chime in; unlike my (insert adjective here) blog engine, Jason's accepts anonymous comments.

Community Server and CAPTCHA

2005-03-23T14:58:00.000-06:00

So far I've been pretty thrilled with Community Server as my blog engine. One of the things I didn't set up right away was anonymous comments for my blog entries. I wasn't sure how CS would handle spam comments, so I left it disabled for the time being. Well, after doing some research this evening I found a few things about controlling spam comments in a blog and, specifically, in CS:

The most popular deterrent is to implement a CAPTCHA control.
A very popular CAPTCHA implementation for ASP.NET is Miguel Jimenez's Clearscreen SharpHIP HIP-CAPTCHA Control.
The Clearscreen SharpHIP HIP-CAPTCHA Control was specifically designed with the .Text blog engine in mind, the predecessor to Community Server. However, it can be used with any traditional ASP.NET web form.
And, one more minor thing: the Clearscreen SharpHIP HIP-CAPTCHA Control doesn't work with Community Server.
Rats.

Community Server does some pretty funky stuff with the request URLs, which, I'm sure is what's hosing up the control. Anyway, I'm going to keep an eye on Miguel's blog to see if he posts an update that's compatible with Community Server.

If anyone else out there has a better solution (besides using a different blog engine), please let me know. Of course, you're going to have to log in to my CS site in order to leave that comment. Oh, the irony.

Archiving Outlook

2004-09-09T09:17:00.000-05:00

I’ve finally discovered a useful reason to keep a blog ;) – it’s a good place to write down how you did something (solved a problem) so you can, by some fluke of a chance, go back years later and recover the solution. Of course, with problems and solutions that involve technology, chances are you’ll never run across the same problem again (at least not in the same form), but hey, at least you can show the world how you did it.

My problem was that of properly archiving Outlook email. For years I’ve used Outlook for both work and personal email and have throughout those years archived emails to Outlook’s proprietary .pst file (Personal Folder File) format. PST files are great in that in one giant file you can store it all – emails, contacts, calendar and task items, etc. The problem with them is they can really only be opened by Outlook and when Outlook opens one, it needs read/write access to the file. This later point isn’t a big deal until you’ve burned all of your PST files to a CD-ROM. Outlook can’t open them when they’re sitting on a CD, which is a read-only format. So in the untimely event that you want to search for an email, you have to copy each PST file from your CD to some place that’s read/writable (like your hard drive). Typically the PST files are quite large so this can be a very cumbersome and painful process (especially if after the search you still didn’t find that email you were looking for).

A more desirable archive format would be to have all of the emails in separate text files that conformed to the RFC-822 format (circa 1974 or whatever date that RFC hit the streets). These files typically have the .eml file extension and just about any email client can open them (hehe, except Outlook). If you don’t have one handy you can always use good ‘ol Notepad.
Unfortunately the road from PST to .eml was a bit rocky and I had to play around with several different techniques to finally find a process that seemed to work well. My first thought was to import all of my email into Outlook Express. You can drag and drop emails from Outlook Express to Windows Explorer and it will create individual .eml files for each email for you automatically. Unfortunately, it has a very limited file naming scheme (it uses {email subject}.eml as the file name); if two emails have the same subject, it doesn’t know enough to give the second .eml file a unique name. The other thing is it would be nice to have more control over names of the .eml files. Names with only the subject in them don’t make for very easy browsing.

Fortunately, someone out there had the same opinion and developed an application called Express Archiver. This handy app reads the folder structure of an Outlook Express profile and allows you to archive the contained messages in a number of ways, including as separate .eml files. It also allows you to customize how those .eml files are named. I chose to use the {date}{from}{subject} as the naming scheme of my Inbox emails and {date}{to}{subject} as the naming scheme of my Sent Items.

This application worked very well. The only “difficult” part was jumping between Outlook, Outlook Express, and Express Archiver to move emails from the PST format all the way to the nice archive-friendly .eml file format. But once I got the hang of it, it wasn’t too bad. As a final touch I was able to zip up all my .eml files and they compressed down a smaller size than even the PST files did. They can also live on a CD and I can browse and search them without having to use Outlook or copy them to my local hard drive.
Very cool!