Zach Bonham

Getting Started with WCF Routing Service, Part 1

noreply@blogger.com (Zach Bonham) — Sat, 16 Oct 2010 13:55:00 +0000

"Change is inevitable. Change is constant."
-- Benjamin Disraeli

In software development, everyone expects change. Change is inevitable. Its constant. Its the law of the land. The Disraeli Principal and all that. This is true through the development of software.

Once software reaches maturity, and is released, then our expectations of change shift radically. A new law takes effect, one almost diametrically opposed to the first:

"Users hate change."
-- anonymous

How we manage that change can make all the difference in the world.

In developing WCF services, we have a new option for mitigating change to a service endpoint, contract or behavior: the WCF Routing Service.

The WCF Routing Service is available with Microsoft .NET 4.0 and can be best described as a out of the box soap router for WCF.

What can I do with a soap router you might ask?

With a intermediate software router you can perform:

Protocol Bridging
Content Based Routing
Access Control
Unified Exception Handling
Logging
Load Distribution / Balancing
just about anything you can think of, both good and bad

Over the next few posts, I’ll be introducing myself to the scenarios supported by the WCF Routing Service and sharing what I find along the way, along with how I might use them in the real world scenarios I’m currently working in. The features I’m most interested in are:

Part 2: Protocol Bridging
Part 3: Content Based Routing
Part 4: Access Control

If your looking for something now go check out the documentation on the WCF Routing Service.

If your looking at how to kick it old school, then check out Building a WCF Router, Part 1 and Part 2 by Michele Bustamante.

[TestMethod] Code Snippet

noreply@blogger.com (Zach Bonham) — Fri, 06 Aug 2010 19:43:00 +0000

Writing lots of tests today and I found myself typing a lot of repetitive code just inserting test methods, so I created the ‘tm’ code snippet.

Of course, as I installed it, I realized that there was already a ‘testm’ code snippet to do almost exactly the same thing. I could/should have modified the original ‘testm’ to follow the naming convention for our tests. The moral of that story is look before you leap.

This gist:

Will generate the following code snippet:

[TestMethod]
public void TestSuite_TestCondition_Assertion()
{

}

GetSmarx C# vs. Ruby (and something about Shaving a Yak)

noreply@blogger.com (Zach Bonham) — Fri, 09 Apr 2010 03:11:00 +0000

Steve Marx, of Windows Azure fame, recently posted “annoy.smarx.com: Letting the Internet Choose My Wallpaper”, on how he allows the Internet to choose his wallpaper using Windows Azure and Service Bus. Somewhat cool use of the technology showcased in a very easy to follow manner.

Of course, the little devil in me thought how easy it would be to write a snippet of code to create an Azure Worker role to randomly change his wallpaper – anything worth doing is worth automating, right?

The requirements were pretty simple.

http GET http://annoysmarx.cloudapp.net/
Parse the xhtml response (thanks, Steve!)
Identify the wall paper links
Randomly select a single link resource
https GET of the resource (e.g. https://annoysmarx.servicebus.windows.net/AnnoySmarx/SetWallpaper?id=ac21c047-f437-4e01-a0d1-25ee47e128b3)

Then I realized I don’t have the money to shell out just to poke Steve Marx, whom I don’t know. Then I thought, well, I *do* have VS2010 Ultimate RC1 running, including the Testers edition (which rocks, btw), so then I thought I’d just plopped the code into a virtual user (VU) and let it (or multiple VU’s!) run every hour.

But, you see, I’ve been hearing so much about Ruby, and how what an awesome language it is. I’ve even started noodling with it on the side (shhh….don’t tell C#). I do kind of like Ruby, but it can be raw. Kinda of like how I view Linux – on the surface it looks great, especially now, but it can get rough quick if your anything more than just a casual user.

Anywayz….I then got distracted with creating a snippet of Ruby code to do the same thing I did in C# just to see if life was better.

So, just like your optometrist…which do you like better?

1) GetSmarx.cs

2) GetSmarx.rb

Of course, the C# version took about as long as it took to type it. The Ruby version took much longer as I had to consult the almighty Google for much of it. Its times like these (Foo Fighters FTW!) that makes the heart all warm when you realize what a rich ecosystem Ruby has underneath it.

And that is how Steve Marx was saved from being sent into an epileptic coma by his constantly changing desktop background due to my being so worn out by Shaving a Yak tonight that I just plain lost interest.

Good night, Steve. Thanks for the Azure content. Keep it coming!

Organize XAML Namespace Declarations with XmlnsDefinitionAttribute

noreply@blogger.com (Zach Bonham) — Thu, 08 Apr 2010 21:38:00 +0000

Microsoft does it and you can do it, too!

Whenever you need to use a control from an assembly you need to provide an xml namespace for it to avoid any collisions with existing types. By default, you need to specifically reference the namespace for each control you need access to in your XAML.

This might lead to declarations like this in your XAML:

<UserControl
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:treeView="clr-namespace:MaryKay.SamPortal.Common.UI.TreeView.Views;assembly=MaryKay.SamPortal.Common.UI"
 xmlns:infoBar="clr-namespace:MaryKay.SamPortal.Common.UI.InfoBar.Views;assembly=MaryKay.SamPortal.Common.UI"

</UserControl>

This can get ugly pretty fast if you have lots of controls in your XAML view!

However, notice how clean the Microsoft xml namespaces are? You get a lot of controls brought into scope by leveraging those simple namespaces. This is accomplished by using the assembly XmlnsDefinitionAttribute.

From MSDN

Specifies a mapping in an assembly between an XML namespace and a CLR namespace.

Which means it allows us to provide a facade, or an alias, for a namespace, or group of namespaces within an assembly. This makes it much easier to bring all the controls in a control library into scope.

For example, in the MaryKay.SamPortal.Common.UI library, all of the controls are surfaced through the namespace alias “urn:marykay-samportal-common-ui” using XmlnsDefinition in the assemblies AssemblyInfo.cs:

[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.InfoBar.Views")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.RoleGroupPicker.Views")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.BetterPopup")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.TextEditor")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.Converters")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.Documents")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.SplashScreen")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.TemplateSelector")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.ModalDialog")]
[assembly: XmlnsDefinition("urn:marykay-samportal-common-ui", "MaryKay.SamPortal.Common.UI.ConsultantSearch.Views")]

and so forth..

This cleans up our required XAML declarations to simply:

<UserControl

  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:commonUI="urn:marykay-samportal-common-ui">

<commonUI:InformationBar DataContext="{Binding InfoBar}"/>

</UserControl>

Which makes our XAML much cleaner and easier to work with. It even supports intellisense!

PANDA – Packaging ANd Deployment Automation

noreply@blogger.com (Zach Bonham) — Thu, 01 Apr 2010 03:03:00 +0000

Just read “CoApp: An open-source package management system for Windows”.

I really respect what CoApp is trying to do. It can be amazingly difficult, and tedious, to deploy various applications types on the Windows platform. Its not like the problem hasn’t been solved. Its unfortunately been solved too many times, by too many.

Of course, anytime you have something amazingly tedious and difficult it needs to be automated. The Windows platform has needed this forever.

Unfortunately, what Windows users got, at least for the desktop, was Windows Installer technology. I never really liked this technology, for a variety of different reasons, but the biggest problem I have with them are that I just don’t care. I don’t care to see your company’s logo, I don’t care to see a progress bar going across the screen, I don’t care to plug in options – I just don’t care. I got frustrated that it would take someone with a PhD in Windows Installer technology to be able to produce a package you could install.

There have been advancements recently, most notably MSDeploy, that seem like they should be able to fit the bill, but they still seem focused on web projects only. I still have hopes for an extensibility model for MSDeploy that is something we can build on. The Web Platform Installer is also a huge step forward – again, would be nice if it were opened up, which is where I think CoApp might come in.

You know your data center operations teams have also solved this problem of packaging, deployment, and dependency management, but its still likely to be focused on a couple of notable application types: web applications and Windows services.

I work for corporate America - which has a plethora of bad practices, some I probably perpetuate, and many I'm not proud of, but every once and a while we go and do something worthwhile. For us, it was the development of PANDA. PANDA, Packaging and Deployment Automation, is as much process as it is actual tooling.

PANDA actually started with the requirement of a repeatable deployment for web sites, windows services, click once applications and just basic file copies. To solve this problem, we chose to rely heavily on convention, with a sprinkle of configuration metadata.

The idea of a PANDA ‘package’ was born, and that package had a specific structure. In addition, it was decided that all applications would have specific target locations, based on conventions set by our operations team. A PANDA package, being heavily file centric, might look like this:

/WindowsServices/{service}
/Web/{website}/{virtual root}
/ClickOnce/{app}
/Config
/Workflows
/Files/{bucket}

This package structure, combined with some magical application metadata, would allow us to write generic MSBuild scripts that would simply know how to execute what was in the package. Samples of application metadata for a Windows service might be:

service name
display name
service account
executable
startup type
restart properties

The Windows service developer would include in their project, not an Installer project, but simply an xml file with a well known schema – a .deploy file. In this case, it would be service.deploy. Changing any of the properties of the service simply meant modifying the service.deploy file and executing the deployment. The actual application code didn’t need to be recompiled each time.

Other application types would have their own metadata schema.

This PANDA package is then what all of our software builds produce. We use Team Foundation Server, but instead of regular output from a build, build output gets rolled into a PANDA package. If a developer needs to install those bits, either on their local machine, or a server, the experience is the same – they execute the deploy.bat found in the package.

Assuming that the deployment package had a consistent structure, we then built MSBuild targets that knew how to install whatever happened to be in the package. Our deployment tools, and scripts, really just reused some community task libraries and a single custom library that was essentially a data access layer for our PANDA package.

The overall execution of the deployment had just a few high level MSBuild targets:

PreDeploy – users could provide their own MSBuild scripts, following the convention of *.predeploy and PANDA would execute them
StopServices – can’t copy over files in use
CopyFiles – a top-level target that….copies files, it actually chains together other file copy operations

CopyConfig, CopyServices, CopyWebs,CopyClickOnces,CopyWorkflow

Uninstall Services – it was easier to uninstall services
Install Services – since we uninstall, we pick up any changes to metadata (e.g. service name)
Start Services – respected the startup type in service metadata
PostDeploy – users could provide their own MSBuild scripts, following convention of *.postdeploy

Each target was smart enough that if there was nothing in the package that matched its criteria, then it didn’t do anything. And that's it. The MSBuild scripts just know how to execute the package, which has a consistent structure.

Here is the breakdown of *.deploy files:

service.deploy – metadata for Windows services
site.deploy – web site metadata
apppool.deploy – app pool metadata
webapp.deploy – virtual directory metadata
clickonce.deploy- click once metadata
files.deploy – files manifests. Only required for copying files that didn’t already fall into an application archetype – usually one off

A PANDA package could contain a single file, or single set of application components, or it could contain and aggregate of many application components, or indeed entire systems – all in a single PANDA package that has a one click installation (deploy.bat).

Other features of PANDA (not exhaustive):

application metadata can specify arbitrary target server role (e.g. ‘web server’, ‘app server’, ‘mylabenvironment’), so application bits only get copied and installed if target server role matches
environmental overrides – e.g. use different service account name for DEV, QA, Staging and Production environments.
use of hashed passwords – we request provisioning of service accounts by our security group. We don’t actually receive a password, but the hash. PANDA will decrypt the hash and install using actual accounts. Passwords aren’t in the open and developers could care less what the actual value is.

Some notable PANDA shortfalls:

PANDA packages are not zipped. We have the actual step to insert into the packaging process to zip up the bits, we just aren’t using it because we are blessed with near infinite bandwidth in our data centers.
PANDA tools need to be deployed to any server, or desktop, prior to attempting to execute a PANDA package. We would like to eventually include the tools required for THAT package version

I didn’t realize I had typed this much until just now.. My intention was not really to toot the horn (toot! toot!) on PANDA – rather pointing out the need to have roll something like PANDA at all.

Granted, PANDA is in its infancy. My preference is that it stay there and not any more time be spent on enhancing it. It meets the current needs of several different teams. I’d rather it was killed off by something supported by either Microsoft, or the community – we don’t want to maintain it indefinitely, but probably would with no other choice. I’ve often thought about approaching our management team about releasing PANDA into the community in hopes it would gain support there.

Would anyone else use something like PANDA?

@ntdebugging Q&A Question Opportunity

noreply@blogger.com (Zach Bonham) — Wed, 10 Feb 2010 14:45:00 +0000

The team responsible for the Advanced Windows Debugging and Troubleshooting blog is looking for your “burning debug questions” that they hope to answer in an upcoming Q&A article. You can tweet your questions to @ntdebugging for consideration for the article. If your remotely interested in Windows debugging, and anything debugging related, I highly recommend checking them out!

Unfortunately, I am finding it particularly hard to frame my question into 140 characters this morning, and short of a vertigo-like experience where I realize “I know Kung-Fu”, I thought I’d post my question here in hopes to get my question answered by the team that does know kung fu.

Realize that anything posted here, especially if false, is due to my imperfect understanding of experiences and knowledge imparted by Advanced Windows Debugging and Troubleshooting, Tess Ferrandez (and her many compatriots!), Jeffrey Richter, and the Godfather of the Debugger, John Robbins.

The Setup

.NET allocates memory for each generation’s heap (0, 1, 2, LOH) in segments to get a continuous block of memory when it attempts to satisfy an allocation request, after a collection, and can’t. This memory for each heap will likely level off as the application “warms up”, except potentially for generation 2, and large object heap. During a garbage collection, each heap (0, 1, 2) is swept and compacted, except for the large object heap (LOH), which is just swept.

I understand the ‘sweep’ part of a collection to mean that the GC identifies which objects are no longer rooted and are available for collection (or finalization) and that ‘compact’ means that the addresses that are still alive in a heap are reorganized so that the heap has more continuous memory available to it. As the budget for each segment within the heap is exceeded, .NET will allocate another segment in order to fulfill allocations if it can.

The Question

My question comes down to what happens to that memory in each heap, that might not be used by the application (committed) any longer, but is still reserved by .NET? When is it released back to the OS?

I’ve heard of rituals such as forcing Windows itself into low memory condition so that it asks each process to give up any reserved memory, or minimizing a process, and then restoring it, which essentially does the same thing. These are just rumors and I’d prefer to know.

There are also rumors of something involving chickens, but I’d rather not go there…no one likes rituals, they are unreliable and often messy (think of the chickens!).

Long Live the Guid!

noreply@blogger.com (Zach Bonham) — Thu, 05 Nov 2009 20:54:00 +0000

Guid generation came up earlier today and it struck me, as someone who loves automation, Guid generation is still a very manual process for me.

It seems like forever that I have used the Visual Studio Tools | Create GUID tool to generate new Guid’s, using the Registry Format option, and then removing the squiggy braces from the end product.

Today I learned from Mr. Anderson that my Guid string can keep the squiggy braces:

var g = new Guid("{10246A29-8E88-46DC-925A-6F4BCB31EB56}");

This code for Guid generation is just as valid as:

var g = new Guid("10246A29-8E88-46DC-925A-6F4BCB31EB56");

I would have sworn there was a time not so long ago that the squiggy braces would have caused an issue.

I also learned that ReSharper has a built-in live template for generating GUID’s called ‘nguid’, much like a snippet. However, it doesn’t generate the Guid with quotes around it – which is my 99.999% usage scenario when creating Guid’s. Outside of COM IDL work, I haven’t had to generate a Guid that wasn’t a string in as long as I can remember. Fortunately, ReSharper gives me a nice little UI editor for modifying their templates (snippets) and now ‘ngen’ works the way I wanted it to by inserting the text:

"10246A29-8E88-46DC-925A-6F4BCB31EB56".

Of course, this got me to thinking surely Visual Studio can do this? Of course it can. Here is the macro I created to do the same thing, which I then promptly mapped to the keyboard shortcut CTRL-N,CTRL-G.

Public Module CodeGeneration

   Sub CreateGuid()
       Dim ts As TextSelection = DTE.ActiveDocument.Selection
       ts.Insert("""" + Guid.NewGuid().ToString() + """")

   End Sub

End Module

So now I can burn through Guids with wild abandon and so can you!

MSMQ.VBS – Manage Private MSMQ Queues

noreply@blogger.com (Zach Bonham) — Tue, 27 Oct 2009 12:21:00 +0000

I have been migrating some scripts and what nots to hosting at github.

This script allows some very basic management of MSMQ private queues. I typically use this from some sort of controlling script, either MSBuild or Nant, using their respective ‘shell’ tasks to cscript.exe.

Set your default scripting engine to cscript.exe

cscript //X:CScript

Run msmq from the command line to get syntax

Bitmasking – A Blast From the Past

noreply@blogger.com (Zach Bonham) — Wed, 07 Oct 2009 03:34:00 +0000

The topic of bitmasking came up recently and nearly made me fall out of my chair! Had to whip something up to see if I could remember how...haven't done it in years (since my C/C++ days). This code snippet below is in C# and is not nearly as elegant as it was in C/C++, but then again I never really cared for bit masking. :) There is some awkward casting I have to do because of language constraints, but the end result is pretty much who we did it in 'the good old days'. I can't remember the last time I had to worry about bits, or bytes. In hindsight I can clean that up using const values instead of an enum, but there you go.

Vipan Singala has an excellent article titled Bitwise Operators and Masks which I can recommend if your interested in this sort of thing.

The output of the sample below is as follows:

We are moving...
We are moving faster...
Not moving faster than light yet.
NOW we are moving faster than the speed of light...
Uh oh, looks like we've dropped out of faster than light travel!
But we are still moving moving fast...
We are still moving...
Removing all other flags..
Now we have stopped.

using System;

namespace BitMasking
{
    class Program
   {

        enum SpeedFlags : byte
       {
            Stopped = 0x00000000,
            Moving = 0x00000001,
            Faster = 0x00000002,
            FTL = 0x00000004
        }

        static void Main(string[] args)
        {

            bytestatus = (byte)SpeedFlags.Stopped;

            // set the 'Moving' bit
            //
           status |= (byte)SpeedFlags.Moving;

            // set the 'Faster' bit
            //
           status |= (byte) SpeedFlags.Faster;


            // status AND'ed with 'Moving' bit equals our 'Moving' bit, then its set
            //
           if( (status & (byte)SpeedFlags.Moving) == (byte)SpeedFlags.Moving )
            {
                Console.WriteLine("We are moving...");
            }

            // check if faster bit is set
            //
           if( (status & (byte)SpeedFlags.Faster) == (byte)SpeedFlags.Faster)
            {
                Console.WriteLine("We are moving faster...");
            }

            // our FTL bit is not set yet!!
            //
           if((status & (byte)SpeedFlags.FTL) == (byte)SpeedFlags.FTL)
            {
                Console.WriteLine("We are moving faster than the speed of light...");
            }
            else
           {
                Console.WriteLine("Not moving faster than light yet.");
            }

            // set the bit
            //
           status |= (byte) SpeedFlags.FTL;

            // check to see if we've got the bit set
            //
           if((status & (byte)SpeedFlags.FTL) == (byte)SpeedFlags.FTL)
            {
                Console.WriteLine("NOW we are moving faster than the speed of light...");
            }

            status ^= (byte) SpeedFlags.FTL;

            if((status & (byte)SpeedFlags.FTL) == (byte)SpeedFlags.FTL)
            {
                Console.WriteLine("We are still moving faster than the speed of light...");
            }
            else
           {
                Console.WriteLine("Uh oh, looks like we've dropped out of faster than light travel!");
            }

            // check if faster bit is set
            //
           if((status & (byte)SpeedFlags.Faster) == (byte)SpeedFlags.Faster)
            {
                Console.WriteLine("But we are still moving moving fast...");
            }

            // status AND'ed with 'Moving' bit equals our 'Moving' bit, then its set
            //
           if((status & (byte)SpeedFlags.Moving) == (byte)SpeedFlags.Moving)
            {
                Console.WriteLine("We are still moving...");
            }

            Console.WriteLine("Removing all other flags..");
            status ^= (byte) SpeedFlags.Faster;
            status ^= (byte) SpeedFlags.Moving;

            if((status & (byte)SpeedFlags.Stopped) == (byte)SpeedFlags.Stopped)
            {
                Console.WriteLine("Now we have stopped.");
            }
        }
    }
}

IDisposable is a Developer Convention

noreply@blogger.com (Zach Bonham) — Mon, 28 Sep 2009 13:49:00 +0000

Given the following bit of code, when does the Dispose method of Trash get called?

using System;

namespace Dispose
{
    public class Trash : IDisposable
    {

        #region IDisposable Members

        public void Dispose()
        {
            Console.WriteLine("I am being disposed");
        }

        #endregion
    }


    class Program
    {
        static void Main(string[] args)
        {

            var c = new Trash();


        }
    }
}

Answer

Never.

The IDisposable interface is a developer convention and is not enforced by the .NET runtime. IDisposable is not called by the .NET runtime on the developer behalf (at the time of this writing). IDisposable exists to help model a more explicit (deterministic) method for releasing of memory for .NET developers. See Implementing Finalize and IDisposable to Clean Up Unmanaged Resources.

Some might say that it was a warm and fuzzy blanket used to swathe all the C++ programmers in as they transitioned into .NET. That may be the case, but inevitably, as a developer, you will need a way to declare your intent that your class has resources that need to be cleaned up now. Traditionally, this has been to represent unmanaged resources but it doesn’t have to be. So, if you see a class that implements IDisposable, consider it good form to go ahead and invoke Dispose as soon as your finished with the object.

An Exception for Every Rule

The exception to the rule is when working with WCF proxies. This well known design pattern of IDisposable is broken in a bad way. For some good information as to why try a search WCF IDisposable is broken. The nut of which is if you call Dispose on a WCF proxy, and the channel has already been faulted, you’ll never see the originating fault because of the proxies implementation of Dispose just tries to Close the channel, which throws a new exception, and stomps all over the call stack of the original exception.

Your damned if you do call Dispose (might lose useful error information) and your damned if you don’t (hold server resources open longer than required). Many of the links in the search query will return useful ways to get around the problem, but it would be nice if, as a community, we adopted one of these solutions.

This has been a .NET public service announcement. You may now return to your regularly scheduled programming.

Reviewing Beginning Xml with C# 2008: From Novice to Professional

noreply@blogger.com (Zach Bonham) — Sat, 26 Sep 2009 13:53:00 +0000

First off, I would like to thank Apress Books for their supporting local user group communities by donating copies of their titles for review!

I would like to be upfront before jumping into the review: the first time I read the book, I did not like it. There was not enough time spent with Xml best practices, not enough space dedicated to more Xml centric terminology and with a book weighing in at 600 pages, way too much information that is readily available via your favorite search engine. So, I put the book down.

After a bit of reflection though I realized what should have been obvious: I was not the target market for this book. While I am likely not familiar with some of the more esoteric features of Xml, I am very comfortable with the day to day application of Xml, and Xml related technologies, so I re-read Beginning Xml with C#: From Novice to Professional with a different perspective.

Xml can be a very wide topic just as ‘development’ can be a broad, as well as deep, topic. For sure, if you are a .NET developer today, you are virtually surrounded by Xml goo and its closing fast! Xml might not always be in your face though, and its easy to ignore for a while. It might be hiding behind some tooling, or buried in a configuration file, but its there nonetheless, just waiting to jump out of the shadows and club you over the head! You can’t ignore Xml for forever, so don’t be a victim of xml, learn how to defend yourself today!

The Good

The author does a good job of uncovering all the nooks and crannies your likely to find Xml hiding: configuration files, serialization formats, Sql Server, and Windows Communication Foundation (WCF).

There was well presented information around when to use XmlDocument v. XmlReader which was nice. XmlDocument is so easy that its simple to overlook the fact that if you really only need read-only access to the data, then XmlReader is your better choice. I even find myself doing this on many occasions.

The chapter on using Xml with Sql Server was done well.

I was puzzled that DTD (document type definitions) received as much attention as they did. However, there is a remote possibility you might run into them, so +1 for covering them.

The Bad

The author appears to make the assumption that Xml, without a namespace, is considered 'the norm'. I say ‘appears’, as xml namespaces were pretty much ignored, and can’t be found in the index. I'm reviewing to see if I just missed it, but working with Xml and Xml Namespaces are probably the first big hurdle a developer will run into.

I, unfortunately, am pretty militant around namespaces, believing if your not using namespaces, well then that's analogous to C# without a namespace, and only acceptable in the most trivial examples. How many Employee schema's do you think are out there? How do you tell your Employee schema from another companies Employee schema? Heck, most companies will have multiple schema's for similar types across departments (Orders, Inventory, Shipment, Customer, etc..). Namespaces are how you tell yours from someone else's and give you a pivotal piece of metadata to key off of in your versioning strategy.

The Ugly

My biggest complaints about the book, is also one mostly driven by yet another personal opinion, and that is the examples. I’m not a fan of WinForm examples, unless your showing me an example that centers around WinForm development. The best way to to show me Xml centric examples is with the good, old fashioned, console application. Otherwise, there is too much technology mixing going on and key points might get lost in demo goo, not to mention consuming valuable page real estate that could be better used for more in-depth coverage of the topic.

Summary

One might think that xml in the .NET world is ubiquitous enough that everyone who picks up Visual Studio will just learn through osmosis what they need to know about xml. Some of this may even be true. However, if you are new to developing for the .NET platform, having this book available could help jumpstart your development and keep you on task.

Observable Property Code Snippet

noreply@blogger.com (Zach Bonham) — Fri, 04 Sep 2009 16:23:00 +0000

I’ve been using the a new code snippet to create an ‘observable’ property when working with WPF and the Model-View-ViewModel pattern. This is really only useful if your class implements INotifyPropertyChanged, which our ViewModel base does.

The snippet generates the following block of code:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {

        if (_name != value)
        {
            _name = value;
            OnPropertyChanged("Name");
        }

    }
}

..and here is the snippet. See my previous post on [DataMember] Code Snippet on how to install snippets.

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>oprop</Title>
            <Shortcut>oprop</Shortcut>
            <Description>Code snippet for an automatically implemented observable property for any class that implements INotifyPropertyChanged.</Description>
            <Author>Your name here</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>field</ID>
                    <ToolTip>Backing Field Name</ToolTip>
                    <Default>_myProperty</Default>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp">
                <![CDATA[
        
            private $type$ $field$;
            public $type$ $property$ 
            { 
                get
                {
                  return $field$;
                }
                set
                {
                
                  if ( $field$ != value )
                  {
                    $field$ = value;
                    OnPropertyChanged("$property$");
                  }
                
                }
             }
            $end$
            
            
            ]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

Ft. Walton Beach Vacation Summary

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:39:00 +0000

Our family spent a week in Ft. Walton Beach, Florida, this year. Below are my notes of each day’s events – Sally has kept her own journal, so there is no telling what additional detail I’ve left out!

From FtWaltonBeach2009

The pictures can be found by following this link for Fort Walton Beach Vacation pictures.

Ft. Walton Beach Vacation, Day 6

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:35:00 +0000

July 10th, 2009

Up at 7:00AM, check out is at 10:00AM. We eat breakfast, finish packing, clean the condo and leave Gulf Dunes by 9:30AM!

We stop at a “Tropical Department Store”, aka another tourist trap, for souvenirs.

On the road back to Texas by 10:00AM. We wave bye to Ft. Walton Beach.

Stop in Covington, LA for lunch @ 2:00PM (right on schedule) – hey, its Chick-fil-a!

Stop for gas, potty break, and change drivers in Alexandria, LA – but forgot the gas! Of course, Josh had to try out the bathroom there. Actually, very clean bathroom in the downtown Alexandria (we got lost – err, took the wrong exit). Kudo’s to McDonalds! I think its a first!

Finally get gas on the other side of Shreveport, LA – nervously watching the gas gauge the whole way.

We pull into our driveway at 10:30PM.

Ft. Walton Beach Vacation, Day 5

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:34:00 +0000

July 9th, 2009

This morning over coffee, I got to see some lifeguard trainees. All girls. Yay!

Southern Star Dolphin Cruise today from 9AM – 11AM in Destin! Destin is only 8 miles east of Ft. Walton Beach. We parked in the public parking of the Emerald Grand and located the Southern Star’s stand along the harbor wall.

From FtWaltonBeach2009

The dolphin cruise was awesome! Saw quite a few dolphins and a spotted eagle ray – I think I saw a shark, but I missed the sea turtle (wrong side of the boat). The glass bottom feature of the cruise was a bit overrated, even when you see fish, you can’t see colors, etc. Usually the boat is moving too fast to see anything through the small port holes.

From FtWaltonBeach2009

Unfortunately, both kids got sea sick. Boo. They didn’t throw up though, and didn’t really fuss much. Very proud of what troopers they were considering it was a somewhat difficult situation.

We ate at Pat O'Brien's (Destin) – had crawfish tacos, muffalata sandwich and the best caesar salad ever! I think it was the freshly grated parmesan cheese that made it pop. The kids, of course, had chicken fingers.

We spend the afternoon on the beach, but pick up supplied for a movie and real popcorn (Rico’s Popcorn) for bedtime.

Kids decided they wanted tattoos to remind them of the trip, so we walked down to Fudpuckers to get inked! Hannah got a bear with hearts and Josh got a tank. Sally’s tattoo washed off in the sudden downpour we got caught in while there. This was the first real rain we’ve had since arriving at Ft. Walton Beach. We wait it out under a patio umbrella until its light enough to walk back.

From FtWaltonBeach2009

This is our last night here.

Ft. Walton Beach Vacation, Day 4

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:34:00 +0000

July 8th, 2009

First one up – before 8AM this time. I go to the local stores looking for ‘sun shirts’ – those shirts that have some UV blocker in them and are basically 50 SPF by themselves. Find one for Josh, but no one else.

We spend the day playing in the surf, building sandcastles and picking up sea shells.

Hannah and Josh really took to riding the “Gnarly Board”. Hannah can go the distance on it, all the way to the beach! Josh just makes it look good!

I tried to help Josh with the board, explaining he had to lay down on it instead of just sitting on it like he wanted, but he wouldn’t listen. First wave tipped him face first into the (soft) sand and rolled him in sand and water. He refused to ride the board for a while stating that it was my fault (meaning Dad) for his wipe out. He later rode the board again, but laying down on the board, and was successful in catching some waves! He later came over to me and told me “Dad, you were right, I was wrong” – priceless!

From FtWaltonBeach2009

The sea shells were really nothing more than fragments of sand dollars, but Hannah did manage to find a really nice one – looked like a conch shaped shell that a hermit crab might have lived in.

From FtWaltonBeach2009

Dad burns more but Josh is fine by slathering him in sunscreen and making him wear his shirt. Hannah and Sally continue to work on their tans.

Threatening rain today, but we don’t see any.

Walk to Fudpuckers for dinner – its a complete tourist trap. Not like I didn’t expect it. There was also some questionable TV on in the background considering half the crowd there was under 10. Commercials for the HBO series “Hung” is not appropriate. I don’t want to explain to my 8 year old what that is – luckily, she didn’t see it.

From FtWaltonBeach2009

We got our picture taken with a baby alligator – pretty cool. Though you kind of feel sorry for the alligators.

Everyone was crashed after dinner, but I had been seeing flashlights on the beach at night and I wanted to see what they were seeing. So I hit the beach around 9:30PM with my flashlight. Turns out that the whole event was probably started by someone who lost their watch – everyone I passed the conversation went like this:

Me - “What are you looking for”?

Them – '”Same thing you are, I guess”.

Me - “I”m not sure what I’m looking for”?

Them - “Oh, OK. Have a good night”!

I did see 3 crabs…kind of like horseshoe crabs, but they are very fast!

Oh, yeah…Capital One disabled my credit card. Seems I forgot to tell them I was travelling – since I’ve used this credit card all over the world (ok – China and US) and never had a problem it never occurred to me. I was fine with them disabling my card, appreciative really. What I was not happy with is that there was no easy way to re-enable it without navigating 5 levels deep of menu options on a crappy Black Jack II phone. Once I got someone on the phone, it took confirming a few charges and we were back in party mode!

Ft. Walton Beach Vacation, Day 3

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:30:00 +0000

July 7, 2009

Up at 8am – first one up. Trend that continues for the rest of the week. Spend every morning with coffee on the patio and listen to the surf and people watch.

Sally took a walk on the beach while I waited for Josh to wake up so we can hit the beach!

Spent all day on the beach, except for coming back up to the condo for lunch. We had sandwiches for lunch and pizza for dinner, followed by a movie and popcorn. Don’t think we went to bed until after 10PM every night.

While on the beach, we built walls and imaginary castles and moats, only to have a rogue wave come in and tear it all down. Fun!

From FtWaltonBeach2009

Kids and Sally bury me in the sand, which evidently exhausted me because I was first in bed.

Josh and I got sunburn on places we missed with sunscreen. Ouch! Hannah and Sally just got deeper tans.

Ft. Walton Beach Vacation, Day 2

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:27:00 +0000

July 6th, 2009

Woke by 9am, but got downstairs too late for the continental breakfast. Ate breakfast at the Chick-fil-a in Covington, LA.

We left Covington in the pouring rain! It was seriously, stop on the side of the road (we didn’t) kind of rain. Which probably explains why I ran over a tree top that had snapped off and blown onto the highway. This went on for about 30 minutes of driving rain travelling between 10 and 20 mph.

Before we knew it, we were finally out of Louisiana and in Mississippi. There is an awesome bridge in Mississippi that I wish I had a picture of.

We blinked our eyes and less than 100 miles later we are in Alabama.

Alabama was notable for the tunnel in Mobile and the U.S.S. Alabama, visible from the highway.

From FtWaltonBeach2009

We hit Florida by 2:30PM and Ft. Walton Beach by 3:30PM via exit 56!

From FtWaltonBeach2009

Checked into the Gulf Dunes complex (#406) which was pretty nice – didn’t know what to expect beyond 1980’s style furniture!

From FtWaltonBeach2009

We didn’t bother to unpack, except for swimsuits and hit the beach.

The sand is everything that we’ve been told…talcum powder by the dunes and sugar by the water. It was great! Water was very clear but had little green algae looking organisms in the water that gave it a really green tint.

From FtWaltonBeach2009

We play on the beach until after dark 30. We are starving at this point and try Fudpuckers but there is a 1 hour wait (there is always a 1 hour wait) so we head up the highway and find Floyd’s. We ordered anything that sounded good off the menu:

Coco Loco Shrimp (sweet)
Kicker Shrimp (spicy)
Corn and Shrimp Chowder
Tuna Rolls
Shrimp Rolls
Emerald Coast (adult beverage)
Raspberry Daiquiri's
Miller Light
Chicken Fingers (of course)

We then hit Publix, a grocery store chain, and bought groceries for the week ($200 – ouch!).

Ft. Walton Beach Vacation, Day 1

noreply@blogger.com (Zach Bonham) — Sat, 11 Jul 2009 18:25:00 +0000

July 5th, 2009

Packed and left the house by 10:15am, which is no mean feat for our family!

Took Hwy 75 to I-20E and hit Shreveport, LA by 2PM. Seems like it took forever to leave Texas…that is, until we entered Louisiana, where we took I-49S towards Alexandria, LA. There are NO bathrooms off of I-49 between Shreveport and Alexandria. Well, there is one. In Natchitoches. Don’t pass this one up! Its the best place for a bathroom before Alexandria.

Since we missed Natchitoches exit, we wound up stopping in a backwater gas station well off the freeway – it was essentially a mobile home (no wheels) and a gas pump. We had to buy something to use the restroom – silly me bought gas. Of course, Josh can’t resist the Pavlovian response to a public bathroom and had to poop. I could hear banjos the whole while…my only regret is that we didn’t get pictures.

Stopped in Alexandria, LA at a McDonalds – bleh.

Made it to Covington, LA by 6:30PM. We stayed at a Courtyard by Marriot, room #311 and used points for it. Total cost: $0.

Ate at Acme for dinner…the red beans and rice were phenomenal, but the Bloody Mary sucks.

From FtWaltonBeach2009

We spent a fortune here.

How Windows Defender Helped Me Save Face

noreply@blogger.com (Zach Bonham) — Wed, 10 Jun 2009 12:54:00 +0000

This morning I received a direct message from my brother on Facebook (warning #1) with a link to a url that just looked 'crazy', I clicked (mistake #1).

I was redirected to a site that appeared to be hosting a video, but prompted that it "Required Adobe Flash Player 10" to continue and attempted a download of file "setup.exe". I downloaded the file and ran it (mistake #2).

Luckily, I am running Windows Defender, which detected changes to my system and prompted me for approval before committing them. Windows Defender prompting me after an install is not unusual, however, it gave me a critical moment to collect my thoughts (first cup o'coffee this am, after all) and review what was about to occur. That's when I noticed that the "Adobe Flash Setup" had installed several Windows drivers. Drivers? Nothing from the browser should EVER install a Windows driver?!

I'm now suspicious (sharp as a spoon, I am) and decide to investigate a little further.

I reviewed the "setup.exe", and viewed its details, there was no manufacturer data. I then navigated to Adobe and downloaded its installation program for Adobe Flash 10. The file name is "install_flash_player.exe" and when viewing the file details is stamped repeatedly that its from Adobe.

Windows Defender reported the following changes to my system.

Windows Defender Report

Description:
This program has potentially unwanted behavior.

Advice:
Permit this detected item only if you trust the program or the software publisher.

Resources:
driver:
podmenadrv

file:
C:\Program Files\podmena\podmena.sys

Category:
Not Yet Classified

Description:
This program has potentially unwanted behavior.

Advice:
Permit this detected item only if you trust the program or the software publisher.

Resources:
regkey:
HKLM\Software\Microsoft\Windows\CurrentVersion\Run\\sysfbtray

runkey:
HKLM\Software\Microsoft\Windows\CurrentVersion\Run\\sysfbtray

file:
c:\windows\freddy46.exe

Category:
Not Yet Classified

Description:
This program has potentially unwanted behavior.

Advice:
Permit this detected item only if you trust the program or the software publisher.

Resources:
regkey:
HKLM\Software\Microsoft\Windows\CurrentVersion\Run\\sysldtray

runkey:
HKLM\Software\Microsoft\Windows\CurrentVersion\Run\\sysldtray

file:
c:\windows\ld09.exe

Category:
Not Yet Classified

That's enough for me...I deny the changes in Windows Defender, which requires a reboot to rollback. After the reboot, all is well in the 'verse.

Shortly afterwards this morning I got an email from my brother warning me about it - he wasn't so lucky.

This is not the first time Windows Defender has saved my bacon. If your running Vista, or Windows XP SP2/3, make sure your running Defender, or a good virus scanner. Defender seems to be less intrusive than the actual virus scanners I've tried over the years.

[DFWCSUG] WCF and Silverlight

noreply@blogger.com (Zach Bonham) — Wed, 06 May 2009 12:40:00 +0000

The Dallas/Fort Worth Connected Systems User Group presentation this month is titled "WCF and Silverlight". Come join us as Amir Rajan (Sogeti) talks about:

Silverlight (crash course)

Walk-through of a simple Silverlight application using WCF

Pros and Cons of using WCF with Silverlight

Walk-through of a more complicated budgeting application that leverages Silverlight and WCF

As always, there will be free food and prizes!

Hope to see you there!

MSBuild

noreply@blogger.com (Zach Bonham) — Tue, 20 Jan 2009 13:45:00 +0000

Recently I posted a little about what I was calling the MSBuild Blahs, but probably more aptly titled “How I spent my Christmas Vacation”, and thought that it needed a follow up.

I continued to [1] twiddle with MSBuild until I was able to build something that met our needs for deployment – ok, should meet our needs. It goes into our development environment this week to work any kinks out. I’ve definitely reached the ‘stage’ of learning that you could call (0ver) confidence with the language (is it a language, or a tool?). You definitely have to change the way you think about accomplishing a task.

The push that got me ‘over the hump’ (besides just head banging)? I read on a blog/MSDN post about XSLT being “the language of XML” and that “MSBuild was built on XML”, so therefore, the “idea of batching targets was taken from XSLT”.

Once I started thinking of everything as ‘batching’ targets, things started falling into place. I found the post that helped me make the leap, by Jeff C. in the MSBuild v. Nant in the MSDN MSBuild forum. Other helpful articles/posts I can be linked back to Sayed Ibrahim Hashimi or the MSBuild Team.

You can be successful with either tool. If your just starting to develop your package and deployment scripts, and target the Windows platform, then checkout MSBuild. If you’ve got existing Nant scripts, target non-Windows platforms, or use open source tools, your likely to get better synergy out of using Nant. With anything, your mileage may vary.

Con

Yes, I’m starting with the Cons, sue me.

Learning Curve – I personally had a higher learning curve for MSBuild than I did with Nant. This is primarily due to lack of intuitiveness about batching, and transformations – two important concepts in MSBuild, which leads to…
Batching – this concept is reportedly borrowed from XSLT – really? Because of the 30 developers I could probably name off the top of my head only two are what I’d call well versed in XSLT, and one is technically a manager now so I’m not sure he counts! My XSLT skills are the equivalent of using flint to start a fire. Yeah, I can do it but its probably going to take a while and I might even get hurt along the way.
Quirky Syntax – @ is for collections (ItemGroup), % is to address an item in that collection (ItemGroup) and $ is for addressing a value in a PropertyGroup. Ok, then lets throw in that % is really like using an MSBuild transform which uses the syntax of @(property->’%(itemmetadata)’). Do we need to say more?
PropertyGroup trumps ItemGroup – if you happen to have an ItemGroup name that collides with a PropertyGroup, the PropertyGroup takes precedent, so you may spin wheels trying to figure out why that shiny new target you just built is spitting out the wrong information (or none at all).
ItemGroup Scope – I discovered that if I created an item group at a ‘global’ level called ‘Servers’ and then used the CreateItem task to create another group (or as an Output from a custom task) and it, too, was named ‘Servers’ then the values were appended to the global instance of ‘Servers’. I’d like to be able to have variable declarations be aware of scope. This cuts down on me having to be too creative on variable naming.

Pro

These Cons are offset by the absolute coolness of:

ItemMetadata – Creating an ItemGroup and then applying pieces of metadata as necessary to describe the item, thats nice. The one thing is that there is no real enforcement of separation of ‘data’ and ‘logic’, which I’ve tried to do in our scripts. I didn’t like that my item metadata (e.g. servers collection, or services collection) might be mixed in with the ‘logic’ of working with that collection. This is true regardless of using MSBuild or Nant and both have constructs for allowing separation.
Batching – Ok, I know I listed this in ‘Cons’ column, but there is something to be said about eliminating foreach loops, which is what batching does, at the cost of some intuitiveness. It did shorten my scripts somewhat. Again, while nice, it requires getting over a learning curve that I’m not sure is worth it – maybe its more mentionable as a side effect?

At the end of the day, I’ve come to like MSBuild (yes, me eating crow), but things could definitely be done to help smooth out the learning curve.

When asked why don’t you use batch files, PowerShell, etc…and why use MSBuild, or NAnt, at all, think of it like this: MSBuild, or NAnt, is like your workflow runtime. You get richer error handling, conditional decisions and some other gooey goodness that make it worth your while to adopt one, or the other. Your Targets are then akin to activities. If you want your activity to invoke a batch file, power shell script, vbscript, you absolutely can.

Don’t forget to take advantage of the community supported MSBuild Task libraries out there. There are three that I’ve found which are fairly solid – my only complaint is that the help files don’t always match up to the Task (e.g. property names), but a quick dive into Reflector and your good to go. As always, if the shoe doesn’t fit, don’t hesitate to jump in and make a better shoe, err custom task.

[1] – twiddle, a polite term for a the Thunderdome style cage fight between myself and MSBuild. Since I’m here to write this story, you know I’m clearly the winner. Ignore the new eye patch, its just a flesh wound.

Lords of Dus: Lawrence Watt-Evans

noreply@blogger.com (Zach Bonham) — Mon, 05 Jan 2009 16:59:00 +0000

This is one of the classic trilogies that fed the imagination growing up. I think I picked these up about the same time I found the “Wizard of Earthsea” trilogy – way back in the day. Anyway, flood, friends, and the ravages of time had destroyed my copies but through the wonders of the Internet I was able to pick up copies of all three (in excellent condition).

The “Lure of the Basilisk” image below is not the original cover art that I remember from my collection, but the rest are. This series spawned many adventurous subplots in various worlds across the (sometimes seemingly empty) expanse of my mind. They are excellent, easy reads if you can find them.

MSBuild Blah's

noreply@blogger.com (Zach Bonham) — Sat, 27 Dec 2008 16:00:00 +0000

I did get to spend more time with MSBuild and I've got to say as a build tool for Microsoft its spiffy. As a scripting tool/language for either automating packaging, or deployment, it comes in as just 'ok'. There are two constraints with MSBuild that require a slightly different way of thinking when approaching how to automate different parts of the package and deployment process: lack of foreach and item collections (ItemGroup) conditions are only evaluated once when determining whether a Task executes for that ItemGroup (for performance).

Neither is insurmountable. The first is slightly problematic for me - I just seem to be wired to think in 'foreach'. The second part of the item collections only being evaluated once means that if I've got an ItemGroup with different metadata values, I can't just throw the ItemGroup at a Task and let the Conditional on the Task determine what executes - only the first item(s) to match the condition will execute (or not) - the rest won't be re-evaluated, even if their values are different. This means I've got to cruft up a dynamic ItemGroup to throw at the Task. Nant does foreach very well - its a first class language construct.

Oh, I'd like to throw a third in there as well - easily iterating child folders of a parent. There seem to be workarounds: parsing dir command output, custom task, or third party community tasks. None of which are intuitive enough for me. Nant has a 'Folder' collection that works well in this scenario.

The other thing that just stands out is that I have never, as in EVER, lost any time figuring out how to accomplish something with Nant. Even back when getting started I don't remember being stymied in getting something done. Just set 'em up and knock them out. With MSBuild, its par for the course. Make some progress, get stymied for an hour or three, make some progress, roll back that progress, rinse and repeat.

Clunky - but doable. I'm getting it, I just don't like it.

What still amazes me is that people, myself included for which I am still slightly embarrassed, keep trying to justify using one tool or the other. Because we are primarily a Microsoft shop, Microsoft tools tend to get a priority they may not rightly deserve. In any case, with time == money, if I can accomplish a task in half the time (or less in some cases) why keep pushing for the 'breakthrough' with a different tool? It just doesn't make sense. I think it comes back to pride/ego: I can do this.

Make sure you've got the right reasons for tool selection. Vendor preference is not necessarily the right one. Not having to distribute the runtime is such a minor inconvenience as to not be mentioned - especially something as file copy centric as Nant. Integration with TFS? TFS can kick off just about any process - Nant is just fine. Nant can call MSBuild just fine (and vice versa). There are really two considerations: development and maintenance. How fast can you get something done and how easy is it to maintain when you need to fix/enhance?

One co-worker's mantra is "build with MSBuild, but automate with Nant" - he should know. I asked him to walk this path (2 years ago?) and had him automate our package and deployment process with MSBuild - for the wrong reason. He did it, but it took him much longer than expected for many of the same reasons I've mentioned here - and when he did it there wasn't a whole lot of blog content to fall back on either.

Don't get me wrong - MSBuild will work. I really do like the Item metadata feature of MSBuild and I am *that* much closer to the breakthrough that I'm probably not going to stop now - its a matter of pride, stupid pride.

[DataMember] Code Snippet

noreply@blogger.com (Zach Bonham) — Thu, 18 Dec 2008 22:29:00 +0000

So I am sitting here, feeding the cold I’ve had, and I found myself creating a DataContract – something that got even easier with the introduction of Automatic Properties in .NET 3.0.

I tend to forget about the Visual Studio feature of Code Snippets, but I am usually reminded again anytime I see a presentation by an experienced technical presenter – then I forget again.

Today, I happened to remember our last instructor making heavy use of the ‘prop’ expanding code snippet during demos and thought - “Hey, I bet they have one for automagically creating properties marked with the DataMember attribute”. Well, I didn’t immediately see it and asking the great information oracle didn’t reveal anything interesting, so I set out to copy the existing ‘prop’ code snippet.

Turns out it was even easier than I expected – it took longer to write this post than it did to create the snippet.

Save the following into a file named dmprop.snippet (or something suitable) and drop it into your C:\Users\xxxxx\Documents\Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets folder, and voila! Visual Studio should automatically detect the new snippet. If not, you can add manually via Tools | Code Snippets Manager.

Now you can type ‘dmprop’ [tab] [tab] and get the same property expansion code snippet as ‘prop’, but marked with a DataMember attribute. Cheesy, but I figured it was appropriate as I was snacking on some sharp cheddar..

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>dmprop</Title>
            <Shortcut>dmprop</Shortcut>
            <Description>Code snippet for an automatically implemented [DataMember] property</Description>
            <Author>Your name here</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp"><![CDATA[[DataMember]
            public $type$ $property$ { get; set; }$end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>