Foo Theory

Back from Microsoft PDC 2009

Matt Ortiz — Wed, 02 Dec 2009 20:10:23 GMT

So we’re back from Microsoft Professional Developer Conference (PDC09) which was held at the Los Angeles Convention Center this past week.

The focus of PDC is future and emerging Microsoft technologies, product roadmaps, and industry trends – making it the premier, developer-focused Microsoft event. It is not held every year. The workshops, keynotes, and sessions were excellent with few exceptions and, as expected, there were a number of important announcements.

Unlike last year we didn’t come back with multiple gigabytes of pre-release bits; none in fact. Truth be told, though, with the rapid and open pre-release cycles on the many key products and technologies soon to release, any bits would be stale quickly. So get out to MSDN Developer Centers, CodePlex, and the like and pull down the latest as needed.

Take a look at the swag attendees did walk away with though (below)…

Key Themes and Announcements

By no means is this comprehensive but a punch list of key themes and announcements we, as as professional developers and Microsoft technology consultants should keep an eye and provide feedback to the product teams on and share with our colleagues, customers, and the community.

“Three Screens and a Cloud”

Ray Ozzie, Microsoft Chief Architect, described Microsoft’s long-term cloud computing strategy as “three screens and a cloud”:

“A journey that started 4 years ago with our Software as a Service platform vision, now materializing. I believe that the world some number of years from now in terms of how we consume IT is really shifting from a machine-centric viewpoint to what we refer to as three screens and a cloud: the phone, the PC, and the TV ultimately, and how we deliver value to them.”

As a very satisfied iPhone user (a WinMo/HTC convert) and someone who has been less than blown away by the Xbox 360/Media Center story, there is work to be done here. As an architect and developer I’m impressed by the leaps made by Microsoft; providing the tools, platforms and technologies to deliver sophisticated, connected solutions. And as a consumer, I’m very excited and look forward to seeing the strategy play out to when “it all just works - seamlessly.”

Providing web-centric experiences, served by private clouds in data centers or by the world wide, public cloud and extended through applications on your desktop, smart phones, and televisions certainly summarizes the current software + services strategy. And Ozzie also let in that, along with the back-end – servers, tools, and cloud computing, and the experience at the top of the Microsoft stack – Windows, IE and Silverlight, Office, and SharePoint, that in Spring, at MIX 2010, Microsoft will make announcements about progress on the Windows Live Platform and about developing applications for the “next generation of the Windows phone.”

So given Microsoft’s commitment, and the tools now at hand, it is as much up to us as technologists to plan for and build solutions that leverage and deliver on the “n screens and a cloud” and “software + services” stories.

Cloud Computing: “Software + Services” 2.0

It was announced that Windows Azure will release in January, with billing starting in February 2010. The November release of the Windows Azure SDK, available now, includes updates to Windows Azure Tools for Microsoft Visual Studio, which extends VS 2008 (and included in VS2010 Beta 2) allowing us to easily model, develop and test, build, deploy, and run Web apps and services for Windows Azure.

The AppFabric: a Unified Development, Configuration Management, and Deployment Model

Today, application architecture, design, and tooling considerations are vastly different for on-premises versus cloud-based applications. Now using Visual Studio 2010 and leveraging the AppFabric, applications can be designed and built once, promoted across environments to either Windows Azure or on-premises infrastructure, and delivered securely to our customers; whatever deployment model, service level or scale they require.

In addition, Windows Azure capabilities such as VMs, along with AppFabric, provide us with flexible options for migrating existing on-premises .NET applications to public and private Windows Azure environments.

Windows Azure Platform AppFabric i

The Windows Azure platform AppFabric provides secure connectivity as a service to help developers bridge cloud, on-premises, and hosted deployments. You can use AppFabric Service Bus and AppFabric Access Control to build distributed and federated applications as well as services that work across network and organizational boundaries.

From simple eventing scenarios to complex protocol tunneling, AppFabric Service Bus gives developers the flexibility to choose how their applications communicate, and to address the challenges of configuration and management of firewalls, NATs and dynamic IP, and disparate identity systems.

AppFabric Access Control enables simple, secure authorization for RESTful web services that federate with a variety of identity providers.

Windows Server AppFabric ii

Windows Server AppFabric is a set of integrated technologies that make it easier to build, scale and manage Web and composite applications that run on IIS. Windows Server AppFabric has these core capabilities:

For Web applications, AppFabric provides caching capabilities to provide high-speed access, scale, and high availability to application data. This feature was previously codenamed "Velocity"
For composite applications, AppFabric makes it easier to build and manage services built using Windows Workflow Foundation and Windows Communication Foundation. This feature was previously codenamed "Dublin."

Project “Sydney”

Project Sydney was announced at PDC. Sydney provides a means to connect existing on-premise or services behind the firewall with those running in the cloud on Windows Azure. Underlying the technologies are IPSec, IPV6, and Microsoft’s federated-identity capabilities (formerly codename “Geneva”).

Sydney can be used for a variety of business cases, such as allowing fail over of on-premises servers to the cloud (or vise versa), to running applications targeting on-premises and cloud deployments, and to synchronize on-premise and Azure-hosted databases, as examples.

Sydney is slated to go to beta early next year and to release in 2010.

Codename “Dallas”

Ray Ozzie announced the public alpha release of Microsoft’s Data Services in the Cloud. Microsoft codename Dallas allows developers and information workers to discover, purchase and manage data subscriptions in the Windows Azure platform. The “data-as-a-service” offering is an information marketplace that will deliver data, imagery, and web services from commercial data providers as well as public data sources from a single location, under a unified provisioning and billing framework.

A Silverlight application was shown using the NASA Mars Exploration Rover Mission Images dataset during the Day 1 keynote where attendees put on a set of silly 3D glasses handed out at registration.

Dallas is available now and surfaced at Microsoft PinPoint here.

Visual Studio 2010 and .NET 4

Visual Studio 2010 Beta 2 was released on October 19^th, so attendees had nearly four weeks to preview prior to the borage of information provided during keynotes and in deep dive sessions at PDC.

Microsoft announced at PDC that Go Live licenses are available for Visual Studio 2010 and .NET 4. So if you’ve not gotten your hands on Visual Studio 2010, it’s time to dig in and socialize the value proposition of transitioning early with customers.

Visual Studio 2010 is a significant release and has been re-designed using WPF 4.0? Cameron Skinner described the dog-fooding process as painful at times but that (paraphrasing here): “there’s nothing like a dev. finding their own (or a colleagues) bug holding them up.” Noting (half jokingly) how quickly things get resolved.

A quote from the Day 1 keynote by Ray Ozzie sums up, for me, how the Windows, Office, and Visual Studio platform and tools continue to be at the heart of what is to come: "We at Microsoft have one simple strategy - that is to focus on leverage and seamlessness in everything we do.”

Of particular interest to me is the new architect tooling: UML Modeling projects (and strategy), MEF extensibility, and T4 goodness. T4 has been there since VS2K5 but seeing it in action in various open source frameworks, being baked in as an extensibility point (along with MEF) in Visual Studio for Entity Framework 4, and shown in various sessions really re-piqued my interest.

I spoke with Cameron Skinner and team, along with some other attendees, after his session “Code Visualization, UML, and DSLs” and as a practicing enterprise and solution architect (and agile practitioner) the direction being taken by the group is compelling; not only from a modeling perspective, but from a tooling and process automation perspective as significant improvements in TFS have been made.

Some of those Team Foundation Server innovations include:

Multi-project Collaboration (i.e. Team Project Collections)
Process automation improvements, including deep agile support and improved workflows
Truly innovative parallel development capabilities with branching and visualizations
Continuous integration ++
Project visibility and health
Deployment, provisioning, and management options

Be sure to take a look at these Visual Studio sessions.

Entity Framework 4

From what I saw in the whirlwind session “Evolving ADO.NET Entity Framework in .NET 4 and Beyond” by Shyam Pather and Chris Anderson there have been significant improvements . The room was packed so the interest was high. As an observation, session goers (including myself) were guarded going in and generally high-energy walking out. Though you see a combination of NHibernate, Castle Active Record, Unity, and Fluent NHibernate, you also see a lot of innovative new capabilities.

Some of those things we’ve been waiting for, and delivered, include model first (as well as round-trip) development, support for POCO and lazy loading, and improved separation of concerns allowing for, among other things, a better testing story.

I did fiddle a bit late night this week, and there seemed to be issues with inheritance, but will dig in deeper and share my experiences with those interested and in posts. As a steadfast NHibernate advocate, I look forward to the discussion here.

.NET 4 and C# Language Enhancements

.NET and C# 4 now includes the dynamic types, named and optional arguments, enhanced Office programmability, and variance. Some additional areas of interest include:

F# for functional programming
Application Compatibility and Deployment
Parallel Computing
Improved Security Model
Core New Features and Improvements
Networking
Web
Client
Data
Communications and Workflow

There were sessions that hit on each of the areas listed so search the PDC and other sites for content; this is our bread and butter.

Office and SharePoint Development Enhancements

Office 2010 is now available in public beta and there are considerable, exciting improvements in Visual Studio 2010 allowing developers to more easily deliver rich business applications using Office. In addition, with Office Web Access (currently Office Live) developers will have real options to deliver connected solutions targeting both on-premises and in the cloud.

Here are links to SharePoint and Office PDC sessions.

VS Product Line-up Changes

Team System branding – no more: it was confusing. Now there is simply Visual Studio and Visual Studio Team Foundation Server and the Visual Studio product line-up has been streamlined. Now there are just three flavors: Professional, Premium, and Ultimate which provide progressively more capabilities. The new line-up doesn’t erase the price tag reality on the higher end but it is easier to understand. And hell the alternative is point solution fun-and-games; on the high-end at ridiculous price tags.

One significant item of note here is that TFS is now included (no limitations, e.g. Workgroup Edition). If you own VS2010 and MSDN then you own a TFS client and can deploy TFS for team use of any size.

So there’s too much on Visual Studio to punch list but I’ll follow-up with multiple posts with a value focused perspective.

Silverlight 4

So I attended a number of Silverlight or UX-related sessions this year. Silverlight 3 was released only 4 months ago but general availability of Silverlight 4 public Beta was announced at PDC. Silverlight 4 provides improved connectivity to peripherals and improves the out-of-browser application options. Together with RIA Services and Prism, Silverlight 4 is a leap ahead for web deployed, core business applications.

Silverlight 4 is planned to release in the first half of 2010.

It was announced at PDC and RIA Services renamed WCF RIA Services. RIA Services simplifies building layered applications targeting Silverlight (and MVC), exposing WCF services and reducing the amount of work for service configuration, contract specification, data validation, and deployment; essentially UI domain services.

Here’s a link to Silverlight sessions and take a look at the Day 2 keynote by Scott Guthrie and team.

SQL Server 2008 R2

Another one of those hot off the presses technologies is SQL Server 2008 R2. Despite the naming it is a major release.

It was also announced that the tooling previously known as codename “Gemini” is now PowerPivot. This is something we need to take a look at along with the BI toolset that Microsoft has delivered along with the partner ecosystem. If you get a chance take a look the PDC workshop “Developing Microsoft BI Applications – the How and Why.” Andrew Brust did a great job of describing the BI landscape and provided pointed guidance on how to approach and transition your customers.

Here’s a link to SQL Server and BI sessions at PDC.

Window Technologies

In case you haven’t noticed, Windows 7 was recently released. In addition to Windows 7 there were announcements about the Release of Windows Identity Foundation, Windows Azure, and the AppFabric.

Take a look at the Windows technologies related sessions here.

Microsoft PinPoint

Microsoft PinPoint was announced. It is a one stop shop providing access to software solutions based on Microsoft technologies. PinPoint is a directory to discover applications, companies, and trusted technology partners through contextual searches; a sort of Apple App Store and Salesforce.com AppExchange rolled together.

“It’s All Data” – Oslo, SQL Server Modeling

So last but not least is something I focused on at last PDC – Oslo, and more generally modeling. It was announced at PDC that Oslo has been renamed SQL Server Modeling and the team (along with XML) have been brought together under Data.

The MSDN Data Developer Center has been redesigned to not only include current and emerging data technologies but also roadmap and way early (or “future”) technologies like Oslo, which includes “M” – the language, Quadrant – the tooling, and SQL Server Modeling Services.

Keep an eye on these technologies and view related PDC sessions here and here.

The Swag, PDC Edition

During the day 2 keynote, Windows and Windows Live Division President Steven Sinofsky announced that attendees would receive an exclusive “PDC Edition” Acer Aspire 1420P Tablet PC designed by the Windows team, for PDC. It was funny watching folks streaming out of the keynote about a half hour early to get theirs, only to be turned away till later in the day.

The tablet’s not yet available to consumers, which make it even cooler, and the stacked configuration (for the nearly netbook form-factor) will allow developers to leverage many of the Windows 7 (64-bit, Ultimate) capabilities, including multi-touch. Take a look at some photos of it here at the Windows Team Blog and the specs here.

Session Videos and Downloads

Session videos, and in many cases the decks, are available publicly at microsoftpdc.com. We encourage you to get out there, download the video and content, and dig into these new technologies. I’d start with the keynotes so you can get a feel for Microsoft technology strategic direction and areas of focus, and then deep dive into the session.

Happy viewing!

i Content was used from the Windows Azure Platform site here.
ii Content was used from the Windows Server Development Center here.

VLookup and HLookup in C# with a DataTable

aendenne — Fri, 29 May 2009 05:39:00 GMT

(Mimicry/Extension of Excel's VLookup/HLookup in C#)

Here I will give you my VLookup and HLookup methods; they have been overloaded to allow flexibility. In Excel the first row or column of values is referred to/searched through. In the HLookup/VLookup functions I wrote, row/column name/index can be specified.

Sometimes a developer may need to dynamically locate a specific text value in order to get an associated data point for that text value (in the same data row or data column). Put another way: these lookup functions allow a developer to determine the contents of one cell by locating an associated cell (at runtime).

I am attaching a demo application that contains examples of HLookup and VLookup and all dependent code. You may download it here: Download Demo App

The Lookup Methods:

   61         /// <summary>
   62         /// Similar to Excel's hlookup. Searches for value (column by column)
   63         /// beginning in the first row of the passed in table and returns 
   64         /// corresponding value from the same (found) column as specified by the
   65         /// matchRow value.
   66         /// </summary>
   67         /// <remarks>
   68         /// If user looks for the 'color' field and the 5th row, 
   69         /// the function will grab data from the color column, 5th row
   70         /// </remarks>
   71         /// <param name="tbl">table to look in</param>
   72         /// <param name="val">value to locate (will pinpoint a row)</param>
   73         /// <param name="lookInRow">
   74         /// row index to look in for specified value, excel uses first row,
   75         /// let us allow a bit more flexibility. (set to 0 for 1st row)
   76         /// </param>
   77         /// <param name="matchRowIdx">index of row to get return data from</param>
   78         /// <param name="partialMatch">whether to stop at a partial match</param>
   79         /// <returns>
   80         /// null if value not found, or data from matching row in same column as found value
   81         /// </returns>
   82         /// <writer>aendenne</writer>
   83         /// <created>5/28/09</created>
   84         /// <edited>5/28/09</edited>
   85         public static string HLookup(DataTable tbl, string val, int lookInRow, 
   86             int matchRowIdx, bool partialMatch)
   87         {
   88             if (tbl == null || tbl.Rows.Count <= 0) return null;
   89             if (string.IsNullOrEmpty(val)) return null;
   90             if (tbl.Rows.Count <= lookInRow || tbl.Rows.Count <= matchRowIdx) return null;
   91 
   92             //still here--try to locate value in specified row:
   93             val = val.Trim().ToUpper();
   94 
   95             DataRow rw = tbl.Rows[lookInRow];
   96             for (int i = 0; i < tbl.Columns.Count; i++)
   97             {
   98                 string fldData = rw.ToString().Trim().ToUpper();
   99                 if (partialMatch && fldData.Contains(val))
  100                     return tbl.Rows[matchRowIdx].ToString();
  101                 if (fldData == val.Trim().ToUpper())
  102                     return tbl.Rows[matchRowIdx].ToString();
  103             }
  104             return null;
  105         }
  106 
  107         /// <summary>
  108         /// Similar to Excel's vlookup. Searches for value (row by row)
  109         /// in one column and returns ENTIRE row where that value was found (first instance)
  110         /// </summary>
  111         /// <param name="tbl">table to look in</param>
  112         /// <param name="val">value to locate (will pinpoint a row)</param>
  113         /// <param name="valColName">name of column to find value in</param>
  114         /// <returns>
  115         /// null if value not found, or data from matching column in same row as found value
  116         /// </returns>
  117         /// <writer>aendenne</writer>
  118         /// <created>5/28/09</created>
  119         /// <edited>5/28/09</edited>
  120         public static DataRow VLookup(DataTable tbl, string val, string valColName)
  121         {
  122             if (tbl == null || tbl.Rows.Count <= 0) return null;
  123 
  124             if (string.IsNullOrEmpty(val) || string.IsNullOrEmpty(valColName))
  125                 return null;
  126 
  127             int valCol = tbl.Columns.IndexOf(valColName);
  128 
  129             //chk that col names do exist in this tbl:
  130             if (valCol < 0) return null;
  131 
  132             foreach (DataRow rw in tbl.Rows)
  133                 if (rw[valCol].ToString().Trim().ToUpper() == val.Trim().ToUpper())
  134                     return rw;
  135 
  136             return null;
  137         }
  138 
  139         /// <summary>
  140         /// Similar to Excel's vlookup. Searches for value (row by row)
  141         /// in one column and returns value from matching column in same row.
  142         /// </summary>
  143         /// <param name="tbl">table to look in</param>
  144         /// <param name="val">value to locate (will pinpoint a row)</param>
  145         /// <param name="valColName">name of column to find value in</param>
  146         /// <param name="matchColName">name of column to get return data from</param>
  147         /// <returns>
  148         /// null if value not found, or data from matching column in same row as found value
  149         /// </returns>
  150         /// <writer>aendenne</writer>
  151         /// <created>5/28/09</created>
  152         /// <edited>5/28/09</edited>
  153         public static string VLookup(DataTable tbl, string val, 
  154             string valColName, string matchColName)
  155         {
  156             if (tbl == null || tbl.Rows.Count <= 0) return null;
  157 
  158             if (string.IsNullOrEmpty(val) || string.IsNullOrEmpty(valColName)
  159                 || string.IsNullOrEmpty(matchColName))
  160                 return null;
  161 
  162             int valCol = tbl.Columns.IndexOf(valColName);
  163             int matchCol = tbl.Columns.IndexOf(matchColName);
  164 
  165             //chk that col names do exist in this tbl:
  166             if (valCol < 0 || matchCol < 0) return null;
  167 
  168             foreach (DataRow rw in tbl.Rows)
  169                 if (rw[valCol].ToString().Trim().ToUpper() == val.Trim().ToUpper())
  170                     return rw[matchCol].ToString();
  171 
  172             return null;
  173         }
  174 
  175         /// <summary>
  176         /// Similar to Excel's vlookup. Searches for value (row by row)
  177         /// in one column and returns value from matching column in same row.
  178         /// </summary>
  179         /// <param name="tbl">table to look in</param>
  180         /// <param name="val">value to locate (will pinpoint a row)</param>
  181         /// <param name="valColIdx">index of column to find value in</param>
  182         /// <param name="matchColIdx">index of column to get return data from</param>
  183         /// <param name="partialMatch">whether to stop at a partial match</param>
  184         /// <returns>
  185         /// null if value not found, or data from matching column in same row as found value
  186         /// </returns>
  187         /// <writer>aendenne</writer>
  188         /// <created>5/28/09</created>
  189         /// <edited>5/28/09</edited>
  190         public static string VLookup(DataTable tbl, string val, int valColIdx, 
  191             int matchColIdx, bool partialMatch)
  192         {
  193             if (tbl == null || tbl.Rows.Count <= 0) return null;
  194 
  195             if (string.IsNullOrEmpty(val) || tbl.Columns.Count <= valColIdx ||
  196                 tbl.Columns.Count <= matchColIdx)
  197                 return null;
  198 
  199             val = val.Trim().ToUpper();
  200             foreach (DataRow rw in tbl.Rows)
  201             {
  202                 string fldData = rw[valColIdx].ToString().Trim().ToUpper();
  203                 if (partialMatch && fldData.Contains(val))
  204                     return rw[matchColIdx].ToString();
  205                 if (fldData == val.Trim().ToUpper())
  206                     return rw[matchColIdx].ToString();
  207             }
  208             return null;
  209         }

Predicates VS For Loops

aendenne — Sun, 25 Jan 2009 09:08:00 GMT

In using the predicate find and replace methods, I wondered whether they were faster or slower than the less elegant for...loop approach.

The code herein demonstrates find, findall and replace predicate usage.

My initial findings are that for...loops searching through an array or list are quicker than using predicates. UNLESS the collection to be sifted through is HUGE.

The form's code-behind file is printed below, but you may download the entire 2008 solution:

http://footheory.com/blogs/aendenne/PredicatesVsForLoops.zip

[Note, yes I am aware that 3.5 language features could be used in this solution. I don't want to get used to them right now, because I have a habit of writing them into my projects at work, where our TFS is not compatible with that framework.]

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Drawing;
    4 using System.Windows.Forms;
    5 
    6 namespace PredicatesVsForLoops
    7 {
    8     public partial class frmListMethodUsage : Form
    9     {
   10         #region Constructors
   11         /// <summary>
   12         /// Constructor: starts up the form object
   13         /// </summary>
   14         public frmListMethodUsage()
   15         {
   16             InitializeComponent();
   17             _formatTxtBox();
   18         }
   19         #endregion
   20 
   21         #region InternalMembers
   22         private double _findTimeForSingleElement;
   23         private double _findTimeForMultiElements;
   24         private double _findTimeForSingleElementWithForLoop;
   25         private double _findTimeForMultiElementsWithForLoop;
   26         private double _removeTime;
   27         private double _removeTimeWithForLoop;
   28 
   29         private int _arrayMemberIdx;
   30         #endregion
   31 
   32         #region StringConstants
   33         private const string _valueProperty = "Value";
   34         //private const string _nameProperty = "Name";
   35         private const string _commonValue = "Same";
   36         //private const string _nonExistentValue = "NonExistentValue";
   37         private const string _setIntro = " Set # ";
   38         private const string _fooObjectName = "foo";
   39         private const string _msgNoResults = "no results found";
   40         //private const string _msgResultsFoundIntro = "The items found";
   41         private const string _msgTimeElapsed = "Time elapsed for";
   42         private const string _findFooMethod = "_findFoo() method";
   43         private const string _findFooInForLoopMethod = "_findFooInForLoop() method";
   44         private const string _findFoosMethod = "_findFoos() method";
   45         private const string _findFoosInForLoopMethod = "_findFoosInForLoop() method";
   46         private const string _removeFooMethod = "_removeFoo() method";
   47         private const string _removeFooWithForLoopMethod = "_removeFooWithLoop() method";
   48         private const string _seconds = "seconds";
   49         private const string _nameFound = "Name of item found";
   50         private const string _valueFound = "Value of item found";
   51         private const string _qtyFound = "Number of items found";
   52         private const string _qtyRemoved = "Number of items removed";
   53         private const string _firstFound = "First Item Found";
   54         private const string _lastFound = "Last Item Found";
   55         private const string _spacerLine =
   56             "--------------------------------------------------------";
   57         private const string _no = "There was no";
   58         private const string _winningMethod = "Winning Method";
   59         private const string _timeDiff = "Time Difference";
   60         private const string _arrayCreation = "Array creation";
   61         private const string _listCreation = "List creation";
   62         private const string _durationWas = "Duration was";
   63         private const string _for = "for";
   64         private const string _items = "items";
   65         private const string _listAddFailedAt = "List.Add method failed at item #";
   66         private const string _arrayAddFailedAt = "Array member access failed at item #";
   67         private const string _success = "SUCCESS";
   68         private const string _failure = "FAILURE";
   69         private const string _outOfMemoryCustomErr =
   70             "Out of memory error: view details in text box";
   71         private const string _otherCustomErr =
   72             "Other error: view details in text box";
   73         #endregion
   74 
   75         #region Events
   76         private void btnRunAll_Click(object sender, EventArgs e)
   77         {
   78             Cursor curr = Cursor;
   79             Cursor = Cursors.WaitCursor;
   80 
   81             btnClear_Click(null, null);
   82             btnDemoFind_Click(null, null);
   83             _addToTxtBox(Environment.NewLine + _spacerLine, Color.Black, true,
   84                 false, false, 14);
   85             btnDemoForLoopFind_Click(null, null);
   86             _showWinner(_findFooMethod, _findTimeForSingleElement,
   87                 _findFooInForLoopMethod, _findTimeForSingleElementWithForLoop);
   88 
   89             btnDemoFindAll_Click(null, null);
   90             _addToTxtBox(Environment.NewLine + _spacerLine, Color.Black, true,
   91                 false, false, 14);
   92             btnDemoForLoopFindAll_Click(null, null);
   93             _showWinner(_findFoosMethod, _findTimeForMultiElements,
   94                 _findFoosInForLoopMethod, _findTimeForMultiElementsWithForLoop);
   95 
   96             btnDemoRemove_Click(null, null);
   97             _addToTxtBox(Environment.NewLine + _spacerLine, Color.Black, true,
   98                 false, false, 14);
   99             btnDemoForLoopRemove_Click(null, null);
  100             _showWinner(_removeFooMethod, _removeTime,
  101                 _removeFooWithForLoopMethod, _removeTimeWithForLoop);
  102 
  103             Cursor = curr;
  104         }
  105 
  106         /// <summary>
  107         /// Button click event that shows implementation
  108         /// of the Find method for a List of objects
  109         /// </summary>
  110         /// <param name="sender">Object that requested the event</param>
  111         /// <param name="e">Event arguments</param>
  112         private void btnDemoFind_Click(object sender, EventArgs e)
  113         {
  114             Cursor curr = Cursor;
  115             Cursor = Cursors.WaitCursor;
  116 
  117             long start = DateTime.Now.Ticks;
  118             int qty = _getQty(txtItemQty);
  119 
  120             List<Foo> findList = _getFooListWithDistinctValues(qty);
  121             Foo f = _findFoo(findList, _valueProperty + (qty - 2));
  122 
  123             //if we run this line INSTEAD of prior, we will receive NO results-here for testing/demo
  124             //Foo m = _findFoo(findList, _valueProperty + 1000000);  
  125 
  126             double ms = _getDuration(start);
  127             _findTimeForSingleElement = ms;
  128             _showResultsOfFindMethod(f, ms, _findFooMethod);
  129 
  130             Cursor = curr;
  131         }
  132 
  133         /// <summary>
  134         /// Button click event that shows implementation
  135         /// of the FindAll method for a List of objects
  136         /// </summary>
  137         /// <param name="sender">Object that requested the event</param>
  138         /// <param name="e">Event arguments</param>
  139         private void btnDemoFindAll_Click(object sender, EventArgs e)
  140         {
  141             Cursor curr = Cursor;
  142             Cursor = Cursors.WaitCursor;
  143 
  144             long start = DateTime.Now.Ticks;
  145             int qty = _getQty(txtItemQty);
  146 
  147             List<Foo> findList = _getFooListWithMatchingValues(qty);
  148             List<Foo> foundList = _findFoos(findList, _commonValue + _valueProperty);
  149 
  150             //if we run this line INSTEAD of prior, we will receive NO results-here for testing/demo
  151             //List<Foo> list = _findFoos(findList, _nonExistentValue);    
  152 
  153             double ms = _getDuration(start);
  154             _findTimeForMultiElements = ms;
  155             _showResultsOfFindAllMethod(foundList, ms, _findFoosMethod);
  156 
  157             Cursor = curr;
  158         }
  159 
  160         private void btnDemoRemove_Click(object sender, EventArgs e)
  161         {
  162             Cursor curr = Cursor;
  163             Cursor = Cursors.WaitCursor;
  164 
  165             long start = DateTime.Now.Ticks;
  166             int qty = _getQty(txtItemQty);
  167 
  168             List<Foo> fullList = _getFooListWithSomeSharedValues(qty);
  169             List<Foo> filteredList = _removeFoo(fullList, _valueProperty + _setIntro + 8);
  170 
  171             //if we run this line INSTEAD of prior, we will receive same results as fullList-here for testing/demo
  172             //List<Foo> filteredList = _removeFoo(findList, _nonExistentValue);    
  173 
  174             double ms = _getDuration(start);
  175             _removeTime = ms;
  176 
  177             _showResultsOfRemoveMethod(fullList, filteredList, ms, _removeFooMethod);
  178 
  179             Cursor = curr;
  180         }
  181 
  182         private void btnDemoForLoopRemove_Click(object sender, EventArgs e)
  183         {
  184             Cursor curr = Cursor;
  185             Cursor = Cursors.WaitCursor;
  186 
  187             long start = DateTime.Now.Ticks;
  188             int qty = _getQty(txtItemQty);
  189 
  190             Foo[] fullArray = _getFooArrayWithSomeSharedValues(qty);
  191             Foo[] filteredArray = _removeFooWithLoop(fullArray, _valueProperty + _setIntro + 8);
  192 
  193             //if we run this line INSTEAD of prior, we will receive same results as fullList-here for testing/demo
  194             //List<Foo> filteredList = _removeFoo(findList, _nonExistentValue);    
  195 
  196             double ms = _getDuration(start);
  197             _removeTimeWithForLoop = ms;
  198 
  199             _showResultsOfRemoveMethod(fullArray, filteredArray, ms, _removeFooWithForLoopMethod);
  200 
  201             Cursor = curr;
  202         }
  203 
  204         /// <summary>
  205         /// Button click event that shows implementation
  206         /// of the old standard for...loop to find an item in a List of objects
  207         /// </summary>
  208         /// <param name="sender">Object that requested the event</param>
  209         /// <param name="e">Event arguments</param>
  210         private void btnDemoForLoopFind_Click(object sender, EventArgs e)
  211         {
  212             Cursor curr = Cursor;
  213             Cursor = Cursors.WaitCursor;
  214 
  215             long start = DateTime.Now.Ticks;
  216             int qty = _getQty(txtItemQty);
  217 
  218             List<Foo> findList = _getFooListWithDistinctValues(qty);
  219             Foo f = _findFooInForLoop(findList, _valueProperty + (qty - 2));
  220 
  221             //if we run this line INSTEAD of prior, we will receive NO results-here for testing/demo
  222             //Foo m = _findFoo(findList, _valueProperty + 1000000);  
  223 
  224             double ms = _getDuration(start);
  225             _findTimeForSingleElementWithForLoop = ms;
  226             _showResultsOfFindMethod(f, ms, _findFooInForLoopMethod);
  227 
  228             Cursor = curr;
  229         }
  230 
  231         /// <summary>
  232         /// Button click event that shows implementation
  233         /// of the old standard for...loop to find all items in a List of objects
  234         /// matching specified value
  235         /// </summary>
  236         /// <param name="sender">Object that requested the event</param>
  237         /// <param name="e">Event arguments</param>
  238         private void btnDemoForLoopFindAll_Click(object sender, EventArgs e)
  239         {
  240             Cursor curr = Cursor;
  241             Cursor = Cursors.WaitCursor;
  242 
  243             long start = DateTime.Now.Ticks;
  244             int qty = _getQty(txtItemQty);
  245 
  246             List<Foo> findList = _getFooListWithMatchingValues(qty);
  247             List<Foo> foundList = _findFoosInForLoop(findList, _commonValue + _valueProperty);
  248 
  249             //if we run this line INSTEAD of prior, we will receive NO results-here for testing/demo
  250             //List<Foo> list = _findFoos(findList, _nonExistentValue);    
  251 
  252             double ms = _getDuration(start);
  253             _findTimeForMultiElementsWithForLoop = ms;
  254             _showResultsOfFindAllMethod(foundList, ms, _findFoosInForLoopMethod);
  255 
  256             Cursor = curr;
  257         }
  258 
  259         /// <summary>
  260         /// Resets the text box contents and formats
  261         /// </summary>
  262         /// <param name="sender">object that called this method</param>
  263         /// <param name="e">Event arguments</param>
  264         private void btnClear_Click(object sender, EventArgs e)
  265         {
  266             txtRpt.ResetBackColor();
  267             txtRpt.ResetFont();
  268             txtRpt.ResetText();
  269         }
  270 
  271         /// <summary>
  272         /// Grabs quantity from text box and adds integers to a List object
  273         /// </summary>
  274         /// <param name="sender">calling object</param>
  275         /// <param name="e">Event arguments</param>
  276         private void btnTestListAddLimits_Click(object sender, EventArgs e)
  277         {
  278             Cursor curr = Cursor;
  279             Cursor = Cursors.WaitCursor;
  280 
  281             long start = DateTime.Now.Ticks;
  282             int qty = _getQty(txtQtyXtra);
  283 
  284             List<int> fooList = new List<int>();
  285             int i = 0;
  286             string msg = string.Empty;
  287             try
  288             {
  289                 for (i = 0; i < qty; i++)
  290                     fooList.Add(i);
  291             }
  292             catch (OutOfMemoryException oe)
  293             {
  294                 msg = oe.Message + " - " + _listAddFailedAt + " " + i;
  295                 MessageBox.Show(_outOfMemoryCustomErr);
  296             }
  297             catch (Exception ex)
  298             {
  299                 msg = ex.Message + " - " + _listAddFailedAt + " " + i;
  300                 MessageBox.Show(_otherCustomErr);
  301             }
  302             finally
  303             {
  304                 double ms = _getDuration(start);
  305                 msg += Environment.NewLine + _durationWas + ": " + ms / 1000 +
  306                     " " + _seconds + " " + _for + " " + i + " " + _items;
  307                 _addToTxtBox(msg, Color.Black, false, false, false, 13);
  308             }
  309             Cursor = curr;
  310         }
  311 
  312         /// <summary>
  313         /// Grabs quantity from text box, builds a List and an Array of Foo 
  314         /// for specified quantity, and reports upon success/failure, and exec time
  315         /// </summary>
  316         /// <param name="sender">calling object</param>
  317         /// <param name="e">Event arguments</param>
  318         private void btnCompareListAndArrayCreation_Click(object sender, EventArgs e)
  319         {
  320             Cursor curr = Cursor;
  321             Cursor = Cursors.WaitCursor;
  322 
  323             long start = DateTime.Now.Ticks;
  324             int qty = _getQty(txtQtyXtra);
  325 
  326             Foo[] fooArray = _getFooArrayWithDistinctValues(qty);
  327             double ms = _getDuration(start);
  328 
  329             if (fooArray == null)
  330                 _showResultsOfCreate(_arrayCreation, qty, 0, ms);
  331             else
  332                 _showResultsOfCreate(_arrayCreation, qty, _arrayMemberIdx, ms);
  333 
  334             start = DateTime.Now.Ticks;
  335             List<Foo> fooList = _getFooListWithDistinctValues(qty);
  336             ms = _getDuration(start);
  337 
  338             if (fooList == null)
  339                 _showResultsOfCreate(_listCreation, qty, 0, ms);
  340             else
  341                 _showResultsOfCreate(_listCreation, qty, fooList.Count, ms);
  342 
  343             Cursor = curr;
  344         }
  345         #endregion
  346 
  347         #region RichTextBoxMethods
  348         /// <summary>
  349         /// To be called after object initialization---sets some style props
  350         /// </summary>
  351         private void _formatTxtBox()
  352         {
  353             txtRpt.Font = new Font("Courier New", 11);
  354             txtRpt.WordWrap = true;
  355             txtRpt.ScrollBars = RichTextBoxScrollBars.Vertical;
  356         }
  357 
  358         /// <summary>
  359         /// Appends any existing text in the text box, can be formatted
  360         /// </summary>
  361         /// <param name="txtToAdd">text to add to box</param>
  362         /// /// <param name="color">Color to set font to</param>
  363         /// <param name="bold">whether to bold this text</param>
  364         /// <param name="italic">whether to italicize this text</param>
  365         /// <param name="bullet">whether to bullet this text</param>
  366         /// <param name="size">font size for this text</param>
  367         private void _addToTxtBox(string txtToAdd, Color color, bool bold,
  368             bool italic, bool bullet, int size)
  369         {
  370             if (string.IsNullOrEmpty(txtToAdd))
  371                 return;
  372 
  373             int beg = txtRpt.TextLength;
  374             txtRpt.AppendText(txtToAdd);
  375             if (beg == 0)
  376                 _formatTxt(beg, txtToAdd.Length - 1, color, bold, italic, bullet, size);
  377             else
  378                 _formatTxt(beg, txtToAdd.Length, color, bold, italic, bullet, size);
  379         }
  380 
  381         /// <summary>
  382         /// Formats text in the text box, from start position to end position
  383         /// as specified by arguments
  384         /// </summary>
  385         /// <param name="startPos">character number to begin formatting from</param>
  386         /// <param name="endPos">character number to end formatting at</param>
  387         /// <param name="color">Color to set font to</param>
  388         /// <param name="bold">whether to bold this text</param>
  389         /// <param name="italic">whether to italicize this text</param>
  390         /// <param name="bullet">whether to bullet this text</param>
  391         /// <param name="size">font size for this text</param>
  392         private void _formatTxt(int startPos, int endPos, Color color, bool bold,
  393             bool italic, bool bullet, int size)
  394         {
  395             if (txtRpt.TextLength < startPos + (endPos - startPos))
  396                 return;
  397 
  398             txtRpt.Select(startPos, endPos);
  399             txtRpt.SelectionColor = color;
  400             FontStyle style = _getFontStyle(bold, italic);
  401             txtRpt.SelectionFont = new Font(txtRpt.Font.FontFamily, size, style);
  402             txtRpt.SelectionBullet = bullet;
  403         }
  404 
  405         /// <summary>
  406         /// Evaluates bold & italic choices to get style enum
  407         /// </summary>
  408         /// <param name="bold">whether to bold the font</param>
  409         /// <param name="italic">whether to italicize the font</param>
  410         /// <returns>FontStyle object</returns>
  411         private static FontStyle _getFontStyle(bool bold, bool italic)
  412         {
  413             if (bold && italic)
  414                 return FontStyle.Bold | FontStyle.Italic;
  415             if (bold)
  416                 return FontStyle.Bold;
  417             if (italic)
  418                 return FontStyle.Italic;
  419             return FontStyle.Regular;
  420         }
  421         #endregion
  422 
  423         #region ReportResultsMethods
  424         /// <summary>
  425         /// Show msg box if no results, otherwise, summarize duration + item found in text box
  426         /// </summary>
  427         /// <param name="f">Foo object</param>
  428         /// <param name="milliseconds">double: number of milliseconds</param>
  429         /// <param name="method">name of method being tested</param>
  430         private void _showResultsOfFindMethod(Foo f, double milliseconds, string method)
  431         {
  432             if (f == null)
  433             {
  434                 txtRpt.Text = _msgNoResults;
  435                 MessageBox.Show(_msgNoResults);
  436                 return;
  437             }
  438 
  439             Color nameColor = Color.DeepSkyBlue;
  440             Color valueColor = Color.DarkCyan;
  441             string data = Environment.NewLine + _msgTimeElapsed + " " +
  442                 method + ":  ";
  443             _addToTxtBox(data, nameColor, true, false, false, 13);
  444 
  445             string ms = (milliseconds / 1000).ToString();
  446             data = ms + " " + _seconds;
  447             _addToTxtBox(data, valueColor, false, true, false, 12);
  448 
  449             data = Environment.NewLine + _nameFound + ":  ";
  450             _addToTxtBox(data, nameColor, true, false, false, 13);
  451 
  452             data = f.Name;
  453             _addToTxtBox(data, valueColor, false, true, false, 12);
  454 
  455             data = Environment.NewLine + _valueFound + ":  ";
  456             _addToTxtBox(data, nameColor, true, false, false, 13);
  457 
  458             data = f.Value;
  459             _addToTxtBox(data, valueColor, false, true, false, 12);
  460         }
  461 
  462         /// <summary>
  463         /// Show msg box if no results, otherwise, summarize duration + 1st & 
  464         /// last item found in text box
  465         /// </summary>
  466         /// <param name="list">List of Foo objects</param>
  467         /// <param name="milliseconds">double: number of milliseconds</param>
  468         private void _showResultsOfFindAllMethod(IList<Foo> list, double milliseconds,
  469             string method)
  470         {
  471             if (list == null || list.Count < 1)
  472             {
  473                 txtRpt.Text = _msgNoResults;
  474                 MessageBox.Show(_msgNoResults);
  475                 return;
  476             }
  477 
  478             Color nameColor = Color.DarkGreen;
  479             Color valColor = Color.ForestGreen;
  480             string data = Environment.NewLine + _msgTimeElapsed + " " +
  481                 method + ":  ";
  482             _addToTxtBox(data, nameColor, true, false, false, 13);
  483 
  484             string ms = (milliseconds / 1000).ToString();
  485             data = ms + " " + _seconds;
  486             _addToTxtBox(data, valColor, false, true, false, 12);
  487 
  488             data = Environment.NewLine + _qtyFound + ":  ";
  489             _addToTxtBox(data, nameColor, true, false, false, 13);
  490 
  491             data = list.Count.ToString();
  492             _addToTxtBox(data, valColor, false, true, false, 12);
  493 
  494             data = Environment.NewLine + _firstFound + ": ";
  495             _addToTxtBox(data, nameColor, true, false, false, 13);
  496 
  497             data = list[0].Name + " - " + list[0].Value;
  498             _addToTxtBox(data, valColor, false, true, false, 12);
  499 
  500             data = Environment.NewLine + _lastFound + ": ";
  501             _addToTxtBox(data, nameColor, true, false, false, 13);
  502 
  503             data = list[list.Count - 1].Name + " - " +
  504                 list[list.Count - 1].Value;
  505             _addToTxtBox(data, valColor, false, true, false, 12);
  506 
  507             //foreach (Foo item in list)
  508             //...
  509         }
  510 
  511         /// <summary>
  512         /// Show msg box if no results, otherwise, summarize duration + 1st & 
  513         /// last item found in text box
  514         /// </summary>
  515         /// <param name="origList">full list of foo objects/param>
  516         /// <param name="newList">filtered list of foo objects/param>
  517         /// <param name="milliseconds">double: number of milliseconds</param>
  518         /// <param name="method">string name of method to report on</param>
  519         private void _showResultsOfRemoveMethod(ICollection<Foo> origList,
  520             ICollection<Foo> newList, double milliseconds, string method)
  521         {
  522             if (origList == null || origList.Count < 1)
  523             {
  524                 txtRpt.Text = _msgNoResults;
  525                 MessageBox.Show(_msgNoResults);
  526                 return;
  527             }
  528 
  529             Color nameColor = Color.DarkGreen;
  530             Color valColor = Color.ForestGreen;
  531             string data = Environment.NewLine + _msgTimeElapsed + " " +
  532                 method + ":  ";
  533             _addToTxtBox(data, nameColor, true, false, false, 13);
  534 
  535             string ms = (milliseconds / 1000).ToString();
  536             data = ms + " " + _seconds;
  537             _addToTxtBox(data, valColor, false, true, false, 12);
  538 
  539             data = Environment.NewLine + _qtyRemoved + ":  ";
  540             _addToTxtBox(data, nameColor, true, false, false, 13);
  541 
  542             int diff = origList.Count > newList.Count
  543                 ? origList.Count - newList.Count : 0;
  544 
  545             data = diff.ToString();
  546             _addToTxtBox(data, valColor, false, true, false, 12);
  547         }
  548 
  549         /// <summary>
  550         /// Build text to report upon/display collection creation in txt ctrl
  551         /// </summary>
  552         /// <param name="_collectionIntro">
  553         /// string to intro the collection TYPE (array/list..)
  554         /// </param>
  555         /// <param name="qty">collection qty requested</param>
  556         /// <param name="count">actual collection count</param>
  557         /// <param name="duration">milliseconds (time elapsed to make collection)</param>
  558         private void _showResultsOfCreate(string _collectionIntro, int qty, int count,
  559             double duration)
  560         {
  561             string txt;
  562             if (count == 0 || count < qty)
  563                 txt = Environment.NewLine + _failure + ":  ";
  564             else
  565                 txt = Environment.NewLine + _success + ":  ";
  566 
  567             txt += _collectionIntro + " " + _durationWas + ": " +
  568                 duration / 1000 + " " + _seconds + " " + _for + " " +
  569                 count + " " + _items;
  570 
  571             _addToTxtBox(txt, Color.Black, false, false, false, 12);
  572         }
  573         #endregion
  574 
  575         #region MathMethods
  576         /// <summary>
  577         /// Takes start time, uses NOW time to compute time difference
  578         /// and return double (difference in milliseconds) value
  579         /// </summary>
  580         /// <param name="start">
  581         /// use DateTime.Now.Ticks to correspond with end comparison
  582         /// </param>
  583         /// <returns>Difference in milliseconds from start to now (end)</returns>
  584         private static double _getDuration(long start)
  585         {
  586             long end = DateTime.Now.Ticks;
  587             long elapsed = end - start;
  588             return new TimeSpan(elapsed).TotalMilliseconds;
  589         }
  590 
  591         /// <summary>
  592         /// Evaluates whether control text can be used for quantity
  593         /// returns default quantity value, if not
  594         /// </summary>
  595         /// <param name="ctrl">Control that contains the text property</param>
  596         /// <returns>int to use as quantity</returns>
  597         private static int _getQty(Control ctrl)
  598         {
  599             long l;
  600 
  601             return long.TryParse(ctrl.Text, out l) 
  602                 ? Convert.ToInt32(ctrl.Text) 
  603                 : 1000000;
  604         }
  605 
  606         /// <summary>
  607         /// Computes difference between method times, and displays
  608         /// winning method (if exists) and a dashed line in the text box
  609         /// </summary>
  610         /// <param name="method1Name">name of 1st method</param>
  611         /// <param name="method1Time">duration of 1st method</param>
  612         /// <param name="method2Name">name of 2nd method</param>
  613         /// <param name="method2Time">duration of 2nd method</param>
  614         private void _showWinner(string method1Name, double method1Time,
  615             string method2Name, double method2Time)
  616         {
  617             string txt;
  618             if (method1Time < method2Time)
  619                 txt = _winningMethod + ": " + method1Name + " - " + _timeDiff +
  620                     ": " + ((method2Time - method1Time) / 1000);
  621             else if (method2Time < method1Time)
  622                 txt = _winningMethod + ": " + method2Name + " - " + _timeDiff +
  623                     ": " + ((method1Time - method2Time) / 1000);
  624             else
  625                 txt = _no + " " + _winningMethod;
  626 
  627             _addToTxtBox(Environment.NewLine + txt, Color.Purple, false, true, true, 12);
  628             _addToTxtBox(Environment.NewLine + _spacerLine, Color.Black, true, false, false, 14);
  629         }
  630         #endregion
  631 
  632         #region PredicateMethods
  633         /// <summary>
  634         /// Uses predicate delegate to search Foo list and return
  635         /// the first foo whose value matches the specified fooValue
  636         /// </summary>
  637         /// <param name="findList">List of foo to search thru</param>
  638         /// <param name="fooValue">Foo value property value to retrieve Foo object by</param>
  639         /// <returns>Foo object</returns>
  640         private static Foo _findFoo(List<Foo> findList, string fooValue)
  641         {
  642             Foo foo = findList.Find(delegate(Foo f)
  643             { return f.Value.Equals(fooValue); });
  644             return foo;
  645         }
  646 
  647         /// <summary>
  648         /// Uses predicate delegate to search Foo list and return 
  649         /// all elements whose value match the specified fooValue
  650         /// </summary>
  651         /// <param name="findList">List of foo to search thru</param>
  652         /// <param name="fooValue">Foo value property value to retrieve Foo objects by</param>
  653         /// <returns>Foo object list</returns>
  654         private static List<Foo> _findFoos(List<Foo> findList, string fooValue)
  655         {
  656             List<Foo> returnList = findList.FindAll(delegate(Foo f)
  657             { return f.Value.Equals(fooValue); });
  658             return returnList;
  659         }
  660 
  661         /// <summary>
  662         /// Uses predicate delegate to search Foo list and remove 
  663         /// all elements whose value match the specified fooValue
  664         /// </summary>
  665         /// <param name="fullList">List of foo to search/filter</param>
  666         /// <param name="fooValue">Foo value to remove Foo objects for</param>
  667         /// <returns>Foo object list</returns>
  668         private static List<Foo> _removeFoo(IEnumerable<Foo> fullList, string fooValue)
  669         {
  670             List<Foo> filteredList = new List<Foo>(fullList);
  671             filteredList.RemoveAll(delegate(Foo f)
  672             { return f.Value.Equals(fooValue); });
  673             return filteredList;
  674         }
  675         #endregion
  676 
  677         #region ForLoopMethods
  678         /// <summary>
  679         /// Uses for loop to iterate Foo list and return
  680         /// the first foo whose value matches the specified fooValue
  681         /// </summary>
  682         /// <param name="findList">List of foo to loop thru</param>
  683         /// <param name="fooValue">Foo value property value to retrieve Foo object by</param>
  684         /// <returns>Foo object</returns>
  685         private static Foo _findFooInForLoop(IEnumerable<Foo> findList, string fooValue)
  686         {
  687             foreach (Foo f in findList)
  688                 if (f.Value == fooValue)
  689                     return f;
  690             return null;
  691         }
  692 
  693         /// <summary>
  694         /// Uses for loop to iterate Foo list and return all
  695         /// items whose value matches the specified fooValue
  696         /// </summary>
  697         /// <param name="findList">List of foo to loop thru</param>
  698         /// <param name="fooValue">Foo value to retrieve Foo object by</param>
  699         /// <returns>List of Foo objects</returns>
  700         private static List<Foo> _findFoosInForLoop(IEnumerable<Foo> findList, string fooValue)
  701         {
  702             List<Foo> returnList = new List<Foo>();
  703             foreach (Foo f in findList)
  704                 if (f.Value == fooValue)
  705                     returnList.Add(f);
  706             return returnList;
  707         }
  708 
  709         /// <summary>
  710         /// Uses for loop to iterate Foo array and remove all
  711         /// items whose value matches the specified fooValue
  712         /// </summary>
  713         /// <param name="fullArray">Array of foo to loop thru</param>
  714         /// <param name="fooValue">Foo value to remove Foo object by</param>
  715         /// <returns>Filtered Array of Foo objects</returns>
  716         private static Foo[] _removeFooWithLoop(ICollection<Foo> fullArray, string fooValue)
  717         {
  718             Foo[] filteredArray = new Foo[fullArray.Count];
  719             int i = 0;
  720             int subtract = 0;
  721             foreach (Foo origFoo in fullArray)
  722             {
  723                 if (origFoo.Value != fooValue)
  724                     filteredArray = origFoo;
  725                 else
  726                     subtract += 1;
  727                 i++;
  728             }
  729             Foo[] finalArray = new Foo[i - subtract];
  730 
  731             i = 0;
  732             foreach (Foo newFoo in finalArray)
  733             {
  734                 finalArray = filteredArray;
  735                 i++;
  736             }
  737             return finalArray;
  738         }
  739         #endregion
  740 
  741         #region BuildListMethods
  742         private static Foo[] _getFooArrayWithSomeSharedValues(int qty)
  743         {
  744             //force it:
  745             if (qty < 10)
  746                 qty = 10;
  747 
  748             Foo[] fooArray = new Foo[qty];
  749             int i = 0;
  750 
  751             try
  752             {
  753                 for (int j = 0; j < 10; j++)
  754                     for (i = i; i < ((qty / 10) * (j + 1)); i++)
  755                         fooArray = new Foo(_fooObjectName + i, _valueProperty +
  756                             _setIntro + (j + 1));
  757             }
  758             catch (OutOfMemoryException oe)
  759             {
  760                 MessageBox.Show(oe.Message + " - " + _listAddFailedAt + " " + i);
  761                 return fooArray;
  762             }
  763             catch (Exception ex)
  764             {
  765                 MessageBox.Show(ex.Message + " - " + _listAddFailedAt + " " + i);
  766                 return fooArray;
  767             }
  768             return fooArray;
  769         }
  770         /// <summary>
  771         /// Creates and fills a foo list with some shared/some distinct values for each foo
  772         /// </summary>
  773         /// <param name="qty">number of foo to add to list</param>
  774         /// <returns>foo list of qty specified w/various values</returns>
  775         private static List<Foo> _getFooListWithSomeSharedValues(int qty)
  776         {
  777             //force it:
  778             if (qty < 10)
  779                 qty = 10;
  780 
  781             List<Foo> fooList = new List<Foo>();
  782             int i = 0;
  783 
  784             try
  785             {
  786                 for (int j = 0; j < 10; j++)
  787                     for (i = i; i < ((qty / 10) * (j + 1)); i++)
  788                         fooList.Add(new Foo(_fooObjectName + i, _valueProperty +
  789                             _setIntro + (j + 1)));
  790             }
  791             catch (OutOfMemoryException oe)
  792             {
  793                 MessageBox.Show(oe.Message + " - " + _listAddFailedAt + " " + i);
  794                 return fooList;
  795             }
  796             catch (Exception ex)
  797             {
  798                 MessageBox.Show(ex.Message + " - " + _listAddFailedAt + " " + i);
  799                 return fooList;
  800             }
  801             return fooList;
  802         }
  803 
  804         /// <summary>
  805         /// Creates and fills a foo list with distinct values for each foo
  806         /// </summary>
  807         /// <param name="qty">number of foo to add to list</param>
  808         /// <returns>foo list of qty specified w/various values</returns>
  809         private static List<Foo> _getFooListWithDistinctValues(int qty)
  810         {
  811             List<Foo> fooList = new List<Foo>();
  812             int i = 0;
  813             try
  814             {
  815                 for (i = 0; i < qty; i++)
  816                     fooList.Add(new Foo(_fooObjectName + i, _valueProperty + i));
  817             }
  818             catch (OutOfMemoryException oe)
  819             {
  820                 MessageBox.Show(oe.Message + " - " + _listAddFailedAt + " " + i);
  821                 return fooList;
  822             }
  823             catch (Exception ex)
  824             {
  825                 MessageBox.Show(ex.Message + " - " + _listAddFailedAt + " " + i);
  826                 return fooList;
  827             }
  828             return fooList;
  829         }
  830 
  831         /// <summary>
  832         /// Creates and fills a foo list with the SAME value for each foo
  833         /// </summary>
  834         /// <param name="qty">number of foo to add to list</param>
  835         /// <returns>foo list of qty specified w/the same values</returns>
  836         private static List<Foo> _getFooListWithMatchingValues(int qty)
  837         {
  838             List<Foo> fooList = new List<Foo>();
  839             int i = 0;
  840             try
  841             {
  842                 for (i = 0; i < qty; i++)
  843                     fooList.Add(new Foo(_fooObjectName + i, _commonValue +
  844                         _valueProperty));
  845             }
  846             catch (OutOfMemoryException oe)
  847             {
  848                 MessageBox.Show(oe.Message + " - " + _listAddFailedAt + " " + i);
  849                 return fooList;
  850             }
  851             catch (Exception ex)
  852             {
  853                 MessageBox.Show(ex.Message + " - " + _listAddFailedAt + " " + i);
  854                 return fooList;
  855             }
  856             return fooList;
  857         }
  858 
  859         /// <summary>
  860         /// Creates and fills a foo Array with distinct values for each foo
  861         /// </summary>
  862         /// <param name="qty">number of foo to add to array</param>
  863         /// <returns>foo list of qty specified w/various values</returns>
  864         private Foo[] _getFooArrayWithDistinctValues(int qty)
  865         {
  866             _arrayMemberIdx = 0;
  867             Foo[] fooArray = new Foo[qty];
  868             int i = 0;
  869             try
  870             {
  871                 for (i = 0; i < qty; i++)
  872                     fooArray = new Foo(_fooObjectName + i, _valueProperty + i);
  873             }
  874             catch (OutOfMemoryException oe)
  875             {
  876                 MessageBox.Show(oe.Message + " - " + _arrayAddFailedAt + " " + i);
  877                 return fooArray;
  878             }
  879             catch (Exception ex)
  880             {
  881                 MessageBox.Show(ex.Message + " - " + _arrayAddFailedAt + " " + i);
  882                 return fooArray;
  883             }
  884             return fooArray;
  885         }
  886 
  887         /// <summary>
  888         /// Creates and fills a foo Array with the SAME value for each foo
  889         /// </summary>
  890         /// <param name="qty">number of foo to add to array</param>
  891         /// <returns>foo list of qty specified w/the same values</returns>
  892         private Foo[] _getFooArrayWithMatchingValues(int qty)
  893         {
  894             _arrayMemberIdx = 0;
  895             Foo[] fooArray = new Foo[qty];
  896             int i = 0;
  897             try
  898             {
  899                 for (i = 0; i < qty; i++)
  900                     fooArray = new Foo(_fooObjectName + i, _commonValue +
  901                         _valueProperty);
  902             }
  903             catch (OutOfMemoryException oe)
  904             {
  905                 MessageBox.Show(oe.Message + " - " + _arrayAddFailedAt + " " + i);
  906                 _arrayMemberIdx = i;
  907                 return fooArray;
  908             }
  909             catch (Exception ex)
  910             {
  911                 MessageBox.Show(ex.Message + " - " + _arrayAddFailedAt + " " + i);
  912                 return fooArray;
  913             }
  914             return fooArray;
  915         }
  916         #endregion
  917 
  918         #region InternalFooObject
  919         /// <summary>
  920         /// Demo/dummy object with two simple properties: Name and Value
  921         /// </summary>
  922         internal class Foo
  923         {
  924             #region Constructors
  925             /// <summary>
  926             /// Default constructor, sets properties to default values
  927             /// </summary>
  928             public Foo()
  929             {
  930                 _init();
  931             }
  932 
  933             /// <summary>
  934             /// Data constructor for, sets properties to passed-in values
  935             /// </summary>
  936             /// <param name="name">string name</param>
  937             /// <param name="value">string value</param>
  938             public Foo(string name, string value)
  939             {
  940                 _name = name;
  941                 _value = value;
  942             }
  943 
  944             /// <summary>
  945             /// Set default values for the employee object
  946             /// </summary>
  947             private void _init()
  948             {
  949                 _name = string.Empty;
  950                 _value = string.Empty;
  951             }
  952             #endregion
  953 
  954             #region PrivateProps
  955             /// <summary>
  956             /// local member to store method name
  957             /// </summary>
  958             private string _name;
  959 
  960             /// <summary>
  961             /// local member to store method value
  962             /// </summary>
  963             private string _value;
  964             #endregion
  965 
  966             #region PublicProps
  967             /// <summary>
  968             /// Read-write property: method value
  969             /// </summary>
  970             public string Value
  971             {
  972                 get { return _value; }
  973                 set { _value = value; }
  974             }
  975             /// <summary>
  976             /// Read-write property: method name
  977             /// </summary>
  978             public string Name
  979             {
  980                 get { return _name; }
  981                 set { _name = value; }
  982             }
  983             #endregion
  984         }
  985         #endregion
  986     }
  987 }

Investigating the new Spatial Types in SQL Server 2008 - Part 2

bennie — Wed, 08 Oct 2008 19:32:51 GMT

Introduction

In the previous part of this series, we talked about the importance of spatial data in our everyday lives. We talked about vector and raster data, and we explained that the current version of SQL Server 2008 focuses on two-dimensional vector data. Next, we introduced the new geography and geometry data types in SQL server 2008, and we took a quick detour into some important object-oriented principles.

In this article, we start out by taking a look at the class hierarchies for both the geometry and the geography data types in SQL Server 2008. We will focus on the concrete classes in the class diagram which are:

Point.
LineString
Polygon

We will also take a look at the collection classes in the object hierarchy, which allow us to store multiple instances of each type.

Once we have a good grasp on the geometry and geography class hierarchy we will dive into the details of each concrete class. We will start our investigation by looking into the details of the Point and LineString class, and we will write a T-SQL script that highlights the most important features. In the process we will take a look at the three different data formats that can be used to represent spatial data:

The Well-Known-Binary (WKB) format
The Well-Known-Text (WKT) format
The Geography Markup Language (GML) data format.

All of these formats are published as a standard by the Open Geospatial Consortium (OGC), which is the leading standards body for geospatial and location based services.

The Geometry class hierarchy

Overview

A class diagram showing the Geometry class and all of its sub-classes is shown below (note that the Geography class diagram is basically identical, with the Geography class at the root of the tree):

The darker-blue shaded classes are abstract base classes, so they cannot be directly instantiated in the database engine. The light-blue shaded classes are the concrete classes that we can use directly in our T-SQL code:

Point
LineString
Polygon

Each of these single-instance classes has a collection equivalent that can contain multiple instances:

MultiPoint
MultiLineString
MultiPolygon

The GeomCollection class is an additional collection class that can contain a mixture of instances of any type (Points, LineStrings and Polygons).

Supported Data Formats

All of the classes in the geometry and the geography class hierarchy can be represented by three different formats:

The Well-Known Binary (WKB) format. This is a byte-stream (binary) representation for a geography instance. This format is the preferred serialization format for those applications that need to store geospatial information in a compact, self-contained format.
The Well-Known Text (WKT) format. This is a compact, easy to read representation. Because of its user-friendly format it is the most commonly used representation for ad-hoc geospatial queries.
The Geography Markup Language (GML) format. This is an XML-based representation, which is best suited for including geospatial information in an XML document. This format is very useful for those applications that need to exchange geospatial information by means of an XML Web service.

All of the above formats are published as standards by the OGC. In the code samples that follow, we will be showing multiple examples of each format.

The Point Class

Basic Representation

A Point is a zero-dimensional object which represents a single, exact location. It always contains an X and Y coordinate, and can optionally can contain a Z (elevation) value, and a M (measure) value. The measure value is an arbitrary floating point measurement value that you can associate with the Point instance.

The sample T-SQL script (GeometryPoint.sql)illustrates some of the capabilities of the Point class. Throughout all of our demos, we will be working with a very simple table called GeometryDemo, which allows us to associate a Geometry instance with an integer ID:

   1: CREATE TABLE GeometryDemo

   2: (

   3:     ID    INT NOT NULL,

   4:     Value GEOMETRY NOT NULL

   5: );

In the following code sample, we insert a Point instance, and then perform a select to retrieve the point instance in a number of formats:

   1: -- Insert a simple Point with an

   2: -- X and Y coordinate

   3: INSERT INTO GeometryDemo (ID, Value)

   4: VALUES    (1, 'POINT(50 65)');

5:

   6: -- Get the X and Y coordinates and

   7: -- the most relevant methods

   8: SELECT ID, Value.ToString() AS WKT,

   9:            Value.STX AS [X Coordinate],

  10:            Value.STY AS [Y Coordinate],

  11:            Value.STAsBinary() as [Binary Representation],

  12:            Value.STasText() as [Text Representation]

  13: FROM GeometryDemo

  14: WHERE ID = 1;

In lines 3 and 4, we use the WKT format to insert a Point with an X coordinate of 50 and a Y coordinate of 65. The WKT format for a Point simply requires you to to specify the X and Y coordinates. Note that you should NOT use a comma separator between the two, which might seem counterintuitive at first.

In lines 8 through 14 we select the instance that we just inserted. Since Value is a geometry class instance, we need to use the dot (".") notation to access properties and invoke methods on the object:

In line 8 we invoke the ToString() method. This method will return the Well-Known Text (WKT) representation of the instance.
In lines 9 and 10 we invoke the STX and STY properties to get the X and Y coordinates of our Point.
In line 11 we invoke the STAsBinary() method to get the binary representation of the Point.
Finally, in line 12 we invoke the STAsText() method, which will again return the WKT format of the Point.

One important note: although TSQL by itself is not case sensitive, the CLR methods and properties on the spatial data types are, so make sure that you spell the property and method names correctly! For example if you would spell "Value.STAsText()" as "Value.STasText()" you would get the following error message:

   1: Msg 6506, Level 16, State 10, Line 34

   2: Could not find method 'STasText' for type 'Microsoft.SqlServer.Types.SqlGeometry' in assembly 'Microsoft.SqlServer.Types'

The output of the select query is shown below:

From the above output, we see that the WKT representation for the Point is returned by both the ToString() and the STAsText() methods. We also see the binary WKB representation and the X and Y coordinates of the Point instance.

Using the Z and M coordinates

As we mentioned earlier, a Point can optionally contain a Z (Elevation) coordinate and a M (Measurement) value. Note that both the Z and M values should be floats. Below is a T-SQL example:

   1: -- Insert a Point with an X, Y, Z and

   2: -- M coordinate

   3: INSERT INTO GeometryDemo (ID, Value)

   4: VALUES (2, 'POINT(55 70 100.2 50)');

5:

   6: SELECT ID, Value.ToString() AS WKT,

   7:            Value.STX AS [X Coordinate],

   8:            Value.STY AS [Y Coordinate],

   9:            Value.Z AS [Elevation],

  10:            Value.M AS [Measure]

  11: FROM GeometryDemo

  12: WHERE ID = 2;

As you can see, we simply added the Z and M values in the WKT format. The output of the select query is shown below:

OGC-compliant methods and Microsoft Extensions

The attentive observer probably noticed that some method and properties have an ST prefix (such as STX, STY and STAsText()), while other properties and methods do NOT have this prefix (for example: Z, M and ToString()). All methods and properties that are prefixed with ST are OGC-compliant methods, while the other methods and properties are Microsoft extensions to the OGC standard.

In the documentation you will notice that the OGC standard methods and the Microsoft extensions are cleanly separated:

In the above diagram we also see sections for static methods (both OGC and Microsoft extensions). We will take a look at static methods in a later section of this post.

Geography Markup Language (GML)

The only format that we have not worked with so far is the Geographic Markup Language (GML), let's write a query to retrieve both points as GML:

   1: --    Select both Points as GML

   2: --  Note that we are NOT retrieving the Z and M

   3: --  coordinates of the second point

   4: --  because they are NOT OGC compliant!

   5: SELECT ID, Value.AsGml() as [GML]

   6: FROM GeometryDemo;

The AsGml() method can be used to retrieve a geometry instance in GML format.

The output of the query is shown below:

The standard XML namespace for GML will have the URN: http://www.opengis.net/gml.

There is also one important note that we can make from the above output: the Z and M coordinates that we used for the second point are NOT returned in the GML! That is because they are proprietary Microsoft extensions to the OGC standard.

Using the static Point methods

The methods and properties we have used so far were invoked on an instance of the Point class, so we used the "dot" (.) notation:

instanceName.Property

-or-

instanceName.MethodCall(... method arguments here ...)

Instance properties and methods are always tied to a particular object instance, in this case a Point instance. Besides instance methods, the spatial data types in SQL Server 2008 also use static methods and properties. Static methods and properties are tied to the class itself, and can thus be invoked without having an instance around. You use the "::" notation in combination with the class name to invoke a static method or property in T-SQL:

className::Property

-or-

className::MethodCall()

One frequent usage pattern for a static method is the Factory Pattern. The Factory Pattern returns a new instance of the class through a static method. This pattern is used in both geospatial types in SQL Server 2008. Below is a code example from the GeometryPoint.sql T-SQL script:

   1: /* =========================================================================

   2:    ======= Using the Static methods to create a Point Instance =============

   3:    ========================================================================= */

   4: DECLARE @Pnt1 Geometry, @Pnt2 Geometry, @Pnt3 Geometry, @Pnt4 Geometry, @Pnt5 Geometry

   5: DECLARE @xmlSnippet xml;

6:

   7: --    1. Create a Point from an X and Y coordinate and an SRID

   8: SET @Pnt1 = geometry::Point(30, 20, 0);

9:

  10: -- 2. Create a Point using the Parse method

  11: SET @Pnt2 = geometry::Parse('POINT( 90 23 56000 231)');

12:

  13: -- 3. Create a Point using the OGC STPointFromText method

  14: -- Notice the SRID at the end

  15: SET @Pnt3 = geometry::STPointFromText('POINT(20 25)', 0)

16:

  17: -- 4. Create a Point from GML

  18: set @xmlSnippet =

  19:     '<Point xmlns="http://www.opengis.net/gml"> <pos>34 23</pos> </Point>';

  20: SET @Pnt4 = geometry::GeomFromGml(@xmlSnippet, 0);

21:

  22: -- 5. Null Point

  23: SET @Pnt5 = geometry::[Null];

24:

  25: -- Now select all points

  26: SELECT @Pnt1.ToString() AS [From Arguments],

  27:        @Pnt2.ToString() AS [From Parse],

  28:        @Pnt3.ToString() as [From STPointFromText],

  29:        @Pnt4.ToString() AS [From Xml],

  30:        @Pnt5 AS [Null Point];

Following is a discussion of each static method:

In line 8, we use the static geometry::Point() method to create a Point instance by passing in the X, Y, Z and M coordinates.
In line 11, we use the geometry::Parse() method to create a Point instance from Well-Known Text (WKT).
In line 15, we use the geometry::STPointFromText() method to create a Point instance from Well-Known Text. The is the OGC equivalent of the geometry::Parse() method.
In line 18, we have an example of how to create a Point instance from a Geographic Markup Language (GML) snippet, using the static geometry::GeomFromGml() method.
Finally, in line 23 we create a NULL Point instance with the static geometry::[Null] property.

The output of the select statement is shown below:

As we can conclude from the above output, the expected Point instances were created by means of the static methods.

The Spatial Reference Identifier

In the previous code sample, you might have noticed the "0" after the @xmlSnippet parameter:

   1: set @xmlSnippet =

   2:     '<Point xmlns="http://www.opengis.net/gml"> <pos>34 23</pos> </Point>';

   3: SET @Pnt4 = geometry::GeomFromGml(@xmlSnippet, 0);

This argument is the SRID, or the Spatial Reference Identifier. The SRID corresponds to a spatial reference system based upon the specific ellipsoid used for either flat-earth or round-earth mapping. Different projection systems exist, some of you might be familiar with the Mercator Projection that was used to create the maps that were in most classrooms in recent times. A good discussion of map projections can be found at: http://maps.unomaha.edu/Peterson/gis/notes/MapProjCoord.html.

Each projection is uniquely defined by its own SRID. You can use any projection you want, but you need to be aware that when you are comparing spatial instances using any of the methods (such as STIntersection()) you need to make sure that all objects have the same SRID otherwise you will get a run-time error!

That concludes part 2 of this series. In part three, we take a look at the LineString and the Polygon class, and we will use some visualization tools such as GeoQuery, Spatial Viewer, and SQL Server Management Studio's very own "Spatial Tab" to get a visual representation of our spatial data!

Investigating the new Spatial Types in SQL Server 2008 - Part 1

bennie — Sun, 05 Oct 2008 22:32:05 GMT

Series Abstract

In this post we take a look at the new spatial data type support in SQL server 2008. First, I will make a case for why you would want to integrate spatial support in your applications. Next we will take a look at the two core spatial data types in SQL Server: the Geometry and Geography types. We will explain when to use each type, and we will take a look at the main application domains for the two types.

The spatial types are implemented as CLR types in the database engine. Since some database folks might be unfamiliar with CLR types, we will make a brief detour into SQL Server and CLR types. We will talk about the differences between static and instance methods, and explain the TSQL calling notation for each.

Both the Geometry and the Geography types are really just the top-level types of a rich object hierarchy. We will take a detailed look at the different classes in this hierarchy, and we will explore the methods and properties of each class by means of a number of TSQL scripts. A part of this exploration we will take a look at the three data formats that can be used to represent the spatial types: the SQL Server-native Well-Know-Binary (WKB) format, and the OGC standard data types: the Well-Known-Text (WKT) and the Geography Markup Language (GML) . We will use TSQL scripts for each object to illustrate the different notations.

As always, a picture is worth a thousand words, and nowhere this is more the case as for spatial information. Therefore, I will use both the "Spatial Results" tab in SQL server and a number of third-party rendering tools such as SpatialViewer and GeoQuery to present a spatial query result.

After we have a good understanding of the spatial data types, we will put them to some practical use. We will use Virtual Earth to create applications in which we create mashups of Spatial data with a variety of business data. A large volume of GIS data is available on the public domain (some good sources are the US Census and USGS Web sites), but the format of this data is typically not compatible with SQL Server. Therefore, as part of this series we will create a library that will enable us to convert the "traditional" formats into a SQL Server 2008-compatible format.

The above abstract covers a wide variety of formats, therefore I am planing to spread out this article over a number of different posts. This first post will cover the need for spatial support in our applications, the basics of the Geometry and Geography data types and a quick OO primer.

Why Spatial Data?

These days it is hard to find any data that DOES NOT have a spatial aspect. A number of applications attempt to answer questions like the following:

Where are my customers located?
What cities have the highest accident rates?
What Florida counties have the highest flood risk? (OK, that one's easy to answer: "All of them"!)

As GPS devices become more prevalent, more and more data is geo-tagged. For example, a lot of modern mobile phones have both a camera and a GPS chip build in.

While the above applications use spatial data only as part of their overall data set, there are a number of applications that use mapping and spatial data as their primary output:

Consumer products such as Microsoft's Virtual Earth or Google maps.
The government publishes the census results as spatial data.
Utilities use mapping tools such as ESRI Server to plot the layout of electrical grid lines or underground gas lines.

While the above examples are pretty self-evident, spatial data also plays an import role in applications that we might not think about right away:

When a warehousing application generates a pallet "pick run", it will use geospatial information to calculate the most optimal route.
When an interior architect uses a CAD tool such as AutoDesk to perform modeling of an interior space, he/she is using spatial data quite extensively.
Computer-aided manufacturing tools use spatial data to layout out parts on a piece of sheet metal.
The program in a municipal kiosk uses spatial data and geometric algorithms to predict the arrival times of buses and trains.
A multi-player computer game use spatial coordinates to keep track of the current locations of all game participants.

From the above discussion it is clear that a large number of application have a need to work with spatial data. Some common requirements for spatial data support are:

The ability to store spatial coordinates directly in the database, preferably in the same tables as its associated data.
The data types used for this spatial data should go beyond simple point coordinates. Most geospatial data consists out of a mixture of points, lines (both single-segment and multi segment), and closed shapes (typically referred to as polygons in the literature).
The ability to perform a multitude of operations on this geospatial data. For example, a chip design application might want to assure that certain routes on a chip do not cross, other applications will have a need to calculate the area of a complex polygon etc.

In the next section will take a look at how SQL Server 2008 addresses the above requirements.

Spatial Data Support in SQL Server 2008

Types of Spatial Data

At the highest level, we recognize two major classes of spatial data:

Vector Data. Vector data is data expressed by a set of vertices and their relationship to one another. Common spatial features represented by vector data include:
- Points.
- Lines (where a line can have one or more segments)
- Polygons. Polygons are typically used to represent areas and regions.
Raster Data. Raster data is data expressed as a matrix of cells. We typically recognize raster data as images. Within a spatial or GIS context, we see raster data manifested as:
- Satellite images.
- The Virtual Earth bird's eye images.
- Google "street level" images.

An example of each type of spatial data is shown below

Sample Raster Image (a sample satellite heat map)	Sample Vector (in this case a simple line vector)

SQL Server 2008 does focus exclusively on Spatial Vector data.

The SQL Server 2008 Spatial Data Types

SQL Server 2008 introduces two new data types:

Geometry. The geometry data type is based on the Cartesian coordinate system, based upon a "flat earth" representation model. In this model, a point is represented by an X, Y and optionally a Z coordinate. This usage domain of this data type is either:
- The representation of simple coordinates in a two or three dimensional space. A example is the precise location of a pallet in a warehouse.
- The representation of map coordinates, where distances are limited enough so that they are not affected by the round earth model.
Geography. The geography data point can store points, lines, polygon and collections of each of these, using a "round earth" model as opposed to the "flat earth" model used by the Geometry data type. Instead of using X and Y coordinates, the geography data type will use a latitude/longitude combination to represent a single point. Most of the GIS data available on the Web is latitude/longitude based, so the Geography data type is the data type you should used in most of you GIS applications, especially when you are dealing with longer distances where the shape of the earth becomes relevant.

Geometry : Cartesian coordinate system, "flat earth" model	Geography: Latitude/longitude coordinates, "round earth" model

The geometry data type conforms to the Open Geospatial Consortium (OGC) Simple features for SQL specification version 1.1.0. The OGC is a non-profit, voluntary concensus standards organization which is the leading consortium when it comes to the drafting and ratification of standards for geospatial and location based services. One of the standards published by the OGC is the Well-Know-Text specification (WKT) for spatial data types. We will investigate this format in detail in part 2 of the series.

CLR Objects in the Database Engine and the Database Developer

Both the geometry and geography data types are implemented as user-defined types (UDT's) in the database engine. These UDT's are implemented as .NET Common Language Runtime (CLR) types. Before we take a more detailed look how to use these types, it is important that we make sure that the reader is familiar with some basic OO principles. If you are already familiar with object-orientation and .NET types, please feel free to skip ahead to the next part in this series.

The core abstraction in the object-oriented world is the class. A class can be seen as the blueprint for a particular type. From this blueprint, a client can create any number of actual object instances. A class hides away its implementation details behind a set of publicly accessible properties and methods. This principle is called encapsulation or information hiding. For example, a Car class will encapsulate the behavior of an automobile. It might expose methods such as Start, Stop, SlowDown and SpeedUp, and it might provide properties such as CurrentSpeed and DaysTillNextOilChange. The Car class will hide the details of how it executes these methods and exposes these properties, enabling the client to be "blissfully unaware" of the implementation details of the Car class.

Classes can be related to one another. At a high-level we can recognize the following types of relationships:

The "has-a" relationship. For example, a Car class might have a SteeringWheel and a GasTank. This type of relationship is sometimes referred to as a "uses" relationship, for example the Car class "uses" the SteeringWheel class and "uses" the GasTank class.
The "is-a" relationship. To stay with our Car example, a SportsCar is a specialized type of Car, which is specially equipped. It might have a Spoiler, a HighPerformanceEngine etc.. When classes have such a relationship they will use an OOP concept called inheritance to implement this relationship. In an inheritance implementation, the class from which we inherit is called the base class and the more specialized class is called the sub class. The sub class gets all of the functionality of the base class "for free", so it only needs to worry about implementing it own specialized behavior on top of the functionality of the base class. For example, the SportsCar class only implements the additional functionality that makes it a sports car.

An example of a "uses" ("has a") and an inheritance ("is a") relationship is shown in the figure below:

Some base classes only define a general abstract concepts or entities. These types of classes cannot be directly instantiated by the client, since they are not "feature complete". Such a class is called an abstract class The features defined by an abstract class are implemented by a sub class of the abstract class. Such a sub class that can be instantiated is called a concrete class. We will see in the next section that the geometry and geography classes are indeed defined as abstract classes in the database engine.

In the next part of this series, we will take a look at the class diagrams for both the geography and geometry classes, and we'll start writing some TSQL code!

An Introduction to LINQ to XML

bennie — Wed, 17 Sep 2008 15:35:18 GMT

Note: This post is a work in progress... not yet completed...

Overview

When Visual Studio 2008 and the .NET Framework 3.5 shipped in late 2007, the feature that got by far the most attention was Language Integrated Query (LINQ). This article will provide a quick overview of the LINQ technologies, and will then focus in on LINQ to XML, which is a subset of the LINQ technologies.

This article is structured as follows:

The next section will provide a short overview of LINQ in general. We take a look at what the main drivers were behind the creation of LINQ, and we will start looking at some of the specifics of LINQ to XML.
Once we have established a basic understanding of LINQ to XML, we will take a look at its object model. LINQ to XML introduces an easy to use, flattened object model, especially when compared to the XML DOM object model.
Next, we will take a look at what is in my opinion one of the most important features of LINQ to XML, and that is Functional Construction. Functional construction enables us to create an XML document in a very straightforward way. No longer do we need to use the elaborate XML DOM object model and write 100 lines of complex code, just to create a simple XML document that is just a few lines long.
After we have an understanding of how to create an XML document, we take a look at how we can use the features on the new LINQ to XML object model to query, iterate, manipulate and validate an XML document.
To illustrate how easy it is to leverage the LINQ to XML features in a real-world application, we will take a look at an example that performs two-way binding of a rather complex XML document to a WPF tree control.
To round out our discussion, we will take a look at some practical tips and tricks, which enables us to take full advantage of LINQ to XML, and we will also mentioned some common pitfalls, and inform you how to save time not making the same mistakes as your truly ;-)!

Prerequisites

If you want to run the code samples that are associated with this article, you will need the following pre-requisites:

Since we will be using LINQ, you obviously need to have a version of Visual Studio 2008 installed. If you install Visual Studio, you will automatically also install .NET 3.5 and the C# 3.0 compiler.
We will be showing how you can use LINQ to SQL to create XML documents, so you will need to have SQL Server 2005 or the SQL Server 2008 beta installed. If you have the express edition installed, I recommend you also download SQL Server Management Studio express.
We will be using the AdventureWorks sample database to illustrate how we can create an XML document from a SQL Server database, so you should have the latest version of the AdventureWorks database installed. If you currently don't have this database installed, you can navigate to: http://www.codeplex.com/MSFTDBProdSamples/Release/ProjectReleases.aspx?ReleaseId=4004, and download the appropriate version of the AdventureWorks*.msi file, and follow the instructions to install the database on your SQL server.

LINQ Overview

Background - Problem Description

Most of us write business applications to earn our living. All business applications that I ever worked with deal with some type of data, and quite a number of them involved multiple heterogeneous data sources.

In the early days (1980-1990) all of the data for an application was centralized in one file, and the data access capabilities were directly built into the language (I know that at this point, my friend Pete Miller is thinking back nostalgically about his FoxPro and DBASE days... ;-). The upside of this was that data querying and data manipulation were a core part of the programming experience, but the downside was that every platform (DBASE, FoxPro, FileMaker) would integrate these data access features in a completely different way, tailored to the capabilities of the underlying data access tool. As a result, programmers faced a steep learning curve when moving from one platform to another. Another drawback of these first-generation data access systems was scalability. All platforms were file-based, and therefore had a hard time scaling to multiple users and large data sizes.

In response to this and other issues, (1990s through early 2000s) relational database systems (RDBMS) were created. All of these databases used an emerging query and DML language called SQL to access the data, and database programs migrated from being strictly tied to a particular data access system dialect, to using industry-standard SQL. The query and data manipulation features became again external to the core programming languages, and were typically made available through a set of external libraries (db-Library anyone?). This process was accelerated by the creation of ODBC, which provides a standard means of accessing any database that provides an ODBC driver.

In recent years, we have seen the emergence of Object-Relational Mapping (ORM) tools. The main philosophy behind the ORM movement was the fact that designers and programmers are dealing with objects to represent their data, but each time they have to persist or load these objects from a data store, they have to make a paradigm shift back to SQL and the relational model, and the specific details associated with the database access libraries that are being used. An ORM tool, such as NHibernate takes over the responsibility of persisting and loading objects to the database in a transparent fashion.

While both SQL and their associated data access technologies (such as ADO.NET) and/or the newer ORM tools have simplified things significantly, we still have a number of challenges that remain:

Most real-world applications out there deal with other data types besides relational data. Indeed, in this connected world, we access a variety of XML data sources, we connect to RSS feeds, leverage Web Services using the SOAP or REST protocols, access data in Active Directory or some other LDAP-based data store, and so on. Each of these data sources have their own data access paradigms.
When working with "plain old objects", we have to use a very different API to sort, filter, group our otherwise manipulate our objects, as compared to relational data. Wouldn't it be nice if we could have one standard API for these common tasks?
Often we have to perform complex data transformations and/or data shaping. The way in which these transformations are performed is often dependent on the type of the data. For XML we use XSLT, for relational data we use views or complex joins, for objects we use manual code etc. Again, it would be nice to have access to one standard approach for performing transformations.
What if we want to access data from a dynamic language, such as Ruby, IronPython, PowerShell, F# or any of the future DLR-based languages? Will these languages be able to use the same data access tool as the statically-typed .NET languages such as C# or VB.NET?

Microsoft's Answer: LINQ

At the core, LINQ is really a set of constructs, built into the language, which allow us to work with any type of data, be it relational, XML or plain old objects. LINQ is supported in both C# 3.0 and VB 9.0, which are compilers that shipped with Visual Studio 2008. In a way, LINQ brings us "back to the future", making querying and manipulating data a core programming concept again. The main different with the "old school" languages such as FoxPro is that LINQ is fully independent of the type of data that is being accessed (object, relational data, XML, etc.), and the specific implementation of the data source (SQL Server, Oracle etc.).

The LINQ features in the C# 3.0 compiler are built on top of a number of other language enhancements such as:

Anonymous types
Anonymous methods
Type inference
Lambda expressions
Expression trees
Extension methods
Instance and collection initializers
Partial methods

A number of these features were addressed in some of my previous posts. Please refer to the blog archives for more information.

The .NET 3.5 Framework also provides LINQ support through a number of types, available in the System.*.LINQ namespaces. These types provide additional support on top of the compiler features.

A graphical overview of LINQ is shown below:

LINQ to XML

LINQ to XML is portion of LINQ that allows us to:

Construct
Traverse
Manipulate
Query
Search

XML documents and fragments, using the standard LINQ API.

One of the main goals of LINQ to XML was to address the main shortcomings in the W3C XML DOM API, as implemented in the System.Xml.* .NET 2.0 namespaces, with a focus on the following areas:

Simplify XML tree construction with functional construction.
Eliminate document centricity in favor of element centricity.
Simplify naming by eliminating prefixes from the API.
Simplify Node value extraction.

The above topics have always been a hard area to deal with for any programmer working with XML documents. XML DOM code is unnecessary complex and bloated, and often unintentionally obfuscated. For example, it is not easy to imply the structure of the created XML document, when reading XML DOM document creation code.

Other issues that Microsoft wanted to address with LINQ to XML is to allow a developer to quickly move data extracted from a relational model to an XML representation, or from an object graph to an XML document. This current DOM API does not support constructs such as projections inside a XQuery, LINQ to XML provides an elegant solution to this problem.

In the .NET 3.5 framework, LINQ to XML is implemented in the System.Xml.Linq.dll assembly, and exposed through the System.Xml.Linq namespace.

The dependencies of the System.Xml.Linq.dll assembly is show in the figure below:

LINQ to XML Object Model

LINQ to XML was developed with Language-Integrated Query over XML in mind from the onset. It takes advantage of the standard query operators and adds query extensions specific to XML. Just as significant as the Language-Integrated Query capabilities of LINQ to XML is the fact that LINQ represents a consistent query experience across all LINQ enabled APIs and allows us to combine XML queries from other data sources. So, with one query, you can access data from:

Local objects in memory
An XML Data Source
One or more SQL Server data sources

The core classes that make up the LINQ to XML object model are listed below:

As you can conclude from the object model above, the number of classes involved has been dramatically reduced, resulting in a reduced learning curve. Actually I think that the biggest challenge in working with LINQ to XML is to unlearn some of the bad practices that we had to burn into our brain to make the W3C XML DOM work for us.

Some key issues regarding this object model are listed below:

You can now work in a "document free mode" if you would like to do so. In some scenarios, you simply want to create or load some XML, manipulate and query it, and save it back. With the W3C DOM, you would be forced to create an XML document. In LINQ to XML, this is no longer the case. To perform the task listed, you could simply:
- Create XElements directly (without having an XDocument involved at all)
- Manipulate the XElements or XAttributes directly.
- Save the resulting XML tree directly to a writer.
XML names have been greatly simplified. LINQ to XML goes out of its way to make XML names as straightforward as possible. One can say that the complexity of XML names does not originate in namespaces, but from XML prefixes. XML prefixes can be used for reducing the keystrokes required when inputting XML or making XML easier to read, however prefixes are just shortcuts for using the full XML namespace. On input LINQ to XML resolves all prefixes to their corresponding XML Namespace and prefixes are not exposed at all in the programming API. In LINQ to XML, a XName represents a full XML name consisting of an XNamespace and the local name. Developers will usually find it more convenient to use the XNamespace rather than the namespace URI string.
An attribute (modeled by means of the XAttribute class) is no longer a subclass of the node class). It is now simply a XName-value pair, which is what it always should have been.

Functional Construction

Querying

WPF Data Binding

Tips and Tricks

Conclusion

Notes: Make sure how to construct an XML document from a LINQ database query

Creating Application Shortcuts with Google Chrome

bennie — Sun, 07 Sep 2008 18:46:44 GMT

Introduction

Unless you have been living under a rock for the last week, you probably know that Google shipped the first beta-version of it's new browser, named "Google Chrome". I am not planning to start yet another debate here about why I think Google decided at this point that it needed to get in the Web browser business. You can read plenty of interesting comments on various blog sites, for example Paul Thurrot, from the Windows Supersite had some very interesting feedback on the subject in his Windows Weekly Podcast with Leo Laporte.

Most of the features introduced by Chrome have an equivalent in Microsoft's upcoming IE 8 browser (beta 2 just shipped a couple of weeks ago). I do want to highlight one interesting feature of Chrome and that is the ability to create application shortcuts.

What is a Chrome Application Shortcut?

A Chrome Application Shortcut is basically a quick, streamlined way to access a Web Application's functionality in it's own window. You can create a shortcut on either the desktop, the "Start bar", or the "Quick Launch" toolbar. Once the short cut is created, you can simply double-click the shortcut to launch the application in it's own window. Using shortcuts is a nice alternative to launching the full browser window, and entering the URL (either manually or through a "favorites" entry).

Also, if you use Google Gears, you optionally have the ability to access the application's functionality if offline mode (if so desired).

Walkthrough

To create a shortcut, first navigate to the URL of the Web Application. Next, click the Page menu next to the address bar, and select the "Create application shortcuts.." menu item, as is shown below:

In the Google Gears dialog box that comes up, you can select the location(s) for your shortcut. So in my case, I elected to create a shortcut to Gmail, and I opted to have a shortcut on both my desktop and the "Quick Launch" bar.

Note that Chrome will use the appropriate icon for your shortcut.

After creating your shortcut, I can simply double-click the shortcut, to open the selected Web Application as show below:

The application opens up in its own Chrome window, without any toolbar or address bar clutter, as shown below:

Unnecessary Abstractions

donnfelker — Wed, 27 Aug 2008 18:29:24 GMT

Jason Bock had a similar title to this post awhile back … and I found a forehead-slapper today when reviewing some code in a app I’m working on during my free time. I seriously said “What the <ExplativeGoesHere>”.

Here’s the code:

There is absolutely no need to do this. This is exactly WHAT the IPAddress class does. The worst part is that the programmer who developed this knew that the IPAddress Class existed. I’m amazed daily.

Twin Cities Code Camp – Oct 11

donnfelker — Wed, 27 Aug 2008 17:47:05 GMT

I will be presenting at the 5th Twin Cities Code Camp on October 11th.

My session is entitled …

Smooth Operator: Using the Workflow Rules Engine Within WCF

Ever changing business logic requires rule systems that are flexible to business demands. The majority of the time the business requires that these rules systems must be consumable by other applications. Come see how we can utilize the Rules Engine within Windows Workflow Foundation to evaluate our rules and simplify our rules configuration. We will then encompass this functionality within a Windows Communication Foundation Service which will enable consumers to utilize the service.

Visit twincitiescodecamp.com to sign up!

Twin Cities Give Camp Update

donnfelker — Sat, 23 Aug 2008 15:56:56 GMT

The Twin Cities Give Camp site has been updated.

If you would like to volunteer, you can sign up on the volunteer page and if you or your company would like to sponsor the event, you can sign up on the sponsors page.

If you have any questions, please email us from the contact us page.

Side note: I have been having an intermittent problem with Grafffiti loading properly on the site. At times when you visit you will receive the graffiti cms error page. If you try to access the site again, it will go away. If you get an error, please let me know as I’m trying to sort it out with the host. Thanks!

Insane Flight Prices

donnfelker — Fri, 22 Aug 2008 12:11:00 GMT

I was on my favorite travel pricing site today and I was looking up how much flights were from MPLS to Des Moines. Now I'd probably never-ever fly to Des Moines because I believe its only about 3.5 hours away via car. But with gas prices these days you have to check it out. When I used to live in Phoenix, a group of friends and I would always go to Vegas every year. We drove a couple of times but we eventually found out that flying was actually cheaper (back then - 6-7 years ago). A round trip ticket would cost us 80 dollars. Talk about DEAL!!!!

So, wondering if I could score the same for another short flight such as Des Moines would be awesome.

YEAH. RIGHT.

Look at this scree capture:

Seriously. Over $700 dollars for a ticket? YOU GOTTA TO BE CRAZY! - or as the New Yorkers in the Bronx where I lived for awhile would say it "Yo dawg, dat price is banana's!"

Its apparent the airlines no longer have deals (at least in this case). If I do go, I'll be driving. :)

The Twin Cities Give Camp

donnfelker — Wed, 13 Aug 2008 03:13:14 GMT

I’ve presented at code camps and given presentations to technical audiences and institutes and I will continue to do so. I have a passion for giving back to the community that has helped me become the what I am today. I’ve decided that I want to give back to the community even further. After doing some research to find someone (or a group) who might already be setting up a Give Camp I’ve come to the conclusion that they don’t exist here in the Twin Cities.

Therefore, I’ve decided to start up the Twin Cities Give Camp (site not complete). The web site is www.twincitiesgivecamp.org.

I’ll be updating the site this week with all relevant info in regards to the Give Camp. No dates have been set, but as soon as we have one the site will be updated.

What is a Give Camp?

A Give Camp is a weekend-long event where software developers, designers, and database administrators donate their time to create custom software for non-profit organizations. This custom software could be a new web site for the nonprofit organization, a small data-collection application to keep track of members, or a application for the Red Cross that automatically emails a blood donor three months after they’ve donated blood to remind them that they are now eligible to donate again. The only limitation is that the project should be scoped to be able to be completed in a weekend.

…

At the Give Camp, there is an expectation of “What Happens at Give Camp, Stays at Give Camp”. Therefore, all source code must be turned over to the charities at the end of the weekend (developers cannot ask for payment) and the charities are responsible for maintaining the code moving forward (charities cannot expect the developers to maintain the codebase).

Source

More in depth info can be found here: www.givecamp.org

Do you want to be a part of this awesome experience?

We are in need of volunteers, developers, designers, DBA’s, volunteers, Project Managers, Charities, Prizes, Giveaways, sponsors and more volunteers. If you would like to participate or sponsor this event, please let me know. I will update this blog as soon as www.twincitiesgivecamp.org is updated. I will be in contact with the local PMI, IIBA, and ISSA, AITP and local .NET User Groups.

More info to come soon!

DiscountASP vs. Me

donnfelker — Fri, 08 Aug 2008 13:25:00 GMT

DiscountASP just won. Argh! I wrote a long blog post (because I dont have access to Live Writer on this PC) and then clicked Publish and it logged me out. Dont understand what I'm talking about? Read on ..

Unfortunately, what DiscountASP.NET does not tell you is that due to Community Server 2007’s large memory footprint (~100 megabytes with little to no activity), DiscountASP.NET has to recycle the application pool frequently, sometimes as often as every 5 minutes. The DiscountASP.NET policy is to recycle an individual website’s entire pool once it reaches a size of 100 megabytes.

Here are the consequences of being forced to recycle the application pool on a CS 2007 server:

* All logged-in users are logged out;
* any posts that you may have been writing will be lost if you try to press the submit button;
* the entire website is brought to a crawl with slow load times;
* and in essence it makes Community Server 2007 unusable.
Source - http://www.marketing-ninja.com/hosting/discountaspnet-and-community-server-do-not-mix-despite-what-discountaspnet-advertises/

*Shakes fist violently*

Is Premature Optimization Really Evil?

donnfelker — Thu, 24 Jul 2008 04:41:31 GMT

Photo Courtesy of: rosendahl

My first initial answer is … it depends. (Isn’t that the case for everything?) :)

Today I had conversation with a colleague and we were discussing how application developers don’t plan ahead.

This eventually brought up the question/topic:

“Is premature optimization pure evil?”

My colleague stated that all optimization should be done up front, while I on the other hand, disagree. In my opinion all development should be done first and then lets figure out where we might have some problems, with some exceptions (which we both agreed upon).

So, what did we agree upon?

Lets look at a classic example:

Developer Joe and his team were asked to create an order management system that could handle up to 10,000 orders a day. This doesn’t sound like that big of an issue, and Joe and his team also agreed. It shouldn’t be a big issue. A fast database, a fast web server, and a few third party controls to interact with. No problem! Heck, this is pretty straightforward they thought. In reality, the requirements were very straight forward, no hidden features, no scope creep, nothing like that. Heck, it was a dream project come true. With that said - development ensued, and two months later Joe’s team delivered the product and everyone was excited to see the product run from end to end. (By the way, this was not done TDD or with any Agile Methods – which IMO would have caught any of our upcoming issues, if the tests were written correctly. But then again “If ‘if’ was a fifth then we’d all be drunk”).

Joe’s team fired up the application for a demo and ran some orders through it and it worked great. They even ran 10 orders through the system in one minute (~14,400 Orders a day). They had gone above and beyond the call of duty (original requirement being 10,000 orders a day)! They were due for a raise! Life couldn't be better! The system was released and the company started to use it. Orders were flowing through the system without failure and the business was happy.

Until the company decided to sell an exclusive hot item two weeks later …

Then SHTF… All of a sudden, customers were experiencing time outs, orders were being duplicated, and the customer service line was being rung off the hook. Essentially, all hell broke loose. After looking into the system, the developers noticed that the system had only accepted 6,000 orders. What gives? This system should handle 14,400 according to their tests. *everyone is scratching their head at this point*

Scalability is Relative

Scalability in this case, is relative. While looking at the stats, Joe’s team realized that those 6000 orders came in in about 1.5 hours. This was the first 1.5 hours that this product was available. At the end of the day the company eventually sold under 10,000 units, so why did this issue happen?

Lets take a look at some stats:

	Orders Per Minute	Time Between Orders (seconds)
Original Spec (10,000 Per day)	~7	8.64
Current State (6000 in 90 Minutes)	~67	0.9

Orders Per Minute Equation: Orders / Minutes Minutes: (HoursInDay * MinutesInHour)

Orders Per Second Equation: Seconds / Orders Seconds: (HoursInDay * MinutesInHour * SecondsInMinute)

Do we see the problem here?

Again, scalability is relative. In this case, analysis and optimization was not done ahead of the time to anticipate the flood of orders at a peak period. The spec was straight forward: The system is to be designed to handle an order rate of 10,000 orders a day. The system was designed exactly to the spec, and in this case, the system was designed incorrectly.

Now, I have a confession… 6 years ago, I was Joe. Yes, I made this very mistake. I was a hero for a couple of weeks, then SHTF. :) Live and learn. Live and learn.

When We Agreed

My colleague and I both agreed that in certain instances premature optimization should be done, such as this case. The developers should optimize the order process to handle issues at peak times. Perhaps implementing a order service, based on MQ, or implementing a service bus for this type of high-availability process would be the best. In this case, we agree. All of this analysis and optimization should be done up front because this type of thing WILL be a problem at any peak utilization times. We both agree that neglecting to analyze the problem domain can and will lead to performance problems down the road. Plain and simple.

When We Disagreed

My colleague and I still disagree on the statement of “all code should be optimized up front”. In my opinion this is a BDUF approach that I tend to shy away from. I don’t necessary mean that no design should happen up front, but I do think it should be limited. In an agile environment things tend to change, and we need to be able to adapt quickly. Wasting months in front of a whiteboard, with of reams of documentation, and endless meetings only slows the process down if something has to change down the road. Re-updating project baselines, and adjusting documentation and so forth is a huge hassle. I would like to state that there is a place for this type of development though. Some companies do require BDUF approaches because of huge regulatory compliance issues, so sometimes there is not much you can do about it. However process driven approaches such as ITIL and Agile can work together if done properly. With that said, I tend to shy away from BDUF approaches because of a simple example that is also exemplified by Jeff Atwood in a previous post of his (and I agree with him and the many other experts in the field). Jeff adds a third rule to M.A. Jacksons Optimization Rules that I like agree with the most:

And I would add a third: don't optimize work that doesn't have to be done. - Jeff Atwood

This can be demonstrated as a sort routine. Lets say you have a menu that will be populated via user selections and the maximum number of values you can have in the menu is 100. You can either implement IComparable and utilize the List<T>.Sort() method to sort the class (which utilizes the Quicksort Algorithm) which would be SUPER easy but may not be the “Fastest” method of sorting, or you could write an extension method to create your own sort routine to sort the 100 items. At this point we’re splitting hairs. A millisecond, or even 10 milliseconds, wont matter at this point in UI response. We’re only sorting a menu that will never grow beyond 100 items. At this point, pre-mature optimization is evil. There is NO need to rewrite something that that does the job well enough. Can we do it better? Yes! Is there a need to? NO. We wont get any value out of it. The time spend on development is wasted compared to the benefit to the application.

On the other hand, if the menu had no upper bound limit, then we would want to implement the best sort routine we could because some routines are exponentially faster than others. In this case we would want to optimize early because the possibility of a bottleneck can and might occur in certain situations.

It all boils down to: “It Depends”

At the end of the day, the true answer to “Is Premature optimization evil?” is “It Depends”.

It depends on the problem. It depends on the architecture and design. It depends on analysis of the domain. It depends on the factors which “could” come into play.

Finally, what it really boils down to is: It depends on MONEY. We can optimize all day and gobs of the companies money in development/optimization costs. This is why deep analysis into the problems need to take place. As architects we need to define the business process that could impact our architecture design and implementation and development of code. At some point we need the business to interject into this analysis and optimization party to say “Listen, I’m willing to deal with X, but I’m not willing to deal with Y”. At that point, our jobs as Architects is to define how much X costs compared to how much Y costs. Only then will the business truly know what should be done juxtaposed with what should not be done.

To sum it up in my own personal opinion, premature optimization can be evil. We, as architects and developers need to think about the problem at hand before we write a line of code. As I stated above, there is no need for a full 90 page document on the process, but at least whiteboard with your colleagues. Are you a solo developer and need someone to bounce ideas off of? Join your local user group, join some groups online, visit the MSDN architecture forum and ask questions.

Mobilizing Your/My Blog - mobile.blog.donnfelker.com

donnfelker — Thu, 17 Jul 2008 12:18:51 GMT

Having a blog has its benefits, but sometimes people want to access your site via a mobile device and, well…. lets face it, rendering your site across many different mobile platforms, looks, well…. LIKE CRAP. Hell, half the time its unreadable.

How to Enable Your Site For Mobile Viewing

If you want to mobile enable your blog, its super-easy with the service provide by mofuse.com (no I’m not getting paid to write this). Literally its only a few steps and you’re done.

Create an account
Plug in your blog url that you want to “mobilize”
Choose the url you want
You’re done!

You can view my mobile site at: http://donnfelker.mofuse.mobi/

Here’s what it looks like in a emulator:

Basic Mobile Phone	Apple IPhone

Sprucing Up the URL

Although this is real easy to set up, the URL “donnfelker.mofuse.mobi” just seems clunky to me. Mofuse gives you the ability to set this to a custom domain.

I wanted my domain name to be representative of the content that was being delivered, therefore I chose mobile.blog.donnfelker.com (it is the mobile version of my blog right?).

Changing this is fairly simple, however you will have to alter your DNS records.

Log into your mofuse account and click on the blog that you’ve Mobilized.

Click Custom Domain

Enter your domain that you will be using and make note of the CNAME entry you will have to make.

Click save and you’re now done with your mofuse portion of this task.

Adding a custom CNAME to your DNS records.

This all depends on where your site is hosted and where your DNS is located. Mine is located on my host. *Important note: This will be different for each person, but this is how I alter my DNS with my host.*

Log into your host.

I selected my domain for editing.

Clicked DNS Configuration

At this point in time my DNS info was displayed to me. It looks like this:

(Click for full size image)

Click “Add DNS CNAME Record”

Add the CNAME record and click Submit

Done

You will have to wait up to 48 hours for this CNAME to take effect. I did mine last night at 9pm and when I woke up at 6 it was already up and running.

Conclusion

Its super simple to set this up and kudos goes to the guys/gals at mofuse. Now I can go to mobile.blog.donnfelker.com and view my blog on my mobile or send the link to anyone else who wants to see it on a mobile. Excellent! Good luck in setting up your own mobile blog!

Passed the ASP.NET 3.5 Exam

donnfelker — Thu, 17 Jul 2008 00:33:00 GMT

I took the ASP.NET 3.5 Exam (in beta form) on June 5th at Tech-Ed 2008 and today I received notification that …. I PASSED! Woohoo!

What does this mean? Well, it means that I’m now an MCTS in ASP.NET 2.0 and an MCTS for ASP.NET 3.5.

Calgary ALT.NET Open Space – August 15-17

donnfelker — Mon, 14 Jul 2008 03:21:21 GMT

So, are you going? If so, you better sign up quick! Space is going fast!

What is an alt.net open space?

First lets define what an open space actually is…

How Open Spaces Works

Whoever shows up is the right group. Whatever happens is the only thing that could have. Whenever it starts is the right time. When it's over, it's over.

An Open Space conference's agenda is decided upon by the conference participants during the opening of the event.

You can identify an issue relating to the theme of the conference for which you have a genuine passion and for which you will take real responsibility.

Think of powerful ideas that really grab you to the point that you will take personal responsibility to make sure that something gets done at the conference.

You may lead sessions, you may participate as an attendee, you may take responsibility for capturing proceedings, or you may just hang out in the halls and talk with interesting people.

Be prepared to be surprised.

source: altnetconfcanada.com

What Topics Will Be Discussed?

* TDD
* BDD
* DDD
* Agile
* Lean
* Practices
* Technologies
* and more...

Check out the open space details here.

Tree Surgeon 2.0 Released

donnfelker — Mon, 14 Jul 2008 03:10:20 GMT

Better late than never…. :)

Our team coordinator, Bil Simser, announced this same thing on his blog a couple of weeks ago.

Tree Surgeon is a .NET Development Tree Generator.

Basically, we added …

Support for Visual Studio 2003, 2005, and 2008
Ability to choose unit testing framework NUnit and MbUnit
Updated NAnt scripts for .NET Framework 1.1, 2.0, 3.5

Download the release here

Virtual Earth - End of Life

donnfelker — Wed, 02 Jul 2008 12:56:32 GMT

This week Microsoft announced that their Virtual Earth product versions 3, 4 & 5 will be retired.

As part of our planned deprecation schedule for older versions of Virtual Earth, we will be permanently retiring Virtual Earth version 3, version 4, and version 5 in the coming months. If you are currently using one of these versions, please read this notification and the end-of-life schedule that applies to the version(s) of Virtual Earth you are using. Please note, this Virtual Earth version end-of-life plan only applies to Virtual Earth and does not affect the MapPoint Web Service.

Please note, this does NOT affect the Microsoft Map Point 4.5 Geocoding class that I wrote. This class will continue to do its job. :)

Related: Google Maps Geocoding Class

My TechEd Experience

choskins — Tue, 24 Jun 2008 21:51:00 GMT

Orlando, FL

June 2008

Introduction

This year was my first visit to TechEd. This about sums it up: I was indoors 99% of the time. I got little sleep. I drank lots of Mountain Dew. I met lots of great people. I saw lots of cool stuff and I can’t wait till next year. The sections below are a more detailed version of what my week entailed. If you aren’t one for reading lengthy and sometimes witty text, you might want to skip to the “Schedule” section below. This is a detailed account for my activities at TechEd.

Pre-TechED

The weeks before I flew to Orlando for TechEd 2008 were full of excitement and anticipation for the 5-day conference. I poured over the session schedules that were posted on the TechEd website. I had at least three classes planned for each 75 min block of time on the schedule – just in case my top two choices were full or canceled. I searched the TechEd website for tips on how to get the most out of the conference. I looked at the blogs of some of the speakers. I printed out maps and directions to my hotel and to the conference. I started packing two weeks early. Most importantly, I decided that I was going to get out of my shell and make a real effort to socialize with other people at the conference. I am normally very reserved and a little bit shy so this does not come naturally to me.

Nerd Heaven

Sometimes when we get all hyped up about an event, we expect too much and are disappointed. As a kid, I experienced this buyer’s remorse several times – after visiting the Ringling Bros circus and feeling sick from eating cotton candy, waiting in line for 90 minutes for every good ride at Disneyland, and watching the Harlem Globetrotters pretend to play a real game of basketball. It was never quite as exciting as I expected it to be. This did not happen to me at TechED. It was even better than I hoped it would be. I was like a little kid in a real-life Candy Land. I didn’t know where to start. I wanted to be everywhere at once and try everything.

I took full advantage of the offerings of the conference…until Wednesday at 9pm when the hands on lab closed. I was exhausted and ran out of steam. I had to tone it down on Thursday and by mid-day, I was so exhausted that I plopped into a random couch and didn’t care if I interrupted the discussion that was going on. While the Mountain Dew was setting in, I ended up joining in on the conversation with two Silverlight nerds who were sitting on the nearby couches. One of them was an R&D consultant for Microsoft and he was the developer who put together the keynote graphics that Bill Gates himself presented on. How cool is that? My whole week was filled with experiences like this.

Going With the Flow

The types of sessions I attended and my general activities changed during the week as I figured out what works for me. As expected, my week did not go according to my detailed plan. Plans change, as they should, and I was happy to go with the flow during the week. During lunch on the second day of the conference, a Microsoft employee asked if I was enjoying myself. I said I was having a great time. He then asked me what sessions I have been attending. My mind went blank. I could not remember. I could feel my face start to redden. Then I realized it was because I was enjoying the people I was interacting with so much. I told him that the presentations I was attending gave me ideas for my own projects. After the presentations, I would often head straight for the Microsoft demo area with questions in hand about the ideas that were forming my head. This, I discovered was the bulk of the content that I was absorbing. I was a sponge.

The great thing about the conference is that the sessions cater to everyone’s learning style. Attendees choose the types of sessions that work for them, including the following:

· Breakout Session

o Large conference rooms with hundreds of people and one expert speaker who is often a published author

· Interactive Theater

o Small chalkboard sessions with a facilitator on a topic that everyone may participate in

· Instructor Led Labs

o Large computer rooms with an instructor who guides the class on a lab that each attendee completes during a 90 minute sprint

· Lunch Sessions

o Watch a short presentation while you carefully pick through mystery pasta pie and multi-colored broccoli. Is it supposed to be brown? And what’s this yellow stuff?

· Birds of a Feather

o Small groups of attendees discussing and debating a topic

· Hands On Labs

o Large computer room with self-serve labs on every Microsoft technical topic you can imagine. Certified trainers walk around, ready to answer any questions we might have. There was no schedule for the labs and they were open from 8:30am to EOB (either 6:30pm or 9:00pm). This was one of my favorite activities of the conference. These fantastic labs gave me material to talk about with the MS developers in the demo station area. This really sparked excitement for me.

· Ask the Expert

o My favorite type of session was not even on the formal schedule – “Ask the Expert”. These sessions, held in a lounge area on cozy couches, start out with about three people gathered around MVPs or Microsoft employees. If the talk is especially interesting, a small crowd hovers around the area. The schedule for these sessions appears on whiteboards in the demo station area.

I also enjoyed other parts of the conference including:

· Lunch

o I loved Lunch. This is not because they had gourmet food. The food was actually terrible, and I am not fussy when it comes to food. The part I loved about lunch was randomly finding a table to sit at with Microsoft employees and talking to them about their job. This gave me the opportunity to ask passionate Microsoft developers and other attendees about what they do for a living in a super casual environment.

· Demo Stations

o Every Microsoft product related to development tools had a booth with 2-4 MS employees and MVPs available to chat with and answer questions. They were kind of like techie therapists. I had the chance to talk about problems I have had in the past, current problems I am struggling with, and coping strategies for future projects. A few times, I asked a question and found myself redirected to the person who actually wrote the code. The opportunity to talk with developers about the tools they have written an amazing experience. Another bonus, I got the best SWAG (by far) at these booths. If you do not already know, SWAG (stuff we all get) is a bunch of freebies that vendors hand out to dweebs to get them to visit their booths. Dweebs just love things that spin around and make funny noises. We also love Tee shirts, pens, hats, key chains, squishy balls, and my personal favorite, flying monkeys that make screeching sounds when you throw them.

· Vendor Booths

o I visited several vendor booths. Talking to the developers about their tools was cool. A few booths only had marketing bozos available to talk to (I do enjoy asking them technical questions and watching them squirm) but most had at least one dev to answer my questions. These vendors gave out lots of SWAG – mostly tee shirts. I got several of these to give to my co-workers who were not able to attend the conference. I did keep one shirt though, from a company called Automated QA. I just love that word – automated. It gives me warm fuzzies every time I hear it.

My Schedule (a Detailed List)

I could go on for days talking about the people I met and the conversations we had. But my goal here is to give in overall picture of my week, not write a book. The detailed list below lays out my entire schedule at TechEd.

Tuesday (Bill looks much smaller from 500 feet away)

1) Bill Gates Keynote

2) Breakout Session -- OFC 202 – Intro to Sharepoint Development

3) Interactive Theater -- TLA03 – Writing Administration Tools For Your Applications

4) Lunch – sat with 2 members of the ASP.Net group

5) Vendor Booths

6) Instructor Led Lab -- OFC16 – Creating & Deploying VS.Net 2005 Workflows

7) Demo Booth – Microsoft Security Development Lifecycle

Wednesday (I can sleep on the plane)

8) Demo Station – Architecture

9) Hands on Labs -- OFC01-HOL - Introducing Content Types for Sharepoint Services 3.0

10) Demo Station – Dynamic Languages

11) Demo Station – Visual C++

12) Breakout Session – ARC 304 User Experience – Selecting the Right Client Technology

13) Lunch – Sat with a member of the Silverlight automated test group

14) Lunch Session – LUN16 – Microsoft Speech Platform: Build tomorrows user interface today

15) Ask the Expert Session – MS MVP who is an expert on Windows Server 2008 Hyper-V

16) Breakout Session – WIN401 – Implementing Objects for Data Binding

17) Hands on Labs -- OFC03-HOL -- MS Office InfoPath 2007 Forms Development

Thursday (I need coffee)

18) Demo Station – Visual Studio .net 2008 TFS (version control and build)

19) Hands On Labs -- WIN11 – Developing a WPF application

20) Lunch – had a nice conversation with a can of Mountain Dew

21) Demo Station – Windows Forms

22) Demo Station – Visual Studio .net 2008 Test Addition

23) Vendor Booths

24) Breakout Session – SOA 315 – Productive Windows Communication Foundation

25) Microsoft party at Universal Studios

Friday

26) Demo Station – Visual Studio .net 2008 Developer Edition

27) Demo Station – Visual Studio .net 2008 Database Edition

28) Demo Station – Visual Studio .net 2008 Extensibility

29) Demo Station – Virtual Earth Demonstration

30) Hands On Labs – WIN08 Building Windows Powershell Providers

31) Breakout session - - ARC 303 Design For Testability

32) Lunch – sat with a developer in SQL server group

33) Breakout Session – TLA 323 – Introduction to IronRuby

Coming Home

After the very last session on Friday, I took one more stroll through the conference halls. Most people had already left. The Microsoft demo booths were empty. The vendor area was blocked off. I wished I could go back in time a few more days and run a few more laps around the arena. I was in a good state for coming back home though. I was very tired but at the same time very excited. My spirits were renewed and I was glowing from experiencing that wonderful feeling of knowing I am in the right field and I love what I do.

Sudden Loss of an Important Public Figure, and Throw-back Journalist

Matt Ortiz — Sat, 14 Jun 2008 01:20:36 GMT

American political journalism, not only by association, is not held in the highest regard these days. NBC's Tim Russert, in contrast, and his enthusiasm for the "truth" is a throw-back and considered among the best of modern American journalists.

Tim provided tough and thoughtful coverage of the most important issues and political figures of our time and strove to provide us with enough information to form an opinion. Russert's infectious passion for the news left those of us with any interest wanting a second hour of Meet the Press or more of his time when on the air.

Tim Russert - NBC News' Washington Bureau Chief and moderator of Meet the Press, preparing for this Sunday's installment of Meet the Press, collapsed and died of a heart attack today: he was 58. His passing is a huge loss to American journalism: he was a beacon of thoughtful political coverage in a day when news outlets are more and more politically charged and inflammatory pundits are flooding network, cable, and radio programming.

Though NBC News and Meet the Press will never be the same without him, I'm hopeful that thoughtful, informative reporting will prevail there and that those he inspired, mentored, and taught by example will continue to elevate the coverage of such an important beat.

Image source: MSNBC (http://www.msnbc.msn.com/id/25145431/)

Technorati Tags: Current Affairs,Stream of Consciousness

GMail = Dog Slow

donnfelker — Fri, 13 Jun 2008 18:00:42 GMT

I've been using GMail since it first came out. I remember getting it and having TWO invites to send to friends. This is back when Gmail invites were going for $100.00 a pop.

Through the years its been a great service and I've love every single second of it. Its truly the best at keeping track of conversations, and this works wonders for insanely active groups like ALT.NET.

Over the last couple of months its seemed that Gmail has gotten progressively slower and slower. Through using Fiddler I was able to determine that larger chunks of JavaScript was coming down the wire. The amount of AJAX and DHTML going on behind the scenes brings Gmail to a crawl.

How to overcome it?

On the top right hand side of your page, click "Older Version".

This will load the UI without all the bells and whistles and its about 5 times as fast in regards to response times.

Unfortunately there is not an option in the preferences to make this stick. As soon as I log in, I immediately click "Older Version". Alternatively you can also switch to "Standard HTML View" at the bottom. But with this, you don't get any smooth AJAX. Its regular HTML page post backs.

I Took The ASP.NET 3.5 Beta Exam, and then the red pill

donnfelker — Mon, 09 Jun 2008 21:26:21 GMT

At Tech-Ed last week they offered the ASP.NET 3.5 Beta Exam. The beta exam is not available in Phoenix, so I decided to give it a whirl on Thursday. I didn't plan to take the test so I didn't have a lot of time to review (maybe 30 minutes of review) and I just dove in and took it.

Normally MS Exams have about ~40 questions and they take a couple of hours for me to complete. I was expecting the same from this one...

Nope. This exam had 70 questions. Wowza. I'm assuming the reason for this is one of these scenarios:

This is a beta exam and they need to weed out some questions
They have bumped up the number of questions in the exam

So how hard was it?

Well ... it's a little harder than the 2.0 version. A lot of it is repeated from 2.0, but this new beta exam threw me for a loop in a few areas.

The areas that threw me for a loop were:

WCF Integration Questions (I'm very well vested in WCF, but I just was not expecting it in this exam - there's a WCF exam for that!)
Deep AJAX Questions (Don't do much AJAX stuff, lets be honest... JavaScript is not my favorite language)
Miscellaneous Mobile Questions

The main thing about MS exams is that they are LONG and tricky. Sometimes you'll get asked a question and all four answers look right. LOOK VERY CLOSE. You'll see that maybe one word is spelled wrong, or the line's are swapped, etc. They will confuse you. But the main thing to do is be alert. The test will wear on you, its long. By the 2.5 hours in, you'll get tired of the test and you'll want to just hurry through it, don't. Just take your time.

So How Did I do?

Since its a beta exam, I won't know for about 2-3 weeks. They send your results in the mail. I feel like I passed, but we'll see when the results come in.

... and no, I didn't take any pills before or after... :) I'm just joshin' ya'll.

Resources from Desert Code Camp

donnfelker — Tue, 03 Jun 2008 12:10:38 GMT

This past weekend I presented the topic "Intro to Dependency Injection and Inversion of Control" at the Phoenix Desert Code Camp. A big thank you goes out to everyone who attended. It was such a popular topic that it actually moved up to the largest room in the conference location, the Theater at UAT! Thanks again everyone!

At the bottom of this post are the resources from this presentation.

Resolution from Error During the Presentation

For those of you were present when I ran into an issue with this "DynamicMethod" error, I have figured out the issue. It's a bug in Unity. It looks like its been fixed and should be available in the next release.

I was able to work around this issue by moving the Dependency attribute into the Interface. I have updated the code in the download below to reflect this.

Presentation Resource Download

Full Solution Download (900K)

PowerPoint Presentation

You can also view the presentation online - located here.

Patterns of Enterprise Application Architecture - Martin Fowler Great book with great patterns for enterprise architecture.	Head First Design Patterns Good intro to design patterns.
The Pragmatic Programmer Great book for those who like to program but what some more direction on the ways of great software development.	Refactoring to Patterns Learn how to refactor your code into patterns.
Working Effectively With Legacy Code New to unit testing? Having problems with how to understand and test old code? READ THIS BOOK. This book helps any developer understand "hand-me-down" code. :)	Agile Principles, Patterns and Practices in C# Can't be a book written by Robert C. Martin like this one. All around goodness.
xUnit Test Patterns You know how to unit test? But what about all of these edge cases? How about testing sending emails? How to test file handling?	Framework Design Guidelines A great resource for someone who is attempting to write a framework for a team. This is not the end-all-be-all, but it is a good resource.
Code Complete 2 A must read for any developer.	Agile Software Development with Scrum Get a grip on the development process with Scrum.
Software Estimation Another classic from McConnell. If you need to learn how to estimate better, pick up this bad-boy. If you're agile or waterfall, this can help.	Release It! Having trouble getting things out the door? This book will help guide you. Completely mind altering book.
Practices of an Agile Developer Excellent book on agile development.	Learning WCF If you're interested in SOA, then you need to learn WCF. This book helps you ramp up and get dirty quick.
Agile Web Development With Rails Again, in my quest to learn new languages, I decided to whip up some web apps with Rails. Very slick, very nice. If you want to learn how to build web apps with Ruby check out this book.	Everyday Scripting with Ruby In my quest to learn a new language every year, I picked up a copy of this book. It has been outstanding in helping a .NET architect become a dynamic language convert.