Latest News from Kevin Hoffman

Would You Like to Touch My Mono?

Mon, 23 Nov 2009 22:00:00 EST

At one point I was actually thinking about writing a book for .NET developers to learn Cocoa but other plans, time constraints, and life issues all got in the way. I have posted countless times comparing the worlds of Cocoa and .NET and have twice presented at Apple's WWDC comparing both the desktop and mobile programming environments of Apple and Microsoft. So you can imagine the raw, unfiltered, pure geek joy that coursed through my veins when I heard about Monotouch, a programming library coupled with an IDE (MonoDevelop + Interface Builder) that would let me write my iPhone applications using C# and the .NET Framework (the mono version).

Kindle 2 vs Nook

Thu, 19 Nov 2009 06:30:00 EST

Barnes & Noble just recently unveiled their upcoming eReader, the Nook. On the blog of my non-techy alter-ego I've posted a comparison of the two readers that is entirely based on my own personal feelings of what is cool and what isn't, so take it as opinion and certainly not as a technical review. Click here to check out the blog post.

Windows Identity Foundation (WIF) Release Candidate Is Out

Tue, 17 Nov 2009 13:45:00 EST

I'm not sure how all this managed to slip by me, but apparently last Friday the Windows Identity Foundation Release Candidate was unleashed on the world. Now keep in mind that this is not the ADFS v2 server, this is the foundational plumbing on which ADFS v2 will run. Good news, though, is that if you're like me and you're using WIF to build your own STS websites, then the RC will suit you just fine and you don't have to wait for the ADFS v2.

Anyway, if you'd like to get your hands on some WIF action, click here for the download link.

It doesn't appear as though there are a lot of changes in the framework itself, though I think there are some possible breaking namespace changes but, I'm still downloading it so I don't know at this point. Also, you might want to pick up the Identity Training Kit. It has been revised and there's a new installer for the samples that works on Windows 7 that actually works and installs the SSL certs properly. Previous versions of the ID kit required lots of manual futzing around to get things to work properly with UAC and permissions and the whole "Internet Zone" download issue.

Enjoy!

Setting up an ASP.NET MVC 2 Application for Windows Azure

Tue, 17 Nov 2009 13:30:00 EST

Yesterday, Microsoft released another update to the Windows Azure SDK. This update includes a truckload of new goodies that I will be covering in additional blog posts. For this blog post, however, I want to walk you through getting an ASP.NET MVC 2 application working on Windows Azure in Visual Studio 2010 Beta 2. Now that Azure and VS2010 are finally starting to sync up, the amount of raw goodness coming out of Redmond cannot be measured. First, install the Windows Azure SDK and the Windows Azure Tools for Visual Studio, making sure you pay attention to all of the installation details. There are lots of little hotfixes and things that you might need. Luckily, if you're running VS2010 Beta 2 on Windows 7, you have very little extra work to do beyond configuring IIS 7 for WCF HTTP activation.

Getting the ASP.NET Providers Working on the Azure Nov 2009 CTP

Tue, 17 Nov 2009 13:30:00 EST

If you've been trying to get the ASP.NET providers working on the November 2009 CTP of Windows Azure then you may have run into a snag, or a couple snags if you're using Visual Studio 2010. First of all, if you're using Visual Studio 2010 Beta 2, then you're going to need to either up-convert the AspProviders project. For this, you want to go and grab the AspProviders (VS2008) sample from the Azure Code Samples home page. Once you've got it, you can either compile it in Visual Studio 2008 or, if you're coding in VS2010 Beta 2, you can either reference the compiled binary directly or just up-convert the project to VS2010 Beta 2.

Working with Table Storage on the Windows Azure

Tue, 17 Nov 2009 00:00:00 EST

If you've been working with Azure for a while then you've probably spent some time using the StorageClient sample that came with previous versions of the SDK. With the November 2009 release of the SDK (the one they'll be using at PDC 2009), they have wrapped that sample up into the SDK and refactored it to fit more in line with the conventions and quality standards of a Microsoft API. As a result, some of your code will break (but not much). Queue storage and Blob storage (discussed in upcoming posts) actually have more breaking changes than table storage.

Table storage, under the hood, is exposed as an ADO.NET Data Service (formerly Astoria). As a result, if you've used the System.Data.Services.Client library before, you've already got a leg up in interacting with Azure Storage.

When you're working with table storage, there are a few things that you're going to need. Once you've got these, you're good to go:

References to System.Data.Services.Client and Microsoft.WindowsAzure.StorageClient (obviously you also need a reference to service runtime if you're hitting table storage from within the cloud itself... remember that you can hit table storage from the desktop too, e.g. from WPF applications).
Credentials. There have been some changes to the way storage client credentials work that are beyond the scope of this post, but you can still use the same accountname/account shared key pattern that you used in the past.
A DataServiceContext. You're going to need this to interact with the tables in table storage. As you'll see in the code below, the pattern is to create your own context that derives from the base and exposes your tables as IQueryables. If you've ever worked with ADO.NET Data Services or Entity Framework before, this pattern should also look familiar.
Entity objects. Every table that you have in table storage contains arbitrary columns. In other words, if you really wanted, you could have a different schema for every row in your table. However, to work with it using the Data Services client, each row needs to conform to a fixed schema - this fixed schema you'll represent with a regular C# class that contains the necessary partition key and row key properties. This class also needs a parameterless constructor (required by the data services client to reconstitute instances of that class from the HTTP results)
The cloud table client. This new class will let you create tables and test for the existence of tables. You do not need to use this class for querying table storage, it's more of an administrative class for dealing with table storage itself.

The first thing we're going to want to do is get the credentials. The new SDK allows us to dynamically determine if we're running in a fabric or running as a standalone app (which allows us to build apps that we can run on-premise OR in the cloud!). Here's some code I used to get the configuration settings for the account name and shared key:

string accountKey = ConfigurationManager.AppSettings["AccountSharedKey"];
string tableBaseUri = ConfigurationManager.AppSettings["TableStorageEndpoint"];
if (RoleEnvironment.IsAvailable)
{
accountName = RoleEnvironment.GetConfigurationSettingValue("AccountName");
accountKey = RoleEnvironment.GetConfigurationSettingValue("AccountSharedKey");
}

Once you've got the account key and the account name, you can get an instance of the storage credentials and table client classes:

StorageCredentialsAccountAndKey creds =
new StorageCredentialsAccountAndKey(accountName, accountKey);
CloudTableClient tableStorage = new CloudTableClient(tableBaseUri, creds);
CustomerContext ctx = new CustomerContext(tableBaseUri, creds);

Using the table storage class, we can create a new table (if it doesn't already exist):

if (tableStorage.CreateTableIfNotExist("Customers"))
{
CustomerRow cust = new CustomerRow("AccountsReceivable", "kevin");
cust.FirstName = "Kevin";
cust.LastName = "Hoffman";
ctx.AddObject("Customers", cust);
ctx.SaveChanges();
}

Here I'm also using my customer context class and my customer row class (will show those shortly) in order to put a new customer into table storage. Note my use of an application name for the partition key and the username for the row key. Entire chapters of books can (and will) be written on strategies and patterns for using partition and row keys.

Now let's say that we're inside an MVC 2 controller and we want to make the list of customers available to the view. If we're not doing a strongly typed view (which we should be doing unless we can't help it...) then we can use code that looks like this:

CustomerRow[] customers = ctx.Customers.ToArray();
ViewData["Customers"] = customers;

Now let's look at the CustomerContext class:

public class CustomerContext : TableServiceContext
{
    public CustomerContext(string uri, StorageCredentials creds) : base(uri, creds) { }
    public IQueryable<CustomerRow> Customers
    {
        get
        {
            return this.CreateQuery<CustomerRow>("Customers");
        }
    }
}

The CustomerRow class is just a POCO class that has a default constructor and a constructor that takes a partition key and a row key, and inherits from the TableServiceEntity class.

public class CustomerRow : TableServiceEntity
{
    private string firstName;
    private string lastName;
    private string userName;
    private string applicationName;

    public CustomerRow(string applicationName, string userName)
      : base(applicationName, userName)
    {
      ApplicationName = applicationName;
      UserName = userName;
    }

public CustomerRow() : base() { }

I snipped out the rest of the class for brevity - I'm assuming we've all seen stock property accessors before. At this point you should be ready to roll using table storage. There is also one other benefit they gave us in November 2009 CTP - you no longer need to pre-rig your database schema in your SQL 2008 database!! The new development storage simulator accurately simulates the dynamic schema nature of the actual table storage in the cloud. I can't begin to describe how many headaches this alleviates.

Enjoy table storage on the new Nov 2009 CTP and I'll be posting similar blog posts about the new Queue storage and Blob storage clients shortly!

Installing Geneva Beta 2 on Windows7

Thu, 05 Nov 2009 08:38:00 EST

Recently I installed the Beta 2 version of "Geneva", or ADFS 2.0. All of my machines are now Windows 7 machines, including just about all of my VHDs and virtual machines. The only time I use Win2k8 R2 is when the product I'm installing specifically requires me to do that. So when I installed Geneva on my Win7 box, I thought everything would be fine.

Then I rebooted. The "Modify STS Reference..." and "Update federation metadata" menu items that are supposed to be added to the list of available options on an ASP.NET web application were gone. They were there before I rebooted but they were gone after. I also noticed something funny with the Identity training kit install. Every single directory and file in there was marked as "read only". I would unset the read-only flag, right click the file, get properties, and sure enough, it was still set to read only. WTF?

Turns out that when I download files from the big bad scary internet, Windows 7 automatically flags them as "bad content" and they are blocked. The permissions of those files are significantly less than those of files I put onto my computer via DVD or whatever. This is actually as it should be, and it's designed to keep me from doing horribly bad things to my computer.

I uninstalled the Geneva SDK and the Identity Training Kit. I then right-clicked each of the .msi files, chose Properties and then clicked the magic Unblock button. After this, when I installed the Framework SDK, the Visual Studio extensions remained after reboot, and the files created by the identity training kit didn't have weird permission problems and the certificates installed by the lab set up actually bound to the SSL port properly.

So, the moral of the story is this: If you're going to install an MSI that you downloaded from a trusted source (like MSDN or Microsoft Downloads or h0tpr0n.com), unblock it before you install just to make sure you don't run into any goofy permission issues.

Why we're all NOT going to die on December 21st, 2012.

Wed, 04 Nov 2009 16:02:00 EST

Unless you've been living under a rock for the past couple of months, you've probably not been able to escape the movie trailers, hype, and even SyFy channel (yes, SYFY channel..that should TELL YOU SOMETHING) specials regarding the Mayan "prediction" that the world will end in 2012.

First, some background on the Mayan calendar. The "long count" Mayan calendar is based, basically (I am oversimplifying a little bit), on interlocking wheels. You can think of these as gears where as the days pass, a bigger gear of seasons pass, which then slowly causes another bigger gear to pass. Finally, you end up with a gear that marks the passing of ages that marks the passage of a total of 26,000 years. There are 13 of these ages on the "big gear".

The Mayan long count calendar reaches 13.0.0.0.0 on December 21st, 2012. Does this mean that the world is going to come to an end on that date? Does this mean that a huge apocalypse is going to rip the earth apart in huge explosions and other hollywood-like demolitions? Are we all going to cease to exist as time itself comes to a crashing halt?

UM. NO.

What we're looking at here is the Mayan equivalent of the Y2K problem. The Mayans, when constructing their calendars and the wheels/gears/ whatever they call them - constructed them to mark the passing of 26,000 years. When you think about how long that is, its a ridiculous amount of time. They probably said to themselves, "Nobody is ever going to need more than 26,000 years on a calendar." Well, let's see. Where have we heard that mistake before? Oh yeah: No one is ever going to need 4 digits to store a year in a piece of computer software.

So if you're smart, you'll get people to give you all their worldy possessions on December 20th, 2012. Then, on December 22nd, 2012 - sell them all back at a premium. Call it the "sucker surcharge", a fee for being such a gullable moron that they believed the world was going to end because a civilization without the ability to predict the future basically ran out of storage space in their gear-based calendar system.

I personally am thinking of having an "end of the world" party on December 21st, 2012. I had one on Jan 1, 2000 and I'll be there laughing at the mindless masses as they cringe in expectation of doomsday. I should be able to pick up some dirt cheap real estate, too.

Something Wicked This Way Comes - Breaking Changes for .NET Services in Azure

Mon, 02 Nov 2009 08:36:00 EST

If you want the full gory details, check out the .NET Services team blog post here. What follows below are some of the things that I think are most crucial to understand both for new developers and for developers unfortunate enough to be in a position of having to migrate a lot of code. Quite possibly the single most important thing to note is this:

If you bought a book on Windows Azure that has already been released or will be released within the next month or two, it is out of date and completely irrelevant. PDC (along with the changes I'm going to outline below) will substantially change all of the Azure offerings.

I've trimmed a little bit because some of the breaking changes are fairly minor and don't have too much impact on developers. Here is the list:

Portal address change. This is an easy enough fix and a simple find-and-replace if you've got any code that uses that portal address.
Solution region migration. Some solutions when migrated to the new version of .NET Services might end up hosted in a different geographical region than before. This isn't all that big of a deal (for most of us).
Queues Are Being Removed. This is huge. In the current version of .NET Services, you can use queues as a way of sending reliable, durable messages between the cloud and on-premise applications without the other endpoint being physically connected. This is a huge change. A new concept called Message Buffers are being introduced. I don't have all that much information on them but it looks as though the message buffers are essentially transient queues. You send a message to a buffer and it'll hang out in the buffer while the other end steadily pulls messages out of the buffer. A key point they make is that if you're looking for durable, reliable, persisted messages between service bus endpoints, you might want to look at using Azure Storage. As painful as it is to see queues go, I think this is a good move. Azure storage already has Queues, and they are robust and powerful. If the reason you were using Queues was to keep from overloading an endpoint with too many messages, the message buffer is your new tool of choice. If you were using Queues so that you could send messages while the polling end was offline, then you're probably going to need to concoct something involving an Azure Storage queue.
Routers Are Being Removed. This is also huge, though slightly less huge than queues. The router concept never really "gelled" with me to begin with - I couldn't quite figure out how best to use it. Now that they're being removed and there will be some samples on how to do things like load balancing and targeted delivery, architectural decisions in this area should become easier to make.
Relay Bindings are now secure (HTTPS) by default. You can override this behavior but there's very little reason to do so unless you are specifically trying to get your security information stolen.
Service Namespace. Now instead of the solution name being the hostname of your *.servicebus.windows.net server, you will be able to choose something called the service namespace and have that be the hostname prefix, e.g. (namespace).servicebus.windows.net. This has low impact but is actually very useful.
TransportClientCredentialType is being limited. Transport client credentials can no longer include X509 certificates, username/password combinations, or CardSpace cards.
TcpRelayConnectionMode.Direct will be removed. This bugs me a little bit because way WAY back when Azure was first unveiled to the public, I remembered talking to someone who said that we'd be able to use the service bus to establish direct connections between two peers both of whom were behind firewalls. This is no longer a possibility, but I can see the reasoning behind it and, quite frankly, my particular use case for this feature was really niche-y.
Service publishing feed now matches transport. This is handy and makes things a little more straightforward. For those who don't know, a service publishing feed is basically an Atom feed that shows all of the endpoints on your service bus service that have indicated they want their presence known publicly. In other words, I could hit the service publishing feed and get a list of all connected endpoints. That one ability is ridiculously powerful and is not getting nearly enough hype for the number of scenarios it enables.
WSHttpRelayBinding has been removed. I'm not gonna miss this one bit as I never used it.
WS2007FederationHttpRelayBinding removed. Again, not gonna miss it.
Solution credentials replaced with issuer credentials in Access Control Service. This one is also quite big. Today, you can use a username/password combo, an X509 cert, or a CardSpace card to request tokens from the STS. As of Thursday, you're going to need an issuer credential (issuer key and issuer name). In addition, we're going to have to upload X509 certs to the portal to allow for SAML token requests. I will probably be doing a blog post on this once I get more information because this one is totally game changing and will halt development workflow as it stands now and totally change it after Thursday.
WS-Trust STS replaced with Web Resource Authorization Protocol (WRAP) STS
- Yes, I made this one gigantic. Why? Ding dong the witch is dead! The wicked witch is dead! WRAP is RESTful people. WS-Trust is EVIL people. Enjoy. We've all just been given a shiny cupcake with a frosting of awesome on top.
Access Control Service data will not be migrated. This means if you're one of those crazy early adopters and you've already written a complete app on the existing ACS - get your data backed up and saved somewhere now. It will be deleted on Thursday morning!
Access Control Management Portal is being replaced with a command-line tool. I know some of you might be thinking, dammit! But I see this as a good thing. It's an absolute pain in the ass to stop what I'm doing and click through 8 billion links (including the 500,000,000,000,000 redirects involved with a Windows Live ID login) just to go tweak some small setting. I could probably take 20 minutes to rig up a couple .cmd files to do regular ACM tasks that are specific to my app and be done with it. This is going to be a big productivity gain, even though we lose some flashy web-based GUI.

Here's the bottom line:

Windows Azure (including Azure Storage, SQL Azure, and .NET Services) is maturing. It is moving away from being an experiment and moving toward a product that can sustain regular income and regular usage and the 90% customer usage scenarios. As a result, they're going to break changes and add features and shut off lame or ineffective or almost-never-used features.

Can't wait to get my hands on the new bits Thursday.

LINQ to SQL and Entity Framework on top of SQL Azure

Sat, 31 Oct 2009 18:00:00 EDT

As mentioned in my previous blog post, you don't get full designer support on SQL Azure within SQL Server Management Studio. In addition, you don't get designer support for LINQ to SQL or Entity Framework, either. So what do you do if you want to take advantage of these awesome object mapping tools but the designers don't work directly against the cloud?

Conveniently enough, if you follow the tips in the previous blog post, you would have already created a local copy of your SQL Azure database. The "trick" (not really a trick at all, just not immediately obvious) is to point your EF or LINQ to SQL Visual Studio projects at your local database. This will give these mappers the schema and relationship information they need in order to create the appropriate conceptual<->relational mappings.

For LINQ to SQL, all you need to do is replace the connection string that it adds to your app.Config file with the connection string supplied by the sql.azure.com portal. Remember to include your password in this connection string because the portal copies a version of this string to your clipboard with the password of myPassword. At this point you should also be thinking to yourself, "Wow, I just put a cleartext password in a .config file. It's a really good thing that this code isn't going to sit on someone's desktop and will be protected in the cloud."

With Entity Framework, the connection string is a little more complicated. There's some entity stuff in there that points to the various model definition files in the project and then there's an embedded connection string. Replace the embedded connection string (take care to maintain the escaping of nested quotes, etc) with the one the SQL Azure portal supplied and change the password to reflect the right password.

At this point you should have been able to generate a model from your local database and then change the connection string so that the actual data comes from the cloud database. It might seem a little inconvenient but it isn't really all that bad. It just adds a few extra steps to your SDLC when you need to change the schema of a live application.

The feeling I got when I ran my first LINQ to Entities query against a cloud-based SQL Server database was overwhelming. Sure I love new technology as much as the next guy, but the possibilities that are being opened for developers by Windows Azure and cloud computing in general are so numerous it's hard to contain myself.

This is a damn good time to be a developer.

Creating and Manipulating Your SQL Azure Database

Thu, 29 Oct 2009 11:45:00 EDT

So after the long and torturous wait, you're now in the SQL Azure CTP and you are ready to get the ball rolling with your fabulous, shiny new cloud-based SQL database server. Now what? Well, the first thing you're going to need to do is create a database.

To do that, you'll go to sql.azure.com and follow the directions to sign in - if you haven't already supplied the invite key you'll need to supply it after you sign in the first time. Select your project and click on it. At this point you'll see a pretty sparse management screen with two tabs: databases and firewall settings. On the database tab, create a new database (its up to you whether you create a 1GB or a 10GB max database). After you've created it, you'll be able to click the Connection Strings button to get an ADO.NET connection string for the database as well as an ODBC connection string.

That's great, but how do you manage the schema? Can you just fire up SQL Server Management Studio (SSMS) and right-click on the "Tables" node and create new tables the old fashioned way? Unfortunately, no. You cannot connect to SQL Azure directly with SSMS the way you can to a regular SQL Server instance.

To connect to SQL Azure with SSMS:

Open SSMS (this part should be pretty obvious)
When you are prompted to connect to a database, cancel that dialog.
You should be left with an empty management console. Click New Query.
For the server name, take the fully qualified host name from your SQL Azure connection string. It should look something like (blah).database.windows.net.
Choose SQL Server Authentication. Supply the username and password that you used for your database. Parts of this information should also be visible on your connection string.
Click on the Options button on the bottom right of the dialog box
Set the database name, manually, to the name of your database. It will not show up in the drop-down list.
Force the network protocol to be TCP/IP (this step may not be necessary, but I do it out of habit)
Make sure Server type is set to Database engine (this is the default, but might not be if you use SSMS for more than your average bear)
Now you can click Connect.

At this point, if everything worked well, you should FAIL to connect to SQL Azure :) You should get some horrid message about a connection from your public IP address not being allowed. This is because this version of SQL Azure has a built-in firewall and, by default, it doesn't allow anything through.

Go back to the sql.azure.com portal and click on the Firewall Settings tab. Check the Allow Microsoft Services to Access this server box. Click the button to add a new record. At this point it will conveniently show you what it thinks your public IP is so you can create a new rule to allow your IP through. Keep in mind this is only required to allow your home computer to access your SQL Azure server. If you have checked the Allow Microsoft Services... checkbox, then connections from within the Azure fabric (like an ADO.NET call from inside an ASP.NET app in an Azure Web Role) will pass through the firewall unhindered. This firewall is specifically to keep the communication safe and give you a "DMZ-like" experience where only the people (IPs) you trust will be able to hit that server from outside the Azure cloud fabric.

Now, after adding the firewall rule, you will need to wait up to 15 minutes or more. When I did it, it took over 20 minutes. The reason is that the portal where you hit the submit button is not the same physical machine as your SQL Azure server. It takes a few minutes for your new firewall rule to make it over to the actual data center where your SQL Azure server has been provisioned (at least that's my best guess to explain this delay). So don't be alarmed if 10 seconds after you add the firewall rule you still can't get into your database.

Now you are free to write T-SQL until you are blue in the face. What's that, you don't love hand-writing T-SQL schema change scripts without any assistance from an IDE? Neither do I. This is why I created a Visual Studio 2008 "Database Project" that references a local database with the same schema as the one I want to have in the cloud. This is useful for multiple reasons. The biggest of which is that with a "Database project" I can version control my scripts. Secondly, I automatically gain the benefit of a local development copy of my database. Finally, this allows me to, from within VS, right-click any schema element and script it into the project. I can then open that script, do some cleaning up, and then execute that script in the aforementioned SSMS query window. The cleaning up I'm referring to means stripping out the plethora of extraneous options on the ends of the CREATE TABLE statements and things like that. A lot of those options aren't available in SQL Azure so just strip them out after you script the table, proc, view, whatever. It's a pain in the butt, but it's certainly better than having to hand-craft all that T-SQL if you aren't into that sort of thing. I know some developers that like to get all kinky with their T-SQL and would never let VS script it for them. Me, I like to wear protective gear when I talk to the database schema so letting VS give me a head start suggestion as to the script I should run on SQL Azure works just fine for me.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

Anytime a feature of a framework gives me something for free that I don't need to manually implement I'm a happy camper. One such feature of ASP.NET MVC 2 is jQuery client-side validation. The reason I like this is that unlike other jQuery frameworks, where you have to write the jQuery yourself - you don't need to do that with MVC 2.

Instead of having to maintain simple validation logic in two places (your business classes and your jQuery code), you can now use the Data Annotations attributes and metadata "buddy" classes to decorate your models. Those decorated models will automatically generate the appropriate jQuery code to enforce all of your validation rules on the client side before the form is ever submitted. Let's see how this works.

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

This is great. I love the fact that it doesn't look ugly and view developers can look at it and immediately know what fields are available and they don't need to sift through a pile of persistence garbage or validation logic. You might have noticed that I've made this class partial. The reason I'm doing this is because I'm going to create another file called Customer.metadata.cs. There are other samples on the web that don't do this, but I like cleanly separating the definition of my model from the validation logic for that model. Here's a look at my Customer.metadata.cs file:

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

What I've done here is used a metadata "buddy class" (that's what posts from Scott Guthrie and Scott Hanselman have been calling them, so I'm sticking with convention here). This buddy class is a placeholder for all my validation logic attributes and the runtime will then merge all this stuff onto the actual model. MVC 2 will then examine the model and , with a few lines of code in the view, generate the appropriate jQuery client-side validation logic.

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

While you could write your own jQuery validation code if you felt like it, using data annotations and MVC 2, you no longer have to maintain your validation logic in two places. The attributes apply to a single view model and all you have to do is change one of those attributes and the generated jQuery code will change as well. This is a huge timesaver and promises to dramatically increase overall productivity of developers building large-scale MVC 2 applications, especially LOB apps with lots of data entry forms.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Wed, 31 Dec 1969 19:00:00 EST

First, we need a model class. Let's do something simple like Customer:

public partial class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

[MetadataType(typeof(CustomerMetaData))]
public partial class Customer
{
    class CustomerMetaData
    {
        [Required(ErrorMessage="You must supply a name for a customer.")]
        [StringLength(50, ErrorMessage = "A customer name cannot exceed 50 characters.")]
        public string Name { get; set; }
    }
}

In your view code, add the following 3 script declarations:

Finally, somewhere before the start of your form tag, add the following markup to the view code:

<% Html.EnableClientValidation(); %>

This will invoke the code that reads through the strongly typed model for your view, figures out all of the validation logic that applies, and generates the appropriate jQuery code.

Binary Serialization and Azure Web Applications

Sun, 25 Oct 2009 02:15:00 EDT

You might be thinking, pfft, I'm never going to need to use Binary Serialization...that's old school. And you might be right, but think about this: Azure Storage charges you by how much you're storing and some aspects of Azure also charge you based on the bandwidth consumed. Do you want to store/transmit a big-ass bloated pile of XML or do you want to store/transmit a condensed binary serialization of your object graph?

Templated Helpers in ASP.NET MVC 2 (VS2010 Beta 2 Version)

Fri, 23 Oct 2009 09:00:00 EDT

Templated Helpers are one of the new features in ASP.NET MVC 2. The other day, Visual Studio 2010 Beta 2 came out and some of you may have noticed that it comes pre-equipped with a beta release of ASP.NET MVC 2. In short a templated helper is a way of using various combinations of implicit and explicit rules to automatically place partial controls wherever particular data types need to appear, either in edit mode or display mode. So let's say you have a DateTime property on your model called MeetingDate. Rather than make every single view write its own (potentially contrasting!) code to render dates in view mode and in edit mode, you can now do something like this:

ADO.NET Data Services Projections Makes Sliced Bread Jealous

Wed, 21 Oct 2009 09:30:00 EDT

The other day I ran into a blog entry from the Astoria team discussing the projections feature of the 1.5 CTP2 version of the product. If you're not familiar with ADO.NET Data Services (formerly codenamed Astoria), it's basically a layer that you can put on top of an Entity Data Model and it will expose that model as a RESTful service. The URL format for this RESTful service is quite flexible, allowing you to select individual rows, perform filters, sorts, and many other things.

One of the new things that you can now do server-side via the new CTP2 URL syntax is projections. Projections actually allow you to control the shape of the output coming back. You can specifically choose which properties on the entity you want. Even more awesome is that this can be controller hierarchically. So if you bring back an Order entity and you include all of the OrderItem entities for that order, you can tell the server that you only want the customer for the Order and you only want Quantity and Price for the order items.

To perform a projection on the URL, you just use the $select parameter, like this:

blah.svc/Orders?$select=OrderID,Quantity,Price

And to control the shape of hierarchical data:

blah.svc/Orders?$select=OrderID,Quantity,OrderItems/Price,OrderItems/Quantity&$expand=OrderItems

At this point when I saw this I started having convulsions of pure joy. The main reasons being that every ADO.NET Data Services URL query will output either AtomPub or JSON. This means I can get only the columns I need and give them to my Ajax calls. Then I noticed that support for the new projections is actually in the Astoria client library as well, allowing me to write the following query:

var q = from order in ctx.Orders
        where order.Price > 300
        orderby order.Price descending
        select new { Price = order.Price, Quantity = order.Quantity };

This will translate into an Astoria query that filters, sorts, AND projects all on the server side, leaving me with a network footprint that only transmits the information I want and nothing else. This is a godsend if you have entities with huge amounts of columns but each individual query might only need to use 1 or 2 of those columns at a time.

And now, if this wasn't ridiculous enough, you can actually perform updates using the projected objects, AND those updates will ONLY transmit the information necessary. For example, if I only want to change an order's price and I got the price from a projection, I don't need to carry the entire order payload across the wire in order to commit the change:

order = q.First();
order.Quantity = order.Quantity + 42;
svc.UpdateObject(order);
svc.SaveChanges();

This will figure out that the only thing changing is the Quantity field and it will ONLY send that information. After discovering the combination of projections and the efficient round-trips of Astoria, this is when my head exploded.

If you have a multi-tier scenario and you're using an Entity Data Model (EDM), then you should definitely look into using ADO.NET Data Services to expose that model via services because now with projections, you can really do some unbelievable stuff. All that garbage code you used to have to generate to convert between DTOs and ViewModels and Entities and back again? You can delete ALL of that crap.

I've said it before but the folks working on ADO.NET Data Services deserve a medal. If you see a member of that team, buy them a beer. You have no idea how ridiculously complicated and difficult it is to write code that supports arbitrary projections like this. I'm pretty sure every time you run an Astoria query with projections, an Angel gets its wings.

The Origin of Stupidity

Wed, 21 Oct 2009 09:30:00 EDT

So apparently Kirk Cameron and a buddy of his are continuing their campaign of lies and outright stupidity because things like common sense, science, and cold hard fact threaten their fragile hold on sanity. Ordinarily I might on on a huge rant about this but everything I could say, the woman in this video says much more eloquently than I could. This is a must-watch.

Get Your Red Hot VS2010 Beta 2

Wed, 21 Oct 2009 09:00:00 EDT

Visual Studio 2010 Beta 2 is now available to MSDN subscribers and will be available to the public at large late next week. The list of stuff that is awesome and worth checking out in VS2010 Beta 2 is too long and ridiculously in-depth for me to cover here. Some of the big things that affect me right off the bat are the following:

Using ASP.NET MVC Action Filters to Declare Reference Data for Views

Fri, 02 Oct 2009 12:17:00 EDT

When we all build websites, usually we're concerned with figuring out how we're going to get the major entities into the view. We want to know how we're going to handle the shopping cart or how we're going to get the customer record onto the page, etc. But, one of the little details that almost always comes back to bite us in the ass is the use of reference data. Reference data is data that rarely changes, is frequently queried, and shows up in multiple places throughout the application. This might be anything from the list of companies currently trading on a particular stock market if you're building a financial web application or things like the list of countries, states, cities, counties, tax rules, and shipping tables if you're doing fulfillment of orders online.

Creating Correlated Workflow Services in WF4 / .NET4 : Part 1

Thu, 01 Oct 2009 16:00:00 EDT

In the sample I'm going to illustrate in this series of blog posts, I'm going to create a customer service helpdesk application. There will be a single workflow at the core of the application - the customer issue workflow. A customer calls complaining that their widget is completely, horribly broken and the customer service rep starts a new issue. The issue then persists forever while communciation goes back and forth between the customer until finally one of the communication types is a "close ticket" type. This is a really simple workflow, but should be similar enough to things that people do in the "real world" that the sample won't feel contrived or too "hello world"-ish.

How to Build your First Azure-Powered MVC App

Tue, 29 Sep 2009 14:00:00 EDT

A good friend and colleague of mine has put up a great tutorial that walks you through the process of creating a new "classic" ASP.NET Azure web application and converting it into a cloud-based MVC application. In addition, he shows you how to point your membership, profile, and role providers at Azure cloud storage instead of the default SQL Express. Great read, check it out here:

http://www.caffeinedi.com/2009/09/29/how-to-build-your-first-azure-powered-asp-net-mvc-app/

Configuration Settings in Azure Applications

Tue, 29 Sep 2009 11:30:00 EDT

One of the double-edged swords of Azure is that it feels so much like building regular web applications. This is a good thing in that you can re-use so much of your existing skills, knowledge, and best practices and they will still apply in the Azure world. However, it is really easy to make assumptions about how things work that turn out to be wrong.

For example, if you look at just about 99% of the Azure samples, blogs, and other reference material, you will see stuff that looks like the code below, sitting right inside web.config:

<add key="TableStorageEndpoint" value="http://foo.table.core.cloudapp.net"/>
<add key="QueueStorageEndpoint" value="http://foo.queue.core.cloudapp.net"/>
<add key="BlobStorageEndpoint"  value="http://foo.blog.core.cloudapp.net"/>
<add key="AccountName"   value="foo"/>
<add key="AccountSharedKey"   value="...lotsa stuff..."/>

If you were to make assumptions about this, one might assume that you should be putting stuff like this in your web.config file even when you go to staging and production. NO! Stop right there!! This is not how Azure configuration settings are supposed to work!

Equally prevalent in the samples you will find calls to methods like GetDefaultTableStorageAccountFromConfiguration. there is actually a bit of useful logic going on in here that might not be immediately obvious.

This method is going to make attempts at getting configuration information from multiple different locations. It will check the web.config/app.config file, but it will also check your service configuration file. The most important thing to remember about this file is that it can be edited directly from the Azure portal. This means that you can deploy your application to stage and then go in and edit the service configuration file to change all the endpoints to your staging endpoints, then activate your app.

The reason this is important is because you never, ever, ever want to include your Azure key information in your web.config file, especially if you're posting on forums or sharing your code with other people. This is because if anybody gets your account name and shared key combination, they have full access to your Azure storage account and can basically run amok all over your data.

So, how do you know when you use a service configuration setting vs. a web.config setting? Here's a quick rundown:

If you need to be able to edit the information after deploying, it must be in service configuration and not in web.config
If the information only changes once per full deploy to production, e.g. it's version bound not environment bound, you can leave the setting in web.config

So, for example, in a typical Azure application, you might store the names of your queues and tables in web.config (because they should rarely change and will remain the same between stage and production), but you'll put the endpoint information related to your Azure Storage account in the service configuration file.

Hope this helps. The key thing to remember is that Azure service configuration can be a really powerful tool if you know its there... it can also screw you up if you forget its there :)

ASP.NET Membership Provider in the Cloud

Tue, 29 Sep 2009 11:30:00 EDT

Let's take a look at this pretty common scenario. You're building an ASP.NET application (MVC or otherwise) and you intend to publish it in the cloud and you're using Azure Storage (not SQL Azure) for your underlying data store. You've already hooked your app up with the sample Azure-based Membership provider that comes with the Azure SDK and everything is running along nicely.

Your application has quite a bit of administrator-only functionality so, after you've been using it locally for a while you put in some safeguards to block access to the admin areas unless the user is in the Administrators role. That's awesome and ASP.NET and ASP.NET MVC both have some really great code shortcuts for enabling this kind of situation and you can make yourself an administrator pretty darn easily.

So you're an admin and you deploy your application to staging and you go to run it and you try to log in. Whoops your account isn't there. This is because for the last couple of weeks you've been running against your local SQL 2008 (or SQL Express) database and you forgot that you did a few tweaks to make yourself an administrator. In the last couple of weeks you removed the code on the site that allows users to self-register since your application is an LOB app with a manually administered user list.

There is a built-in tool that comes with Visual Studio 2008 that allows you to do site administration. In a non-cloud environment, this was a great way to do things because you could simply configure your providers and then click "Project" and then "ASP.NET Configuration" and you would be taken to a Cassini-based website that allows you to add/remove users, manipulate roles, etc. It was great.

The problem is that when you run an Azure application locally, you're running the Role, you're not running the ASP.NET application. This means that when you launch (at least as of last night when I tried this) the ASP.NET configuration site, you're going to get a pile of errors all stemming from the fact that information contained in your service configuration file wasn't found and you'll get other errors because the local fabric doesn't get initialized when you don't start the app through the role.

So what can you do? If you can't use the admin site then how do you create an admin user that can then create more users? Lots of really talented people have contributed to the MVC community including a fully functional admin site that uses the membership provider to administer users, etc and you can use this if you want. What I've been doing, however, to ensure that I'm never left without some form of administrative access to my sites is by creating a root account.

What I do is in the service definition I declare three settings: RootAccountName, RootAccountPassword, AdminRoleName. I then have code in my application startup that will use the Membership API to create this user with the given password and add them to the Admin Role (and create that role if it isn't created already). This guarantees me that any time I do a fresh deploy or even wipe my storage account that I'll still be able to login as an administrator to stage or production and I can keep the root account name different between stage and production.

Again, Azure development is awesome and shares a lot of similarities with traditional ASP.NET development but some things (like the built-in site admin tool) don't work out of the box via the cloud and so we have to keep these things in mind as we build applications for the cloud.

The Rite of Spring

Thu, 24 Sep 2009 08:29:00 EDT

The main thing that I get from this picture is a feeling of awe. I mean, it's Saturn for crissakes... and we've got a machine flying around that planet, taking pictures that can be assembled into the massive image in the link and sending those pictures across the solar system back to machines on Earth. Just take a deep breath and stop and think about that for a minute. Today we take virtually all things technological for granted - nobody notices that our phones are using more technology today than the super computers that launched man to the moon 40 years ago. Nobody seems to care that when we were younger, the most awesome kickass gaming rig was a 486 DX2 that ran at 66Mhz. 66Mhz! And that was really just a trick, it's clock speed was really only 33Mhz.

ViewState is the Froo-It of the Dev-Il

Wed, 23 Sep 2009 22:45:00 EDT

The other day I was running Microsoft's malicious software removal tool and, to my shock and horror, it did not remove all of my ASP.NET applications that make use of ViewState. I'm sure it's just an oversight and Microsoft will be releasing a patch for that soon... if there is one application that could be called malicious, it's an app that uses ViewState.

On Testing

Mon, 21 Sep 2009 13:53:00 EDT

A while ago my mother found a bunch of my grade school (like 3rd - 5th grade era) report cards and progress reports. They pretty universally read like "Kevin is struggling" or "Kevin is having a hard time" and go on and on to describe that I'm not doing well and that my mother really needs to fix it or else I'm going to start failing, etc. I didn't feel stupid or incapable at the time, I just felt entirely unremarkable. I didn't feel as though there was a single thing about me that was any different than any other kid ... except maybe that I didn't do as well scholastically as my friends. Somehow, despite "needing help" and "struggling", I was reading at a 12th grade level in 4th grade. I was placed in remedial to average classes until grade 8.

I didn't know it at the time, of course, but I had (and still have) ADD. I do not have any hyperactivity problems and in fact have sometimes been referred to as a sloth in the past. On subjects that I could obsess over and that interested me, I did exceptionally well (except for testing) and on boring subjects I did exceptionally bad (including testing).

A common thread here is testing. I have never tested well and never will. I hate the experience of being in a test. My stomach churns and I fidget, twitch, itch, and otherwise cannot focus on the test. I fail tests for easy and hard classes alike and only in recent adult years have I ever been able to pass a test on a boring topic (passed the MCSD exam for SQL Server 2005.. good lord that test was boring.. I had to take it twice to pass).

While in the middle of a test, there is a single thread running through my mind... it sounds like this "I want to be done. I don't care if I get all the answers wrong I don't care if it ruins the rest of my life I don't care I don't care I want to be done!!!". I remember a mid-term exam for Calculus once while at University - I was maintaining a decent Bish/Cish average. I got to the mid-term, panicked, and randomly picked all answers on the test and fled the mid-term 15 minutes after the exam began. I failed it and tanked my average.

When someone with my particular type of ADD is confronted with a long-running task that gives them anxiety such as studying for an exam, I have two standard responses:

Obsess about the studying for, preparation for, and acing of, said exam to the exclusion of all else, including daily responsibilities such as acknowledging the presence of one's family and friends.
Ignore it. Avoid it. Run like hell and pretend the exam doesn't exist. When it comes time to take the test, pick random answers and be done with it as soon as humanly possible.

Unfortunately, I have in the past done both #1 and #2. I've spent months preparing for an exam and then blew it off out of raw, primal fear when it came time to take the test. That allows me to wallow in self-pity for months after receiving my 0% grade, further increasing my test-related anxiety.

Want to hear how the cycle of self-destruction continued? I decided to start learning Japanese a while back. I felt as though the study of it was floundering (though I was having a crapload of fun) so I decided maybe if I set a goal, some kind of target, then I'd have more productive studies. What did I set as my goal? Why, the JLPT3 Japanese Language Proficiency Test, a once-a-year, international certification. So I did my usual - I turned what was once a fun passtime/hobby into a hyper-obsessed anxiety-ridden downward spiral while preparing for this test.

So I've decided to not take the test.. ever. Regardless of whether or not I think I can pass it, I've decided not to take it. Within minutes of making this decision, I felt happier, lighter, and less stressed. The ominous, looming shadow of the upcoming test went away and learning Japanese became instantly fun again.

So what's the moral of the story? I'm not really sure. A wise friend of mine once passed a quote (perhaps paraphrased) on to me that everyone should live by:

"Find out what you don't like doing, and stop doing it."

Simple, yet powerful.

Does Google Translate Suck?

Thu, 17 Sep 2009 08:33:00 EDT

Before I get into the main part of the blog post, I want to preface this whole thing by saying that I am well aware of the problems of doing language translation by a machine. It's an inherently difficult problem.

My issue here isn't so much with Google Translate as it is with the public perception of Google. I've read a few reviews of Google Translate and seen some blog posts. The general consensus is that because Google built it, its awesome and flawless. People think that Google is building this massive, soon-to-become-self-aware giant brain in the cloud that is sucking intelligence out of search patterns to be used for some world dominating purpose in the future.

The Difference Between Web Hosting and Cloud Computing

Sat, 12 Sep 2009 17:15:00 EDT

Yesterday a friend of mine was asking me what I've been doing lately in my spare time. When I mentioned that I'd been doing a lot of messing around with Windows Azure, he was naturally curious. After explaining what Azure is, he asked me what the difference was between Windows Azure, a cloud computing environment, and traditional web hosting scenarios. On a really high level, he's got a valid point : With Azure you can develop your application offline locally and then when you're done you can publish it to a remote host. To the casual observer, this looks exactly like what you might do with a web hosting company that provides space on an IIS box and let's you use ASP.NET and maybe even a little SQL server database.

Deploying Azure Hosted Services Should Be as Easy as Deploying a Heroku Application

Tue, 08 Sep 2009 09:30:00 EDT

Recently a friend of mine showed me Heroku, an "instant Ruby platform". Basically what you can do with Heroku is build your Ruby application and the deployment to the remote Heroku site is not only brainless, painless, and simple, but it can be done entirely from the command line (which means it can be automated even further than it already is). But don't take my word for it, check out this screencast showing exactly how simple it is to build Ruby applications in the cloud using Heroku.

Silverlight Polling Duplex Channel is NOT a Scalable Solution

Tue, 08 Sep 2009 09:00:00 EDT

This is great and the programming model for communicating with the Polling Duplex channel is brain-dead simple. It does NOT get any easier to implement push data to a RIA - not in Flash, not in AIR, and certainly not in JavaFX. The problem is that this solution doesn't scale. On the server side, for each concurrently running Silverlight application (so probably one per concurrent user), there is a full live socket being consumed that will not be relinquished until the client disconnects/closes their browser.

Live Framework Developers Get Boned

Tue, 08 Sep 2009 09:00:00 EDT

When I first read this, I was all "OMFGWTFNoMesh!?!" and exploded in front of my computer. After cleaning the bits of my exploded brain off the keyboard and looking at it again, some of it made sense. They are taking the Live Framework stuff down and theoretically coming up with a better, more in-depth, more unified API for Live. This step is long overdue because for a very, very long time developers have been confused because there is "old live framework" and then "live mesh/live framework" and then there's Azure and then there's a bunch of crap that's been labelled as part of "Live" for which there is no developer API.

How Win7's "Boot to VHD" Feature has Changed the Way I Work

Tue, 08 Sep 2009 08:45:00 EDT

This is normally an adequate situation for me. However, with some things I just don't want the virtualization overhead or the difference in environment. For example, VS2010's GUI is written in WPF and that particular GUI hates being virtualized. When put under a virtual machine running Windows 7, VS2010 fails to render things, borders disappear, windows become unusable and the experience is downright awful. On the other hand, when you run VS2010 "bare metal" with no virtualization between it and your video card, everything is beautiful and all works well.

Upgrading the default ASP.NET MVC project with IoC and the Unity Controller Factory

Wed, 22 Jul 2009 11:45:00 EDT

The ASP.NET MVC framework is one of the coolest things to happen to ASP.NET since its creation. One of the things that I love about the MVC framework more than anything else is its flexibility. This flexibility allows it to be configured anyway the developer likes, including replacing the factory that creates controllers. There are two main things that I wanted to accomplish with the Unity integration. The first was that I wanted my controllers to have the objects on which they depend injected into them in standard DI fashion. Secondly, I wanted the controllers themselves to be resolved through the IoC container rather than being tightly coupled by the routing rules. This would allow me to yank in and out different controller implementations if I need to (I figured this would come in quite handy for TDD and unit testing).

Modifying The Default Unit Tests for an ASP.NET MVC Project To Use Moq

Wed, 22 Jul 2009 11:45:00 EDT

When you create a new ASP.NET MVC project, one of the first things that you might notice is that you get an AccountController which takes advantage of the ASP.NET membership provider to allow your site to automatically do forms-based authentication right from the very beginning. This is a very handy feature and definitely helps get you going quickly. The issue is that when you look at the unit tests for the AccountController, they are positively littered with manually mocked classes. I realize that this is because you don't want to make the default project template rely on a third party mocking library so in this blog post, I'm going to show how you can delete all of the manually implemented mocks for the identity, principal, membership service and forms auth service. The secret is using Moq. Moq is a lightweight mocking framework for .NET that was designed specifically for the .NET Framework 3.5 and LINQ. As such, definining mock expectations and mock return values is all done through lambdas in a ridiculously easy to read syntax, as you'll see below.

Blogs on WCF4, WF4, C#4, Azure, and Goodies Coming Up

Tue, 21 Jul 2009 07:30:00 EDT

A couple of weeks ago my family and I started packing boxes in preparation for fleeing the great state of New Jersey. We packed everything up, threw as much as we could in the minivan and trekked up to Connecticut where I have taken a new position with a new company as a .NET Architect. As any of you who have moved before know, it's an incredibly stressful experience and the logistics involved are absolutely ridiculous. It's a miracle I still know where my car keys, sneakers, and computers are. At one point I was sure I'd left the cat on the roof of the minivan.

Fix for Minor Bug in ASP.NET MVC New Project Template

Sun, 03 May 2009 22:48:00 EDT

This evening I discovered a minor bug in the new project template for the ASP.NET MVC 1.0 release

Tour of Oslo: Storing Models in the Repository

Wed, 31 Dec 1969 19:00:00 EST

In my last blog post on Oslo , I walked through a simple scenario where we created an "M" file that contained the models for a fictitious science fiction game. We used this file and IntelliPad to see what the T-SQL might look like if we were to create just the tables defined by the model. In this blog post, I'm going to walk through the process of taking an "M" model, compiling it into an MX image, and finally storing that image in the repository.

If you're following along, you can grab the "M" file that I created in the previous blog post or you can create your own. The repository is a central storage location for models. Not only does it contain the actual schemas generated by your model image, but it also contains a lot more like security and versioning information. In the interest of keeping this post as small as possible I won't go into too much detail, but you can find tons of Repository-related videos over on the Oslo Developer Center .

The first thing we need to do is compile our model. To do that, we'll use the command-line tool that ships with the CTP called m.exe. This tool can be used to generate regular T-SQL, repository SQL, and of interest to us: a repository image of the model. Sticking with the M file I created last time, I can open up a command prompt, make sure the Oslo SDK "bin" directory is in my path and issue the following command:

m UlyssesAgenda.m /p:image

The output is a file named UlyssesAgenda.mx. This is a compiled M file. Now we need to get the compiled M image into the repository. Using this CTP we can accomplish that from the command-line as well using the MX utility:

mx -i:UlyssesAgenda.mx -d:Repository -s:kev-win7\SQLEXPRESS

Depending on your configuraiton, you may not need the "-s" command line switch to indicate the server where the Repository database is stored. In my case, I have a full-blown installation of SQL Server 2008 and SQLEXPRESS is not my default instance so I've found that every now and then that means I have to modify connection strings or, in this case, pass the server/instance explicitly.

And now we can look at SQL Manager and we see that all of the tables that correspond to our high-level model were created:

Using the MX command-line tool we can also directly query the repository. I thought it worth showing the output of this because it illustrates one of the more valuable aspects of Oslo - model versioning:

>mx -l -d:Repository -s:kev-win7\SQLEXPRESS

Microsoft (R) code name "M" Command-line Utility version 1.0.1308.1
Copyright (C) Microsoft Corporation. All rights reserved.

Contents of the database
============================================================

Models.mx                 Models.mx;Version=1.0;Locale=neutral
UlyssesAgenda             UlyssesAgenda;Version=1.0;Locale=neutral

Models.mx is the compiled list of all of the stock models that Microsoft has provided and put into the database as part of the core Oslo offering. What I think is really important to keep track of is that the models themselves are versioned. There are no table versions - the versioning takes place at the model level which is, IMHO, where it should be. Also keep in mind that because at the lowest level we've also created a standard SQL schema, you can use any tool you like against this server, including LINQ to SQL or ADO.NET or the Entity Framework.

So now we've created a model and put it in the repository. In upcoming blog posts, I'm going to cover some of the other interesting things that you can do with models.

Latest News from Kevin Hoffman

Would You Like to Touch My Mono?

Kindle 2 vs Nook

Windows Identity Foundation (WIF) Release Candidate Is Out

Setting up an ASP.NET MVC 2 Application for Windows Azure

Getting the ASP.NET Providers Working on the Azure Nov 2009 CTP

Working with Table Storage on the Windows Azure

Installing Geneva Beta 2 on Windows7

Why we're all NOT going to die on December 21st, 2012.

Something Wicked This Way Comes - Breaking Changes for .NET Services in Azure

WS-Trust STS replaced with Web Resource Authorization Protocol (WRAP) STS

LINQ to SQL and Entity Framework on top of SQL Azure

Creating and Manipulating Your SQL Azure Database

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Client-Side Validation with jQuery, DataAnnotations, MVC 2, and VS2010 Beta 2

Binary Serialization and Azure Web Applications

Templated Helpers in ASP.NET MVC 2 (VS2010 Beta 2 Version)

ADO.NET Data Services Projections Makes Sliced Bread Jealous

The Origin of Stupidity

Get Your Red Hot VS2010 Beta 2

Using ASP.NET MVC Action Filters to Declare Reference Data for Views

Creating Correlated Workflow Services in WF4 / .NET4 : Part 1

How to Build your First Azure-Powered MVC App

Configuration Settings in Azure Applications

ASP.NET Membership Provider in the Cloud

The Rite of Spring

ViewState is the Froo-It of the Dev-Il

On Testing

Does Google Translate Suck?

The Difference Between Web Hosting and Cloud Computing

Deploying Azure Hosted Services Should Be as Easy as Deploying a Heroku Application

Silverlight Polling Duplex Channel is NOT a Scalable Solution

Live Framework Developers Get Boned

How Win7's "Boot to VHD" Feature has Changed the Way I Work

Upgrading the default ASP.NET MVC project with IoC and the Unity Controller Factory

Modifying The Default Unit Tests for an ASP.NET MVC Project To Use Moq

Blogs on WCF4, WF4, C#4, Azure, and Goodies Coming Up

Fix for Minor Bug in ASP.NET MVC New Project Template

Tour of Oslo: Storing Models in the Repository