The Developing Developer

Important: ASP.NET Security Vulnerability

2010-09-20T09:37:00.002+08:00

A few hours ago we released a Microsoft Security Advisory about a security vulnerability in ASP.NET. This vulnerability exists in all versions of ASP.NET.

http://weblogs.asp.net/scottgu/archive/2010/09/18/important-asp-net-security-vulnerability.aspx

Silverlight - The project type is not supported by this installation.

2010-07-12T10:51:00.002+08:00

Launch a command window, navigate to "C:\Program Files\Microsoft visual Studio x\Common7\IDE" (where x is the version number. i.e. 8, 9.0, 10.0) and run:

devenv /setup

SQL Optimization

2010-04-06T10:52:00.002+08:00

I recently had to do some serious optimization to our SQL servers as load testing revealed that they would not cope under load. I found this article by Grant Fritchey, that was very helpful and I thought I'd share.

Controlling Execution Plans with Hints

SQL Server Index Basics

2009-12-18T10:46:00.006+08:00

SQL Server Index Basics
25 November 2008
by Robert Sheldon

Given the fundamental importance of indexes in databases, it always comes as a surprise how often the proper design of indexes is neglected. It often turns out that the programmer understands detail, but not the broad picture of what indexes do. Bob Sheldon comes to the rescue with a simple guide that serves either to remind or educate us all!

One of the most important routes to high performance in a SQL Server database is the index. Indexes speed up the querying process by providing swift access to rows in the data tables, similarly to the way a book’s index helps you find information quickly within that book. In this article, I provide an overview of SQL Server indexes and explain how they’re defined within a database and how they can make the querying process faster. Most of this information applies to indexes in both SQL Server 2005 and 2008; the basic structure has changed little from one version to the next. In fact, much of the information also applies to SQL Server 2000. This does not mean there haven’t been changes. New functionality has been added with each successive version; however, the underlying structures have remained relatively the same. So for the sake of brevity, I stick with 2005 and 2008 and point out where there are differences in those two versions.

Index Structures
Indexes are created on columns in tables or views. The index provides a fast way to look up data based on the values within those columns. For example, if you create an index on the primary key and then search for a row of data based on one of the primary key values, SQL Server first finds that value in the index, and then uses the index to quickly locate the entire row of data. Without the index, a table scan would have to be performed in order to locate the row, which can have a significant effect on performance.

You can create indexes on most columns in a table or a view. The exceptions are primarily those columns configured with large object (LOB) data types, such as image, text, and varchar(max). You can also create indexes on XML columns, but those indexes are slightly different from the basic index and are beyond the scope of this article. Instead, I'll focus on those indexes that are implemented most commonly in a SQL Server database.

An index is made up of a set of pages (index nodes) that are organized in a B-tree structure. This structure is hierarchical in nature, with the root node at the top of the hierarchy and the leaf nodes at the bottom, as shown in Figure 1.

Figure 1: B-tree structure of a SQL Server index

When a query is issued against an indexed column, the query engine starts at the root node and navigates down through the intermediate nodes, with each layer of the intermediate level more granular than the one above. The query engine continues down through the index nodes until it reaches the leaf node. For example, if you’re searching for the value 123 in an indexed column, the query engine would first look in the root level to determine which page to reference in the top intermediate level. In this example, the first page points the values 1-100, and the second page, the values 101-200, so the query engine would go to the second page on that level. The query engine would then determine that it must go to the third page at the next intermediate level. From there, the query engine would navigate to the leaf node for value 123. The leaf node will contain either the entire row of data or a pointer to that row, depending on whether the index is clustered or nonclustered.

Clustered Indexes
A clustered index stores the actual data rows at the leaf level of the index. Returning to the example above, that would mean that the entire row of data associated with the primary key value of 123 would be stored in that leaf node. An important characteristic of the clustered index is that the indexed values are sorted in either ascending or descending order. As a result, there can be only one clustered index on a table or view. In addition, data in a table is sorted only if a clustered index has been defined on a table.

Note: A table that has a clustered index is referred to as a clustered table. A table that has no clustered index is referred to as a heap.

Nonclustered Indexes
Unlike a clustered indexed, the leaf nodes of a nonclustered index contain only the values from the indexed columns and row locators that point to the actual data rows, rather than contain the data rows themselves. This means that the query engine must take an additional step in order to locate the actual data.

A row locator’s structure depends on whether it points to a clustered table or to a heap. If referencing a clustered table, the row locator points to the clustered index, using the value from the clustered index to navigate to the correct data row. If referencing a heap, the row locator points to the actual data row.

Nonclustered indexes cannot be sorted like clustered indexes; however, you can create more than one nonclustered index per table or view. SQL Server 2005 supports up to 249 nonclustered indexes, and SQL Server 2008 support up to 999. This certainly doesn’t mean you should create that many indexes. Indexes can both help and hinder performance, as I explain later in the article.

In addition to being able to create multiple nonclustered indexes on a table or view, you can also add included columns to your index. This means that you can store at the leaf level not only the values from the indexed column, but also the values from non-indexed columns. This strategy allows you to get around some of the limitations on indexes. For example, you can include non-indexed columns in order to exceed the size limit of indexed columns (900 bytes in most cases).

Index Types
In addition to an index being clustered or nonclustered, it can be configured in other ways:

Composite index: An index that contains more than one column. In both SQL Server 2005 and 2008, you can include up to 16 columns in an index, as long as the index doesn’t exceed the 900-byte limit. Both clustered and nonclustered indexes can be composite indexes.

Unique Index: An index that ensures the uniqueness of each value in the indexed column. If the index is a composite, the uniqueness is enforced across the columns as a whole, not on the individual columns. For example, if you were to create an index on the FirstName and LastName columns in a table, the names together must be unique, but the individual names can be duplicated.

A unique index is automatically created when you define a primary key or unique constraint:

Primary key: When you define a primary key constraint on one or more columns, SQL Server automatically creates a unique, clustered index if a clustered index does not already exist on the table or view. However, you can override the default behavior and define a unique, nonclustered index on the primary key.

Unique: When you define a unique constraint, SQL Server automatically creates a unique, nonclustered index. You can specify that a unique clustered index be created if a clustered index does not already exist on the table.

Covering index: A type of index that includes all the columns that are needed to process a particular query. For example, your query might retrieve the FirstName and LastName columns from a table, based on a value in the ContactID column. You can create a covering index that includes all three columns.

Index Design
As beneficial as indexes can be, they must be designed carefully. Because they can take up significant disk space, you don’t want to implement more indexes than necessary. In addition, indexes are automatically updated when the data rows themselves are updated, which can lead to additional overhead and can affect performance. As a result, index design should take into account a number of considerations.

Database
As mentioned above, indexes can enhance performance because they can provide a quick way for the query engine to find data. However, you must also take into account whether and how much you’re going to be inserting, updating, and deleting data. When you modify data, the indexes must also be modified to reflect the changed data, which can significantly affect performance. You should consider the following guidelines when planning your indexing strategy:

For tables that are heavily updated, use as few columns as possible in the index, and don’t over-index the tables.

If a table contains a lot of data but data modifications are low, use as many indexes as necessary to improve query performance. However, use indexes judiciously on small tables because the query engine might take longer to navigate the index than to perform a table scan.

For clustered indexes, try to keep the length of the indexed columns as short as possible. Ideally, try to implement your clustered indexes on unique columns that do not permit null values. This is why the primary key is often used for the table’s clustered index, although query considerations should also be taken into account when determining which columns should participate in the clustered index.

The uniqueness of values in a column affects index performance. In general, the more duplicate values you have in a column, the more poorly the index performs. On the other hand, the more unique each value, the better the performance. When possible, implement unique indexes.

For composite indexes, take into consideration the order of the columns in the index definition. Columns that will be used in comparison expressions in the WHERE clause (such as WHERE FirstName = 'Charlie') should be listed first. Subsequent columns should be listed based on the uniqueness of their values, with the most unique listed first.

You can also index computed columns if they meet certain requirements. For example, the expression used to generate the values must be deterministic (which means it always returns the same result for a specified set of inputs). For more details about indexing computed columns, see the topic “Creating Indexes on Computed Columns” in SQL Server Books Online.

Queries
Another consideration when setting up indexes is how the database will be queried. As mentioned above, you must take into account the frequency of data modifications. In addition, you should consider the following guidelines:

Try to insert or modify as many rows as possible in a single statement, rather than using multiple queries.

Create nonclustered indexes on columns used frequently in your statement’s predicates and join conditions.

Consider indexing columns used in exact-match queries.

Index Basics
In this article, I’ve tried to give you a basic overview of indexing in SQL Server and provide some of the guidelines that should be considered when implementing indexes. This by no means is a complete picture of SQL Server indexing. The design and implementation of indexes are an important component of any SQL Server database design, not only in terms of what should be indexed, but where those indexes should be stored, how they should be partitioned, how data will be queried, and other important considerations. In addition, there are index types that I have not discussed, such as XML indexes as well as the filtered and spatial indexes supported in SQL Server 2008. This article, then, should be seen as a starting point, a way to familiarize yourself with the fundamental concepts of indexing. In the meantime, be sure to check out SQL Server Books Online for more information about the indexes described here as well as the other types of indexes.

Author profile: Robert Sheldon

After being dropped 35 feet from a helicopter and spending the next year recovering, Robert Sheldon left the Colorado Rockies and emergency rescue work to pursue safer and less painful interests—thus his entry into the world of technology. He is now a technical consultant and the author of numerous books, articles, and training material related to Microsoft Windows, various relational database management systems, and business intelligence design and implementation. He has also written news stories, feature articles, restaurant reviews, legal summaries, and the novel 'Dancing the River Lightly'. You can find more information at http://www.rhsheldon.com/.

Search for other articles by Robert Sheldon

Microsoft PDC 09

2009-12-01T07:51:00.002+08:00

If like me, life got in the way of you being at the 2009 PDC and you getting your free ACER laptop/tablet, there is some hope. Microsoft have graciously, as usual, posted the videos on the PDC website for the rest of us to enjoy.

http://microsoftpdc.com/
http://microsoftpdc.com/Videos

Maybe next year, right?
:(

Using the using statement with WCF proxy.

2009-11-26T11:27:00.013+08:00

There are many post on the net telling you not to use the using statement with WCF proxies. Now while the intent is good, I feel that is a good code practice to use the using statement where appropriate to automatically dispose of your objects.

This is obviously a controversial statement as using the using statement with a WCF proxy can throw unwanted error(s) when trying to call the close method on a service that is in a faulted state.

I have reasently been privileged enough to go on a WCF Workshop presented by Mahesh Krishnan from Readify, where he showed me the right way to do this.

When the using statement is exited, it calls the dispose method on the proxy class. So it is simple. Overload the Dispose method, checking the state of the service. If faulted then call the abort method, if not call close. Simple and elegant.

For those of you who have generated proxy classes, remember that the generated proxy class is a partial class... So you can create another partial class with the same name and do your overload there.


try
{       
  if(this.State == CommunicationState.Faulted)
  {
    this.Abort();
  }
  else
  {
    this.Close();
  }
}
catch (Exception)
{
  this.Abort();
}

Never compromise on code quality!

Event Extensions: Methods for firing events and managing event listeners

2009-06-30T10:05:00.010+08:00

In most modern C# applications, generous usage of events have become the norm. Gone are the days where we were afraid to use them because of the "black magic" code that they seemed to execute.

Today, perhaps the opposite is true, and they are used too lightly, with disregard for the memory leeches they are (those small, black slimly kind that you're never aware of what damage they're doing until it's too late).

Here's some code to make usage of the leeches a little easier :).

The typical firing of an event from C# code looks something like this:

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

There are 2 essential problems with this code:

It's too many lines of code for something so mundane.

What happens if there are more than 1 listeners listening to the event, and one of them throws an exception? Normal .NET behaviour dictates that the other listeners never get to hear about the event, but what if it's important that all listeners know about the event before application execution is halted?

Solution to problem #1: wrap the logic in an extension method

MyEvent1.Raise(this, EventArgs.Empty);

there - isn't that better? Here's sample of the implementation:

public static void Raise(this EventHandler handler, object sender, EventArgs e)
{
 if (handler != null)
 {
   handler(sender, e);
 }
}

Solution to problem #2: expand on the extension method (now that all the logic is conveniently in one place)

MyEvent1.Raise(this, EventArgs.Empty, true);

...where the boolean parameter tells the extension method to make sure that all the event listeners get to hear about the event before throwing an exception. The exception that is then thrown, is an EventListenerException, which is just basically a wrapper for all exceptions that occurred on the event listener's event handling code.

sample implementation: (called from the event extension method)

private static void ManageEventListeners(IEnumerable delegates, object sender, EventArgs e)
{
EventListenerException eventListenerException = null;
foreach (Delegate listner in delegates)
{
//the listner could throw an unhandled exception in the handler method
//make sure that the other listners still handle event if this is the case
try
{
 listner.DynamicInvoke(new[] {sender, e});
}
catch (TargetInvocationException ex)
{
 //add a new event listner
 EventListener eventListener = new EventListener
                                   {
                                     Listener = listner,
                                     ListenerException = ex.InnerException
                                   };

 //NOTE: The exception which occurs is "TargetInvokationException", but the
 //actual exception which occurs in the listner is contained in the innerException

 //add listner to eventListnerException
 if (eventListenerException == null)
 {
   eventListenerException = new EventListenerException();
 }
 eventListenerException.EventListenerCol.Add(eventListener);
}
}

//if an exception was thrown by one of the listner's event handlers
if (eventListenerException != null)
{
 throw eventListenerException;
 //then re-throw the exception that thrown in the handler
}
}

Here's some sample code with unit tests included in case you need to play with the code (NUnit 2.4.7 & VS 2008)

PS: It's Silverlight compatible (of course :) )

Original post by: JAX

TFS Baseless Merges

2009-06-18T15:04:00.004+08:00

The branch command creates a relationship between two folders which you can leverage to perform merges of code between the branches. The relationship is bi-directional so code can be merged both ways but Team Foundation Server currently doesn’t facilitate merging between child branches. To begin to understand baseless merges, let’s consider the following structure:

In the scenario above, we have well-defined code promotion path between:

$/MyProduct/MAIN <=> $/MyProduct/PRODUCTION/Release1.0
$/MyProduct/MAIN <=> $/MyProduct/PRODUCTION/Release2.0

These code promotion paths exist because both Release1.0 and Release2.0 under production are children of MAIN. Unfortunately, there is no direct relationship between the child branches - Release1.0 and Release2.0, which makes it difficult for us to merge, for example, a hotfix from Release1.0 into Release2.0 without having to traverse through $/MyProduct/MAIN.

If we followed the merge path established by the branch command, a fix from Release1.0 will need to be merged in the following sequence for it to be available in the Release2.0 branch:

$/MyProduct/PRODUCTION/Release1.0 => $/MyProduct/MAIN => $/MyProduct/PRODUCTION/Release2.0

In some cases it may not be feasible to traverse through MAIN because MAIN could potentially have moved far ahead of the source code versions in both Release1.0 and Release2.0, and it would take a significant amount of work to merge, build, and test the hotfix in MAIN. Here is where baseless merges become necessary. The following diagram explores the existing relationship and baseless merges.

MSDN defines a baseless merge as “a merge (performed) without a basis version.” That is, it allows the user to merge files and folders that do not have a branch/merge relationship. After a baseless merge, a merge relationship exists and future merges do not have to be baseless.

While baseless merges are a powerful feature that Team Foundation Server provides (only via the command line; see: How To: Perform a Baseless Merge in Visual Studio Team Foundation Server) we recommend that you use this feature sparingly and only under very exceptional circumstances. In most cases, a well-defined code promotion model should provide you with a good way to merge changes without have to resort to baseless merges.

Original post by: grahamba

Disabling the back button on the browser.

2009-06-10T13:45:00.004+08:00

Now this sounds like a trivial exercise right? When I tried to search for this, I found hundreds of answers to this question and none of them worked. Then finally I stumbled on to this gem, I thought I’d share it with you.


function noBack(){window.history.forward();setTimeout(”noBack()”, 500);}
noBack();
window.onload=noBack;
window.onpageshow=function(evt){if(evt.persisted)noBack()}
window.onunload=function(){void(0)}

Silverlight 3

2009-03-26T08:07:00.003+09:00

Some links to and about the new Silverlight 3 (BETA) release.

Everything you need to get started

http://silverlight.net/getstarted/silverlight3/default.aspx

Silverlight Toolkit

http://silverlight.codeplex.com/

Building Silverlight 2 and Silverlight 3 Beta applications on the same machine

http://www.jeff.wilcox.name/2009/03/sxs-sl2-sl3-building/

Silverlight 3 Release Date (RTW) Surprise

http://silverlighthack.com/post/2009/03/22/Silverlight-3-Release-Date.aspx

Getting Started with Virtual Earth Silverlight Map Control SDK CTP

http://pietschsoft.com/post/2009/03/Getting-Started-Virtual-Earth-Silverlight-Map-Control-SDK-CTP.aspx

Hight-Speed RIA Development with the Microsoft Silverlight Toolkit

http://videos.visitmix.com/MIX09/T15F

Sample LOB Silverlight application

http://labs.cas.de/silverlight/CASPIASL/

The ViewModel Pattern. (WPF & Silverlight)

2009-02-17T10:14:00.001+09:00

A great article on the Model-View-ViewModel pattern by David Hill.
http://blogs.msdn.com/dphill/archive/2009/01/31/the-viewmodel-pattern.aspx

TFS Offline Solution

2009-02-12T09:17:00.003+09:00

When and how does my solution go "offline"?
TFS 2008 adds improved support for "offline" scenarios. This blog post identifies the scenarios under which a solution will be placed in "offline" mode.

If the Visual Studio IDE is unable to connect to the TFS server when it is opening the solution, then it will mark the solution as being offline. It will also mark the TFS server as being offline. A messagebox will be displayed indicating the solution was taken offline and a message to the same effect will appear in the Output window.
If the Visual Studio IDE is opening a solution and finds the TFS server to which the solution is bound is marked as offline, then VS will mark the solution as being offline
In this scenario, a message about the solution being opened offline will appear in the Output window, but no messagebox will appear.

Notes

Offline detection is done ONLY during solution open. Failures to connect to the server during other version control operations within VS do not affect the offline state of the solution or server.
The offline state for the solution is stored in the solution's local .suo file.
When the server is marked offline, we also turn off the server's "AutoReconnect" setting.
The server's offline state is stored in a registry value named Offline, and the AutoReconnect state is stored in in a value named AutoReconnect. Both of these live under the key: HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\TeamFoundation\Servers\
A solution remains offline until it is explicitly taken online.
A TFS server remains marked offline until an offline solution bound to that server is taken online.
Opening a solution that was previously marked offline while its server is still marked offline opens the solution without any messageboxes appearing. We will present a message in the Output window indicating the solution is still offline.
Opening a solution that was previously marked offline when its server is marked online presents the user with a messagebox.

Original post by: Benryan

VS2008 fails to uninstall.

2009-02-12T09:10:00.002+09:00

A couple of days ago I needed to add C++ to my VS2008 install. When I tried to open the setup from add remove programs it just failed. After a couple of hours of struggling I came to the conclusion that my only option was to uninstall and the reinstall.

To my surprise I was unable to uninstall Visual Studio. After searching the web for a while I found the solution to uninstalling Visual Studio 2008. I thought I'd share this with everybody as I doubt that I'm the only one having this problem.

http://msdn.microsoft.com/en-us/vstudio/bb968856.aspx

C# 4.0 - New Features

2009-02-11T12:12:00.002+09:00

This article summarizes the changes that are going to be present in C# 4.0. C# 4.0 is scheduled to be released sometime during 2010 along with the new version of Visual Studio which has been "Rosario". In the meantime, if you are an early adopter, CTPs will be made publicly available as a Virtual PC image.

Dynamic Look up - This feature will give you the ability to resolve names during run time instead of at compile time. In Visual Basic .NET this is referred to as "late binding" and has been available for quite some time now. Dynamic look up will be very useful for solutions which involve any kind of COM Interop. COM Interop allows .NET code to call COM components and COM code to call .NET components. An example of this would be Office automation.

Named and optional parameters - Finally we have the ability to specify default values for parameters. In additional optional arguments can be added to the method signature. These changes should reduce the need for method overloading and increase the compatibility between C# and Visual Basic.

Covariance and Contravariance - These topics can be a little bit hard to wrap your head around. Therefore lets starts with some definitions. An operator between types is said to be covariant if it orders these types from more specific to more general ones. Similarly an operator between types is said to be contravariant if it orders them in the reversed order. Whenever neither of these conditions is met, an operator is said to be invariant.

In any case covariance, contravariance and invariance already exist in the C# language. The changes made in 4.0 will just make these features a little easier to utilize. For a good overview of the topic read Charlie Calvert's post. If you still want more information then visit Eric Lippert's blog. He has a series of posts on the topic.

In conclusion, C# 4.0 will continue to evolve based on the trend of dynamic programming. This is primarily due to a ripple effect created by languages like IronRuby, IronPython and Visual Basic. On the flip side, VB will also get some language enhancements in order to keep it on even keel with C#. Perhaps someday the classic debate between C# and VB.NET developers about which language is better may start to fade away. This will be primarily due to the standardization of features across languages.

Original post by: Michael Ceranski

Why Silverlight is the future

2009-02-11T12:08:00.001+09:00

I think Silverlight represents the likely future of computing for most of us. And by “us”, I mean both Windows and web developers on the Microsoft platform (and maybe beyond).

I think we’re at a point of convergence, where two industry trends are coming together in a way that makes Silverlight the most compelling answer for a lot of development scenarios. These trends are the continued abstraction away from the hardware, and now the operating system; and the likelihood that the web as we know it is nearing the end of its life, so we’re looking for the next big thing in that space.

Arguably, Silverlight’s primary competitor is WPF. But I don’t think WPF is the long-term winner. Another obvious competitor is Flash/Flex/Air, and that could be serious except for the fact that Silverlight lets existing .NET developers (and there are a lot of us) leverage our existing skills, while Adobe means starting over. And another competitor is Gears, which may be valid, time will tell (as long as I don’t have to do Javascript), but also means starting over and discarding all the .NET skills we’ve accumulated. And Gears, to me, represents the last gasping attempt to salvage the web as we know it – and I suspect that’s a lost cause.

Part of the appeal of Silverlight, and the reason it almost instantly gains traction in any conversation with my clients, is that it is independent of Windows. They like the idea that it works across Windows versions without worrying that Microsoft will fix some Windows thing and break their app.

Some of them, especially those that deal with the government, really like that it works on the Mac as well as Windows. They have cross-platform requirements mandated by either the market or by law, and Silverlight gives them the option of using .NET (which they love) to run apps on the Mac.

Another part of the appeal of Silverlight, across the board from what I can see, is that people don't trust ClickOnce. But they do trust the browser as a deployment vehicle. I suspect this goes back, somewhat, to Silverlight being independent of Windows, while ClickOnce is more vulnerable to the OS itself. Our overall experience with ClickOnce is that it works great 99% of the time. And then 1% of the time it fails for no reason anyone can figure out. Same target machines, same configuration, but it just doesn't quite work. Maybe, over time, we'll find out Silverlight is also unreliable in this manner - but early indications are that this is not the case.
If you look at the theme here, it is about escaping the OS and all its complexity. And that's not entirely surprising.

We build the first OSes to abstract the hardware. And they evolved over decades until they were terribly complex, and somewhat intertwined with the hardware (driver issues are the major failure point for Windows).

So we built runtimes to abstract the OS (starting perhaps with Smalltalk, then VB, the JDK and now .NET). And they evolved over the past couple decades until they are becoming terribly complex, and somewhat intertwined with the OS (installing/upgrading .NET usually requires a reboot of Windows).

It appears to me that we're now building smaller, decoupled runtimes that are a bit less complex, and that are intentionally decoupled from the OS, and are largely self-contained. It is just the next step in the evolution - though I suspect it does mean Windows (or any other OS) becomes substantially less relevant to most people.

By itself, I'm not sure that a runtime that is less coupled to the OS would be enough to drive Silverlight’s future. But there's another dynamic here too: the aging of the web, and the search for "what's next".

I was subscribed to the Usenet newsgroups in the early 90's, when they were discussing the future of the global network. When WAIS, Gopher and HTTP were competing (Gopher came from Minnesota after all : ) ). And HTTP/HTML won, because they really were the superior document viewing technology. A global version of lex; something that should have filled the role of PDF.

But as we got into the mid-90's, people started bastardizing and hacking this technology. Warping it into something far different from its original intent. And that's OK - but it is important to realize this was done ad-hoc, with little or no pre-planning or thought of proper architecture.

I know, I sound like a CS purist, but really the web, as we know it, is a stack of horrible hacks, all leaned up against each other like the world's biggest and most expensive house of cards. In short, the technology of the web is a mess. Just witness the insanity around browser versions, the standards compliance farce, and the ridiculously inefficient ways we waste time/money building a web app that runs on more than one version of even one browser.

Yes, the web has transformed the world. And it revealed some very good patterns for software and usability. But it became mainstream over 10 years ago, and most technologies fade gracefully away at the 10 year mark. So it is time for the web (as we know it) to die.
The question then, is what comes next? Do browsers become the new standards-based OS? Or do we extend the runtime concept into the web, as a long-term replacement.

Google is betting on the former, with Gears and Chrome. They clearly hope/expect that the browser itself will be the next OS - the thing that makes Windows and Mac OSes irrelevant. Adobe is betting on the latter. They clearly hope Flash/Flex/Air will be the runtime that makes both the browser and the OS irrelevant.

Microsoft is playing a smart game, imo. Silverlight (with Mesh and Azure) represents a strategy very similar to Adobe's (but bigger), where a runtime may well make the browser and the Windows/Mac/Linux desktop irrelevant. At the same time, they've got WPF as a fall-back in case the core OS does remain important to the average consumer.

So I think these two dynamics - the desire by our customers to escape the shackles of the OS (not just Windows - the OS in general), coupled with the fact that the industry is looking for the next step in the evolution of the web itself - work together to make this the perfect time for Silverlight to be the hot technology.

And I do think this works against WPF, because it neither helps us escape the OS, nor does it represent the future of the web. And it works against Adobe, because their vision isn’t big enough, nor their established developer base large enough. And against Google, because they are still trying to shape the stack of hacks that is the browser into something reliable, and I suspect that’s simply unrealistic.

In short, I think Silverlight offers the power needed for smart client business apps, with the best deployment and navigation characteristics of the web. Sure, it needs to continue to grow and evolve (the search issue needs addressing for example), but I really think Silverlight represents the future of development for most of us.

Microsoft Silverlight. http://silverlight.net/

Original post by: Rockford Lhotka

Enabling WCF tracing and using it.

2009-02-11T09:34:00.003+09:00

How to enable WCF tracing:

Open the Visual Studio Command Prompt.
Run svcconfigeditor.exe
Go File/Open and browse to the web.config file of your WCF service.
In the "Configuration" section click on "Diagnostics".
In the "Diagnostics" section click on "Enable Tracing".
Now click on the link next to "Trace Level:" and select the level of tracing. (I like verbose)
File/Save

Viewing your tracefile

Open the Visual Studio Command Prompt.
Run svctraceviewer.exe
File/Open and find your *.svclog file. (Usually in the same location as your "web.config" file)

Happy tracing!

Passing Large and Complex objects in WCF

2009-02-11T08:54:00.004+09:00

Generally WCF has no restrictions on the maximum size of the message that can be passed across the wire. Technically speaking, the maximum size of a message that can be passed and processed in a typical WCF communication is about 9,223,372,036,854,775,807 bytes (which is about 8.5 billion GB!). That is, only if you explicity allow the WCF service and client to receive messages of such sizes. However, there are certain caveats to keep in mind.

For most part, it is possible to set maxReceivedMessageSize attribute to a large value (the defualt being 64KB) to get it going. If a plain large object (say of size 22 MB) is serialized while sending across the wire, it would work just as well as it may not have objects nested within one another. But in cases where there are too many nested objects, with many nested Lists containing a large number of items (say 10,000) embedded, then the number of objects going across the wire crosses the default limit of 65,536.

This restriction is placed to prevent Denial of Service attacks. But by configuring dataContractSerializer you can pass such complex objects of large sizes. This attibute is not available through the bindings, but actually as an extension of the service and endpoint behavior. The value needs to be set in both the client and the server.

Client

Server

Once this behavior is set, the WCF service and client can send and receive not only large objects, but also highly complex ones.

Original post by: Kishore Gopalan

The remote server returned an error: (400) Bad Request. (WCF)

2009-02-10T08:52:00.006+09:00

If you want to send parameters across WCF larger than a few bytes,you'll need to increase some tags in your web.config.

WEB.CONFIG

NOTE: the "bindingConfiguration" was added manually, as was the binding declaration below;

Now delete the app.config from client and refresh your services references.

Don't forget to delete identity tag either to avoid those pesky undecipherable exceptions.

Original Post by: Herman Schoenfeld

OO Design Principels

2009-01-20T10:11:00.000+09:00

Great summary of principles to understand in order to design / write great OO code
http://www.noctovis.net/blog/index.php/2009/01/15/design-principles/

To GUID or not to GUID

2009-01-09T10:52:00.007+09:00

This week I have been having some interesting discussions with some of my colleagues on whether we should be changing our SQL database from identifier (int) primary key columns to GUID/UNIQUEIDENTIFIER primary key columns. The discussion is a bit mute, because we need our distributed winforms application to synchronise up to a central database. BUT... Some very interesting points where raised that I'd like to share.

Please before I get crucified here, SQL is not my strongest technical skill.

"GUIDs are nice for their uniqueness but are quite nasty on SQL DBs as primary keys because they consume 4 times the space of an identity column (so your DB's operating memory footprint goes up) and fragment to hell because they are generated in a random fashion making the index slow to update. ... I wouldn't be inclined to go this route if we're talking thousands of users and hundreds of thousands of rows of data." DBA

Now when people make statements like this the hair on the back of my neck immediately stand up. He seems to be aware of the problems but did not even bother to fully understand it before preaching it as fact.

So... I had a quick chat with my friend google and found this article:

Working with GUIDs in SQL Server
by Zach Nichter

Using GUIDs - Inserts

Currently we are designing a database schema. When I heard they were using GUID's (Global Unique Identifier) as PK's (primary keys) my jaw about dropped. Turns out the reasoning behind the use of the keys was completely legitimate and actually is the reason GUID's were implemented by MS in the first place. They needed a key that would be unique across databases and database servers. The GUID certainly fulfills this need but it comes a cost.

The GUID is a wide column (16 bytes to be specific) and contains a unique combination of 33 hex value characters. This column, because it is the primary key, is going to be stored in, of course, the clustered index (unless specified to be a non- clustered index), and will be the page pointer for each leaf page in a non-clustered index. Also, if a GUID is used instead of an integer identity column then the bits need to be matched up for each row, which is relatively fast. If a high volume of inserts are done on these tables then GUID's being large will contribute to page splits, as will the fact that the NEWID() function generates a random GUID value, which could place the new record on any of the data pages for this table and could cause performance problems. Another reason is that typically primary keys are searched most frequently and trying to recall a GUID from memory to type into a query is not probable.

If you needed a key that would be unique across all servers I would recommend a composite key as the PK instead of the GUID. Use a single integer identity column to uniquely identify the rows and another column to identify the server, placing a default server id value and placing a check constraint on the server id column to validate that the value is only what you would expect for it to be for that server.

I have mocked a test to validate my theory on inserts only (results below), I'll get to the selects a little later.

Test 1 - Completed in 79 seconds on test machine

Created table with the following syntax.

create table test1
(tid uniqueidentifier default newid() not null,
col1 char(1) not null
primary key (tid)) on [primary]

I used the following script to insert into the table.

declare @d1datetime, @d2 datetime, @i int, @j int
select @d1=getdate(), @i=1, @j=100000

while @i <= @j
begin
insert test1 (col1)
values ('a')

set @i= @i + 1
end

select @d2=getdate()
select datediff(s,@d1,@d2)

Test 2 - Completed in 33 seconds on test machine

Created the second test table with the following syntax.

create table test2
(tid int identity(1,1) not null,
sid int default 2 not null
check (sid=2),
col1 char(1) not null
primary key (tid,sid)) on [primary]

I used the following script to insert into the test2 table.

declare @d1 datetime, @d2 datetime, @i int, @j int
select @d1=getdate(), @i=1, @j=100000

while @i <= @j
begin
insert test2 (col1)
values ('a')

set @i = @i + 1
end

select @d2=getdate()
select datediff(s,@d1,@d2)

Test 3 - Completed in 33 seconds on test machine

Created the second test table with the following syntax.

create table test3

(tid uniqueidentifier default CONVERT(UNIQUEIDENTIFIER, CONVERT(BINARY(10), NEWID()) + CONVERT(BINARY(6), GETDATE())) not null,

col1 char(1) not null

primary key (tid)) on [primary]

I used the following script to insert into the test2 table.

declare @d1 datetime, @d2 datetime

select @d1 = getdate()

declare @i int, @j int

select @i = 1, @j = 4000000

while @i <= @j

begin

insert test3 (col1)

values ('a')

set @i = @i + 1

end

select @d2 = getdate()

select datediff(s, @d1, @d2)

Using GUIDs - Selects

Alright, so I tested the GUID usage a bit more. In my previous post you can see I already tested the inserts for 100,000 rows using the 3 different methods. The first method (I refer to this method as Test1 throughout) used the NEWID() as a default on the uniqueidentifier clustered primary key. The second method was to use a composite key made up of 2 integer columns, one being an identity and one forced with a server id (this method is referred to as Test2 throughout), these columns make up this tables clustered primary key. And the third method uses a function to create a sequential uniqueidentifier, using a combination of the NEWID() function and a converted binary(6) datetime value (referred to as Test3 throughout) to make up the clustered primary key.

CODE FOR SEQUENTIAL NEWID() USED IN TEST3

SELECT CONVERT(UNIQUEIDENTIFIER, CONVERT(BINARY(10), NEWID()) + CONVERT(BINARY(6), GETDATE()))

These tests did the following, first truncated the tables and inserted 4,000,000 rows into test table, Test1, Test2 and Test3. Next, I tested single row selects for each table. For the next test, I selected 70,000 rows from each table. For the 70,000 row selects I did a ranged select, first I cleared the proc cache, the buffer cache, did a checkpoint, and then ran the select statement. I did this 10 times for each query and took the averages to report here.

INSERTS

Inserts for Test1 took 79 seconds to insert 100,000 rows and 45,191 seconds to insert 4,000,000 rows. The inserts for Test2 it took 33 seconds for the 100,000 rows and took 1630 seconds for the 4,000,000 rows. For Test3 the inserts took 33 seconds for the 100,000 inserted rows and 2025 seconds for the 4,000,000 rows.

	Test 1 - Uniqueidentifier NEWID()	Test 2 - Composite Key	Test 3 - Uniqueidentifier getdate()
Insert - 100000	79 sec	33 sec	33 sec
Insert - 4000000	45191 sec	1630 sec	2025 sec

It took much longer for test1 because to insert because the GUID values are random values and because the default fill factor for indexes is 80%, which wasn't changed for this test, there were a great number of page splits. Because the inserts for Test2 and Test3 are sequential the fill factor for those indexes could be set to 100% for better performance on inserts and selects because fewer data pages would be used or returned. The inserts took longer for Test3 than they did for Test2 because of the overhead associated with executing a function 4,000,000 times.

SELECTS

The CPU Time for all single row selects took 0ms. However, the average CPU and Elapsed times for the 70,000 row ranged select varied for each test. On average Test1 performed better on CPU time than the other two tests but Test2 faired better on logical reads and elapsed time than the other 2 tests, this was because the size of a Test2 row is 9 bytes while the size of the Test1 and Test3 rows is 17 bytes. Test1 caused a tremendous amount of page splits and had a scan density around 12% when I ran a DBCC SHOWCONTIG after the inserts completed. The Test2 table had a scan density around 98% and the Test3 table had a scan density around 86% after inserts (I should have rebuilt the indexes after the data load, but I didn't :)). All of the CPU times were close enough in range to be circumstantial, but the elapsed time seemed to very between all of them. I think the variance is because of the nature of the data being returned to Query Analyzer for a more accurate test of elapsed time (I should have used OSQL, but I didn't :)). The tests seem to prove that the binary comparison of the GUID performs quite well.

	Test 1 - Uniqueidentifier NEWID()	Test 2 - Composite Key	Test 3 - Uniqueidentifier getdate()
Select Range 70000 - CPU TIME (AVERAGE)	43 ms	50 ms	48 ms
Select Range 70000 - Elapsed TIME (AVERAGE)	1987 ms	712 ms	1175 ms
Select Range 70000 - Logical Reads	331	159	439
Select Range 70000 - Physical Reads	2	2	3
Select Range 70000 - Read Aheads	331	159	440
Select 1 Row - CPU Time	0 ms	0 ms	0 ms
Select 1 Row - Logical Reads	3	3	3
Select 1 Row - Physical Reads	3	3	3

Conclusion

It would seem to be as a result of the tests that the uniqueidentifier data type performs about the same as an integer when filtering the data through the where clause. There are only a couple of downsides I can see in using the uniqueidentifier.

First, and probably the most important, the size of the column (which can be an issue). It adds overhead to a system to have to return more data pages than possibly necessary (I/O's are the most expensive of system costs). The large size could in turn cause more page splits during inserts depending on whether the data is static or not (but so can adding a unnecessary column to a table).

Second, with the use of the NEWID() function, inserts will be random and therefore will by nature, cause page splits. Using an integer identity column will place the records sequentially into the table. "Ah...", you say, "...but the use of the function that parses the NEWID() and adds the converted getdate value to the end will do that as well." Yes, it does, and if you use it then I would say, “good for you, but why not use an integer then? It requires less space to store the unique value in an integer.” To be honest, I don’t think you will really save yourself that much in resources, except for the space if the table is really large. The inserts take roughly the same duration for inserting a single row and for the 100,000 rows. I don't often load 4 million rows into a table, and so for me that is not as big a deal (just use the modified NEWID() function when doing a mass load into a table or use it as the default value).

The third issue is having to type that uniqueidentifier value into a query manually, in my opinion it has more potential for user error.

So in short, it looks as though if you plan carefully and design wisely, then the use of the uniqueidentifier can perform as well in SELECT statements as an integer. Inserts are a different story and we already discussed that as long as they are sequential values it really shouldn't matter that much, unless you’re inserting millions of rows.

I apologize for my initial shock in the usage of the uniqueidentifier column, hoping that everyone who read the initial statement can forgive me, Integers still rule the inserts though.

SPECIAL NOTE: I would like to thank Adam Machanic for all of the help and direction during the research of this topic.

Zach Nichter has been working with SQL Server for 11 years. Currently he holds a position at Levi Strauss & Co.
Zach specializes in architecture, optimization and performance of SQL Server systems and Transact SQL.
His blog can be found athttp://www.sqljunkies.com/WebLog/odds_and_ends/default.aspx.


CONVERT(UNIQUEIDENTIFIER, CONVERT(BINARY(10), NEWID()) + CONVERT(BINARY(6), GETDATE()))

Designing software is like being married. It's full of compromises. No one thing will work for EVERY situation. Yes GUID's have over head, but in certain very specific circumstances they are the correct choice. You should always weigh up all the pros and cons in your given circumstance and then select the appropriate technology to solve that problem. Remembering next time that your previous selection/choice most probably will not be right for this new situation.

PS. I love my wife and like being married. No really. :)

StableGen version 1.5

2009-01-08T13:31:00.018+09:00

Retrieving data, from a SQL stored procedure in .net 2.0 as an object, with a single line of code, with intelisense, auto consistency checking, soft deleting, auditing, parameter & result interface generation and .net transactional support. So here is my code generator.

If you are thinking: Yes but why? Please see StableGen version 1 article.

I have been using the generated code from this version in production code and so far have not had any major issues. Generating wrapper classes for my data access layer in .NET C#, has sped up development time tremediously. (Currently only supports SQL.)

What has changed in this version:

Generated code is now FxCop & StyleCop compliant.
Interface classes now generated for Stored Procedure parameters and results.
Result object has been changed to a struct implementing the result interface.
Default indexer added to class.
ExecuteStoredProcedure method now also accepts any object implementing the parameter interface.
ExecuteStoredProcedure now returns a collection of the calling class if it implements the result interface.
Interface ExecuteStoredProcedure method now omitted if there is only one input parameter.

FxCop & StyleCop

I'm a sucker for clean well formatted code, that can be easily understood and maintained. Must be because of all my experience trying to understand and maintain other peoples code. Consider the next guy when you write your code. I have also found FxCop/Code Analysis to be an invaluable learning tool for any developer.

Interface classes now generated for Stored Procedure parameters and results.

To simplify the use of my generated class even more I have decided to generate 2 interface classes for each stored procedure: Parameter and Result. By having any business object implement the parameters interface, you can simple pass that whole class in as the parameter for the stored procedure. The result from the stored procedure will also conform to the resulting interface.

Result object has been changed to a struct implementing the result interface.

There was no need for this to be a class, so for performance and resource reasons I made it a struct.

Default indexer added to class.

Duh!

ExecuteStoredProcedure method now also accepts any object implementing the parameter interface.

See interface classes now generated.

ExecuteStoredProcedure now returns a collection of the calling class if it implements the result interface.

I use reflection and the System.Activator.CreateInstance to create an instance of the calling class if it implements the result interface for this stored procedure. The reasoning behind this is that you would then not need to map the business objects properties to the stored procedure result. I know there is a slight performance hit here, but in my opinion if you weigh this off against the saving in development time then it is well worth it.

Interface ExecuteStoredProcedure method now omitted if there is only one input parameter.

If the stored procedure ends up having only one or no parameters then we need not have a parameter interface. Having two method with the same number of parameters with different types is also not supported in the .NET framework.



// 
// Copyright (c) 2008 All Right Reserved
// 
// DataGen v1.5.0.137 (Dana Beck)
// ABC@DEF.com
// 9/01/2009 10:28:06 AM
// Generated Data Access wrapper layer for sql stored procedures on databse SS-N-001 for stored procedure dbo.uspGetBillOfMaterials.

namespace DB.AdvantureWorks
{
    using System;
    using System.CodeDom.Compiler;
    using System.Collections.ObjectModel;
    using System.Data;
    using System.Data.SqlClient;
    using System.Diagnostics;

    using DB.AdvantureWorks.Interfaces;

    /// Generated data access struct item from stored procedure 'uspGetBillOfMaterials'

    /// Generated by DataGenAddin(Dana Beck) ver 1.5.0.137 for DataBase SS-N-001 on 9/01/2009 10:28:07 AM.
    [GeneratedCode("StableGen", "1.5.0.137")]
    internal struct RowObject_uspGetBillOfMaterials : IuspGetBillOfMaterials_Result
    {
        private Nullable productAssemblyID;
        private Nullable componentID;
        private string componentDesc;
        private Nullable totalQuantity;
        private Nullable standardCost;
        private Nullable listPrice;
        private Nullable bOMLevel;
        private Nullable recursionLevel;

        /// Gets or sets ProductAssemblyID.

        public Nullable ProductAssemblyID
        {
            get { return this.productAssemblyID; }
            set { this.productAssemblyID = value; }
        }

        /// Gets or sets ComponentID.

        public Nullable ComponentID
        {
            get { return this.componentID; }
            set { this.componentID = value; }
        }

        /// Gets or sets ComponentDesc.

        public string ComponentDesc
        {
            get { return this.componentDesc; }
            set { this.componentDesc = value; }
        }

        /// Gets or sets TotalQuantity.

        public Nullable TotalQuantity
        {
            get { return this.totalQuantity; }
            set { this.totalQuantity = value; }
        }

        /// Gets or sets StandardCost.

        public Nullable StandardCost
        {
            get { return this.standardCost; }
            set { this.standardCost = value; }
        }

        /// Gets or sets ListPrice.

        public Nullable ListPrice
        {
            get { return this.listPrice; }
            set { this.listPrice = value; }
        }

        /// Gets or sets BOMLevel.

        public Nullable BOMLevel
        {
            get { return this.bOMLevel; }
            set { this.bOMLevel = value; }
        }

        /// Gets or sets RecursionLevel.

        public Nullable RecursionLevel
        {
            get { return this.recursionLevel; }
            set { this.recursionLevel = value; }
        }
    }

    /// Generated data access class from storedproc 'uspGetBillOfMaterials'

    /// Generated by DataGenAddin(Dana Beck) ver 1.5.0.137 for DataBase SS-N-001 on 9/01/2009 10:28:07 AM.
    [GeneratedCode("StableGen", "1.5.0.137")]
    public partial class uspGetBillOfMaterials : IDisposable
    {
        private Collection rows;

        /// Prevents a default instance of the uspGetBillOfMaterials class from being created. Please use factory pettern constructor uspGetBillOfMaterials.CreateInstance().

        private uspGetBillOfMaterials()
        {
        }

        /// Gets a collection of uspGetBillOfMaterials (item) records as RowuspGetBillOfMaterials objects.

        public Collection Items
        {
            get { return this.rows; }
        }

        /// Default indexer for uspGetBillOfMaterials.

        /// The zero-based index of the element to get or set.
        /// 
        public IuspGetBillOfMaterials_Result this[int index]
        {
            get { return this.rows[index]; }
            set { this.rows[index] = value; }
        }

        /// Factory pattern constructor.

        /// Sql Connection objects to be used for this SQL dataAccess.
        /// Any object implementing IuspGetBillOfMaterials_Param.
        /// An instance of uspGetBillOfMaterials.
        public static uspGetBillOfMaterials ExecuteProcedure(SqlConnection connectionObject, IuspGetBillOfMaterials_Param parameters)
        {
            return
            uspGetBillOfMaterials.ExecuteProcedure(connectionObject, parameters.StartProductID, parameters.CheckDate);
        }

        /// Factory pattern constructor.

        /// Sql Connection objects to be used for this SQL dataAccess.
        /// Generated parameter called startProductID.
        /// Generated parameter called checkDate.
        /// An instance of uspGetBillOfMaterials.
        public static uspGetBillOfMaterials ExecuteProcedure(SqlConnection connectionObject, Nullable startProductID, Nullable checkDate)
        {
            uspGetBillOfMaterials tmpuspGetBillOfMaterials = new uspGetBillOfMaterials();

            bool didIOpenTheConnection = false;
            SqlCommand cmd = new SqlCommand();
            SqlDataReader result = null;
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "dbo.uspGetBillOfMaterials";
                cmd.Parameters.Add("@StartProductID", SqlDbType.Int).Value = startProductID;
                cmd.Parameters.Add("@CheckDate", SqlDbType.DateTime).Value = checkDate;

                if (connectionObject != null)
                {
                    // If the connection object I received is closed, try to open it. If I open it, I must close it again.
                    if (connectionObject.State == ConnectionState.Closed)
                    {
                        connectionObject.Open();
                        didIOpenTheConnection = true;
                    }

                    cmd.Connection = connectionObject;
                }
                else
                {
                    throw new ArgumentNullException("connectionObject", "Please use the TheConnection.SqlConnectionObject to get a connection object.");
                }

                result = cmd.ExecuteReader(CommandBehavior.Default);

                tmpuspGetBillOfMaterials.rows = new Collection();

                while (result.Read())
                {
                    IuspGetBillOfMaterials_Result tmpRowObj = null;
                    Type[] typeList = (new StackFrame(1, false).GetMethod().DeclaringType).GetInterfaces();

                    foreach (Type itemType in typeList)
                    {
                        if (itemType.Name == "IuspGetBillOfMaterials_Result")
                        {
                            // StackFrame: This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.
                            tmpRowObj = (IuspGetBillOfMaterials_Result)System.Activator.CreateInstance(new StackFrame(1, false).GetMethod().DeclaringType);
                            break;
                        }
                    }

                    if (tmpRowObj == null)
                    {
                        tmpRowObj = new RowObject_uspGetBillOfMaterials();
                    }

                    tmpRowObj.ProductAssemblyID = result.IsDBNull(result.GetOrdinal("ProductAssemblyID")) ? null : (Nullable)result["ProductAssemblyID"];
                    tmpRowObj.ComponentID = result.IsDBNull(result.GetOrdinal("ComponentID")) ? null : (Nullable)result["ComponentID"];
                    tmpRowObj.ComponentDesc = result.IsDBNull(result.GetOrdinal("ComponentDesc")) ? null : result["ComponentDesc"].ToString();
                    tmpRowObj.TotalQuantity = result.IsDBNull(result.GetOrdinal("TotalQuantity")) ? null : (Nullable)result["TotalQuantity"];
                    tmpRowObj.StandardCost = result.IsDBNull(result.GetOrdinal("StandardCost")) ? null : (Nullable)result["StandardCost"];
                    tmpRowObj.ListPrice = result.IsDBNull(result.GetOrdinal("ListPrice")) ? null : (Nullable)result["ListPrice"];
                    tmpRowObj.BOMLevel = result.IsDBNull(result.GetOrdinal("BOMLevel")) ? null : (Nullable)result["BOMLevel"];
                    tmpRowObj.RecursionLevel = result.IsDBNull(result.GetOrdinal("RecursionLevel")) ? null : (Nullable)result["RecursionLevel"];

                    tmpuspGetBillOfMaterials.Items.Add(tmpRowObj);
                }
            }
            finally
            {
                if (result != null)
                {
                    result.Close();
                    result = null;
                }

                if (didIOpenTheConnection)
                {
                    if (connectionObject != null)
                    {
                        connectionObject.Close();
                    }
                }
            }

            return tmpuspGetBillOfMaterials;
        }

        /// Types that own disposable fields should be disposable.

        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// The bulk of the clean-up code is implemented in Dispose(bool).

        /// True or false.
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                // Do nothing!
            }
        }
    }
}
// 
// Copyright (c) 2008 All Right Reserved
// 
// DataGen v1.5.0.137 (Dana Beck)
// ABC@DEF.com
// 9/01/2009 10:28:07 AM
// Generated Data Access wrapper interface for sql stored procedures on databse SS-N-001 for stored procedure dbo.uspGetBillOfMaterials.

namespace DB.AdvantureWorks.Interfaces
{
    using System;
    using System.CodeDom.Compiler;

    /// Generated stored procedure result interface.

    [GeneratedCode("StableGen", "1.5.0.137")]
    public interface IuspGetBillOfMaterials_Result
    {
        /// Gets or sets ProductAssemblyID.

        Nullable ProductAssemblyID { get; set; }

        /// Gets or sets ComponentID.

        Nullable ComponentID { get; set; }

        /// Gets or sets ComponentDesc.

        string ComponentDesc { get; set; }

        /// Gets or sets TotalQuantity.

        Nullable TotalQuantity { get; set; }

        /// Gets or sets StandardCost.

        Nullable StandardCost { get; set; }

        /// Gets or sets ListPrice.

        Nullable ListPrice { get; set; }

        /// Gets or sets BOMLevel.

        Nullable BOMLevel { get; set; }

        /// Gets or sets RecursionLevel.

        Nullable RecursionLevel { get; set; }
    }

    /// Generated stored procedure parameter interface.

    [GeneratedCode("StableGen", "1.5.0.137")]
    public interface IuspGetBillOfMaterials_Param
    {
        /// Gets or sets StartProductID.

        Nullable StartProductID { get; set; }

        /// Gets or sets CheckDate.

        Nullable CheckDate { get; set; }
    }
}

Plans for version 2

Regular expressions for use with templates rather than the current string builder. :o
Visual Studio integration. (To much copy and pasting at the moment.)

Conclusions

This implementation was not designed for large, high performance applications but I have been load testing it and have been getting very good results. This article is not about my code generator but rather the code that I have chosen to generate. I could have easily used something like CodeSmith, but that would not have been half as much fun.

In the end it's all about experimenting, learning first hand what works and more importantly what does not work. I hope that you got something out of this post and welcome any constructive criticism.

Australian life

2009-01-08T11:51:00.002+09:00

We arrived in Perth on the first of June as planned.

I LOVE PERTH! (My only regret is not moving here sooner.)

My family and I have now completely settled in and have had a wonderful Christmas. The new year has started and it's time for some longer term planning.

I am full of optimism and looking forward to the challenges of the new year.

PS. I found work as a Technical Lead Developer, 3 weeks after landing here.

Some more OZ progress

2008-05-22T20:36:00.003+08:00

We're flying to Perth next Saturday the 31st of May.

VISA in hand
Plane tickets in hand
Container shipped
TV air freighted. :)
No job yet. :(

So if anybody in Perth is looking for a pretty decant C#.NET programmer give me a shout!

OZ Progress

2008-04-09T19:35:00.002+08:00

Our OZ plans are now finally starting to come together.

Sponsorship has been approved.
Medicals done.
VISA application submitted and received.
My wife has found a job.
Secured a rental property.

If all goes well, we will be in Perth by the 1st of June '08.

Windows mobile 7

2008-01-08T18:19:00.000+09:00

Found this blog. Is this really Windows Mobile 7?

Look really cool.

Windows Mobile update

2008-01-03T20:10:00.000+09:00

I finally got my TyTn II. I'm loving it.

Started playing around with the WM SDK. Stumbled onto these 3 sites.

More later...

Windows Mobile

2007-12-07T16:13:00.000+09:00

Saturday I ordered my HTC TyTn-II, still waiting. :)

I have decided to focus my Microsoft skill sets on

.NET Framework (MCTS)
WPF (lack some artistic flair...)
WCF
Windows Mobile development (WM & tabletPC)

I have a real passion for Microsoft Surface computing. I have even gone to the extreme of building my own surface computer, with the help of some South African university students. I think the future of surface and other multi-touch consumer devices is only starting to be realised. The iPhone is only a glimpse of what can be done. With the highly anticipated release of silver light WPFe for windows mobile... This will open the floodgates.

If you interested in this kind of thing you can also have a look at the .NET Micro Framework.

This is just an introduction to a topic I will be blogging about a lot in the future.

Top 10 Ways To Demotivate Your Programming Team

2007-11-29T17:01:00.000+09:00

If you're in charge of an overly motivated programming team that meets all deadlines and produces high quality code you may recognize that they don't really need you. Here are 10 tips how to regain control.
Top 10 Ways To Demotivate Your Programming Team

StableGen

2007-09-26T19:40:00.011+08:00

Retrieving data, from a SQL stored procedure in .net 2.0 as an object, with a single line of code,with intelisense, auto consistency checking, soft deleting, auditing and .net transactional support.

A while back I worked for a company, and we decide that we will be using an object wrapping system for all stored procedures. It soon became apparent that using these objects to get to SQL data was just sweet. BUT. (There is always one of those aren't there?)

Writing these object wrappers was tedious and time consuming. So one night I decided to write a little application that would generate this code for me, and so StableGen was borne.

After selecting and connecting to your SQL database, simply browse to the stored procedure and right click. Alternatively you can right click on the table and generate the stored procedure for you, as in this example.

Give the stored procedure a name, select the flag delete column and finally select the primary key column.

Click generate and wham, your select stored procedure. Copy and past, and you're done.

Refresh the "Database Properties" window and right click on your new stored procedure.

Supply the namespace you want to use, I like DB.(Database name), It works well when you have a shared "Data Access Layer". Select how you want your data returned and "Generate".

Copy and past the code into your project. You are now ready to access the stored procedure with a single line of code.

Features of StableGen

.NET transactional support.
Threading.
Generate Select stored procedures.
Generate Create/Update/Delete stored procedures.
Generate Enum(s) from lookup tables.
Generate Stored procedure wrapper classes.
Nullable types.
Fully commented generated code.
FxCop clean generated source code.
Partial class, easy to extend generated classes.
Factory pattern constructors (static).

Sample of a generate Stored Procedure wrapper class.


using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections.ObjectModel;
using System.Globalization;

using DB.InternalData.Row;

namespace DB.InternalData
{
    /// Generated data access class from storedproc 'PersonGet'

    /// Generated by DataGenAddin(Dana Beck) ver 0.7.2.578 for DataBase (local) on 26/09/2007 13:01:55.
    public partial class PersonGet : IDisposable
    {
        private Collection _rows = new Collection();

        /// Private constructor, please use static method Construct.

        private PersonGet() { }

        /// Factory pattern constructor..

        /// Sql Connection objects to be used for this SQL dataAccess.
        /// id.
        /// An instance of PersonGet.
        public static PersonGet Construct(SqlConnection connectionObject, Guid id)
        {
            PersonGet tmpPersonGet = new PersonGet();

            bool didIOpenTheConnection = false;
            SqlCommand cmd = new SqlCommand();
            SqlDataReader result = null;
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "PersonGet";
                cmd.Parameters.Add("@Id", SqlDbType.UniqueIdentifier).Value = id;
                if (connectionObject != null)
                {
                    //If the connection object I received is closed, try to open it. If I open it, I must close it again.
                    if (connectionObject.State == ConnectionState.Closed)
                    {
                        connectionObject.Open();
                        didIOpenTheConnection = true;
                    }
                    cmd.Connection = connectionObject;
                }
                else
                {
                    throw new ArgumentNullException("connectionObject", "Please use the TheConnection.SqlConnectionObject to get a connection object.");
                }

                result = cmd.ExecuteReader(CommandBehavior.Default);

                while (result.Read())
                {
                    RowPersonGet tmpRowPersonGet = new RowPersonGet();
                    tmpRowPersonGet.Id = result.IsDBNull(result.GetOrdinal("Id")) ? Guid.Empty : (Guid)result["Id"];
                    tmpRowPersonGet.StaffCode = result.IsDBNull(result.GetOrdinal("StaffCode")) ? null : result["StaffCode"].ToString();
                    tmpRowPersonGet.Surname = result.IsDBNull(result.GetOrdinal("Surname")) ? null : result["Surname"].ToString();
                    tmpRowPersonGet.FirstName = result.IsDBNull(result.GetOrdinal("FirstName")) ? null : result["FirstName"].ToString();
                    tmpRowPersonGet.Extension = result.IsDBNull(result.GetOrdinal("Extension")) ? null : result["Extension"].ToString();
                    tmpRowPersonGet.LastModifiedBy = result.IsDBNull(result.GetOrdinal("LastModifiedBy")) ? Guid.Empty : (Guid)result["LastModifiedBy"];
                    tmpRowPersonGet.LastUpdated = result.IsDBNull(result.GetOrdinal("LastUpdated")) ? null : (Nullable)result["LastUpdated"];
                    tmpRowPersonGet.Deleted = result.IsDBNull(result.GetOrdinal("Deleted")) ? false : (bool)result["Deleted"];

                    tmpPersonGet.Items.Add(tmpRowPersonGet);

                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                if (result != null)
                {
                    result.Close();
                }
                if (didIOpenTheConnection) { if (connectionObject != null) { connectionObject.Close(); } }
            }

            return tmpPersonGet;
        }

        /// Returns a collection of PersonGet (item) records as RowPersonGet objects.

        public Collection Items
        {
            get { return _rows; }
        }

        /// Types that own disposable fields should be disposable.

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// The bulk of the clean-up code is implemented in Dispose(bool).

        /// True or false.
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                // Do nothing!
            }
        }
    }
}

namespace DB.InternalData.Row
{
    /// Generated data access class item from storedproc 'PersonGet'

    /// Generated by DataGenAddin(Dana Beck) ver 0.7.2.578 for DataBase (local) on 26/09/2007 13:01:56.
    public struct RowPersonGet
    {
        private Guid _Id;
        private string _StaffCode;
        private string _Surname;
        private string _FirstName;
        private string _Extension;
        private Guid _LastModifiedBy;
        private Nullable _LastUpdated;
        private bool _Deleted;

        /// Id.

        public Guid Id
        {
            get { return _Id; }
            set { _Id = value; }
        }

        /// StaffCode.

        public string StaffCode
        {
            get { return _StaffCode; }
            set { _StaffCode = value; }
        }

        /// Surname.

        public string Surname
        {
            get { return _Surname; }
            set { _Surname = value; }
        }

        /// FirstName.

        public string FirstName
        {
            get { return _FirstName; }
            set { _FirstName = value; }
        }

        /// Extension.

        public string Extension
        {
            get { return _Extension; }
            set { _Extension = value; }
        }

        /// LastModifiedBy.

        public Guid LastModifiedBy
        {
            get { return _LastModifiedBy; }
            set { _LastModifiedBy = value; }
        }

        /// LastUpdated.

        public Nullable LastUpdated
        {
            get { return _LastUpdated; }
            set { _LastUpdated = value; }
        }

        /// Deleted.

        public bool Deleted
        {
            get { return _Deleted; }
            set { _Deleted = value; }
        }

        /// In most programming languages there is no default implementation of the equality operator (==) for value types. Therefore, you should overload the equality operator (==) any time equality is meaningful.

        /// RowPersonGet.
        /// RowPersonGet.
        /// Reference equality.
        public static bool operator ==(RowPersonGet p1, RowPersonGet p2)
        {
            return p1.Equals(p2);
        }

        /// The inequality operator (!=) returns false if its operands are equal, true otherwise. Inequality operators are predefined for all types, including string and object. User-defined types can overload the != operator.

        /// RowPersonGet
        /// RowPersonGet
        /// Reference equality.
        public static bool operator !=(RowPersonGet p1, RowPersonGet p2)
        {
            return !(p1.Equals(p2));
        }

        /// Determines whether the specified Object is equal to the current Object.

        /// The Object to compare with the current Object.
        /// true if the specified Object is equal to the current Object; otherwise, false.
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// It is recommended that any class that overrides Equals also override System.Object.GetHashCode.

        /// Returns a hash code, using a hashing algorithm that ignores the case of strings.
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// Overriding existing methods in order to add extra features.

        /// Returns a string representation of this struct.
        public override string ToString()
        {
            return base.ToString();
        }

    }

}

Microsoft Surface Computing

2007-08-24T18:46:00.000+08:00

Microsoft Surface represents a fundamental change in the way we interact with digital content.

With Surface, we can actually grab data with our hands, and move information between objects with natural gestures and touch.

Surface features a 30-inch tabletop display whose unique abilities allow for several people to work independently or simultaneously. All without using a mouse or a keyboard.

more

What lurks below Microsoft's Surface? A brief Q&A with Microsoft

Designing Object Models

2007-08-17T20:14:00.000+08:00

"Designing a custom object model can be a tricky business. If you dive in and start coding right away, you may find yourself realizing in the middle of your development process that your design is less than ideal. It pays to take some time to think through an object model, and even draw diagrams and make notes by hand. You may also want to study other object models to understand how they were constructed. When you design an object model, you are taking abstract processes and imposing concrete relationships upon them. In essence, you are creating artificial conceptual divisions for your code." MSDN Article

A common problem that I run into again and again is the idea that a data model should drive the development of your objects. This idea comes in two flavors: your physical data schema should drive the development of your objects and that a conceptual/logical data model should be (almost) completely developed up front before you begin to design your objects. Both of these views are inappropriate for non-agile projects and clearly wrong for agile projects. Let’s explore this issue in more depth.

Why do people want to base their object models on existing data schemas? First, there is very likely a desire to reuse the existing thinking that went behind the current schema. I’m a firm believer in reusing things, but I prefer to reuse the right things. There is an impedance mismatch between the object and relational paradigms, and this mismatch leads object and data practitioners to different designs. You also saw in Object Orientation 101 that object developers apply different design techniques and concepts than the techniques and concepts described in Data Modeling 101 that data modelers apply. Second, the database owner seeks to maintain or even enhance their political standing within your organization by forcing you to base your application on their existing design. Third, the people asking you to take this approach may not understand the implications of this decision, or that there are better ways to proceed.

Why is basing your object model on an existing data schema a bad idea? First, your legacy database design likely has some significant problems. In practice, I look at existing physical data models to get an idea of what is currently going on, and to get a feel for the technical constraints that I’ll have to work with, but I won’t unnaturally constrain my application with a bad data design. Second, even if the existing database design is very good there can be significant differences in the way that you map objects to relational databases. Complete Article

Why is basing your object model on a conceptual or logical data model a bad idea? Actually, it’s not such a bad idea, as long as you’re taking an iterative and incremental approach, the real problem is the big design up front (BDUF) approach that many data professionals seem to prefer.

The great trek.

2007-08-16T21:23:00.000+08:00

For a while now my wife and I have been considering immigrating. We decided that if we are going to do it, we want to do it before my eldest child goes to school. Well that would be next year, so the time has come to make a decision. We have always loved South Africa and would really have “…sterwe vir jou Suid-Afrka” ~ “…died for our country”. But I’m not willing to die for nothing.

But like many South Africans, we feel this is no longer our country, towns and streets have different names, crime is out of control, and the future looks bleak for us. For a long time now, I have felt like a foreigner in my own country, or maybe orphan is more apt? So, we are not immigrating, we are finding ourselves a home, with a family that wants us.

So we have decided to move to Australia, as this seems to be the family/home that is the closest to what we need to live in peace and happiness. Having some friends in Melbourne, that is where we are off to. I will keep you informed of our life changing journey here. (Will keep you posted.)

History

2007-08-15T19:48:00.000+08:00

Curriculum Vitae

Biographical Information
First Name(s): Petrus Dana
Surname: Beck
Initials: PD Title: Mr
Known as: Dana
Email Address: danabek(a)gmail.com
Gender: Male Marital Status: Married
Date of Birth: 7 May 1974 Nationality: South African
Current Location: Cape Town

About myself:
I’m a highly motivated person, who likes to do things the right way. I like solving problem and find great joy in doing something that “can’t be done”. My feeling about technology is, give me the right book and yes I can do that. I want to start studying for a degree next year and am in the process of selecting which course I should take. I’d like to work for a company that encourages its employees to study.
A sentence that describes me.
A day that you have learned nothing new is a day wasted.
Hobbies:
Computer game development, Hiking and Karate/Kick boxing.
Proficiencies
Please see attached skills matrix.

References
Myburgh du Plessis (IT Manager) – Balltron
Contact 09:00 to 16:00 on cell: ********

Schalk Lubbe (Senior Architect) – Sanlam
Contact 09:00 to 16:00 on cell : ********

Malcolm Jack (Analyst Developer) – Sanlam
Contact 09:00 to 16:00 on cell : **********

Education
Detailed Description: Institution and Date:
Matric Eben Donges, 1992
MCSE Old Mutual, 1997 (expired)
MCSD Old Mutual, 1997 (expired)
OOA & OOD using UML Software Futures, 2005
Ms.Net Applications for Windows (2555A) Sanlam, 2005
The last 10 Books I have read:
Title Author
Patterns of Enterprise Application Architecture Martin Fowler
Programming C# (4th Edition) Jesse Liberty
Programming MS DirectShow for Digital Video & TV Mark D. Pesce
HTML & XHTML (The Definitive Guide) Chuck Musciano & Bill K
JavaScript Bible (4th Edition) Danny Goodman
UML Distilled (2nd Edition) Booch, Jacobson, Rumbaugh
Amazon.com Get Big Fast Robert Spector
MCSD
Analyzing Requirements and Defining MS.Net Solutions Architectures (70-300)
Developing Web Applications with MS VB.NET and MS C#.NET (70-315)
Developing Windows-Based Applications with VB.NET & MS C#.NET (70-316)

Work History
Job Title: Senior Developer
Employer Name: Balltron
Industry: Financial
Start Date: Feb 2006 End Date: Current
Is current Job: No
Job Description: Redesign all the current systems, using OO techniques and agile methodologies, documenting design in UML (VISIO), implementing design in C# .NET 2.0 and managing, logging and handling all support issues, mentoring and training junior developers.
Reasons for leaving: Company downsized.
__________________________________
Job Title: Analyst developer
Employer Name: Sanlam
Industry: Insurance
Start Date: Jun 2003 End Date: Jan 2006
Is current Job: No
Job Description: Do analysis and help redesign current VB6/SQL back-office applications into n-Tier, Object Oriented and distributed systems, (Web services) while maintaining the current VB6/SQL system. A big focus has been given to performance / multi-threading and the proper use of XML.
Reasons for leaving: Contract came to an end.
__________________________________
Job Title: Analyst developer
Employer Name: Sanlam
Industry: Insurance
Start Date: Jun 2002 End Date: Jun 2003
Is current Job: No
Job Description: Helped develop an Intranet system for Sanlam, using VB.NET, ASP.NET and JScript, while maintaining the current VB6, SQL and ASP applications.
Reasons for leaving: Intranet project completed and moved on to the next project.
__________________________________
Job Title: Analyst developer
Employer Name: Sanlam
Industry: Insurance
Start Date: Jun 2001 End Date: Jun 2002
Is current Job: No
Job Description: Helped develop a web based application with a Mainframe backend for managing sales leads. (COBOL and DB2)
Reasons for leaving: Project completed.
__________________________________
Job Title: Senior Developer
Employer Name: IExchange
Industry: Software Development. (Product development)
Start Date: Feb 2001 End Date: May 2001
Is current Job: No
Job Description: Web front-end (JScript) and Install Shield development.
Reasons for leaving: Company went bankrupt.
__________________________________
Job Title: Software Engineer
Employer Name: Naspers
Industry: Online Publishing
Start Date: April 1998 End Date: Feb 2001
Is current Job: No
Job Description: I was one of the developers involved in the News24 web development. I ran a couple of projects as project lead and lead developer. I was sent to Holland at the end of 1999 to evaluate a new software product that the company wanted to purchase. Did extensive R&D work on WAP. Most of the work done was in ASP, SQL, JScript and HTML.
Reasons for leaving: Wanted a permanent position as my first child was about to be born. Nasper could not offer me one at that time.
__________________________________
Job Title: Software Engineer
Employer Name: MicroSys
Industry: Internet/E-Commerce
Start Date: March 1996 End Date: April 1998
Is current Job: No
Job Description: Client services application developer in Delphi. Mostly contract work for Old Mutual.
Reasons for leaving: Company had financial problems.
__________________________________
Job Title: Senior Developer/ Project leader
Employer Name: Old Mutual
Industry: Insurance
Start Date: June 1993 End Date: March 1996
Is current Job: No
Job Description: Network administrator, Junior Developer, Developer, Senior Developer, Lead Developer and Project Leader. I started out at Old Mutual and worked my way up. OM had a very nice culture at that time and I learned a lot while I was there. (PS must say Project Leader position was because of attrition, I was the most senior person in that department at the time.)
Reasons for leaving: OM started outsourcing its development to MicroSys.
__________________________________

Database design

2007-08-14T20:20:00.001+08:00

Ok we need a real business problem to solve. Something simple, but that allows enough scope to not be simplistic. A recipe application, which stores nutritional information, user preferences and allergies, will do.

Ok here is my first stab at the database design, it is still incomplete but at a point where we can start having a meaningful discussion about it.

Naming conventions: I feel that naming conventions are a good thing and when not overly implemented is very helpful. The naming convention that I use, is very simple and strait forward.
“t_” = a table containing data
“l_” = a table containing static data that would be needed in production. (e.g. Lookup tables )
“j_” = a table contain relationship data. (I believe that this design is the most flexible and allows for future changes to be implemented, with minimal impact.)

LastModifiedBy, LastUpdates, Deleted: These columns are implemented only on tables that need auditing and/or consistency checking.

Please review the design and comment.

"Perfect App"

2007-08-14T16:36:00.001+08:00

I’ve been in IT for almost 13 years now, and know that there are many ways to skin a cat. I’ve worked for 4 major corporate companies and each had a distinctive way of implementing the same standards and SDLC principals.

I have decided to take the best I have learned, and will learn, and combine it into a “Perfect App”. The idea behind this is that each time I learn something new, or even just a better way of doing something, I would re-factor my “Perfect App”.

To limit the scope to something realistic, the app would at least have to implement the 3 layers of n tier development, access a SQL database, have an ASP.Net front-end and expose some of it functionality via a web service. I will be using UML to document the design.

To make things a little more interesting, and to learn the latest new technologies, I also would like to use AJAX, Silverlight, XAML, WPF & WCF, to name a few. I’m planning on getting myself an M8 MiniOne when it becomes available (Meizu MiniOne M8), so a Windows Mobile 6 front-end is also on the wish list.