Toasted Code

ADO.Net Entity Framework – Assembly Not Found Exception

2008-12-24T10:42:00.001-08:00

Technorati Tags: ADO.Net Entity Framework,Debugging,SQLite

Allow me to share with you the resolution for one of those simple things that should take a few minutes to resolve but ends up taking 3 days.

I’m using the ADO.Net Entity Framework within Code Toaster, my template-based code generation tool, to retrieve and store statement completion metadata to a SQLite database. SQLite newly supports the Entity Framework Designer from within Visual Studio.Net 2005 and 2008, and all that works wondrously.

But when I ran my code in the debugger my entity context object’s constructor threw an “Unable to load System.Drawing, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a” exception. Oddly enough, the version number was for the .Net 1.0 version of System.Drawing. Code Toaster is 100% .Net 3.5 code (or so I thought), which means the version number should have read 2.0.0.0 (.Net 3.5 is really .Net 2.0 plus some extras, like WCF and WPF).

I enabled .Net Framework source stepping (an awesome new feature in VS.Net 2008 SP1), and stepped through the actual .Net Framework source code to try and figure out why .Net felt it needed to load the 1.0 version of System.Drawing when establishing a connection to SQLite.

Enabling .Net Framework source stepping

As it turned out, .Net was trying to load lots of assemblies! It appeared as though it was traversing through every assembly I was referencing, as well as every assembly those assemblies referenced, recursively! Dude.

I cranked open Reflector and examined every assembly I had explicitly referenced. Sure enough, an assembly from Actipro Software was referencing System.Drawing, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a. The next question was – why was the .Net Entity Framework doing this?

After some more Googling and soul searching, I discovered precisely why. When you add an .edmx model to your project, an Entity Framework connection string is automagically added to your app.config (or web.config, as the case may be). Upon closer inspection, one realizes that this connection string is not like others you may have seen before.

For one, it includes a metadata section, which looks something like this:

metadata=res://*/IntellicacheModel.csdl|res://*/IntellicacheModel.ssdl|res://*/IntellicacheModel.msl

The metadata section is a map that tells .Net where to find these three resources. res://*/ means “search all the assemblies you can find, and don’t stop until you’ve either thrown an exception or found what you’re looking for.”

I replaced the asterisk with the name of the correct assembly (the one whose project that contained the .edmx model; you can also verify by inspecting your assembly in Reflector for these three resources), and it worked! Eureka!

I suppose if I had simply read the documentation first I could have saved myself some trouble.

Microsoft Installation Troubles

2008-12-08T10:31:00.001-08:00

I cannot install Microsoft Expression Blend 2. If you look here, you'll see that lots of other people can't either. The problem seems to occur if you had installed and then uninstalled a pre-release version of Blend - it hoses up future attempts to install later versions. I even read about one dev who just wanted to reinstall the product to try and fix an Intellisense issue, but the installer wouldn't even let him do that.

I did, however, get it to install in a pristine virtual machine. But lo, I needed to upgrade to Blend 2 SP1 to get the latest Silverlight 2 support. And to do that, I had to install the .Net Framework 3.5 SP1 update.

The screenshot below shows what happened next. This is the most bizarre frustrating thing. Can you tell what's messed up about this picture?

That's right, the installer is telling me that it can't continue until I close... the installer!

Online Charting and Graphing

2008-11-12T04:58:00.001-08:00

If you have a need for powerful web-based charting and graphing with a low learning curve, I highly recommend either of these two solutions.

Flot - Flot is a 100% javascript-based library built on top of jQuery, and which can generate very nice looking charts and graphs (with tooltips and such-like). Plays nice with Internet Explorer 6, Google Chrome, Firefox 2.x+, Safari 3.0+, Opera 9.5+ and Konqueror 4.x+, but in my testing does NOT work with IE 7 OR 8.
Visifire - Visifire is a great open-source charting platform using Silverlight. Silverlight must be installed on client workstations, but I've had remarkable success using Visifire. The web-based chart designer is a great starting point to using this incredibly powerful tool.

Now go wow the boss!

Technorati Tags: Visifire,Charting,Graphing,Flot,jQuery

Code Toaster AppDomain Magic

2008-10-01T05:15:00.001-07:00

My personal project for almost 4 years now, Code Toaster, is almost ready to show to the world (again, if you've been following this blog for a while). Code Toaster is an Integrated IDE, and libraries, for rapid creation of developing code generation templates. You can find a lot more information over at http://www.codetoaster.com/, including documentation, code samples, and video tutorials.

But in this post, I'd like to take a look at a few of the more difficult architectural challenges I faced when building Code Toaster, all of which were solved by taking advantage (or working around issues with) the .Net Application Domain (aka AppDomain). But first, some background information.

The AppDomain

A .Net process consists of one or more Application Domains, which are used to provide code isolation, security, and so forth. Code running in one Application Domain cannot directly invoke code running in another Application Domain, however methods on the AppDomain class make it possible to load a .Net assembly into a new AppDomain, create an instance of a class in that assembly, and invoke its properties and methods.

AppDomain's are important to Code Toaster for several reasons. The foremost is that, once an assembly is loaded into an AppDomain using Assembly.Load (or one of its associated methods), the assembly cannot be unloaded from the AppDomain. In several cases it's necessary for Code Toaster to temporarily load an assembly to retrieve type (or other) information contained in an assembly, and then unload the assembly to reclaim the memory used.

Scenarios that benefited from using AppDomains

In one scenario, Code Toaster loads assemblies in the GAC to determine each assembly's target runtime. Loading every assembly in the GAC into memory could consume roughly 25-50 megabytes of RAM : it's nice to be able to reclaim that memory afterwards.
In another scenario: when Code Toaster compiles a template project into a new assembly, that assembly must be loaded (into some AppDomain) so that it can be executed. As the developer iteratively modifies, compiles, modifies, and compiles, each time loading a new assembly, memory usage can slowly add up (each compile loads a new assembly). It's nice to be able to reclaim that memory after each compilation.
Another very important scenario occurs when debugging templates. Attaching the Visual Studio debugger to a template executing in Code Toaster's AppDomain causes the Code Toaster process (codetoaster.exe) to end when the debugger detaches. This is not unique to Code Toaster: the popular CodeSmith code generation tool suffers from the same problem. As I was later to discover, executing templates in their own AppDomain causes debugging to operate as desired (detaching the debugger does not kill the process).

The figure below shows how Visual Studio attaches to a separate AppDomain within the CodeToaster.exe process, whose purpose is solely to contain and execute templates in isolation. This provides several benefits:

Each time a template is recompiled, the "template execution" AppDomain is unloaded and recreated, reclaiming any memory space used by the previously loaded template assembly.
Debugging works as expected (detaching the Visual Studio debugger from a running template will not crash CodeToaster.exe).

This was easier said than done. It's one thing to run some code in another AppDomain. It's quite another to load a Type in AppDomain B into a Property Explorer in AppDomain A, and have it appear and work correctly, with the appropriate adornments for UITypeEditors and so forth (see the figure to the left : the template BDC.Sample is loaded in another AppDomain, but appears correctly in the Template Property Explorer).

In future posts I intend to take a closer look at the code that made all of this come together. For now, I invite you to head on over to http://www.codetoaster.com/ and check out the finest code generation tool ever made!

Internet Security

2008-09-03T04:34:00.001-07:00

This video from F-Secure corporation provides a great outline of how malware and other virii have evolved over the last decade or so, and why security (in particular browser security) is of critical importance.

And along those lines, Google Chrome has already been found vulnerable to a big nasty security glitch.

Technorati Tags: Internet Security,F-Secure,Google Chrome,malware,virus

Google Chromium (Chrome)

2008-09-02T12:59:00.001-07:00

I'm sure by now you've heard, and perhaps played with, Google's new free, open-source web browser: Google Chromium.

If not, well... I've spent the last 30 minutes messin' around. And as far as the overall browser experience, I must confess to not being terribly impressed. The "new tab" feature that keeps track of your favorite sites is pretty cool. And it is lightning fast, except where the "OmniBox" seems to update a little jerkily.

But the developer tools are a different story. It looks like someone at Google decided to spend a good ol' chunka time making their browser very developer friendly.

To launch the Chrome "Inspector", right-click anywhere on a page and click the Inspect Element menu item. From there, you can browse the DOM, inspect javascript errors, investigate resource problems (broken links, large files), and so much more.

There's also a nifty-orama javascript debugger. See the screenshot below for an example of Chrome Inspector catching one of my javascript bugs.

And then there's the javascript console window, which seems to actually work(!), and comes with a slimmed down and barely there version of Intellisense (but Intellisense no less). I'm very excited about this because it's hard to find a readily available javascript command window that just works. And I've been having issues with FireBug of late.

Oh yeah, I'm going to have loads of fun with this. If you're a web dev, I encourage you to give it a whirl.

Technorati Tags: Google Chrome,javascript,DOM

Red Gate purchases Reflector

2008-08-21T06:54:00.001-07:00

Red Gate software has purchased, and take over future development of, Lutz Roeder's uber-popular tool.

Under an agreement announced on Wednesday 20th August , Red Gate will be responsible for the future development of .NET Reflector, the popular tool authored by Lutz Roeder. Red Gate will continue to offer the tool for free to the community.

Is this good news? I'm not sure. Red Gate says they will continue to offer Reflector as a free community-based tool, so it remains to be seen what this really means for .Net coders everywhere.

Click the link for full article.

Technorati Tags: Reflector,Lutz Roeder,Red Gate

Keep It Simple...

2008-08-15T05:56:00.001-07:00

Programming is like sex. One mistake and you have to support it for the rest of your life.
~Michael Sinz

I was in the process of reviewing some documentation for a bit of popular legal software my employer purchased a while back, when I stumbled upon an interesting tidbit. I recognized it immediately for what it was, but I'll get into that a bit later.

This particular vendor provides a RESTful API into their offerings. When invoking several of said API's methods, you can specify, as a parameter, a contactId in either one of two formats, termed Windows and Web.

The Windows format looks like this: 2/2195. Essentially two numbers delimited by a slash. Easy enough!

The Web format, on the other hand, looks like this: 8589936787.

So, to call their RESTful findContacts method, I would pass one of these two formats, thusly:

http://…/findContacts?contactId=[insert contact id here]

Reading further, I discovered that the Web format is actually a fancy calculation computed against the parts of the Windows format, thusly:

Source ID = 2

ID = 2195

Web ID = (2 * 2^32) + 2195

The result of that calculation would give us the longer Web format: 8589936787.

According to the documentation, this was recently added as a "feature", which I suppose could be marketed as "slashless Web Ids". But, as far as mine eyes can see, really adds no value to the application.

What it does offer is oodles of cyclomatic complexity, the extent of which may not be apparent at first glance. Let's take a closer look:

Following this change, all developers on the project need to be educated that IDs can be input in two different ways. Why do they need to be aware? So that they don't assume that all IDs going forward will contain a slash, and can revise the way they handle ID input. Maybe they need to call a different function to parse IDs. Maybe they don't need to do anything at all. But I'm betting that somebody, somewhere, will either need to send an email about this change, spend an hour discussing it in a meeting, or add it to the project's internal documentation.
The test cases developed before this change are no longer valid for testing ID input. Now you have to test the case where ID input doesn't contain a slash (the Windows format), as well as the detection of the ID input format (i.e. running different code based on whether the ID contains a slash or not).
In this case, a new web method was developed, convertDualId, which does the math for any math-challenged developers out there. Something else that needs to be tested.
The documentation I'm reading contains three (3) HTML (.chm file) pages of documentation on this topic, explaining the difference between the two formats, and how to do the math to calculate the Web Id if you don't want to call the new convertDualId method. All of which needs to be validated, proofread, and so on.

And all that for... what? Seriously. To calculate the Web Id, I still need to have the two original slash-delimited values, so what am I gaining? I'll tell you what I'm gaining: an id that doesn't contain a slash.

Woop-te-doo.

If a slash is bothering you that bad, I can think of several other much simpler alternatives. Like, say, just HTML-encoding the thing as %2F. But of course that wouldn't properly showcase the developer's creativity, virility, and prowess.

And therefore I must conclude that what this is, in fact, is gold plating at its finest. An anonymous developer's proud signature, showcasing his unique ability to do maths.

Hardly aware is he that writing code like this is akin to locking a ball and chain around his ankle, forcing him into supporting this unnecessary code until the end of time. Or at least until he realizes what he's done and leaves for unspoiled pastures.

Keep It Simple, Stupid.

Technorati Tags: cyclomatic complexity,REST,gold plating

xmlns='' was not expected

2008-08-10T18:29:00.001-07:00

If you ever run into this XmlSerializer error: it's thrown because the name of the class being deserialized and the root node are not the same.

For example, if you're deserializing XML that looks something like this...

<PersonData>
    <FirstName>Bob</FirstName>
    <LastName>Black</LastName>
</PersonData>

...into a class called...

public class PersonDataXml
{
...
}

...you'll get this error.

To resolve, just add the XmlRootAttribute to your class, thusly...

[XmlRoot( "PersonData" )]
public class PersonDataXml
{
...
}

Now XmlSerializer won't get all confused.

Technorati Tags: XmlSerializer,XmlRootAttribute,xmlns

REST vs. SOAP

2008-08-08T13:00:00.001-07:00

I really hate this darn machine;
I wish that they would sell it.
It won't do what I want it to,
but only what I tell it.
~Author Unknown

My intent for this post is to be a 5 minute primer on the major differences between REST and SOAP. Of course, some folk may find a short post inadequate to discuss this particular topic, but hopefully many of you will find this helpful in some way. Before we get started, I'd like to point out that there are many alternatives to these two technologies that won't get discussed here, including (but not limited to) Binary XML, DCOM, CORBA, ICE, .Net Remoting, etc, each of which have their own unique advantages and disadvantages. REST and SOAP, however, are likely the more well-known and more accessible (i.e. easy to pick up).

A look at SOAP

The acronym SOAP was originally defined as Simple Object Access Protocol, but as of version 1.2 of the standard that meaning was dropped in favor of the (allegedly) more accurate Service Oriented Architecture Protocol. SOAP is an XML based protocol which provides for the passing of messages over a network, from computer to computer. In my humble opinion, the original acronym provides a more accurate description of its use today as an IT Enterprise solution for object transfer. But for the purest out there, allow me to clarify that SOAP does not pass objects over the wire, but messages.

Here's a sample SOAP request ("borrowed" from w3schools.com), which requests the current stock price for ticker symbol IBM:

<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Bodyxmlns:m="http://www.example.org/stock">
    <m:GetStockPrice>
      <m:StockName>IBM</m:StockName>
    </m:GetStockPrice>
</soap:Body>
</soap:Envelope>

And the response would look something like this:

<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Bodyxmlns:m="http://www.example.org/stock">
    <m:GetStockPriceResponse>
      <m:Price>34.5</m:Price>
    </m:GetStockPriceResponse>
</soap:Body>
</soap:Envelope>

SOAP is obviously very verbose. But it's approach is also very object-oriented, which makes it easy for most object-oriented developers to wrap their brains around. A SOAP service could be considered an object, which contains several methods that can be invoked, or properties that describe the object. If we used .Net to create a proxy class to call this web service, the C# code to invoke the GetStockPrice method might be something like this...

StockService service = new StockService();

float currentStockPrice = service.GetStockPriceResponse();

Console.WriteLine("Current stock price: {0}", currentStockPrice);

I'm using .Net here mainly to illustrate my point, which is that calling a web service looks and feels very object oriented. Even though we're not actually passing objects over the wire, it feels like we are, and so it's easy to work with.

A look at Representational State Transfer (REST)

In its most basic form, a RESTful service is "just" a URL that provides access to a resource. For example, a RESTful URL to get Apple's latest stock price might look something like this:

http://URI/CurrentStockPrice/AAPL/

Or maybe like this:

http://URI/CurrentStockPrice?AAPL

The World Wide Web is the most oft-cited example of RESTful design. Web pages support POST, GET, PUT, and DELETE, often used by RESTful applications to retrieve or modify data. Some RESTful applications add their own HTTP methods, such as WebDav, which adds PROFIND, PROPPATCH, MKCOL, COPY, MOVE, LOCK, and UNLOCK.

REST is very intuitive for GET operations, and is a popular architectural choice for services on the public Internet. For example, Amazon and Google both provide RESTful interfaces to their APIs, and according to Jeff Barr, Amazon's chief web services evangelist, 85% of developers prefer Amazon's REST interfaces over their SOAP counterparts (Amazon provides both).

SOAP seems to be more easily adopted by the Enterprise, while REST is a natural fit for publicly facing Internet applications, in particular those applications where most operations are retrieving data (versus writing/posting/updating data). For example, XML results from a RESTful service seem more conducive to formatting with XSLT, simply because of the absence of the "extra" SOAP XML.

An RSS feed is a great example of a RESTful interface. I just point my favorite news reader to an RSS URI, and it's easily consumed. I can save the feed results to an XML file and easily convert it to XML using an XSL style sheet. REST is a data consumer friendly interface.

Which is Best?

Is one better than the other? I would say: hardly. That would be rather like choosing VB.Net over C#. Many developers may prefer one over the other, but you can get the job done using either tool.

On the flip side, I might recommend considering the desired feel of your application's API when choosing betwixt these two technology choices. Consider SOAP's object-orientedness vs. REST's web request based feel, and how each might impact adoption of your API.

Or, if you're using a technology like Microsoft's Windows Communication Foundation, which provides built-in support for both SOAP and REST, you won't have to choose at all.

But at least you'll know the difference.

Technorati Tags: SOAP,REST,WCF,API

Twitterpated

2008-08-04T06:19:00.001-07:00

I done did it. I went and got me an account on Twitter. I thought I'd give it a try and see what comes of it, what with all the hullabaloo about how wonderful it is. I suppose it was bound to happen sooner or later.

And so I submit to you this segment from Bambi, which I think sums up Twitter's Twitterpatedness.

Resistance is futile.

Technorati Tags: Twitter,Bambi,Twitterpated

IE 8 Seeking Beta Testers

2008-07-31T04:54:00.001-07:00

But becoming a beta tester apparently requires writing an essay.

According to Allison Burnett's (Program Manager) latest post on the IE8 blog,

Currently the only way to directly file a bug with the IE Team is to be a part of the IE8 Technical Beta program on Microsoft Connect. Beta 2 is right around the corner and we are expanding our reach! If you wish to be a part of making IE better by contributing great bug reports then please email us at IESO@microsoft.com and tell us a little about yourself including why you’d be a great beta tester.

An essay? You mean I have to sell myself as a worthy tester before I can submit a bug?

Judging by the comments she's getting, I'm not the only one that sees this as a mite odd...

Maybe more people would participate if:

a.) You allow users to download/view attachments so they can test bugs.

b.) You gave them feedback to indicate which bugs are being fixed, and when they are fixed.

c.) The current beta didn't have such a horrible auto-scrolling issue.

d.) MSFT made some sort of declaration that IE Feedback would actually be around after the IE8 RTM. The fact that this was shut down after IE7 went RTM ***LOST*** most of your loyal contributors.

...and...

I am not writing an essay on why I'd be a great tester. You want/need more testers upload a current complied working build and the bug report tool in one place. Let the web both see and use it. Most of us have had terrible experiences so far with Beta 1 so perhaps it's time to release a Beta 2.

... and also...

Why, on earth, when other browser developers provide open and easy to use bug systems, would Microsoft limit itself in this way?

I have a bug in Webkit, five minutes can help me determine if someone had already reported the bug; no more than another five to submit the bug, with test case.

Mozilla created software to make it easy to search on, and submit bugs. Why, I bet even you all could use it.

Opera has a handy, dandy bug form that makes bug submission a snap.

And here is the IE team "If you email us and ask us really nice we may, just may, mind you, deign to let you actually tell us about that bug, which if left in the released product will haunt us until the end of time. If you don't ask nice, you can stuff your bug."

...and...

Dear Allison Burnett,

I've been a software engineer for 10 years and I'm taken back by why we need to provide reasons as to why we want to be great beta testers for a product that's on the decline in the web browser market. I expect this from a would be employer. I'm all for a better IE but this is not the best effort in gaining interest that Microsoft so dearly needs. You need to do more than just offer invitation to other beta programs.

...and so on. I think one commenter had Microsoft's thought process pegged on this one. That if you allow everyone to post bugs, and some of them don't get fixed, it might make them look bad.

And I'll just leave you with that.

LINQ Over Interwoven

2008-07-28T11:06:00.001-07:00

Here at the large, International law firm in which I'm employed, we use Interwoven as our document management system (DMS) of choice. We've found it advantageous to expose a slice here and a slice there of Interwoven functionality via web service API's, which has become all the more easier using C# 3.0's new language improvements.

Allow me to demonstrate:

Extension Methods

If we want to use LINQ to enumerate over Interwoven's COM-based collections we need a way to easily convert them into an IEnumerable (or IQueryable). Extension method provide us with an elegant way of extending the Interwoven API so that it appears to give us IEnumerable access to its collections.

Here's a sample extension method for converting an IManage.IManFolders collection into an IEnumerable.

public static IEnumerable<IManage.IManFolder> ToIEnumerable(this IManage.IManFolders folders)
{
    List<IManage.IManFolder> list = new List<IManFolder>(folders.Count);

    foreach (IManFolder folder in folders)
    {
        list.Add(folder);
    }

    list.TrimExcess();

    return list.AsEnumerable();
}

To really get a sense of how this makes our lives much easier as developers, let's just dive right into...

LINQ over XML

If you haven't played with LINQ over XML yet, allow me to demonstrate a smidgen of its power. This next block of code will recursively build a nested (and correctly indented) block of XML containing an Interwoven folder and all of it's child folders (using the extension method we created above).

public XElement GetFolderAsXElement(IManFolder folder)
{   
    return new XElement("IManFolder",
            new XAttribute("Name", folder.Name),
            new XAttribute("NrtId", folder.ObjectID),
            new XAttribute("ObjectType", folder.ObjectType),
            new XAttribute("FolderType", folder.ObjectType),
                from IManFolder subFolder in folder.SubFolders.ToIEnumerable()
                select GetFolderAsXElement(subFolder)
        );
}

The beauty of the new .Net 3.5 XML classes (XElement, XDoc, XAttribute, et al), is in its readability. Anyone can take one look at that code and instantly understand the structure of the XML that's being created. And if you're paying close attention, you'll note that all the work being done in that function was succinctly described in only one statement!

I've heard many developers express concern over their coworkers and comrades going all rogue with these new features, particularly extension methods. But here, I think is an example where the new language features actually improve our code, and enable us to do what otherwise would have taken much longer.

Technorati Tags: Interwoven,LINQ,XML,Extension Methods,DMS

No Developers for Windows Vista?

2008-06-16T09:09:00.001-07:00

This CNET.com article (well, actually this report from Evans Data {login required}) implicates Windows Vista as not having a huge developer following. Which would be a little worrisome (for Microsoft) if true, as they have a history of providing fantastic developer support, yadda yadda.

But is it true?

First off, how would a developer write an application for Windows Vista? Unless you're writing device drivers or WPF-heavy applications (note that WPF also runs on XP after installing an update), I would find it difficult to write an application that didn't run equally well on Windows XP, or even Windows 2000.

I'm guessing (sorry, I don't have any charts and graphs eye candy) that most Windows-based LOB applications are developed against the .Net Framework, or are at least moving in that direction. DotNet applications Just-In-Time compile to run on the target platform (be it 32-bit or 64-bit, or even Linux or Mac OS), so it matters little what OS version you're running.

But if I could write a Vista targeted application, wouldn't that be a little stupid? Why would I limit my customer base to only Vista? Especially with all the bad press it's been getting lately.

I suspect Evans Data accurately surveyed the developer community, which accurately reported back that no, they're not writing applications for Windows Vista. But I submit that the results were a bit misconstrued.

But hey, maybe I'm way off base here, and totally clueless, so feel free to let me know in the comments!

Technorati Tags: Windows,Vista,Developers,Microsoft

System.Diagnostics.Stopwatch

2008-06-13T11:50:00.001-07:00

I've noticed in a few forums here and there that, when gathering performance data, many developers often compare two System.DateTime objects (a before and an after object) to measure time-based performance stats. This works fine, but there's a much better way provided by the Stopwatch class in the System.Diagnostics namespace.

The Stopwatch class, believe it or not, works just like a real stopwatch. It has a method called Start(), a method called Stop(), and a few properties, Elapsed (which returns a TimeSpan) and EllapsedMilliseconds (which returns a long), that give you easy access to how long it took for your code to run. To start measuring performance you call the Start() method, and when your code is done doing what you want to measure, call Stop(). Then spit out the EllapsedMilliseconds somewhere convenient, maybe using a Tracepoint.

If your hardware and OS support a high-resolution performance counter, Stopwatch will use that, otherwise it measures time using the system timer. You can check if you high-res performance measurement is available using the IsHighResolution property.

Sample code is readily available in MSDN offline and online documentation.

Technorati Tags: Stopwatch,.Net Performance,Tracepoint,System.Diagnostics

Supporting IE 8

2008-06-12T05:46:00.001-07:00

Bill Gates announced during his Tech Ed keynote in Orlando last week that IE 8 Beta 2 would be released this August. You may already be aware that Microsoft has decided to release the final version of IE 8 with standards-compliant mode enabled, which will break many sites that assume that Internet Explorer is not a standards compliant browser.

To make it easy for sites to support IE 8 while retaining backward compatibility, Microsoft is introducing a few compatibility features.

A meta tag that will enable IE 7 mode on a per page basis (note that this is already available in Beta 1). This meta tag must be placed within a page's <HEAD> tags, thusly:

<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" />

Other browsers will of course ignore this tag.

If you want to enable IE 7 layout for an entire site, you can add a custom header (this will be available in Beta 2 this August):

X-UA-Compatible: IE=EmulateIE7

When IE 8 detects either the site header or the meta tag, it will then look at each document's DOCTYPE to determine whether to render the page in IE 7 Quirks or IE 7 Standards mode.

One migration strategy would be to add the site-wide EmulateIE7 header, and add the meta tag with content="IE8" to pages as they are modified to support IE 8's standards-compliant layout mode.

For more information on adding custom headers on various versions of IIS and Apache, notes about detecting different browser versions, and more, I refer you to the Internet Explorer blog on MSDN.

Technorati Tags: IE 8,IE Standards

Touching Windows 7

2008-06-11T13:29:00.001-07:00

Bill Gates and Steve Ballmer gave a recent demo of the new Windows 7 user interface at the D6 executive conference this year. Or at least the touchy, feely bits. Check out the YouTube vid below for a look (warning: this video is eerily silent until the last few seconds, for some inexplicable reason).

Very nice and all, but this seems to violate the don't touch my monitor directive that many people (including myself) are quite passionate about. My brother in particular is fanatical about keeping dirty fingers away from his monitor.

Which just makes sense. Who wants to write code through a thin layer of greasy smears? Or look at pictures, browse the web, play games, or pretty much anything?

So, maybe I just don't get it, but not sure this feature would see much mileage on my desktop.

Technorati Tags: Windows 7

SQL Server 2008 Feature Highlights

2008-06-11T12:35:00.001-07:00

I just got back from Tech Ed 2008 in Orlando, FL, last week, and, having drunk deeply from the pool of Microsoft Kool-Aid, am full of exciting tidbits. I attended several sessions that revolved around some of the new stuff that will be part of SQL Server 2008 (due for release around Q3 of 2008), which I'd like to discuss in this post. Keep in mind this is a broad overview (with links to resources for a closer look), smattered with some key insights I garnered from a few of the Tech Ed speakers.

So without further ado, let's dive right in.

Data Compression

This isn't compression in the traditional sense – SQL Server 2008 won't be ZIP compressing and uncompressing your data on the fly, or anything like that, it will just be way smarter when it comes to storing data compactly. One way it will accomplish this is using variable length data types, which allows SQL Server to use
only the bytes necessary instead of reserving unused bytes just because you declared (for example) a column as char(20) and only used two characters.

SQL Server 2008 can also maintain PAGE or ROW level references to duplicate data. For example, if several columns in a ROW contain the same default values, SQL Server will store the value once, and refer back to that stored value when it's used again in that same ROW or PAGE. This is a setting you can turn on or off, as necessary.

Sparse Columns

Entity-Attribute-Value (EAV) is a "popular" way of storing data that (supposedly) can't be modeled. An EAV table is generally comprised of two columns, NAME and VALUE, the latter of which is typed as either nvarchar or sql variant so that anything can be dumped into it, rather like a property bag. Yes, this solution does indeed have the appearance of nastiness, but ever so often you run into a situation where some database entities will have properties that no other entities share. And EAV is a common way of modeling that scenario.

Enter sparse columns: SQL Server 2008 allows you to designate a column as sparse, which means if its value is NULL it won't consume any space on disk. The idea behind sparse columns is that they will be NULL most of the time, and so won't consume physical space, allowing SQL Server 2008 to support up to 30,000 columns! That nasty EAV table can now be turned into a super-wide table of strongly typed sparse columns.

But that's not all! Sparse columns can be combined into a column set that allows you to return all sparse columns together as one XML column. Even better, any sparse columns with NULL values won't be included in the XML column, which helps keep things nice, simple, and manageable, which is important when you're working with a 30,000 column table.

There are some downsides to sparse columns, namely performance related. They also take up a tad more space when they're non-NULL than other column types.

Spatial data

SQL Server 2008 will include new spatial types (GEOMETRY and GEOGRAPHY), along with new functions for performing spatial calculations, such as how far one location is from another and so forth. The difference between the two data types is simple: GEOMETRY is flat, GEOGRAPHY is ellipsoidal. Think of GEOMETRY as a way to represent points on the Cartesian Coordinate System, or maybe to model a warehouse floor plan, whereas GEOGRAPHY can represent real-world geographical locations on the spherical world we live on. Which isn't flat, but you knew that, right?

These data types are abstract, in the sense that a column defined as GEOMETRY can store a Point, a Curve, a MultiPolygon or any of several types that "inherit" from GEOMETRY. For more information on how this works, check out Jason Follas' excellent blog post on spatial types.

Someone in one of the Tech-Ed sessions mentioned that SQL Server Management Studio will include a new results pane view for displaying spatial type results, but I haven't yet had a chance to see that for myself.

The HierarchyID Datatype

The new HierarchyID data type provides a compact and "easy" way to model a tree, which in the past had to be modeled using several tables. Now you can model a tree using only one column.

Behind the scenes, the HierarchyID type borrows a lot of its functionality from the XML type, XML having a tree-like internal representation (every node has a single parent and none or more children). It's important to note that the HierarchyID type doesn't completely remove all the effort from the developer – application logic is still necessary to maintain the integrity of the tree. Nothing is stopping you, for example, from inserting an "orphan" node that doesn't have a parent, which in some cases might fit into your application's design goals.

The benefits of using the HierarchyID type (over modeling your own tree representation) are many:

The HierarchyID type is very compact. According to MSDN, a node in an organization hierarchy with 100,000 people with an average fanout of 6 levels takes about 38 bits, which would be rounded up to 5 bytes for storage.
Comparison is in depth-first order (you can change this in SQL, if desired), but in a nutshell in means you don't have to implement your own custom sorting logic – SQL Server will sort your tree correctly when it's queried.
Support for arbitrary insertions and deletions, which means you don't have to write any fancy tree-balancing logic or whatnot, and you can easily insert nodes pretty much anywhere in the tree.

A potential downside to the HierarchyID type is that it can't handle truly ginormous trees, where the size of the HierarchyID value would exceed 892 bytes. Given the above example of a 100,000 node tree consuming 5 bytes, I'm guesstimating that the HierarchyID could support trees of up to 17 million nodes, which should be more than adequate for most scenarios.

FILESTREAM

In past versions of SQL Server, storing files was problematic. You either had to store files on a file server, and save a reference to each file in SQL Server (which meant files weren't included in database backups, introduced the potential for files to be modified outside of SQL transactions, etc, but was faster than storing the files inside SQL Server), or suck files into SQL Server as BLOBS (which had performance implications, and was a bit more complicated to retrieve files that just opening a file from disk).

Now SQL Server 2008 brilliantly offers a third option: storing files on disk while retaining the transactional context that SQL Server provides. To store a BLOB as a FILESTREAM, you must first set up a filegroup for BLOB storage. Any BLOBS written to the filegroup are included in database backups, and participate in SQL transactions, but are not stored within SQL Server.

And here's the real kicker: you can access FILESTREAM objects directly from your middle tier .Net code using a lightweight wrapper object. When accessing FILESTREAM objects in this way, you still get full SQL transactional support, which means you can open a file, modify its contents, and roll it back or commit, all without going directly through SQL Server (you do have to use the lightweight wrapper object, however).

For more information on FILESTREAM, visit this great article from MSSQLTIPS.com.

XML Enhancements

In SQL Server 2005, you could create a Schema Collection to validate an xml column against an XML schema. But in some scenarios you might want to validate all of the XML data except for a specific section or two, which might contain dynamically generated or otherwise unpredictable XML. To support these types of scenarios, SQL Server 2008 introduces better support for Lax Validation by introducing the processContents="lax" attribute. This setting will enforce schema validation for any elements that have schema declarations associated with them, but ignore any elements not defined in the schema.

When modifying a schema that contains lax validation, XML columns that reference said schema will be revalidated, which should make for a nice and simple way to add support for new strongly typed XML blocks in a schema without breaking stuff. I haven't had a chance to actually try this out, so feel free to leave me some feedback and let me know how this works.

SQL Server 2008 also includes full xs:datetime support; you can omit the time zone, but any time zone information provided is preserved. This is actually the case across the board in SQL Server 2008, which provides much improved support for time zone offsets when storing date time information.

In addition to these enhancements, SQL Server 2008 also offers the new Union and List XML types, which make it easier to define and work with XML lists. Union and List types are a topic unto themselves, so I refer you to the below whitepaper for a deeper look at this and a few other enhancements you just can't live without!

Whitepaper: What's New for XML in SQL Server 2008

Visual Studio 2008 Extensions for Windows Sharepoint Services released!

2008-06-04T18:27:00.001-07:00

Today, Microsoft released Windows Sharepoint Services 3.0 Tools, version 1.2, which contains mostly the same feature set as version 1.1, but now with support for VS.Net 2008.

To develop solutions for Windows Sharepoint Services (in the most productive way), you'll need to install the following:

Windows Sharepoint Services 3.0, installed locally
Visual Studio.Net 2008
This update (VS.Net 2008 Extensions for WSS 3.0)

Why I Migrated from Wordpress

2008-05-22T06:46:00.001-07:00

The real money isn't in the software. It's in the service you build with that software.
Jeff Atwood

Note: This post compares Blogger with Wordpress.com, and not the free Wordpress product available at Wordpress.org which you can install and manage yourself on a hosted server.

I had used Google's Blogger in the past for my personal blog, but had heard such good things about Wordpress (mostly that several A-List bloggers used it, ala Robert Scoble) that I thought I would give it a try. And initially I was impressed by it's auto-pingback feature (which I believe Blogger still lacks), and how you could create Pages, which meant you could construct a mini web site around your blog. Perfect for my needs, or so I thought.

The biggest problem I had with Wordpress was that you could customize the CSS, provided you shelled out some dough, but that was pretty much it. There's no way for you to get at the actual HTML of your blog. This really hit home when I tried to add the JavaScript code Google Analytics requires to track site traffic. Interestingly, Wordpress uses Google Analytics to track site traffic to your blog behind the scenes, but they prohibit you from adding Google Analytics code directly to your blog. And even though they're tapping into the power of Google Analytics, they're not passing along the benefits to their blog users – Wordpress traffic statistics reporting stinks (compared to Google Analytics, anyway).

Of course, if I had downloaded Wordpress from Wordpress.org and installed it myself, I would have faced none of these issues, and I would have had total control over my blog. But there were several reasons why I didn't want to go that route.

Planning ahead, I'm assuming that one day this blog will be very popular and will consume a lot of bandwidth. If my blog were hosted on Blogger or Wordpress (or any other free blog site) I wouldn't have to pay for that bandwidth, redundant servers, backend database systems, etc.
As Jeff Atwood noted, Wordpress performance stinks. Yeah, I know, unless you enable caching using WP-Cache, or some other caching mechanism. As far as I can tell, and for some bizarre reason, this isn't enabled by default. But let's say, for the sake of argument, that with the proper tweaks and configuration Wordpress is the best performing blog system on earth. In that case I don't really care – I barely have time to write coherent blog posts, much less time enough to figure out why my blog suddenly died because it got a few thousand extra visits.

And so here I am at my new domain, www.toastedcode.com, hosted by Blogger, with lots of new bells and whistles from Disqus and FeedBurner and a snazzy UI, all of which were a pain to get cranking on Wordpress. Granted, if I had set up a domain a long time ago the transition between blog providers would have been greatly eased. But sometimes progress is painful, right?

If you're interested to know how I imported all my posts from Wordpress to Blogger, you can read about that process here.

And I say to you, welcome to my new home!

Installing Fedora 9

2008-05-20T05:49:00.001-07:00

There is only one satisfying way to boot a computer.
J. H. Goldfuss

I'm not by any means an expert in Linux, but over the weekend I decided to try to install the latest Fedora release (version 9) to see what all the hoopla was about. My hardware platform of choice was a VMWare Workstation virtual machine, with around 500 MB of RAM allocated, and a 10 GB expandable hard drive, all of which seemed adequate.

One of the reasons I chose Fedora over Ubuntu for my first Linux installation was a fairly simple one. I couldn't get Ubuntu to download (from Ubuntu.com). The connection kept timing out about halfway through, which was enough of a nuisance to make me stop trying. Mayhaps the fault was mine somehow, but I was able to download Fedora 9 with no issues.

Anyhoo, I wanted to approach this "review" from the perspective of a typical user – someone looking for basic web browsing, document editing functionality from a PC, with little if any pre-existing knowledge of Linux. I fit that last description nicely, since I've never seen a Linux desktop before. Would Fedora be a good bet for Grandma? That's what I wanted to find out.

I booted up from the Fedora ISO image I had downloaded earlier, and within seconds the pleasantly designed Fedora installer UI appeared. Nice.

No DOS-like installer here, and clicking the Next button allowed me to select my language, and then (on the following screen) my keyboard language (layout). I'm guessing most people know what language they speak: so far easy as pie.

Next, I clicked Yes to create a new partition.

The next screen presented networking options. I opted to enable DHCP, as most people probably would, and went on to the next step.

I found it interesting (and positive) that from this point on the Fedora install was able to swing on out to the Internet and download additional packages and whatnot. Networking worked without a hitch before the installation had completed. So far, this was proving to be brain dead easy. I was impressed.

I thought the next screen, where I was asked to select my time zone from a map, was a much simpler approach than having to choose the appropriate GMT offset (in my case, GMT – 5) from a drop-down list. But just a tiny suggestion – if you're going to let people choose their time zone from a map, the time zones should maybe appear as highlighted regions so you can select your time zone instead of the closest city. For example, Monticello is awful close to the left edge of the Eastern Standard zone – it would help if I could see where it falls in respect to time zones. But that's kinda nit-picky.

Also of note was that Atlanta, the largest city in the South East, and frequently called the New York of the South, was nowhere to be found. That hurt my feelings.

Next, some more questions about partitioning. I accepted the defaults and moved on.

And then Fedora was off and away to format the new partition.

After the partition was all set up, I was asked if I wanted to install additional software. I thought this was actually quite nice. Very nice, in fact, as (in theory, at least) it let me hit the ground running with everything I (or Mom/Grandma, as the case might be) might need to edit documents, and just be productive.

I decide to go hog wild and select everything.

And that's when I hit my first little snag. Whoopsadaisy! The option to install "Additional Fedora Software" caused a big 'n' nasty unable to read package metadata error. So I just unchecked that option and everything proceeded without a hitch. I'm still not sure what I would have gotten as part of "Additional Fedora Software".

After about 10 or 15 minutes while all of my software choices were installed (well, except for Additional Fedora Software, that is), Fedora started booting up! Woohoo!

And a nice looking boot up screen it was, too.

Here's the login screen after the startup process completed.

So I immediately popped in and started messing about. The first thing I did was try to change the display settings to a higher resolution. And that's when I got my first big surprise.

A User Account Control dialog! Apparently I need "root" access to change my resolution settings. And, as I soon discovered, Fedora prompts you for the root password when you try to do any admin-level task, just like Windows Vista! Wasn't this one of the "features" everyone was complaining about in Vista? That users would find it aggravating beyond belief?

Again, I'm a self-professed Linux newbie, so maybe this has been in Fedora since version 1. All I know is UAC is in Fedora now. And to be honest, I don't think that's a bad thing. I've always been very positive about UAC in Vista; I think it makes the OS more secure, and I've never been annoyed at its not-so-often-as-people-think dialogs (which I still haven't disabled yet, I might add). So I'm not complaining. I'm just sayin', that's all.

But back to changing the Display Settings: surprisingly, after I selected the new resolution settings I was presented with the below dialog prompting me to reboot! Say whut now? I need to reboot just to change my display settings?

That's kinda stinky-winky. What if I change my display settings to a resolution my monitor doesn't support, and I can't get back into the OS. That is so 1995-ish. Giving the benefit of the doubt since I'm not a Linux power user, maybe this isn't really a problem for some reason unbeknownst to yours truly. But this struck me as kinda goofy. Also the fact that, after rebooting, my display settings hadn't changed!

I found the UI layout intriguing. Fedora has two task bars – a bottom bar for displaying running applications, and a top bar for accessing System options. One of the System options I found interesting was the Notes feature, which allows you to keep note-ful items at the ready (and searchable).

Another handy feature (depending on your style of working) is Fedora's support for multiple desktops. At the bottom right of the screen are four little squares that represent four separate desktops, which you can use to keep tons of running applications organized. Multiple desktop support comes in various flavors for Windows, but I haven't yet figured out how to use multiple desktops in a way that improves my productivity.

The Final Word

After this first impression, I think Fedora would make be a great fit for your parent or other relative/friend that needs a cheap PC for browsing the web, reading email, editing documents and other simple tasks. The active word here being cheap. Fedora still seemed a little flaky in spots, for example when changing display settings. And what if a Fedora user decides to get into digital photography, or wants to install TurboTax in April? That could cause some problems.

But the installation went incredibly smoothly, and I was quite impressed by the overall experience. I plan to use Fedora as a test platform for Mono.Net applications, general experimentation and so forth. But as my primary (or even secondary OS)? I think Fedora still has a long way to go before that becomes a remote possibility.