Code Capers

A Neat Way to Set the Cursor in WPF

Fri, 30 Nov 2012 12:17:00 -0100

I found this excellent post on stack overflow which uses a Stack to set and unset the cursor. Normally when you want to set the wait cursor in your application you would use a try/finally block to ensure that the cursor eventually gets set back to the original value:

Mouse.OverrideCursor = Cursors.Wait;
try {
    return Foo.Execute();
}
finally
{
    Mouse.OverrideCursor = null;
}

Don't get me wrong here...There is nothing wrong with using a try/finally. However, there is an alternative way to solve the same problem which I personally think is a more elegant and foolproof. So without further ado, here is the OverrideCursor class.

static Stack<Cursor> s_Stack = new Stack<Cursor>();

public OverrideCursor(Cursor changeToCursor) {
    s_Stack.Push(changeToCursor);

    if (Mouse.OverrideCursor != changeToCursor)
        Mouse.OverrideCursor = changeToCursor;
}

public void Dispose() {
    s_Stack.Pop();

    Cursor cursor = s_Stack.Count > 0 ? s_Stack.Peek() : null;

    if (cursor != Mouse.OverrideCursor)
        Mouse.OverrideCursor = cursor;
}

With the help of this class, we can ditch the try/finally and use this block of code instead:

using (new OverrideCursor(Cursors.Wait)) {
    return Foo.Execute();
}

So what is happening here? Well, in the OverrideCursor's constructor the current cursor is pushed on the stack and the cursor is updated to whatever you value you passed in as an argument. Later on when the object is Disposed the original cursor is fetched from the stack and restored. Since the code that launches my dialog is wrapped in a using statement the OverrideCursor instance will be disposed as soon as my form is displayed. Neat Trick!

My First Arduino Robot

Thu, 24 May 2012 19:08:00 -0100

Late last year, I discovered the Arduino. The Arduino is an open-source physical computing platform based on a simple i/o board and a development environment that implements the Processing/Wiring language. The Processing/Wiring language is a simplified version of the C programming language that has extensions to access the underlying hardware. The Arduino can be used to develop stand-alone interactive objects such as robots, led displays or 3D printers like the MakerBot Replicator.

Since I write software for a living, I am extremely comfortable with the software aspect of the Arduino. However I was a little worried about my lack of electronic skills. Just to give you some background, at the beginning of this project I knew absolutely nothing about electronics. I never used a soldering iron or even held a multimeter. So its goes without saying that I had a lot to learn. I spent a lot of time reading blogs, watching YouTube videos and I even bought the book “Electronics for Dummies”. I typically try to avoid the Dummy books because I find the title to be self deprecating. However in this case, the title fit. Fortunately, after a couple of fun filled weeks, I learned how to solder, felt comfortable using a multimeter and started to understand the basic concepts. I eventually got to the point where I felt I could build something without electrocuting myself! After some brainstorming I decided to build a robot!

The first step in building a robot is to pick a chassis. If you are handy, you can build something from scratch or hack apart an existing toy. In my case, I decided to use a chassis that I found on eBay. The kit I purchased was actually the 2WD Mobile Platform from DFRobot. Buying a pre-built platform has some advantages. Mainly because the kit comes with 2 motors, mounting hardware, wheels, hookup wire and a platform large enough to attach an Arduino, some shields and a small breadboard. The kit also comes with a toggle switch and a six AA battery holder. If you are a beginner like me, then I would recommend buying a kit because it will save you the time of trying to figure out which parts to buy. Finding parts on sites like Mouser or Digi-Key can be intimidating for beginners.

While I was waiting for my chassis to arrive, I purchased a motor shield kit from Adafruit. There are a variety of motor shields on the market but I settled on the Adafruit board for a few reasons. First of all it has excellent documentation. If you are a newbie like me, then getting a step by step instruction guide with pictures is very important. Second, I know that the Adafruit team stands behind their products. If I run into any issues I can rest assured that someone will help me out. Finally, the shield comes with a software library and a sample sketch. On top of all that, the hardware and software are open source! If you are going to build a robot then I would highly recommend buying this shield.

Once you assemble the motor shield you can simply stack it on top of an Arduino board. The male pins from the motor shield plug directly into the female headers of the Arduino board beneath it. The motor shield will occupy quite a few pins. In the end, you will be left with digital pins 2 and 13 and all of the analog pins. The analog pins are conveniently broken out in the bottom right hand corner. The board also gives you easy access to additional +5 volt and ground connections. In order to make prototyping easier and to increase the reusability of the shield, I soldered a 6 pin female header across each of the three rows in the bottom right hand corner of the PCB. I also ended up placing a 2 pin header across digital pins 0 and 1 which are used for TX (transmit) and RX (receive). The TX and RX pins are used for communication to the Arduino, for example when you upload a sketch to the Arduino or when you are sending serial commands from an external device. As a tip, if you have the RX and TX pins wired to a separate device for processing commands, you will need to disconnect these wires before you can upload any sketches.

For phase one of my project, I decided to make my robot autonomous. Autonomous means that the robot can drive around without anyone controlling it. In order for this to work, the robot needs to be able to detect and avoid obstacles. In other words, it needs to be able to see. The easiest way to implement this functionality is to use some sort of distance sensor. After a bit of research I decided to use the Parallax PING))) Ultrasonic sensor. There are cheaper distance sensors available but the PING sensor had sample code and I knew it would be easy to use.

The PING sensor was extremely easy to setup. Within minutes of using it, I had the sample sketch working. After I attached it to my robot chassis, I quickly realized that my robot lacked peripheral vision. If an object was not directly in front of the PING sensor the robot would crash into it. I solved this problem by purchasing a pan and tilt bracketfrom Sparkfun. The pan and tit bracket uses two servos which allows for 180 degrees of movement vertically and horizontally. I mounted the PING sensor on top of the bracket and hooked the servo wires to the motor shield. After a little bit of coding, my robot was able to take distance measurements in multiple directions!

Unfortunately, with the addition of the two servos I exceeded the amount of amps that six AA batteries could provide to the motor shield. Six AA batteries will provide you with approximately 9 volts at 1-1.5 amp hours (series gives you more volts but not more amp hours). As a result, I decided to invest in some Lipo batteries. The Lipo batteries are small and light enough for the robot to carry and provide sufficient amperage to drive 2 motors and 2 servos. After doing some price comparisons, I ended up buying my Lipo batteries from Hobby King. I bought one 1300mAh 2S 20C battery to run the Arduino and a 2200mAh 3S 20C to supply power to the motor shield. I also picked up some XT60 connectors to make it easier to connect and disconnect the batteries. Of course, Lipo batteries are useless without a charger so I threw one of those in my cart too. At the end of the day, I ended up spending more money than I wanted too but since the batteries are rechargeable they can be used on other projects.

Once I got the robot to work autonomously I quickly got bored of watching it drive aimlessly around the room. So I decided to add a remote control mode. As a starting point, I found an instructable which used a $10 Bluetooth adapter paired with an Android phone as a remote control. Once paired, the BlueTooth module can be used as a virtual serial port. Then it becomes a simple matter of sending and receiving serial commands in order to make the robot move. In the instructable, the author uses a Python script to send commands, but I decided to use a native Android app instead. So I downloaded the Eclipse IDE and started working my way through the “hello world” Android tutorials. To my surprise, Android development is easy to learn. There is ample documentation and plenty of community support. I also got lucky because the Android SDK includes a BlueTooth Chat application. I ended up using this application as the basis for my remote control app.

In order to switch the robot between autonomous and remote control mode I added a toggle switch to my robot. The toggle switch controls the power to the BlueTooth adapter. I use one of the analog pins on the Arduino to check if the Bluetooth module is active (HIGH) or inactive (LOW). If the BlueTooth module is active I process serial commands, otherwise I run the autonomous code.

The Arduino Code

Here is a brief summary of the Arduino code. The full source code is available on GitHub

The Adafruit motor library is really simple to use. Simply add a reference and use the methods to control the speed and direction of the motors. If you are using servos with the motor shield you can leverage the existing Servo library that comes with the Arduino IDE. Here are some examples of the methods I used to control the motors.

void brake()
{
  leftMotor.run(RELEASE);
  rightMotor.run(RELEASE);
}

void moveForward( int duration = 110 )
{
  leftMotor.run(FORWARD);
  rightMotor.run(FORWARD);
  delay(duration);
}

void moveBackward( int duration = 1000 )
{
  leftMotor.run(BACKWARD);
  rightMotor.run(BACKWARD);
  delay(duration); //amount of time it takes to back up 
}

void turnLeft( int duration = 480)
{
  leftMotor.run(FORWARD);
  rightMotor.run(BACKWARD); //turns off the motor
  delay(duration);
}

void turnRight( int duration = 480 )
{
  leftMotor.run(BACKWARD);//turns off the motor
  rightMotor.run(FORWARD); 
  delay(duration);
}

For processing serial commands, I leveraged the SerialCommand library. The library allows you to map incoming commands with methods in your Arduino sketch. For example, if you send the command “F 1000” to the Arduino my code will run the forwardCommand. The library also gives you easy access to the arguments sent with the command. For example the command “F 1000” has two parts. The command is “F” for “Forward” and the argument is 1000. In my case, this means move forward for 1000 milliseconds or 1 second. Here is the code:

void setupSerial()
{
  Serial.begin(9600);
  sCmd.setTerm(';');
  sCmd.addCommand("F", forwardCommand );
  sCmd.addCommand("f", forwardCommand );
  
  sCmd.addCommand("B", backwardCommand );
  sCmd.addCommand("b", backwardCommand );
  
  sCmd.addCommand("L", turnLeftCommand );
  sCmd.addCommand("l", turnLeftCommand );
  
  sCmd.addCommand("R", turnRightCommand );
  sCmd.addCommand("r", turnRightCommand );
  
  sCmd.addCommand("?", showCommands );
  sCmd.setDefaultHandler( unrecognized );
}

void showCommands()
{
  Serial.println( "Hello Master. I am awaiting your commands." );
  Serial.println( "------------------------------------------" );
  Serial.println( "Commands must be terminated with a semi-colon:" );
  Serial.println( "\tMove (F)orward - F <# of steps>");
  Serial.println( "\tMove (B)ackward - B <# of steps>");
  Serial.println( "\tTurn (R)ight - R <value>");
  Serial.println( "\tTurn (L)eft - L <value>");
}

void unrecognized(const char *command)
{
  Serial.println("Huh?");
}

Here is the code that uses conditional logic to determine whether the robot is in autonomous or remote control mode:

void loop()
{   
  //check if we are using the bluetooth module, if so listen for commands only
  if( digitalRead(btPin) == HIGH ) { 
    sCmd.readSerial();
    return;
  }
  
  //do autononmous functions ....
}

The Android App – Remote Control

Here is a brief summary of the Android code. The full source code is available on GitHub.

The UI is pretty simple. It’s basically just a joystick, a few labels and a connection dialog which allows you to choose which BlueTooth device to connect to. For the joystick I used the Mobile Anarchy Widgets. At this point, my app still needs quite a bit of work. However, the basic concept is proven and its just a matter of adding some trim and polish.

Here is the chunk of code that creates the virtual serial connection:

String address = data.getExtras().getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);
String deviceName = data.getExtras().getString(DeviceListActivity.EXTRA_DEVICE_NAME);
// Get the BLuetoothDevice object
BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);         
try {
    Method m = device.getClass().getMethod("createRfcommSocket", new Class[] {int.class});
    socket = (BluetoothSocket) m.invoke(device, 1);
    socket.connect();
    txtHeader.setText("connected to device: " + deviceName );
    outputStream = socket.getOutputStream();
    //InputStream inputStream = socket.getInputStream();                
} catch (Exception e) {
    txtHeader.setText("connection failed: " + e.getMessage() );
}

When the joystick is moved, a event handler is called. I then look at the location of the joystick and send the appropriate command to the Arduino. I also added a little bit of code to control how often a command is sent. If you send too many commands at once you can overflow the serial port and the app will crash.

private JoystickMovedListener _listener = new JoystickMovedListener() {

Date lastSent = new Date();

@Override
public void OnMoved(int pan, int tilt) {
    txtX.setText(Integer.toString(pan));
    txtY.setText(Integer.toString(tilt));

    if( socket == null || outputStream == null ) return;
    
    //only send a message once a second
    long diff = new Date().getTime() - lastSent.getTime();
    if( diff < 500 ) return;
    lastSent = new Date();
    
    String command = getCommand( pan, tilt );
    if( command.length() == 0 ) return;
    
    byte[] bytes = command.getBytes();
    try {
        outputStream.write(bytes);
        outputStream.flush();
    } catch (IOException e) {                
        e.printStackTrace();
    }                            
}

public String getCommand( int x, int y )
{
    if( ( x >= -3 && x <= 3 ) && y > 3 )
        return "B 1000;";
    
    if( ( x >= -3 && x <= 3 ) && y < -3 )
        return "F 1000;";
    
    if( ( y >= -3 && y <= 3 ) && x < -3 )
        return "L 1000;";
    
    if( ( y >= -3 && y <= 3 ) && x > 3 )
        return "R 1000;";
    
    return "";
}

@Override
public void OnReleased() {
    txtX.setText("released");
    txtY.setText("released");
}

public void OnReturnedToCenter() {
    txtX.setText("stopped");
    txtY.setText("stopped");
};

Introducing “Robie” the Robot

Here is a video of “Robie” the Robot (my kids named him) running in autonomous mode. This video was taken prior to adding the remote control capabilities.

Conclusion

One of the best things about building this robot was that my kids are now interested in electronics. They love to ask me questions about how the robot works and they are extremely curious about the projects that I have sitting on my workbench. For years I have tried to get them interested in engineering but I could never find the right project to motivate them to learn. However, the Arduino seems to have a special appeal towards makers and even children. As proof, here is a picture that my daughter Noelle drew of her and I working on “Robie”.

Since I started working with the Arduino I have really gained confidence in my ability as a maker. In the past, when something electronic would break around the house I would either throw it away or send it out for repair. Nowadays, I attempt to fix things myself. Once you consider yourself a maker, you start to think differently. After all, “If You Can’t Open It, You Don’t Own It”

Using PowerShell to Publish a NuGet Package

Mon, 07 May 2012 12:26:46 -0100

At my employer we have a local NuGet server to host all of our internal packages. Occasionally, I’ll be working on a project and realize that I need to tweak something in one of my NuGet packages. Initially, I got into the habit of opening up a second instance of Visual Studio, making the necessary changes and using the NuGet web interface to re-upload the package. I quickly realized that manually uploading the package was too time consuming. Therefore, I started looking for a way to automate the process instead. Eventually that led me to the PowerShell script you see below.

$nugetServer = "https://<your nuget server here>"
$apiKey = "<your api key here>"
$packageName = "<your package name here>"

$latestRelease = nuget list $packageName
$version = $latestRelease.split(" ")[1];

$versionTokens = $version.split(".")
$buildNumber = [System.Double]::Parse($versionTokens[$versionTokens.Count -1]) 
$versionTokens[$versionTokens.Count -1] = $buildNumber +1
$newVersion = [string]::join('.', $versionTokens)
echo $newVersion

get-childitem | where {$_.extension -eq ".nupkg"} | foreach ($_) {remove-item $_.fullname}
nuget pack -Version $newVersion
$package = get-childitem | where {$_.extension -eq ".nupkg"}
nuget push -Source $nugetServer $package $apiKey

The script needs a few variables defined in order for it to run. The first variable ($nugetServer) is the URL of the NuGet Server. The second variable ($apiKey) is your personal API key. You can get your API key by logging into your NuGet Server with a browser. After you log in, click on your username in the upper right hand corner. This will take you to your account page. On the bottom of the “My Account” page there is a box which you can click on to make your API key visible. Finally the last variable ($packageName) is the name of the package you are uploading. This can be easily acquired by looking at your project properties and copying the Assembly name from the Application tab.

Depending on how your machine is configured you may have the option to Run with PowerShell on your context menu. If not, you can take a look at this blog post in order to configure it manually. Alternatively you can use the following command instead.

powershell.exe "<path to the script>\publish.ps1"

If you have any problems running the script then please refer to the following TechNet article or send me a question and I’ll be glad to help.

jQuery + CSS3 Media Queries = Dynamic UX

Wed, 18 Apr 2012 17:27:00 -0100

I have been working on a project where I render an HTML table to display some information about a project. When the table is displayed on a wide monitor I can comfortably fit about 10-15 columns. However, when viewing the same page on a screen with less real-estate things get crowded. Most people would probably address this problem by creating a mobile version of the site. In many cases this is the proper solution if you really want to tailor the user experience for the device. However, in my case I just wanted to toggle the visibility of some of the columns in the table based on the screen size and I really did not want to get into the hassle of maintaining a separate mobile interface. Therefore I came up with a solution based on jQuery and CSS Media Queries. Below is a screenshot that shows how columns are being toggled on and off based on the width of the browser.

So let me start this tutorial by showing you the markup that I used to generate the HTML table. If you are not a MVC/Razor developer then this part of the tutorial may not be useful to you. However I wanted to include this extra step because the Razor grid’s Html Helper has some limitations which I addressed with jQuery.

@{ 
    var grid = new WebGrid( 
        canPage: true,
        rowsPerPage: Model.PagingInfo.PageSize,       
        ajaxUpdateContainerId: "container",
        ajaxUpdateCallback: "gridLoaded"
    );
    
    grid.Bind(Model.Data, rowCount: Model.PagingInfo.TotalItems, autoSortAndPage: false);    
       
    <div id="container">
        @grid.GetHtml(
            tableStyle: "webGrid",
            headerStyle: "header",
            alternatingRowStyle: "alt",
            htmlAttributes: new { id = "grid", page = Model.PagingInfo.PageNumber },
            columns: grid.Columns(
                grid.Column("Title", "Title"),
                grid.Column("StartDate", "Start"),
                grid.Column("EndDate", "End"),
                grid.Column("PercentComplete", "%"),

                grid.Column("Status", "Status", style: "xtra"),
                grid.Column("Notes", "Notes", style: "xtra"),
                grid.Column("MetaData", "MetaData", style: "xtra"),
                grid.Column("MoreMetaData1", "More MetaData", style: "xtra"),
                grid.Column("EvenMoreMetaData1", "Even More MetaData", style: "xtra")
            )
        )
    </div>     
}

As you can see, the razor grid allows you to specify styles for each column (TD), so I added the style class "xtra" to the fields that I want to hide when the screen with is 800 pixels or less. Unfortunately the (TH) columns can not be styled directly with the Html Helper. Therefore I needed a way to apply the “xtra” class to the headers that correspond with each column. This was very easy to do with jQuery:

$("#grid tbody tr:first td.xtra").each(function (index,td) {                
    $('#grid thead th').eq($(td).index()).addClass("xtra");                
});

The snippet above uses a selector to get at the first row of the table. It then loops through all of the columns in that row that have the "xtra" style applied to it. Then for each column it finds the corresponding header and adds the "xtra" style to it. This is important because if we did not apply the style to the headers then our CSS below would only hide the columns and not the headers.

Now let's move on to adding the CSS media queries to our style sheet. If you are unfamiliar with media queries then here is a quick definition that I found on the W3C site:

Media queries extend the functionality of media types by allowing more precise labeling of style sheets. A media query consists of a media type and zero or more expressions that check for the conditions of particular media features. Among the media features that can be used in media queries are ‘width’, ‘height’, and ‘color’. By using media queries, presentations can be tailored to a specific range of output devices without changing the content itself.

So in simple terms, we can have sections in our style sheet that only apply when the screen is a certain size. In my particular case I decided to hide the columns with the “xtra” style applied to them whenever the screen width is less than 800 pixels:

@media screen and (max-width:800px) { 
  .webGrid .xtra { display: none;}  
  .webGrid .xtra > th { display: none;}    
}

Keep in mind that you can also do things like adjust fonts, remove background images and hide navigation panels. This can help make the user experience better when dealing with smaller screens. Although this trick is not a replacement for a well crafted mobile interface it certainly gives you a quick way to make your site look good on smaller screens.

Happy Coding!

INotifyPropertyChanged with Compile Time Checking

Tue, 27 Mar 2012 19:34:00 -0100

Update: An anonymous reader left a great tip! ".NET 4.5 gives you the new Caller Info attributes, which would remove the need to actually pass in the name of the property, if you're raising the notification from withing the property itself." For more details read this blog post.

Once you start doing WPF MVVM development you will quickly grow tired of implementing the INotifyPropertyChanged interface. So in order to preserve my sanity, I create a base class which implements the INotifyPropertyChanged interface. The first version of my class was defined as:

public class NotifyPropertyChangedBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged = delegate { };

    protected void RaisePropertyChanged(string propertyName)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

This is about as basic as an implementation of INotifyPropertyChanged can get. To use it, you just implement the class and call RaisePropertyChanged. Here is an example:

public class MyViewModel : NotifyPropertyChangedBase
{
    private string _name;
    public string Name {
      get{ return _name; }
      set{ 
       _name = value;
       RaisePropertyChanged("Name");
      }
    }
}

After using this version of the code for a couple of days I quickly realized that using a lambda to get the property name would be less error prone than using a string. So in version 2 of the code, I added lambda support.

By the way, the ExtractPropertyName method you see below, was copied verbatim from the Prism project. Prism and MVVM Light Toolkit both take care of wrapping the INotifyPropertyChanged interface. I personally do not use either framework because I feel that they are both too bloated for my purposes. After a bit of contemplation, I ended up building my own MVVM framework, which I have packaged up and placed on my private NuGet server. However, if you are new to .NET or MVVM then I would suggest starting with a framework first. In any case, here is the updated code:

protected void RaisePropertyChanged<T>(Expression<Func<T>> propertyExpression)
{
    var propertyName = ExtractPropertyName(propertyExpression);
    RaisePropertyChanged(propertyName);
}

protected string ExtractPropertyName<T>(Expression<Func<T>> propertyExpression) {
    if (propertyExpression == null) {
        throw new ArgumentNullException("propertyExpression");
    }

    var memberExpression = propertyExpression.Body as MemberExpression;
    if (memberExpression == null) {
        throw new ArgumentException("The expression is not a member access expression.", "propertyExpression");
    }

    var property = memberExpression.Member as PropertyInfo;
    if (property == null) {
        throw new ArgumentException("The member access expression does not access a property.", "propertyExpression");
    }

    if (!property.DeclaringType.IsAssignableFrom(this.GetType())) {
        throw new ArgumentException("The referenced property belongs to a different type.", "propertyExpression");
    }

    var getMethod = property.GetGetMethod(true);
    if (getMethod == null) {
        // this shouldn't happen - the expression would reject the property before reaching this far
        throw new ArgumentException("The referenced property does not have a get method.", "propertyExpression");
    }

    if (getMethod.IsStatic) {
        throw new ArgumentException("The referenced property is a static property.", "propertyExpression");
    }

    return memberExpression.Member.Name;
}

With the lambda version of RaisePropertyChanged in place, I can now get compile time checking. Compile time checking is great if you have fat fingers or if you do a lot of refactoring. Let’s take a look at our updated ViewModel:

public class MyViewModel : NotifyPropertyChangedBase
{
    private string _name;
    public string Name {
      get{ return _name; }
      set{ 
       _name = value;
       RaisePropertyChanged(() => Name);
      }
    }
}

I also added an overloaded version of the RaisePropertyChanged method so I could raise multiple properties using a single method call. This is useful when you have two of more related properties.

protected virtual void RaisePropertyChanged(params string[] propertyNames) {
    foreach( var property in propertyNames ) {
        RaisePropertyChanged(property);
    }
}

Unfortunately, I could not figure out how to make an overloaded method that takes multiple lambdas. Because the type that represents "T" needs to be different for each expression I struggled to find any syntactical sugar that would make it work. To clarify the problem, I made an overloaded version of the method that takes two lambda expressions. You will notice that T and X are different types. T may be an integer and X may be an observable collection.

protected void RaisePropertyChanged<T,X>(Expression<Func<T>> one, Expression<Func<X>> two ) 
    RaisePropertyChanged(one);            
    RaisePropertyChanged(two);            
}

With this method you could use the following syntax. Of course, with my sample method above you are limited to two parameters only:

RaisePropertyChanged( () => CountryId, () => States );

If you have a solution for making an overloaded method with params and lambdas then please leave a comment.

Moving on...The classic example of two related properties are Country and State. When you change the value of the country drop down, you want the corresponding states or provinces to appear. Here is an example:

public class AddressViewModel : NotifyPropertyChangedBase
{
     private Address Model { get; private set; }
     
     public AddressViewModel( Address model )
     {
         Model = model;
     }

     public int Country
     {
         get { return Model.CountryId; }
         set
         {
             Model.CountryId = value;
             RaisePropertyChanged( () => CountryId);
             RaisePropertyChanged( () => States);
         }
     }

     public ObservableCollection<Country> Countries {
         ...
     }

     public ObservableCollection<State> States
     {
         ...
     } 

     public int StateId
     {
         ...
     }
}

To summarize, if you find yourself implementing INotifyPropertyChanged a lot then I would highly recommend moving that functionality into a base class. In addition, using the lambda version of the RaisePropertyChanged event can provide you with compile time checking which is always a great thing to have!

EF Code First - Tips and Tricks

Tue, 13 Mar 2012 18:31:00 -0100

These days I do all of my development work with EF code first. One of the cool things about EF is its ability to drop and recreate the database when the models change. This is great when you are trying to associate your source code with a particular revision of the database schema. However, dropping and recreating a database on a production or staging environment can have some serious repercussions. Therefore, I like to put some safeguards in place to make sure that this only happens under the right conditions.

Please keep in mind that the newest version of EF has migration support! So you can alter the database instead of dropping and recreating it. However, if you use the DropRecreateDatabaseIfModelChanges feature of EF then you may find the following tip useful.

Safeguarding from an Accidental Drop/Recreate

In wrap the code that sets up the EF Context initializer with the following helper method which determines whether or not I am in development mode. For me, development mode means I have the debugger attached or I am working with a local SQL instance:

static bool InDevelopmentMode {
    get {    
        if (System.Diagnostics.Debugger.IsAttached) return true;
        if (Environment.UserName.ToUpper().Contains("<YOUR ID HERE>")) return true;    

        var connectionString = ConfigurationManager.ConnectionStrings["MyDbContext"].ConnectionString;
        var csb = new SqlConnectionStringBuilder(connectionString);
        return csb.DataSource.Equals("."); //shorthand for localhost                
    }
}

Now we can leverage the method to conditionally execute the DB initializer:

if (InDevelopmentMode) {
    Database.SetInitializer(new MyContextInitializer()); //Register the EF context initializer
}

Disabling EF Migrations

As I mentioned earlier, the latest version of EF has migration support. By default, migrations will be enabled. If you want to disable it you can do the following:

Create a Migrations Configuration class

using System.Data.Entity.Migrations;

namespace MyApp.Domain.DataContext {
    public sealed class MigrationConfiguration : DbMigrationsConfiguration<MyContext> {
        public MigrationConfiguration() {
            AutomaticMigrationsEnabled = false;
        }
    }
}

Bootstrap it!

For web apps this would add this code to the Global.asax.cs and in WPF apps you would do this in App.xaml.cs...

new DbMigrator(new MigrationConfiguration()); //migrations are disabled

Happy Coding!

Using Self Referencing Tables With Entity Framework

Mon, 13 Feb 2012 06:00:00 -0100

Since EF was released I have been a fan. However, every once in a while I’ll run into a table design situation that I am not sure how to handle with EF. This week, I needed to setup a self-referencing table in order to store some hierarchical data. A self referencing table is a table where the primary key on the table is also defined as a foreign key. Sounds a little confusing right?

Let’s clarify the solution with an example. Let’s say I am building an application where I have a list of categories and subcategories. One of my top level categories is “Programming Languages” and under programming languages I have to subcategories which are “C#” and “Java”. In order to store this data I can use a single table with the following structure:

The actual data would look like this:

Just to clarify, a top level category will have a null value for the ParentId field. For all child categories the ParentId field is used as to represent its parent’s primary key value. As a programmer you may want to think about the ParentId field as a pointer. To complete the example lets take a look at the SQL used to create the table.

CREATE TABLE [dbo].[Categories] (
    [CategoryId] [int] IDENTITY(1,1) NOT NULL,    
    [Name] [nvarchar](255) NOT NULL,    
    [ParentId] [int] NULL,
PRIMARY KEY CLUSTERED 
(
    [CategoryId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

GO

ALTER TABLE [dbo].[Categories]  WITH CHECK ADD  CONSTRAINT [Category_Parent] FOREIGN KEY([ParentId])
REFERENCES [dbo].[Categories] ([CategoryId])
GO

ALTER TABLE [dbo].[Categories] CHECK CONSTRAINT [Category_Parent]
GO

Upon examining the SQL, you should have noticed that the CategoryId is the primary key on the table and the ParentId field is a foreign key which points back to the CategoryId field. Since we have a key referencing a another key on the same table we can classify this this as a self-referencing table. Now that we fully understand what a self-referencing table is, we can move forward to the Entity Framework code. To get started we first need to create a simple C# object to represent the Category table. Of course, keep in mind that if you are using EF Code first you do not need to create the table or database ahead of time. I only showed the table first because I wanted to better illustrate what a self referencing table is.

public class Category
{
    public int CategoryId { get; set; }
    public string Name { get; set; }
    public int? ParentId { get; set; }
}

So far the Category class is very simple. However, we really want to add a few more properties in order to make this class useful. For example, if you are a child category you really want to be able to use dot notation to get the name of the parent category (e.g. subCategory.Parent.Name). Using EF, we will create a virtual property named Parent. By making the property virtual we are letting EF know that when this property is accessed we want to load some data. Based on your configuration settings and the code you use to retrieve your data (whether or not you used DbSet.Include), EF will lazy load or eager load this data.

public class Category
{
    public int CategoryId { get; set; }
    public string Name { get; set; }
    public int? ParentId { get; set; }
    public virtual Category Parent { get; set; }
}

Finally, we also want a property called Children so we can use dot notation to enumerate over the child categories. Once again, here is the modified class:

public class Category
{
    public int CategoryId { get; set; }
    public string Name { get; set; }
    public int? ParentId { get; set; }
    public virtual Category Parent { get; set; }
    public virtual ICollection<Category> Children { get; set; }
}

The final step is to let EF know how these properties are related to one another. This can be done using EF's fluent API. If you are new to EF and are unaware of the fluent API then you may want to read this article first.

public class CommodityCategoryMap : EntityTypeConfiguration<Category> {
    public CommodityCategoryMap() {
        HasKey(x => x.CategoryId);

        Property(x => x.CategoryId)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);

        Property(x => x.Name)
            .IsRequired()
            .HasMaxLength(255);

        HasOptional(x => x.Parent)
            .WithMany(x => x.Children)
            .HasForeignKey(x => x.ParentId)
            .WillCascadeOnDelete(false);
    }
}

Hopefully you paid careful attention to the last section of code where we state the a Category has an optional Parent property. In database speak, this simply means that the ParentID field is nullable. The code also states that if a Category object can have zero or many children. In order to specify that a record is a child, we leverage the ParentId field to hold the primary key value of the parent record. As I mentioned earlier, if you are a programmer its easier to think of the ParentId field as a pointer. Finally, I disabled the cascade on delete option. This step is optional and probably based on your own personal preferences. If you enable cascade on delete and you delete a category that has 100 children then you will effectively remove 101 records. For whatever reason this scares me a little bit. Perhaps, my short career as a DBA caused me to not trust people with large volume delete statements. However, you may decide differently depending on your circumstances.

Hopefully, this short EF tutorial will help you if you are working through a scenario where you need to capture and manipulate hierarchical data. If you have any questions please leave a comment.

How to Set Up a Local NuGet Gallery

Mon, 06 Feb 2012 12:50:51 -0100

First of all you may be wondering, why do I want my own local Nuget Gallery? Well, here are two reasons:

Having your own NuGet server is perfect for when you need share modules with other people on your team but you do not necessarily want to make them available for public consumption.
If you are a consultant then having your own personal NuGet Gallery may be a handy way to keep your libraries and utilities accessible to you when you are on the road. This is an great way to utilize your home broadband connection.

Last year I wrote an article about how to Build a NuGet Server with gold plating. At the time, there were two methods for hosting your own NuGet feed. The first option was to install the Orchard-based NuGet Gallery. I personally stayed away from this option because setting up an entire CMS just to host a few small NuGet packages seemed like overkill to me. The second option was to create an empty ASP.NET MVC site and install a few NuGet packages from Phil Haack that turned your empty website into a NuGet server. I call the second option the recursive NuGet server because you install NuGet packages which in turn help you to create a NuGet server. Anyway, if you compare the features of the Orchard Nuget Gallery to the recursive NuGet server, you will instantly notice that the Orchard version had a lot more functionality. Unfortunately, at the time I still could not justify setting up an entire CMS just to get a few small features.

Eventually someone on the NuGet team realized that having the gallery so tightly coupled with Orchard was probably not a good idea. So sometime late last year, the NuGet gallery was removed from Orchard which made the setup process a lot less complex. Unfortunately the documentation page for Setting Up a Local NuGet Gallery has not been updated yet and still reflects the steps for creating the Orchard-based gallery. Since I recently setup a NuGet server at the office I decided to document the new steps in order to save you some trouble.

Download the latest source from GitHub. I just grabbed the zip file since I do not have a Git client on my machine.
Extract the zip file and navigate to the Website subdirectory. Locate the web.config file and open it up in your favorite editor. Inside the web.config you will want to change the following options:
1. Modify the configuration/connectionStrings/NuGetGallery key so it points to your locally hosted SQL Server.
2. Change the appSettings/GalleryOwnerEmail to the email address of the person who is going to administer the site.
3. Change the appSettings/Configuration:SiteRoot to reflect the domain name you are going to use for the site.
Run the Build-Solution.ps1 script using Powershell in the root directory. This will compile the website and assemble the binaries.
Open up your IIS Manager
1. Create a new application pool. The pool should use the 4.0 framework and use an integrated pipeline. Please pay careful attention to the Identity of the pool because you will need to grant this account permissions to your SQL Server.
2. Create a new website. Set the site’s physical path to point at the Website directory. Also make sure the site uses the application pool that you created in the previous step. Do not start the website yet.
Open up SQL Server Management Studio
1. Grant db_creator to the identity of the application pool you created earlier. The account needs db_creator because the first time you run the applicaton, the Entity Framework context initializer will run. If no database exists yet then it will create the database for you. After, the database is created you can trim back the permissions to db_datareader and db_datawriter. This tends to make your DBA happy.
Start your website and launch the browser of your choice. In the browser, navigate to the NuGet server. It may take a second or two for the page to appear because the database needs to get created during the first run.

If you followed the steps properly then you should see the following page:

Getting Started With The Arduino

Tue, 31 Jan 2012 09:21:00 -0100

As an engineer, I constantly feel the need to learn new things in order to keep the "saw sharp". Since I write code for a living, I often feel dissatisfied by the notion that everything I create is "virtual". The only way to interact with the things that I create are with a keyboard and mouse. The thought of this often makes me wonder if I would have been happier in a profession where I built things with my hands. People tend to appreciate things more that they can hold and physically interact with. So naturally, this led me to the idea of "How can I make software take on a more physical presence?". Of course I immediately thought of robotics, so I typed the term "robotics" into Google and I discovered the term "Physical Computing". According to Wikipedia, the definition of physical computing is:

Physical computing, in the broadest sense, means building interactive physical systems by the use of software and hardware that can sense and respond to the analog world. While this definition is broad enough to encompass things such as smart automotive traffic control systems or factory automation processes, it is not commonly used to describe them. In the broad sense, physical computing is a creative framework for understanding human beings' relationship to the digital world. In practical use, the term most often describes handmade art, design or DIY hobby projects that use sensors and microcontrollers to translate analog input to a software system, and/or control electro-mechanical devices such as motors, servos, lighting or other hardware.

Immediately after reading about physical computing I was intrigued by the idea so I decided to learn more about the different kinds of microcontroller that are available on the market. Of course, since I am a .NET Developer I already knew about the Netduino. The Netduino is a microcontroller that runs the .NET micro framework and you can use Visual Studio to create sketches. Although this sounded cool I decided that 40+ hours a week in Visual Studio is more than enough for me. Therefore, I opted to go with the Arduino platform instead. The Arduino programming language is a implementation of Wiring, a physical computing platform, which is based on the Processing multimedia programming environment. With the combination of some basic electronics skills and the Arduino you can create almost anything. If you search online you will find all kinds of Arduino based projects which include clocks, weather stations, robots and even 3d printers! To make a long story short I ended up ordering the SparkFun inventor's kit. The kit includes an Arduino Uno R3, some basic components and a step-by-step guide on how to use each one. If you are starting from scratch like me and you have no prior experience with electronics then I strongly recommend buying a kit. The manual that comes with the SparkFun Kit is very well done and of course there are a large community of Arduino developers willing to help if you get stuck.

After you make it through all the tutorials in the kit you will probably lay awake at night just thinking of the possibilities. In addition, you will probably drop some cash because on a bigger breadboard, a multimeter and a soldering station. Anyways, just to whet your appetite here are some examples of things that you can do with an Arduino:

RGB LEDs controlled by an Arduino and sequenced with Flash.

Arduino Robot using a Adafruit motor shield, 2x Sharp IR sensors, one PING sensor and an XPAL XP8000 battery.

And finally, a 3D Printer from MakerBot. Yes, I said 3D Printer! Apparently, this uses a Arduino MEGA under the covers.

In the upcoming months you can expect to see some Arduino and electronics based articles appearing on my blog. Perhaps even an article about how I built my first robot!

Getting Assembly Information Using Reflection

Tue, 03 Jan 2012 17:37:47 -0100

I recently took over a WPF application that needed a little bit of refactoring. One of the places that had a lot of repeated code was the about screen. By using reflection a bunch of properties were being created to display things like the assembly title, version, description and etcetera. The original code looked like this:

public string AssemblyDescription
{
    get
    {
        object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false);
        if (attributes.Length == 0)
        {
            return "";
        }
        return ((AssemblyDescriptionAttribute)attributes[0]).Description;
    }
}

public string AssemblyProduct
{
    get
    {
        object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false);
        if (attributes.Length == 0)
        {
            return "";
        }
        return ((AssemblyProductAttribute)attributes[0]).Product;
    }
}

You may have noticed that this code does not follow the DRY principle. In case you arent familiar with the term, DRY stands for Don't repeat yourself. In otherwords, if you repeat the same code multiple times then you should try to refactor it into a more generic method.

After analyzing the code you may notice that both of the property getters do the same thing. First, it gets a handle to the current assembly. Next, the GetCustomAttributes method is called to get an object array which contains all the attribute values for a given type. Finally, a little bit of conditional logic is used to emit a value. Using the power of generics and some reflection we can easily build an extension method that will eliminate the redundant code.

Warning: If you are not familiar with generics, reflection and lambda statements then the following code may cause your brain to explode

public static TAttribute[] GetAttributes<TAttribute>(this Assembly assembly) where TAttribute : Attribute {
    return assembly.GetCustomAttributes(typeof(TAttribute), false) as TAttribute[];
}

public static object GetFirstAttributeValue<TAttribute>(
    this Assembly assembly,
    Expression<Func<TAttribute, object>> propertyLambda) where TAttribute : Attribute {
    Type type = typeof(TAttribute);

    var attributeValues = assembly.GetAttributes<TAttribute>();
    if (attributeValues.Length == 0)
        throw new ArgumentException("No values found");

    var member = propertyLambda.Body as MemberExpression;
    if (member == null)
        throw new ArgumentException(string.Format("Expression '{0}' refers to a method, not a property.", propertyLambda));

    var propInfo = member.Member as PropertyInfo;
    if (propInfo == null)
        throw new ArgumentException(string.Format("Expression '{0}' refers to a field, not a property.", propertyLambda));

    if (type != propInfo.ReflectedType && !type.IsSubclassOf(propInfo.ReflectedType))
        throw new ArgumentException(string.Format("Expresion '{0}' refers to a property that is not from type {1}.", propertyLambda, type));

    var firstValue = attributeValues[0];
    return propInfo.GetValue(firstValue, null);
}

The code above basically takes the lambda statement, makes sure its a property expression and then uses reflection to get the value of the object. By the way, I do not take credit for writing the reflection code, most of it was borrowed from this stackoverflow post. In any case, with the help of the extension method above we can now simplify our code as:

private Assembly Assembly { get; set; }

public AboutViewModel()
{
    Assembly = Assembly.GetExecutingAssembly();
}

public string AssemblyDescription {
    get {
        return Assembly.GetFirstAttributeValue<AssemblyDescriptionAttribute>(x => x.Description).ToString();
    }
}

public string AssemblyProduct {
    get {
        return Assembly.GetFirstAttributeValue<AssemblyProductAttribute>(x => x.Product).ToString();
    }
}

As you can see, the code is much cleaner. Also take notice that I cached the call to Assembly.GetExecutingAssembly() in a private variable. This helps with performance and also cleans up the code a little.

Happy Coding!