.Net Musings

This blog has moved (Finally)!

2009-09-07T11:36:00.002-04:00

I finally did it. I set up my own hosted site using .NET Blog Engine. The new site is http://www.skimedic.com/blog.

All of my previous posts have been moved, and I have a new feed burner link: http://feeds.feedburner.com/skimedic

Why did I move? For control. I wanted to have separate pages hosting abstracts, sample code, etc, and I didn't want to have to maintain separate web sites.

Why skimedic.com? Well, japikse.com was taken (by a cousin of mine), and nobody can spell my name anyway. :-)

So, look for all of these posts over at the new home, and lots more goodness to come! :-)

As always,

Happy Coding!

Multi-value Error Conditions with IDataErrorInfo

2009-07-26T14:26:00.001-04:00

Technorati Tags: WPF,C#,Visual Studio 2008,Smart Client

In my last post on IDataErrorInfo, we implemented the interface and created a custom template for showing the errors. That works very well for single-valued error checking. But what if the business logic is conditional (if Field A = x, Field B must be >= y)? That implementation falls down. The reason is that WPF only checks the error condition when the PropertyChanged event fires. The solution is very simple, but does potentially come with a cost.

To illustrate this, we need to update our Product class to include a SalePrice property:

private decimal _salePrice;
public decimal SalePrice
{
    get { return _salePrice; }
    set
    {
        if (_salePrice == value) return;
        _salePrice = value;
        onPropertyChanged(FieldNames.SalePrice);
    }
}

The business (albeit the one in my head :-)) has decided if the inventory gets to be over 50 units, then the item must be marked down 10%, but if the count < 50, it should not be marked down at all. So the following code is introduced to enforce this rule:

case FieldNames.SalePrice:
    if (Inventory > 50 && SalePrice > (Price*.9M))
    {
        return ModelName + " must be marked down due to stock quantity greater than 50";
    }
    if (Inventory < 50 && SalePrice != Price)
    {
        return ModelName + " must not be marked down if the quantity is less than 50";
    }
    break;

When we run the form and update the Inventory to 51, we don’t get any error indication unless we also update the Sale Price.

We need the PropertyChanged event to fire for the SalePrice property. But, if we were to add a line in the Inventory and/or Price validations to raise the event, we could end up with an infinite loop as they refer back to each other.

Fortunately, the solution is simple. If we raise the event without a property name in the even arguments, WPF will check all of the properties to see if they have changed. The cost here is that a lot of potentially needless checking is occurring, so you will have to make a decision if this solution works for you (we will explore other options in future posts).

Change the event raiser so that string.empty is passed into the even arguments, and the form works as expected.

private void onPropertyChanged(Enum fieldName)
{
    if (PropertyChanged != null)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(string.Empty));
    }
}

Happy Coding!

IDataErrorInfo, Error Templates and WPF

2009-07-15T17:10:00.001-04:00

Technorati Tags: WPF,XAML,Smart Client,C#,IDataErrorInfo,Custom Error Templates

Another gem of WPF is the ability to poll a data bound item for errors. This is done by implementing IDataErrorInfo in your entities (support was added into WPF in .NET 3.5).

The interface adds a string property “Error” and a string indexer. The indexer accepts a property name and returns the error detail. A simple implementation for the indexer for our Product class (continued from my previous posts in this WPF series) follows:

public string this[string columnName]
{
    get
    {
        var field = (FieldNames) Enum.Parse(typeof (FieldNames), columnName);
        switch (field)
        {
            case FieldNames.Inventory:
                if (Inventory < 0)
                {
                    return "Inventory can not be less than zero";
                }
                break;
            case FieldNames.ModelName:
                if (ModelName.Contains("XXX"))
                {
                    return "Our Store does not support adult content.";
                }
                break;
            case FieldNames.Price:
                if (Price < 0)
                {
                    return "Price can not be less than zero";
                }
                break;
            default:
                break;
        }
        return string.Empty;
    }
}
public string Error
{
    get { throw new NotImplementedException(); }
}

The key to the indexer is the string value that is returned. If the returned value is string.Empty or null, there is no error. Otherwise an error condition exists. In my simple example, the code considers a negative Inventory or Price to be an error condition, along with finding “XXX” in the ModelName.

To have the WPF Window display an error condition simply add the ValidatesOnDataErrors=true attribute to the binding. This uses the default error skin (thin red border) to graphically show the error condition. The updated XAML for the Inventory Text Box is updated to this:

<TextBox Grid.Row="3" Grid.Column="1" Margin="1,1,1,1" HorizontalAlignment="Stretch"
     Text="{Binding ElementName=ProductSelector, Path=SelectedItem.Inventory, ValidatesOnDataErrors=true}" />

The resulting UI appearance shown with a negative Inventory value is shown here:

If you need more information supplied to the user, you don’t have to use the default error template. The thin red line doesn’t convey enough information to the user, and is more detrimental than beneficial. At a minimum, the tool tip for the control needs to be set to the error text, and a more visual indicator that there is an issue.

To do this, we are going to create a style that replaces the default error template. The sample here only applies to Text Boxes, but can be simply extended for other controls.

To set the ToolTip for the control, we use a Style Trigger that will be activated when the Validation.HasError property is true (this property is a benefit of IDataErrorInfo). The Binding expression refers back to itself, and in the Path, we need to surround Validation.Errors in parentheses to indicate that it’s an attached property as opposed to a property of the TextBox.

<Style.Triggers>
    <Trigger Property="Validation.HasError" Value="true">
        <Setter Property="ToolTip"
          Value="{Binding RelativeSource={x:Static RelativeSource.Self},
          Path=(Validation.Errors)[0].ErrorContent}"/>
    </Trigger>
</Style.Triggers>

The complete style (shown in the next code block) adds the red border and the asterisk as a replacement for Validation.ErrorTemplate, the default error template.

<Style TargetType="{x:Type TextBox}">
    <Setter Property="Validation.ErrorTemplate">
        <Setter.Value>
            <ControlTemplate>
                <DockPanel LastChildFill="True">
                    <TextBlock DockPanel.Dock="Right" 
                       Foreground="Red"
                       FontSize="14pt" 
                       Margin="-15,0,0,0" FontWeight="Bold">*
                    </TextBlock>
                    <Border BorderBrush="Red" BorderThickness="1">
                        <AdornedElementPlaceholder Name="controlWithError"/>
                    </Border>
                </DockPanel>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
    <Style.Triggers>
        <Trigger Property="Validation.HasError" Value="true">
            <Setter Property="ToolTip"
                Value="{Binding RelativeSource={x:Static RelativeSource.Self},
                Path=(Validation.Errors)[0].ErrorContent}"/>
        </Trigger>
    </Style.Triggers>
</Style>

The ErrorTemplate resides in the Adorner layer. This allows for creating templates that appear to change the control being adorned. By adding an additional border (with a Background=”Red” Opacity=”0.2”), we can create the look below, which is much more pronounced.

When the additional border with a background is added, the ToolTip on the TextBox never displays since the adorner captures the hover. To solve this, we move the ToolTip to the DockPanel in the ErrorTemplate. We now reference the name we gave the AdornedElementPlaceholder in our binding, and the ToolTip is back.

<Style TargetType="{x:Type TextBox}">
    <Setter Property="Validation.ErrorTemplate">
        <Setter.Value>
            <ControlTemplate>
                <DockPanel LastChildFill="True" 
                           ToolTip="{Binding ElementName=controlWithError,Path=AdornedElement.(Validation.Errors)[0].ErrorContent}">
                    <TextBlock DockPanel.Dock="Right" 
                       Foreground="Red"
                       FontSize="14pt" 
                       Margin="-15,0,0,0" FontWeight="Bold">*
                    </TextBlock>
                    <Border BorderBrush="Red" BorderThickness="1">
                    <Border Background="Red" Opacity="0.2">
                        <AdornedElementPlaceholder Name="controlWithError"/>
                    </Border>
                    </Border>
                </DockPanel>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Updated 7/26/2009

There is an issue with the XAML above, in that the mouse clicks are swallowed by the Borders, and the text box doesn’t receive them. The solution to this is simple, and that is combining the Validation.ErrorTemplate property setter with Style Triggers. The corrected XAML is below:

<Style TargetType="{x:Type TextBox}">
    <Style.Triggers>
        <Trigger Property="Validation.HasError" Value="true">
            <Setter Property="Background" Value="Pink"/>
            <Setter Property="Foreground" Value="Black"/>
        </Trigger>
    </Style.Triggers>
    <Setter Property="Validation.ErrorTemplate">
        <Setter.Value>
            <ControlTemplate>
                <DockPanel LastChildFill="True" 
                   ToolTip="{Binding ElementName=controlWithError,Path=AdornedElement.(Validation.Errors)[0].ErrorContent}">
                    <TextBlock DockPanel.Dock="Right" 
                       Foreground="Red"
                       FontSize="14pt" 
                       Margin="-15,0,0,0" FontWeight="Bold">*
                    </TextBlock>
                    <Border BorderBrush="Red" BorderThickness="1">
                    <AdornedElementPlaceholder Name="controlWithError" />
                    </Border>
                </DockPanel>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

In my next post, we look at evaluating error conditions based on multiple properties.

Happy Coding!

INotifyCollectionChanged (Observable Collections) and WPF

2009-07-12T21:46:00.001-04:00

Technorati Tags: WPF,C#,XAML,INotifyCollectionChanged,ObservableCollection

In my previous post (MultiBinding and Command Parameters in WPF), I discussed how you can pass multiple values into a CommandParameter. In this post, In this post, we will make sure the User Interface get’s updated when the Collection changes (items are added or removed), and will need MultiBindings to keep the View Model clean. If you haven’t yet implement INotifyPropertyChanged on your entities, see my previous post on INotifyPropertyChanged and WPF.

We want our ComboBox (or any list control, for that matter) to accurately display the list of items in the collection when said collections change. We get this functionality by implementing INotifyCollectionChanged (we get this out of the box with the ObservableCollection collection class, but we are going to implement it by hand first). But before we jump into coding, lets create the framework and the failing test (albeit a UI test).

To do this, we are going to start with the Add Product functionality. This will build on the previous MultiBinding from the Update Price command, and leverage the same Parameter and MultiValueConverter classes. We first refactor the XAML to move the resource definition to the Window as shown here:

<Window.Resources>
    <ViewModels:ChangeNotificationMultiConverter x:Key="ChangeNotificationMultiConverter"/>
</Window.Resources>

We also need to refactor the ChangeNotificationParameter class to include another property for the List itself. I chose to add another property instead of create a new parameter class since we will be needing all of the fields for the Delete implementation. The new code is shown here:

public class ChangeNotificationParameter
{
    public ContentControl CallBackControl { get; set; }
    public Product Prod { get; set; }
    public IList<Product> Products { get; set; }
}

The last refactoring we need to conduct is in the MultiValueConverter itself to take advantage of the new property.

The XAML for the new button (placed in the StackPanel with the Update Price button) looks like this (passing in the Products List from the View Model and the Label from the Window):

<Button Margin="3" Content="Add Product"
                    Command="{Binding Path=AddProductCmd}">
    <Button.CommandParameter>
        <MultiBinding Converter="{StaticResource ChangeNotificationMultiConverter}">
            <MultiBinding.Bindings>
                <Binding Path="Products" />
                <Binding ElementName="CurrentValue" />
            </MultiBinding.Bindings>
        </MultiBinding>
    </Button.CommandParameter>
</Button>

The final implementation is for the AddProductCommand, shown here:

private class AddProductCommand : ICommand
{
    public void Execute(object parameter)
    {
        var p = parameter as ChangeNotificationParameter;
        if (p == null || p.Products == null) return;
        p.Products.Add(new Product { ID = 20, ModelName = "New Model", Inventory = 20, Price = 20M, SKU = "1234567890" });
        if (p.CallBackControl != null)
        {
            p.CallBackControl.Content = p.Products.Count.ToString();
        }
    }
    public bool CanExecute(object parameter)
    {
        return true;
    }
    public event EventHandler CanExecuteChanged;
}

When we run the app, we see that we have two items in the ComboBox (our two hardcoded products). Clicking the Add Product button adds a product (confirmed by the label), but our ComboBox still shows only two items.

To enable the hook up of the notifications, we need to create a custom class that implements INotifyPropertyChanged. We also want to keep our list as an IList<Product> (our current implementation).

I first create an interface with both interfaces included. In this manner, I can still code to an interface instead of concrete classes.

public interface IProductList:IList<Product>,INotifyCollectionChanged {}

Now for the class itself. I chose to use the Decorator pattern, since it provided the least friction. There is still a bit of code to write, but less than other options I considered. The entire class is shown here:

public class ProductList:IProductList
{
    private readonly IList<Product> _products;
    public ProductList(IList<Product> products)
    {
        _products = products;
    }
    public IEnumerator<Product> GetEnumerator()
    {
        return _products.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public void Add(Product item)
    {
        _products.Add(item);
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add,item));
    }
    public void Clear()
    {
        _products.Clear();
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
    public bool Contains(Product item)
    {
        return _products.Contains(item);
    }
    public void CopyTo(Product[] array, int arrayIndex)
    {
        _products.CopyTo(array, arrayIndex);
    }
    public bool Remove(Product item)
    {
        var removed = _products.Remove(item);
        if (removed)
        {
            notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove,item));
        }
        return removed;
    }
    public int Count
    {
        get { return _products.Count; }
    }
    public bool IsReadOnly
    {
        get { return _products.IsReadOnly; }
    }
    public int IndexOf(Product item)
    {
        return _products.IndexOf(item);
    }
    public void Insert(int index, Product item)
    {
        _products.Insert(index, item);
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
    public void RemoveAt(int index)
    {
        _products.RemoveAt(index);
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
    public Product this[int index]
    {
        get { return _products[index]; }
        set
        {
            _products[index] = value;
            notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace,_products[index]));
        }
    }
    public event NotifyCollectionChangedEventHandler CollectionChanged;
    private void notifyCollectionChanged(NotifyCollectionChangedEventArgs args)
    {
        if (CollectionChanged != null)
        {
            CollectionChanged(this, args);
        }
    }
}

For each of the methods that alter the collection, we need to raise the CollectionChanged event. This event has a custom Event Arguments class that takes in its constructor an enumeration of the change that took place (Add, Move, Replace, Reset, or Remove). (One could argue whether it makes sense to make specific action calls or always declare the action as Reset, but that isn’t the purpose of this post.)

The ViewModel needs to be changed to utilize the new collection class. The altered code is shown here:

public ChangeNotificationViewModel()
{
    Products = new ProductList(new ProductService().GetProducts());
}
public ChangeNotificationViewModel(IList<Product> products)
{
    Products = new ProductList(products);
}
public IProductList Products { get; set; }

Now when you click to Add Product, the list automatically shows the new product.

Now, to do it the easy way! Change the ViewModel code to use an Observable Collection, and you can eliminate the entire custom class!

public ChangeNotificationViewModel()
{
    Products = new ObservableCollection<Product>(new ProductService().GetProducts());
}
public ChangeNotificationViewModel(IEnumerable<Product> products)
{
    Products = new ObservableCollection<Product>(products);
}
public IList<Product> Products { get; set; }

Much simpler!

In my next post, we take a look into IDataErrorInfo and Error Templates in WPF.

Happy Coding!

MultiBinding and Command Parameters in WPF

2009-07-12T16:42:00.001-04:00

Technorati Tags: WPF,MultiBinding,CommandParameter,XAML,C#

In my previous post (INotifyPropertyChanged and WPF), I discussed how WPF can detect when the values of properties change. In that post, I fired off a Message Box from the View Model, and commented that you shouldn’t do this. However, I didn’t expound on how to work around this. In this post, I am going to show how we can pass multiple values into the Command as the Command Parameter so we can interact with the user through the View with a much cleaner implementation.

Instead of a message box, we are going to add a label to the form that will display the current price of the Product. When we update the price, the label gets updated with the current price of the product displayed. Note the it isn’t bound to anything in the product, it is purely a UI item. The finished product will look like this (with the INotifyPropertyChanged event handler NOT getting fired):

The XAML changes for the label are minor. We add an additional RowDefinition to the table, and in that row, add two label controls. One for the actual “Label” and the other to hold the price.

The changes for the Button allow us to pass in the multiple parameters into the CommandParameter. To implement this, we need to execute the following steps:

Create a class to hold our parameters. This is due to the fact that the Execute method of the ICommand interface allows for only a single object. I create custom classes to give type safety to my code and therefore a cleaner implementation.
Create a class that implements IMultiValueConverter. This converts our multiple parameters into the class that we created in step 1.
Change the XAML for the button to use a MultiBinding instead of a single binding.
Change the Execute method of the ICommand implementation to use this new parameter type.

The Parameter class is very straightforward, having two properties. One is for the product that is the target of the invocation, and the other is for the UIElement that will receive the updated value for display to the user. I typed the UIElement as a ContentControl to allow for more re-use instead of typing it as a Label. I don’t have any other uses currently, and some would argue YAGNI (you ain’t gonna need it) here, but the code is still very clear, so I opted for the less specific implementation.

public class ChangeNotificationParameter
{
    public ContentControl CallBackControl { get; set; }
    public Product Prod { get; set; }
}

To implement IMultiValueConverter, create a new class. There are two methods in the interface, Convert and ConvertBack. For this use case we only need to implement Covert. The first parameter to the Convert method is an array of objects that are the binding values set in the XAML of the control on the Window. There are several other parameters that we won’t need to worry about here, but will be discussed in a later post.

A new ChangeNotificationParameter is created, and it’s properties are set in the Convert method. I iterate through the list of objects, checking their type, and then correctly assign the properties of the parameter class. Again, one could argue that you know the order of the parameters set in the XAML, but I opt for a more defensive stance in case the order isn’t guaranteed. The return value of the method is what gets passed into the Execute method if the ICommand implementation.

public class ChangeNotificationMultiConverter : IMultiValueConverter
{
    public object Convert(
        object[] values, 
        Type targetType, 
        object parameter, 
        System.Globalization.CultureInfo culture)
    {
        var param = new ChangeNotificationParameter();
        foreach (var obj in values)
        {
            if (obj is Product)
            {
                param.Prod = obj as Product;
            }
            if (obj is ContentControl)
            {
                param.CallBackControl = obj as ContentControl;
            }
        }
        return param;
    }
    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

To wire up the XAML to take advantage of this class, we have to do a few tasks. First, add a namespace reference to where your MultiValueConverter’s namespace. This is done at the top of the Window in the <Window element>. This element now looks like this (assuming your namespace is “WPF.ViewModels”:

<Window x:Class="WPF.Views.ChangeNotification"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:ViewModels="clr-namespace:WPF.ViewModels"
    Title="Change Notification" Height="235" Width="300">

Next, we remove the CommandParameter attribute and include the <Button.CommandParameter> element. This contains the <MultiBinding> element, which has the “Converter” attribute. The Window needs to know where it can find the type of the converter, so we need to add the type as a resource. I chose to add it to the button to make this post easier to read, but convention usually dictates resources are added at the Window level to allow reuse and readability. Under the MultiBinding.Bindings element, we add a <Binding> element for each parameter that we need to pass into the command. In this case the SelectedItem from the ProductSelector ComboBox (to get the current Product) and the Label “CurrentPrice”.

<Button Margin="3" Content="Update Price" 
        Command="{Binding Path=UpdatePriceCmd}">
    <Button.Resources>
        <ViewModels:ChangeNotificationMultiConverter x:Key="ChangeNotificationMultiConverter"/>
    </Button.Resources>
    <Button.CommandParameter>
        <MultiBinding Converter="{StaticResource ChangeNotificationMultiConverter}">
            <MultiBinding.Bindings>
                <Binding ElementName="ProductSelector" Path="SelectedItem" />
                <Binding ElementName="CurrentPrice" />
            </MultiBinding.Bindings>
        </MultiBinding>
    </Button.CommandParameter>
</Button>

The final change is to the PriceUpdaterCommand to utilize the new parameter. The updated Execute is shown below (with some guards thrown in for safety).

private class PriceUpdaterCommand : ICommand
{
    public void Execute(object parameter)
    {
        var p = parameter as ChangeNotificationParameter;
        if (p == null || p.Prod == null) return;
        p.Prod.Price *= 1.1M;
        if (p.CallBackControl != null)
        {
            p.CallBackControl.Content = p.Prod.Price.ToString();
        }
    }
    public bool CanExecute(object parameter)
    {
        return true;
    }
    public event EventHandler CanExecuteChanged;
}

In this way we’ve gotten rid of that nasty MessageBox call in the initial implementation, and extended our capabilities significantly. We will use this pattern in the next segment, which dives into INotifyCollectionChanged.

Happy Coding!

INotifyPropertyChanged and WPF

2009-07-11T10:05:00.001-04:00

Technorati Tags: WPF,Smart Client,C#,.NET,XAML

Windows Presentation Foundation provides a lot of “Out Of The Box” features that greatly enhance the development and user experience. One of these is the auto-hookup of the INotifyPropertyChanged. What does this mean? It means that if the data that you bind to in you WPF changes (and correctly implements INotifyPropertyChanged), it will be reflected in the user interface auto-magically!

To demonstrate this, we will create a very simple Product class.

public class Product
{
    public int ID { get; internal set; }
    public string ModelName { get; set; }
    public string SKU { get; set; }
    public decimal Price { get; set; }
    public int Inventory { get; set; }
}

Since we don’t want to bind directly to the model classes, we will create a (again, very simple) View Model to bind our window to.

public class ChangeNotificationViewModel
{
    public ChangeNotificationViewModel()
    {
        //TODO: Get From Service or Datastore
        Products = new ProductService().GetProducts();
    }
    public ChangeNotificationViewModel(IList<Product> products)
    {
        _products = products;
    }
    private IList<Product> _products;
    public IList<Product> Products
    {
        get { return _products; }
        set { _products = value; }
    }
    private ICommand _updatePrice;
    public ICommand UpdatePriceCommand
    {
        get
        {
            if (_updatePrice == null)
            {
                _updatePrice = new PriceUpdater();
            }
            return _updatePrice;
        }
        set { _updatePrice = value; }
    }
    private class PriceUpdater :ICommand
    {
        public void Execute(object parameter)
        {
            var p = parameter as Product;
            if (p == null) return;
            p.Price *= 1.1M;
        }
        public bool CanExecute(object parameter)
        {
            return true;
        }
        public event EventHandler CanExecuteChanged;
    }
}

A couple things to point out about the view model.

We use Dependency Injection in one constructor to take an IList<Product>. This allows us to better test our view model, and opens up the door for several different methods of getting the constituted data into the View Model.
The internal constructor is in place to get some initial data as we are spiking up the Window so we reduce complexity.
The only real code that the WPF Window cares about is the Products and the UpdatePriceCommand properties, as that is what the Window will bind to.
This is a very rudimentary implementation of the Command Pattern. I will enhance this in a future blog post as the application gets flushed out into a true MVVM implementation. Typically firing off a UI specific item like a MessageBox is not a good idea in the View Model, but it is here to demonstrate the INotifyPropertyChanged concept that this post is focusing on.

Now let’s get a very simple WPF Window coded up to display the data. The ComboBox allows for the selection of the product, and once one is selected, the text boxes are populated with the values for the product. The Window that we create looks like this:

And the XAML for the window looks like this:

<Window x:Class="WPF.Views.ChangeNotification"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Change Notification" Height="200" Width="300">
    <Grid Grid.IsSharedSizeScope="True">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <Grid Grid.Row="0" Grid.Column="0" HorizontalAlignment="Stretch" Height="Auto">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" SharedSizeGroup="Label"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>
            <Label Grid.Row="0" Grid.Column="0" Margin="0,0,1,0" HorizontalAlignment="Right">Products:</Label>
            <ComboBox Name="ProductSelector" Grid.Row="0" Grid.Column="1" Margin="2,1,2,1"
                      ItemsSource="{Binding Path=Products}"
                      DisplayMemberPath="ModelName"/>
        </Grid>
        <Grid Grid.Row="1" Grid.Column="0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" SharedSizeGroup="Label"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>
            <Label Grid.Row="0" Grid.Column="0" Margin="0,0,1,0" HorizontalAlignment="Right">ModelName:</Label>
            <TextBox Grid.Row="0" Grid.Column="1" Margin="1,1,1,1" HorizontalAlignment="Stretch"
                     Text="{Binding ElementName=ProductSelector, Path=SelectedItem.ModelName}"></TextBox> 
            <Label Grid.Row="1" Grid.Column="0" Margin="0,0,1,0" HorizontalAlignment="Right">SKU:</Label>
            <TextBox Grid.Row="1" Grid.Column="1" Margin="1,1,1,1" HorizontalAlignment="Stretch"
                     Text="{Binding ElementName=ProductSelector, Path=SelectedItem.SKU}"></TextBox>
            <Label Grid.Row="2" Grid.Column="0" Margin="0,0,1,0" HorizontalAlignment="Right">Price:</Label>
            <TextBox Grid.Row="2" Grid.Column="1" Margin="1,1,1,1" HorizontalAlignment="Stretch"
                     Text="{Binding ElementName=ProductSelector, Path=SelectedItem.Price}"></TextBox>
            <Label Grid.Row="3" Grid.Column="0" Margin="0,0,1,0" HorizontalAlignment="Right">Inventory:</Label>
            <TextBox Grid.Row="3" Grid.Column="1" Margin="1,1,1,1" HorizontalAlignment="Stretch"
                     Text="{Binding ElementName=ProductSelector, Path=SelectedItem.Inventory}"></TextBox>
        </Grid>
        <StackPanel Grid.Row="2" Grid.Column="0">
            <Button Content="Update Price" 
                    Command="{Binding Path=UpdatePriceCommand}" 
                    CommandParameter="{Binding ElementName=ProductSelector, Path=SelectedItem}">
            </Button>
        </StackPanel>
    </Grid>
</Window>

Clicking on the Button increases the price of the currently selected product by 10%, then shows the new price in a message box. However, the data bound text box doesn’t change the Price text to reflect the updated price.

This is where in WinForms we would need to add event handlers or other types of call backs to make sure the UI accurately reflects the state of the data when a change occurs. In WPF, however, we merely need to correctly implement INotifyPropertyChanged and it all gets wired up automagically!

To implement the pattern, we need to change all properties that we care about from auto properties to properties with backing fields. This is so we can raise the NotifyPropertyChanged event in the setter. The INotifyPropertyChanged interface consists of one event (PropertyChanged). The event arguments (PropertyChangedEventArgs) has one property that gets set in the constructor, and that is the property name that changed. WPF will then poll its bindings to look for anything bound to that property and requery the data context for the current value.

public event PropertyChangedEventHandler PropertyChanged;
private void onPropertyChanged(string fieldName)
{
   if (PropertyChanged != null)
   {
       PropertyChanged(this,new PropertyChangedEventArgs(fieldName));
   }
}

The first issue I have with this implementation is that we need to pass in a string for the property name, which can lead to run time errors if the properties change in our entity but the “magic strings” don’t get updated in our code. If you have good test coverage, then this will get caught in development, but additionally, I create an enumeration of all of the properties on the entity, and pass the enumerated value into event raiser. The enumeration get updated each time I regenerate my entities from the data base (I use CodeSmith templates), so I get compile time checking for my property names. Here is the code for the Product class refactored:

public class Product : INotifyPropertyChanged
{
    public enum FieldNames
    {
        ID,
        ModelName,
        SKU,
        Price,
        Inventory
    }
    private int _id;
    public int ID
    {
        get { return _id; }
        set
        {
            if (_id == value) return;
            _id = value;
            onPropertyChanged(FieldNames.ID);
        }
    }
    private string _modelName;
    public string ModelName
    {
        get { return _modelName; }
        set
        {
            if (_modelName == value) return;
            _modelName = value;
            onPropertyChanged(FieldNames.ModelName);
        }
    }
    private string _sku;
    public string SKU
    {
        get { return _sku; }
        set
        {
            if (_sku == value) return;
            _sku = value;
            onPropertyChanged(FieldNames.SKU);
        }
    }
    private decimal _price;
    public decimal Price
    {
        get { return _price; }
        set
        {
            if (_price == value) return;
            _price = value;
            onPropertyChanged(FieldNames.Price);
        }
    }
    private int _inventory;
    public int Inventory
    {
        get { return _inventory; }
        set
        {
            if (_inventory == value) return;
            _inventory = value;
            onPropertyChanged(FieldNames.Inventory);
        }
    }
    public event PropertyChangedEventHandler PropertyChanged;
    private void onPropertyChanged(Enum fieldName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this,new PropertyChangedEventArgs(fieldName.ToString()));
        }
    }
}

There are a couple of items missing from this implementation that will be discussed in a future post:

IsNew: This is a calculated field that indicates if the entity is transient (has not yet been persisted)
IsDirty: This is also a calculated field that indicate if the entity has been updated (the onPropertyChanged method sets the property)
INotifyCollectionChanged: This interface allows for WPF to update elements bound to collections when the collection changes

In my next post I get rid of the MessageBox and show MultiBindings for CommandParameters.

Happy Coding!

NDepend - a Quick Review

2009-06-17T17:57:00.001-04:00

Technorati Tags: NDepend,Code Quality,Code Metrics

I finally got around to test driving NDepend today, and I must say it’s pretty slick. I’m sure there is a ton more stuff it can do than what I’ve found so far, but here is a quick synopsis…

Starting it up is easy, simply start a new project or select “Analyze a set of .NET assemblies”. Once that is done, however, the main screen can be a bit overwhelming. (TIP: Watch the videos on the NDepend site http://www.ndepend.com/GettingStarted.aspx) However, if you want to dive right in, hopefully this will help. Actually, it’s pretty cool.

To get started, fire up VisualNDepend.exe. When you create a new project, there is an option to Add Assemblies of a Visual Studio Solution.

This will load all of your application assemblies on the left and your dependent assemblies on the right (including the requisite system assemblies).

The analysis tab allows for setting up some project options (probably could be call Project Options, but it’s just semantics). The cool stuff here is if you run NCover like I do, you can specify the coverage file so you get it all in the analysis.

Once setup, click “Run Analysis”. This loads up a web page with the summary, but also gets you to the screen shown here (admittedly hard to read):

Here’s the key for me. Focus on the CQL section at the bottom (highlighted in the red box). This is a list of queries for your code. The out of the box groups are:

Code Quality (14 sub queries)
Design (17 sub queries)
Unused Code / Dead Code (3 sub queries)
Encapsulation (16 sub queries)
Diff / Changes/ Evolution (44 sub queries)
Test Coverage (29 sub queries)
Purity / Immutability / Side-Effects (6 sub queries)
Naming Conventions (13 sub queries)
Statistics (12 sub queries)
Samples of Custom Constraints (20 sub queries)
Constraints extracted from Source Code (0 sub queries)

When you select one of the queries, you get detailed information about your code base. Here I clicked on the “Name Too Long” query, and it determined that my test names are too long. In the Metrics Matrix Window (top right) you get color coding of the code base for hits on that particular rule. Interesting graphic, but not that useful by itself, until you double click on the blue. It then loads up your code in Visual Studio! (I would prefer it to load my solution as well, but maybe that’s a setting I haven’t tweaked yet). Same goes for the list on the left referred to as the Code Tree window). Single clicking on the method name gives you additional information in the Info Viewer window just below the code tree.

As I was clicking around, I saw that several of their default rules don’t match our coding standards (e.g. the “m_” prefix rule). Fortunately, the rules are cake-easy to edit and modify for your organizations standards. Rules can be disabled and additional rules can be added as well.

So, the question I have to ask, and you should be asking yourself, is “Do I have time to code review all of the code that I should be code reviewing”. If your schedule is like mine, than the answer is “Absolutely not.” If your answer is “Yes”, then I have to ask “How do you find the time?” and “Couldn’t you be doing something more productive?”

Bottom line (for me) is this. NDepend will help find those sections of code that need a code review so you don’t have to waste time sifting through your entire codebase to do code reviews, or (worse) throwing darts at the wall to decide.

If you value your time and your code quality, get a copy, and start using it. Does it do more than this? I’m sure it does. But does it need to?

Happy Coding!

Cincinnati ORM Firestarter Registration is now open!

2009-05-21T14:17:00.001-04:00

Technorati Tags: CIncinnati .NET Users' Group,ORM Firestarter,NHibernate,Entity Framework,LINQ to SQL

It’s true! Registration for the ORM Firestarter is now open! You can register at http://tr.im/cincyorm. More information about the event can be found on the official CINNUG website http://cinnug.org/specialevents.aspx.

Registration is capped at 90, so make sure you reserve your spot quickly!

We will be serving Pizza for lunch, providing soda and water throughout the day, and have an exceptional cast of speakers coming in to get you started in NHibernate, LINQ to SQL, and the Entity Framework.

Happy coding!

Client Application Development ArcReady Slides

2009-05-12T13:16:00.001-04:00

I have been helping my Architect Evangelist for the Heartland District Brian H. Prince with this quarter’s ArcReady events, and several folks have asked me to post the slides that I used for the presentation. Most of these slides were given to me by the good folks in DPE, although I did do some modifications to the slide deck.

So, without further ado, the slides can be attained here.

Ping me if you have any questions, and as always, Happy Coding!

Technorati Tags: ArcReady,Smart Client,WPF,Silverlight

StirTrek was Awesome!

2009-05-11T09:29:00.002-04:00

Technorati Tags: StirTrek,JQuery,JSSpec,Web Development

So, it’s Monday morning, and we are all back to work. But the weekend was capped by an excellent event in Columbus, OH. I always love going to events in an around the heartland, since it gives me an opportunity to catch up with so many friends and get great content at the same time. This was no different. Well, actually it was…we got to see the new Star Trek movie. Imagine 400 geeks hanging out watching Star Trek…

Hats off to Jeff Blankenburg, Matt Casto, Jody Morgan, Carey Payette, and any others I might have neglected to mention for putting on such an awesome event!

I attended some great sessions, had some great hallway conversations, and left a better developer for it all. Here is what I attended (all of them were excellent):

What’s New in ASP.NET 4.0 (Steve Smith)
Choosing Between ASP.NET Web Forms and MVC (Rachel Appel)
Seeing Through The Clouds: Introduction to the Azure Services Platform (Brian H. Prince)

I gave a talk on JQuery called “JQuery and JSSpec – Making the Web Developer Friendly”. I had some technical issues at the start (playing with Windows7 deep zoom for the first time in the middle of a talk is a bad idea), but recovered quickly, and made it through the material in the allotted time.

The samples can be found here.

Happy Coding!

Why VisualSVN is Way Cool

2009-04-21T13:44:00.001-04:00

Technorati Tags: VisualSVN,Source Control,Visual Studio 2008

I am a convert. I admit it. The Edit-Merge-Commit model for source control has me hooked. I wish all of my projects would use source control software that fit that model. I also want to be able to do commits and updates from either the command line or from within my development environment.

So I’ve been using AnkhSVN for SubVersion support in Visual Studio 2008. AnkhSVN works really well, and is free, but has some limitations. Mainly, you have to set it as your default Source Control tool. That means that when you go back to work on a TFS code base, you have to remember to change your Source Control Provider, and back and forth.

VisualSVN works differently. It doesn’t even show up in the Source Control Provider drop down (which made me pause for a second), but has it’s own menu in the Visual Studio toolbar. So, on a whim, I opened up a TFS solution – sure enough, got prompted for my credentials, and connected just fine. While that was open, I fired up another instance of Visual Studio and opened up a SVN based solution, and it worked seamlessly.

That reason alone has me convinced that VisualSVN is worth the price of admission.

Happy coding!

Error Dropping a User in SQL Server

2009-04-19T15:41:00.001-04:00

Technorati Tags: SQL Server,Error Dropping User

When you need to drop a user from a SQL Server Database (maybe you entered the name wrong, it needs to be changed, whatever), quite often you will run into an error due to schema ownership.

“The database principal owns a schema in the database, and cannot be dropped.”

Try as you might, the GUI (Management Studio) isn’t going to help you out on this one. You need to transfer the schema that matches the user name to another principal (like dbo) so that you can delete the user.

ALTER AUTHORIZATION ON SCHEMA::[username] TO [dbo]

Then you can delete the user.

Happy Coding!

StirTrek is Coming!

2009-04-19T15:01:00.001-04:00

Technorati Tags: StirTrek,JQuery,Web Development

On May 8th, Microsoft will be hosting a one day event with 10 great sessions of content for Web Development, straight from a large web oriented conference that Microsoft help in Las Vegas earlier this year (not sure if I’m allowed to say the title :-))

Here is the line up:

What's New in Silverlight 3 - Tim Heuer

.NET RIA Services: Building Data-driven Applications in ASP.NET and Silverlight - Tim Heuer

Choosing Between ASP.NET Web Forms and MVC - Rachel Appel

What's New in ASP.NET 4.0 - Steve Smith

Internet Explorer 8, SuperPreview, and Web Platform Installer -
Jeff Blankenburg

Seeing Through The Clouds: Introduction to the Azure Services Platform - Brian H. Prince

Building Microsoft Silverlight Controls - Matt Casto

SketchFlow: From Concept To Production - Tim Hibner

What’s New In WPF 4 - Michael Eaton

An Overview of jQuery - Phil Japikse

After a full day of learning, we get a special private screening of the brand new Star Trek movie! Registration is open here http://stirtrek.eventbrite.com/.

It will be rocking day – I hope to see you there!

Happy Coding!

Central Ohio Day of .NET Wrap Up

2009-04-19T14:39:00.001-04:00

Technorati Tags: SQL Server,Test Driven Development,T-SQL

I had a great time (again) at Central Ohio Day of .NET, despite presenting with a broken pinkie finger on my left hand. (Ok, since you asked, I smashed it between a really heavy object and an immovable object.) Turns out I use my pinkie when I type. Who knew? (I think there is an alt key and a ctl key on the right side of my keyboard, but I just can’t find it…)

My session went very well (despite the pain in my finger). I spoke on Test Driven Development for T-SQL (you can download my slides from here). My session was in the last time slot, which can be good or bad, but it was well attended, and followed by some really good questions, so the attendees were really listening!

I’ve been promoting and speaking TDD (in managed code) for a couple of years now, and I was challenged by a friend of mine to solve the problem for T-SQL. I blogged about this in January (see post here) after working through the issue with a couple of co-workers, but it still wasn’t the best solution.

On the Gallio/MbUnit forums, someone suggested looking into TST (T-SQL Testing Framework) on Codeplex, so I gave it a whirl. Turns out it was a great fit for what I was trying to accomplish. I will blog more about how I’m using it later, but it’s definitely worth checking out. As a sample of how you use it, here is one of my unit tests. Note how the tool supports the ARRANGE/ACT/ASSERT pattern seamlessly!

ALTER PROCEDURE SQLTest_UpdatePricesByCategoryID
AS
BEGIN
	--Arrange
	SET IDENTITY_INSERT dbo.Categories ON;
	INSERT INTO dbo.Categories (CategoryID,CategoryName,ParentCategoryID) 
		VALUES ( 1,'Test1',null);
	INSERT INTO dbo.Categories (CategoryID,CategoryName,ParentCategoryID) 
		VALUES ( 2,'Test2',null);
	SET IDENTITY_INSERT dbo.Categories OFF;
	SET IDENTITY_INSERT dbo.Products ON;
	INSERT INTO dbo.Products (ProductID,CategoryID,ModelNumber,UnitCost,
		CurrentPrice,UnitsInStock) VALUES (1,1,'Model1',1,1.5,10);
	INSERT INTO dbo.Products (ProductID,CategoryID,ModelNumber,UnitCost,
	CurrentPrice,UnitsInStock) VALUES (2,2,'Model2',2,2.5,20);
	INSERT INTO dbo.Products (ProductID,CategoryID,ModelNumber,UnitCost,
	CurrentPrice,UnitsInStock) VALUES (3,2,'Model3',3,3.5,30);
	SET IDENTITY_INSERT dbo.Products OFF;
	--Act
	EXEC UpdatePricesByCategory 2,1.0;
	--Assert
	CREATE TABLE #ExpectedResult (
		ProductID INT PRIMARY KEY NOT NULL,
		UnitCost money,
		CurrentPrice MONEY,
		UnitsInStock int
	) 
	
	CREATE TABLE #ActualResult (
		ProductID INT PRIMARY KEY NOT NULL,
		UnitCost money,
		CurrentPrice MONEY,
		UnitsInStock int
	) 
	INSERT INTO #ExpectedResult (ProductID,UnitCost,CurrentPrice,UnitsInStock) 
	VALUES (1,1,1.5,10) ;
	INSERT INTO #ExpectedResult (ProductID,UnitCost,CurrentPrice,UnitsInStock) 
	VALUES (2,2,3.5,20) ;
	INSERT INTO #ExpectedResult (ProductID,UnitCost,CurrentPrice,UnitsInStock) 
	VALUES (3,3,4.5,30) ;
	INSERT INTO #ActualResult (ProductID,UnitCost,CurrentPrice,UnitsInStock) 
		SELECT ProductID,UnitCost,CurrentPrice,UnitsInStock FROM Products;
	EXEC TST.Assert.TableEquals 'Changes Happened';
END
GO

More on this tool and TDD for T-SQL will be coming to these pages, so stay tuned!

Happy Coding!

It Takes a Village…

2009-04-17T12:05:00.001-04:00

Technorati Tags: Microsoft MVP Award,Community Events

On April 1st, I was notified that I had received an MVP award from Microsoft. This is a great honor, and not one that I could have accomplished alone. I wanted to take a moment to thank many people who helped me on this journey. If I inadvertently leave someone out, flame me, and I will fix it!

First and foremost, Mike Wood, who pushed me into speaking for the community. I have done a ton of speaking and teaching over the years, but always for private classes and/or customers. It wasn’t until I spoke at the Cincinnati Day of .NET in 2007 that I realized how important the community really is to me as a developer, and how I can give back to that community. Mike has given me advice, urging (where necessary), and criticism (where warranted) over the past two years, and for that I am very thankful.

Brian H. Prince has been an excellent influence and mentor as my Architect Evangelist from Microsoft DPE, and Jeff Blankenburg additionally has helped me along the road as my Developer Evangelist.

Jim Holmes for having the faith in me to have me speak at CodeMash (even though he didn’t really know me that well yet). Leon Gersing for all of those great conversations and debates over beverages, Wally McClure has made a point of introducing me to everyone he knows (which is a significant number of people) whenever we share the same geography, and Alan Stevens who went out of his way at CodeMash this year to bring me onto the radar screens of some people I hadn’t yet met.

Suzanna Moran, my MVP lead, and the Client Application Development Group at Microsoft who gave me the award.

And lastly, all of the user group leaders and conference organizers for all that you do, and for allowing me to speak in front of your attendees. You guys are the ones that make the community as great as it is, and I’m glad I’ve been able to contribute and support your efforts.

Happy Coding!

MockupScreens 4.0 Just Went RTM

2009-04-08T16:24:00.001-04:00

Technorati Tags: MockupScreens,Wireframes,Prototyping

For working up wireframes and application screens, there aren’t many tools better than MockupScreens. The problems with using other tools like Visio (or even Visual Studio) is that it takes too much time. When I’m sitting with a customer, I want to be able to crank out screens in a very fluid and frictionless manner.

I also don’t want the customer to think that it’s too costly to make a change. Often, when presented with something that “looks” real, they will either a) want to know when they can install it, or b) be afraid to suggest a change because of the perception that it’s too costly to change it now that “all of that code has been written.”

Here is the official word from the creators of MockupScreens:

Preview Of MockupScreens 4

In short, new release does much better job than the old one. For one it's much more robust, being completely redesigned and rewritten during past 14 months (wow, it went by so fast!). Other major improvements are the very same you kept requesting:

Both much nicer and more "standard" interface - single main screen, native windows controls and dialogs, etc
Ability to switch look and feel at any time among Black and white, Windows and Web look and feel
Finer control of the mocked screens' element formatting: font color, font size, bold, italic, underline, etc

Not to keep you waiting any longer, here is the screenshot so you can see by yourself what I'm talking about. You have to click on it to really see the details.

(If you can't see the image, your e-mail program is blocking it. Open it here)
And below is the same mockup displayed in two skins: "Windows" and "Black and white". Again, click on it to see the details.

(If you can't see the image, your e-mail program is blocking it. Open it here)
Among great many other improvements, below are those that had also been much requested by you:

Jump to another screen from any element while in slideshow mode or in exported HTML, and not just from "mark" icons
Comments for any element (instead of having to put "mark" icons to comment something), along with comments being more prominent as important part of the Mockup Screens functionality, and with many small improvements in comments' exporting, printing, word-wrapping, the way how comments are displayed on screen, etc
Improved "table editor" so you can draw and populate your tables more easily, and even paste the actual data from Excel
Printing from MockupScreens directly, instead of exporting project to HTML so it could be printed
Copying screen snapshots directly to Word (or other programs), with no need to export snapshots to image files first
Importing and exporting whole scenarios or just copy-pasting them between different projects
Better performance, especially with large files with many screens crowded with elements
Export to XML so the mockups can be transformed by xsl-transformations to actual programming code
Most elements can be shown as "disabled", to indicate that they are read only for example
Simple file locking mechanism, for people that use MockupScreens in teams often working on the same file
Ability to resize working panes to accommodate people with different display size and resolution

ReSharper 4.5 Goes RTM

2009-04-08T14:44:00.001-04:00

Technorati Tags: ReSharper,R#,C#

It’s here! I’ve been using the daily downloads from the EAP site for a while now, and have been extremely happy with the improved performance.

Run, don’t walk, and download it here!

Happy Coding!

VSLive Vegas 2009 Discount Code Still Available

2009-04-08T13:22:00.001-04:00

Technorati Tags: VSLive,Conferences,C#,.NET

Now that I have your attention, a little background. I have attended VSLive conferences for over 10 years, and more recently became a speaker for them. In June, I’ll be speaking at VSLive in Las Vegas, NV. in the Agile/Design Track on Development Patterns and Enterprise Agility.

In a post that I wrote in September, 2009, I discussed what makes me a better developer, and I want to revisit some of that now. In that post I discussed three aspects:

Community,
Don’t be the smartest person in the room,
Attend a national conference.

I live in the Heartland District (Ohio, Michigan, Kentucky, and Tennessee), and we are fortunate to have developer events all the time. Whether it’s the larger events like Central Ohio Day of .NET, CodeMash, CodeStock, and DevLink, or the smaller events like West MI .NET University or KalamazooX (and all of the other Day of .NETs and code camps occurring throughout the district), we have a terrific code of speakers and organizers that are very passionate about the development community.

With all of these regional events, why go to a national conference like VSLive? There are several reasons, but the main one that I go for is the range of topics presented. I go through cycles of different technologies that I work with for various clients. I might spend a significant amount of my time working in Smart Client, and don’t want to get completely left behind on what’s happening in Web Development (hello MVC/JQuery/Prototype/etc). My first real exposure to WPF was at a VSLive. There’s just too much in the .NET FW to keep current on everything.

VSLive will help you keep current on all of the different aspects of development, and provide the opportunity to dig deeper into your topics of interest. So, does that intrigue you enough yet? How about a $400 discount on an all access pass to the conference? Use the following code when you register, and you will get the Passport Package for just $1,295. You can get more conference information and register at http://vslive.com/2009/lasvegas/. The discount code is (drum roll please):

S9V13

Between the regional events and attending at least one national event a year, it’s easy to surround yourself with people smarter than yourself. I love being the least smart person in the room. That means all I can do is learn!

I hope to see you there, and as always, Happy Coding!

ReSharper Import Symbol (aka Type Name) Completion and VMWare Console

2009-04-06T12:36:00.001-04:00

Technorati Tags: ReSharper,VMWare Server,Import Symbol Completion

ReSharper (R#) has a great feature that will complete the type (and add the correct “using” statement) for any referenced assembly regardless of current visibility in your class.

The default keystrokes for this is ctl-alt-space. This works great, but stopped working for me when I started running everything in a Virtual Machine Console window. I thought (for too long) that it was an issue with the daily builds, but it occurred to me that it is really a side effect of running in VMWare Server console. The console window maps ctl-alt to “release your cursor”. The prevents programs running in the VM from using that keystroke combination.

The solution was simple. In Visual Studio, goto Tools->Options->Keyboard. In the textbox for “Show commands containing:”, type “CompleteCodeTypeName”, and two options will show. Select the choice “ReSharper.ReSharper_CompleteCodeTypeName” and map it to something else (I selected ctl-shift-alt-space) and viola, it works again!

Happy Coding!

West Michigan .NET University Slides and Code

2009-04-04T15:24:00.001-04:00

Technorati Tags: TDD,Unit Testing .Net,Windows Presentation Foundation,West Michigan .NET University

I have just finished both of my talks at West Michigan .NET University, and the feedback was overwhelmingly positive. There are a great bunch of attendees here, and we have had great discussions today!

I’ve had several folks asking me for the slides, and for once I’m getting it posted in a timely manner! Here are the slides for Effective Unit Testing and my joint presentation with Cary Payette on Introduction to Windows Presentation Foundation.

The source code for my WPF demo is located here.

Happy Coding!

Cincinnati Object Relational Mapping (ORM) Firestarter

2009-03-28T13:03:00.001-04:00

Technorati Tags: NHibernate,Entity Framework,Firestarter,Cincinnati .NET Users' Group,ORM

What is an ORM (you ask)? Then this event is perfect for you!

What is a Firestarter event (you ask)? The Firestarters are meant to serve as an entry point into a technology (or technologies). So, for this event, we assume you know nothing about ORMs. Should you come if you have been using NHibernate or Entity Framework? ABSOLUTELY!

We are well into the planning stages for the Cincinnati ORM Firestarter, sponsored by the Cincinnati .NET Users’ Group (CINNUG) and hosted at the Microsoft Offices in Mason on June 13, 2009.

Although we are starting at the beginning with both NH and EF, the presenters will be working up a real application with the different tools so you can see how they work, how they are different, and why you should use one particular tool over the other.

An amazing group of speakers have come forward to help me out (bios coming soon), and as a team we’ve come up with the following lineup:

ORM Architectural Overview
NHibernate 101
Fluent NHibernate and Structure Map
Castle Active Record
LINQ to SQL and Entity Framework 101
Applied Entity Framework

Keep a close eye on this blog post, CINNUG, and Start A Fire. More information will be coming soon!

In the meantime, Happy Coding!

Come on out to Kalamazoo…X?

2009-03-26T11:10:00.001-04:00

Technorati Tags: KalamazooX,Test Driven Development,Unit Testing .Net

Since when did Kalamazoo get spelled with an X? Well, when it hosts a conference focusing on the humans in IT! This one day conference on April 25 in Kalamazoo, MI will host sessions on

Human Interaction
Interface and Graphic Design
Development Processes
Application Lifecycle Management

I will be speaking on Effective Unit Testing leading to Test Driven, and I hope to see you there!

More information can be found at www.kalamazoox.org, including registration details.

Happy Coding!

Central Ohio Day of .NET is Coming April 18

2009-03-26T10:56:00.001-04:00

Technorati Tags: Central Ohio Day of .NET,T-SQL TDD

Once again I will be speaking at the Central Ohio Day of .NET. What is it? And Why Central Ohio? Well, I’m glad you asked!

CODODN is a combined effort of the Cincinnati .NET Users’ Group (CINNUG), Cincinnati SQL Server and Business Intelligence Users’ Group (CincySQL), Dayton .NET Developers’ Group, and the Central Ohio .NET Developers’ Group.

From this amazing pool of talent, there will be sessions presented on Architecture, Testing, SQL Server, well, just check the list out for yourself here!

I will be speaking on Test Driven Development in T-SQL, registration is open (go here). I hope to see you there!

Happy coding!

West Michigan .NET University is coming April 4

2009-03-26T10:30:00.001-04:00

Technorati Tags: .Net,C#,WPF,TDD,Unit Testing .Net,Conferences,West Michigan .NET University

What is a .NET University? Well, first of all, it’s FREE! Secondly, it’s a one day conference given by members of the development community for the development community.

Are you new to .NET? Or are you new to some part of .NET, like WPF? or Sharepoint?Maybe you’ve been hearing all about this Test Driven Development thing, and need more information? Or you just need to get better at Unit Testing?

We have a very talented group of outstanding speakers presenting on:

.NET Boot camp and Intermediate .NET (whole day)
ASP.NET/Ajax and Intermediate Web Development (whole day)
Real World Architecture
Windows Presentation Foundation
SQL Server Data Models and T-SQL
Sharepoint
Web Services/Windows Communication Foundation
Silverlight

The format of the .NET University is longer sessions (3 hours), with some of them running essentially the entire day. So no constants switching rooms/speakers. Also, the sessions are long enough that the law of two feet can apply. Want to see two sessions that are concurrent? Hop back and forth, settling into the one that intrigues you the most.

You can register for the event here, and also get more information at the home page.

I will be speaking in the morning with Carey Payette on Windows Presentation Foundation and in the afternoon with Len Smith on Effective Unit Testing and Test Driven Development. I hope to see you there!

Happy Coding!

Gallio and MbUnit 3.0.6 RTM!

2009-03-26T10:09:00.001-04:00

Technorati Tags: MbUnit,Gallio,Unit Testing .Net

The folks at Gallio and MbUnit (led by Jeff Brown) have done a fantastic job with the latest release of Gallio and MbUnit. Lots of new features including ReSharper 4.5 integration (w00t!), Parallelizable tests, more control over time outs, updated contract verifiers, XML Data sources, and more!

Check out all the juicy details here, and enjoy the new framework.

Happy coding!