I love working with other developers, whether it be formal “paired programming” or just one person helping the other with a problem.  I love it so much because I always learn something new.  Sometimes what I learn is some major, powerful technique for doing something complicated but usually it is not.  Usually it is one of those simple, cool, helpful tidbits.  You probably know what I mean.  You sit with a coworker and without any fanfare they type some keystroke and you say, “Whoa, I didn’t know you could do that… how did you do that?”  Here’s an example of something I do that I’ve noticed many developers aren’t aware of. It’s nothing fancy, but I find it helpful.

Like many developers, I like to surround my code in collapsible regions.  I don’t get too carried away with this technique, but I usually have a region for Public Properties, another for Public Methods, maybe one for Class Level variables.  Stuff like that.  Anyway, most people label the top of the region but I’ve found that many developers don’t know you can label the bottom.  That extra label on the bottom is really helpful when you are scrolled down far.  Without the label, you find an #endregion and you don’t know what region it is the end of.  This is especially tricky when working with nested tags.  How do you do it?  Just type the label :).

#endregion with label:

          #region Public Methods //
put stuff here... #endregion Public Methods

I think the reason people don’t do this more is that (I’m pretty sure) you could NOT do this with some earlier version of Visual Studio.  Those of us that have worked with VS for a long time just got used to doing #endregions without the label.  Back then I used to put a comment at the end of my region like this, but it isn’t necessary anymore:

          #region Public Methods //
put stuff here... #endregion //Public
Methods 

But at some point, maybe VS2008, we were allowed to just put the label at the end. 

But wait, there’s more…

Recently I had the idea to update the code snippet for “Surround with Region”.  You can use this built in Visual Studio snippet by highlighting some code and hitting “Ctrl + s”, then select #region from the dropdown.  When you do, your code is automatically surrounded by the #region and #endregion, plus you’ll be prompted for the text for the label.  I tweaked it so it puts the label at the beginning and the end. 

• You can find your snippets by going to the Code Snippets Manager (Tools > Code Snippets Manager, or Ctrl + k, Ctrl + b).
• Then select Visual C# (or VB I guess, I don’t use it :) )
• When you click on the folder or the name of the snippet, the path is shown in the window.  See the screen shot below…
• In my case, and I think it is pretty standard, I open the snippet in Notepad at the following path: C:\Program Files\Microsoft Visual Studio 10.0\VC#\Snippets\1033\Visual C#\pp_region.snippet
• Then change the snippet and use the XML listed below.
• The only thing I changed was the 24th line.  After “#endregion” I put in the $name$ variable.  The variable was already used in the snippet on line 22 so it was easy. 
• Note: If you can’t save this snippet with notepad, make sure Visual Studio is closed and run notepad “as administrator”.

Snippet XML:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>#region</Title>
            <Shortcut>#region</Shortcut>
            <Description>Code snippet for #region</Description>
            <Author>Microsoft Corporation</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
                <SnippetType>SurroundsWith</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>name</ID>
                    <ToolTip>Region name</ToolTip>
                    <Default>MyRegion</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp"><![CDATA[#region $name$
        $selected$ $end$
    #endregion $name$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

Code Snippets Manager:

Code Snippets are really cool and easy to use.  For more information, please see this post.

I’m a big fan of the MVVM Pattern for Silverlight development, so naturally I was excited about Silverlight 4 having support for Commanding.  I recently upgraded my current project to Silverlight 4 and I found that binding my buttons to my View Model commands was pretty easy.  However, it wasn’t long before I needed to create a custom control and I wasn’t sure how the Command Binding would work.  I searched the web for some samples but found none so I was on my own.  It wasn’t too hard to figure out the solution, here is how I did it.

The setup… For the sake of this demo, I’ll need a resuable control that combines 2 buttons:  Save and Cancel.  I’ll call it a SaveCancel control :).  The control is simple enough.  Thanks to Silverlight 4, buttons already support the command binding – all you have to do is bind the command in your View Model to the Command property of the button (and optionally the CommandParameter property).  If you aren’t familiar with the basics of commanding, I suggest you check out this blog post by John Papa.  Anyway, when it is time to use the SaveCancel control on another page/control, it becomes pretty clear that you can’t access the individual button’s properties to bind to them!  The individual buttons are not publicly available since they are “child” controls of the SaveCancel control.  The solution:  The Command and CommandParameter properties of each button are just DependencyProperties so all you have to do is create matching properties on the new control that “wrap” the internal properties.

Here’s how it’s done…

First, the XAML of the SaveCancel control is pretty straightforward:

          <
          UserControl 
          x
          :
          Class
          ="CustomControlWithCommanding.SaveCancel" 
          xmlns
          ="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
          xmlns
          :
          x
          ="http://schemas.microsoft.com/winfx/2006/xaml" 
          xmlns
          :
          d
          ="http://schemas.microsoft.com/expression/blend/2008" 
          xmlns
          :
          mc
          ="http://schemas.openxmlformats.org/markup-compatibility/2006" 
          mc
          :
          Ignorable
          ="d"
> <
          StackPanel 
          x
          :
          Name
          ="LayoutRoot" 
          Orientation
          ="Horizontal"
> <
          Button 
          x
          :
          Name
          ="Save" 
          Width
          ="50" 
          Height
          ="25" 
          Content
          ="Save" 
          Margin
          ="0,0,5,0"
/> <
          Button 
          x
          :
          Name
          ="Cancel" 
          Width
          ="50" 
          Height
          ="25" 
          Content
          ="Cancel"
/> </
          StackPanel
          >
</
          UserControl
          > 
        

Next the Code Behind of the SaveCancel control.  Here is where all of the wiring is done for each button’s commands. There are a few parts.  First is the DependencyProperty for the Save button’s command.  Like any dependency property, you need a public property with a Get/Set that sets the value of the Dependency Property as well as a DependencyProperty:

          public 
          ICommand SaveCommand
{ get { return (ICommand)GetValue(SaveCommandProperty);
} set { SetValue(SaveCommandProperty, value);
} } public static readonly DependencyProperty SaveCommandProperty
= DependencyProperty.Register("SaveCommand", typeof(ICommand), typeof(SaveCancel), new PropertyMetadata(null,
OnSaveCommandChanged));

Note that in the PropertyMetaData argument for the SaveCommandProperty we are passing in a callback reference (OnSaveCommandChanged).  We’ll use that method to set the value of the new DependencyProperty to the actual Save button.  Here is the code:

          private static void OnSaveCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{ SaveCancel sc = (SaveCancel)d;
sc.Save.Command = (ICommand)e.NewValue; }

To be complete, we’ll do some similar work to make sure that we can wire up the CommandParameter to the Save button as well, even though we don’t really need it to make the button work for this sample.  

          public object SaveCommandParameter
{ get { return GetValue(SaveCommandParameterProperty);
} set { SetValue(SaveCommandParameterProperty, value);
} } public static readonly DependencyProperty SaveCommandParameterProperty
= DependencyProperty.Register("SaveCommandParameter", typeof(object), typeof(SaveCancel), new PropertyMetadata(null,
OnSaveCommandParameterChanged)); private static void OnSaveCommandParameterChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{ SaveCancel sc = (SaveCancel)d;
sc.Save.CommandParameter = e.NewValue; }

To use the new SaveCancel control in another Silverlight control, all I need is some code like the sample below.  It works perfectly with no events wired up and no code behind on the page where it is used!

          <
          CustomControlWithCommanding
          :
          SaveCancel 
          SaveCommand
          ="{
          Binding 
          SaveCommand
          }" 
          CancelCommand
          ="{
          Binding 
          CancelCommand
          }"
/> 
        

Of course, my ViewModel must have the commands (SaveCommand and CancelCommand) to support this as well.  But that is just normal ViewModel commanding.  Again, if you aren’t familiar with that, check out John Papa’s blog post.

Complete Source Code:

To see the complete sample solution, download it here.

We went to the beach for a long weekend as a family of three, we came home as a family of four!  Here are the details of our adventure.  Read it if you want or just look at the pictures!

On Thursday afternoon Rebecca went for her weekly checkup at the doctor.  Our baby was due in 3.5 weeks but they said she was doing great and had nothing to worry about.  We should go enjoy ourselves at the shore.  We were both really looking forward to the long weekend.  We had just found a new house, sold our house (although both closings are in September), and we have a baby on the way.  Plus our son Ben was really hitting his stride as a two year old, mastering the art of “No”.  So some time off was really in order.  We had a nice relaxing day on Friday, the weather was perfect and Ben was having a blast playing in the sand.

Ben at the beach playground with cousins Hannah and Sam.  And Ben playing with Hannah (and Uncle Andy)

Part 1 – Controlled Panic:  Later that evening we were headed for a walk on the boardwalk with family.  Ben and I were a few minutes ahead of Rebecca.  When Rebecca didn’t follow us, we had to head back to see what was up.  We met up with Rebecca and she said “I think my water just broke”.  FYI, that didn’t happen when Ben was born so she wasn’t positive what was happening.  There was a lot of family at the house and lots of opinions and ideas.  “You should call the doctor”, “You should pack up and leave”, “Relax and go for a walk”, etc.  We called the doctor back home.  Keep in mind, we’re on the Jersey shore near Atlantic City, about 1.5 hrs from home.  The doctors advice was to head right to the hospital.  After water breaks anything could happen, and happen fast.  I thought, the last thing we want to have happen is to deliver a baby on the side of the AC Expressway.  Next, we had a nice family discussion/argument about which hospital to go to.  There were three to choose from.  My brother-in-law and sister-in-law took charge of that and called to figure out which is best.  That was a big help.  By this time it was about 8:30pm.  The next problem to deal with was how to get Ben to sleep.  Since it is the beginning of the summer, the house is a bit strange to him and he wanted me to sleep in the room with him.  I laid down for a while and every minute felt like an hour.  He finally fell asleep, we packed up and we were off to Atlanticare Regional Medical Center Mainland Campus. 

On our walk before things got interesting.  Ben’s with cousin Sylvia (Sylvie) but Ben calls her “So-be”.  I think he is love with her.

One nice part of this whole crazy situation is that we had plenty of people to help with Ben.  If we were at home we would have had to find someone to come over and watch him for the night, plus we’d need people to help out all weekend long too.  Instead, we just drove off.  Well, first we spewed out a bunch of instructions about how to keep him happy while everyone nodded their heads saying “Sure, we’ve got it”.  Most of it didn’t matter, we knew he’d be in great hands if they followed our advice or not.

Part 2 – Hurry Up and Wait:  We got to the hospital and finally were in our room by around 11pm or so.  The staff now told Rebecca that since her water broke, she had to stay in bed.  Rebecca was seriously unhappy with that information.  When Ben was born she was told the best way to work through labor and keep things moving was to be up and around.  And she wasn’t that far along, so we’d likely not have a baby until the next day!  We both slept in the hospital but I’m sure that everyone knows you can’t really get much sleep in a hospital. 

Part 3 – Time to Rock and Roll:  Around 5:30 am they gave Rebecca a shot of Pitocin to move things along.  At 6:30 they injected some pain killers into her epidural and at 7:30 am on July 3rd Sarah Maya Schwam was born!  She weighed 5 lbs, 12 oz and was 19.25 inches long.  As a side note, I thought she looked shorter than that.  This week the pediatrician measured her at 18.5 inches.  I’m not sure what is up with that.  Being 3.5 weeks early, the staff was a little concerned and put the NIC unit on alert.  But after a check up, they decided that she was ok to stay with us and they’d keep an extra close eye on her.  That was a BIG relief to us.  10 fingers, 10 toes, and TONS of dark brown hair and cute as a button (whatever that means). 

Part 4 – Now What?:  OK, so we’ve got a healthy baby but we are pretty far from home with no “baby stuff”.  Well it turns out you don’t need too much stuff and in our neck of the woods (even down at the shore) there are always stores around.  My sister-in-law Dawn hit the drug store for some diapers and stuff, and a little boutique at the beach for a few outfits.  But you can’t leave the hospital without a car seat!  We planned to send the family out to Baby’s R Us to buy a new one when a few friends came to the rescue.  Neighbors Megan and Glen were on their way to the shore for July 4th when they saw my email baby announcement.  They offered to stop at our house and pick up the baby seat and other supplies and drop them at the hospital!  How cool is that?  We were all set!

Our family including Aunt Dawn, Megan (who came to our rescue) and Sarah, and the four of us leaving the hospital via the required wheel chair.

Part 5 – Home At Last:  After 2 nights in the hospital (3 if you count the night before Sarah was born) everyone was released and we went back to the beach house.  It was Monday of a holiday weekend and we didn’t want to get stuck in any traffic coming home so we spent the night at the beach.  Of course, we didn’t have a bassinette there so we had to improvise with a drawer!   By noon on Tuesday we were finally back in our house!  It was great coming home and Benny was really happy.  I think the trip was toughest on him.

Sarah with Rebecca’s dad, with my Mom, in her drawer (it looks safe and comfy, right?). 

What a crazy “vacation” this turned out to be!  It would have been a lot harder without our family that helped out so much with Benny.  He had a great time playing at the beach with his cousins.  I have no idea how we could have got through this without the family helping out.  Now Benny is totally in love with Sarah, like nothing I have ever seen before.  He just wants to kiss her and hug her and tickle her and just be around her ALL of the time.  “I want Sarah” is the new phrase heard around the house… over and over and over again.  We’re glad he likes her but it is making us a little crazy.  I’ve been told that this will wear off pretty soon and he’ll get used to having her around.  Having a sister certainly did not cure the “terrible two’s”.  This little guy really tries to run the show around here.  Lucky for us he’s still a sweet kid most of the time.

Code snippets are a great time saver and they are pretty simple to create.  Any time you find yourself typing the same thing over and over again, you may want to consider creating your own code snippet to make life easier.

Here’s an example… I was recently working on a large refactor of some error handling code for a user interface.  Basically, I went from form to form, refactoring the way the error handling was implemented and then test it.  How did I test it?  By throwing exceptions in my code.  Doing so is pretty easy, just find the portion of code that needs to be tested and type “throw new Exception(“This is a test”);”  Plus, for good measure and safety I’d add this above it: “//TODO – Don’t forget remove this test code”

          //TODO: Don't forget to remove this test
code: 
          throw new 
          Exception("This
is a test");

Sure, it is easy enough to type but it got old pretty quick and I decided to create a simple snippet.  Once I did, all I needed to type was “tne” (it stands for “Throw New Exception) and hit “tab” twice (hitting “Tab” twice tells Visual Studio to use the code snippet based on what you just typed).  Sounds cool huh?  Ok so here is how you create a simple code snippet…

Snippets are stored in XML files on your pc.  To create a new one, it is easiest to just start with an existing snippet and modify the xml to meet your needs.  Here is an example of the one I am using:

          <?
          xml 
          version
          ="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>Throw
new Exception</Title>
<Shortcut>tne</Shortcut>
<Description>This
will generate code to throw a new Exception</Description>
<Author>Andy
Schwam</Author>
<SnippetTypes>
<SnippetType>Expansion</SnippetType>
</SnippetTypes>
</Header>
<Snippet>
<Code Language="csharp">
<![CDATA[ //TODO: Remove this test code: throw
new Exception("An Exception has been thrown"); $end$]]>
</Code>
</Snippet>
</CodeSnippet>
</CodeSnippets>

If you want to use your own snippet, just change the Title, Shortcut, Description and Author elements.  And of course, you need to put your snippet inside of the CDATA area of the the Code Element.

Next, you just need to save this file in a place where Visual Studio will pick it up.  To tell VS2008 where to look for it, go to Tools > Code Snippets Manager.  Make sure you select the correct language in the drop down, otherwise Visual Studio can’t connect your snippet to the language you meant it for.  You’ll also notice the existing folders for snippets.  That may give you an idea of where you should store your own snippets ;).

You can also write more complex snippets that allows you to use the snippet and then type in values that get used within the snippet.  For instance, I do a lot of work with Silverlight and for databinding my public variables must implement INotifyPropertyChanged.  Instead of manually typing a property that does so, plus a backing variable, I use a snippet with the shortcut “npc”.  In the sample below, you will see the words TYPE, PROPERTY and FIELD highlighted in Green.  Those are placeholders and when I utilize the code snippet, VS will prompt me to replace those values.  So if I want to create a public property and backing variable for a string FirstName, I just type the following:  “npc” TAB TAB “string” TAB “FirstName” TAB “_firstName” (but don’t type the quotes!).  It may seem weird at first but makes coding much easier.

          private TYPE FIELD; 

Here is the XML for my “NotifyPropertyChanged” snippet:

          <?
          xml 
          version
          ="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>Notify
Property Changed Property</Title>
<Shortcut>npc</Shortcut>
<Description>Code
snippet for creating a property with a backing variable that calls NotifyPropertyChanged</Description>
<Author>Andy
Schwam</Author>
<SnippetTypes>
<SnippetType>Expansion</SnippetType>
</SnippetTypes>
</Header>
<Snippet>
<Declarations>
<Literal>
<ID>type</ID>
<ToolTip>The
Type for the Property</ToolTip>
<Default>TYPE</Default>
</Literal>
<Literal>
<ID>fieldname</ID>
<ToolTip>The
Type for the field</ToolTip>
<Default>FIELD</Default>
</Literal>
<Literal>
<ID>propertyname</ID>
<ToolTip>Parameter
name</ToolTip>
<Default>PROPERTY</Default>
</Literal>
</Declarations>
<Code Language="csharp">
<![CDATA[ public $type$ $propertyname$ { get {
return $fieldname$; } set { if ($fieldname$ != value) { $fieldname$ = value; NotifyPropertyChanged("$propertyname$");
} } } private $type$ $fieldname$; $end$]]> </Code>
</Snippet>
</CodeSnippet>
</CodeSnippets>

Unfortunately, there isn’t a Code Snippet Editor included in VS.  There is some kind of plug-in available for creating VB snippets but I’ve never used it.  I’m sure you can find it with your favorite search engine.  Still it is pretty easy to write these yourself.

I’ve been working on continuous integration and automated builds/deployment lately.  I put together a MSBuild script that does a whole bunch of typical stuff including getting code from my repository, compiling, and running tests.  I also want to create a Tag in my Subversion repository so I know which code was deployed.  That wasn’t too hard to do either.  The tricky part was that I want my build to fail if I try to make a Tag that already exists!

I fumbled around with this for a while trying a wide variety of ideas.  In the end, it turned out to be pretty simple.  There may be better ways to accomplish this, but here is how I am doing it…

I’m using the SvnClient task (it’s part of the MSBuild.Community.Tasks download) and executing a command:  “ls $(SvnRepository)/tags/$(SvnTagName)”.  Of course, my MSBuild script already has the variables $(SvnRepository) which is the path to my repository and $(SvnTagName) which is the name of the Tag I hope to create.  You may have to tweak this stuff depending on the layout of your SVN repository.  The command “ls” will actually list the contents of my Tag.  Since I know my tag just has a few folders in it (it isn’t a recursive task), it isn’t too harmful if it succeeds.  If the Tag does not exist in my repository, the command actually fails.  Oddly, I actually want this task to fail!  Yes, in my case, I am hoping the task does not find the Tag with the specified name.  When the task is executed, it returns an ExitCode which is 0 for success or 1 for failure.  Next I just check the returned code and if it is successful I generate an error.  Sure this feels a bit odd.  I don’t love using this kind of logic, hoping for an error to occur. I’d much rather have some subversion command I could execute to see if the Tag exists but I couldn’t find anything like that.  Here is the actual xml from my Build file to check for the Tag:

          <
          Target 
          Name
          ="CheckSvn">
<Message Text="***
Checking to see if the tag already exists"/>
<!-- this task will look up the tag supplied.
If it exists it will return a code of 0 Technically this is a success but for this
instance, it is a failure because we don't want to find it! -->
<SvnClient Command="ls
$(SvnRepository)/tags/$(SvnTagName)" Username="xxx" password="xxx" ContinueOnError="true">
<Output TaskParameter="ExitCode" PropertyName="CommandResult"/>
</SvnClient>
<Message Text="***
ExitCode = $(CommandResult)"/>
<Error Condition="$(CommandResult)=='0'" Text="This
Tag already exists!"/> <Message Text="***
Finished Checking to see if the tag already exists"/>
</Target>

Working with MSBuild is becoming a love/hate relationship for me.  I really love the power of what you can do to automate tasks.  But it can be a real pain to write, test, and debug these scripts.  I hope my sharing this code will make your life a little easier.