Tim's Brown Bag Lunch

Azure In Action Book Review

2010-05-29T08:31:00.001-05:00

This week I just finished co hosting the Minneapolis Windows Azure boot camp. We had about 100 folks show up which near as I can tell makes it one of the largest if not the largest boot camp in the country. By way of preparation for the event Manning Publishing, Chris Hay, and Brian Prince were kind enough to provide me with a copy of Azure in Action. Being a consultant at Intertech here in Minneapolis, I pretty much always have a full time customer that pays me to do work (for them of course). When I am trying to learn a new subject I tend to do it off hours and I tend to only have small half hour time slices to really focus on it. I need a book that I can pick up for a short period of time 4 or 5 times a week and if I skip a couple days I don’t want to have to struggle with trying to remember where I left off. Azure In Action fit the bill perfectly.

Chris Hay and Brian Prince (Manning Publications) do an excellent job of sprinkling in a refreshing dose of IT humor as they show us how to use this exciting new platform and teach us how we need to think differently about how we architect an application for the clouds. Chapter 11 section 1 has a perfect example of this combination of humor and new way of thinking about architecture:

“Surely I always need a relational database, you pillock?
Over the past decade or so, there has been a government conspiracy to make us always use relational databases to track our data ;). Every database vendor has some secret code in their product that means the government can query our data whenever they want.
Okay, so the above statement is a bunch of baloney but there is a serious point there (no really there is). We are a little conditioned to store our data in a relational form, even when it's not strictly necessary.
If you can expand your mind and except that there are other ways of storing data then you can use the Table Service to store your data in a highly scalable (and cheaper fashion).”

If you are thinking about using the Windows Azure platform or just getting started on an Azure project, do yourself a favor and go out and get a copy of Azure in Action – you won’t regret it.

http://www.manning.com/hay/

Technorati Tags: Windows Azure,Azure In Action,Prince,Hay,cloud computing

Moved to the Intertech site

2010-03-05T17:58:00.001-06:00

I have moved my blog to the Intertech site.

Here is my first post

http://www.intertech.com/Blog/post/Software-as-a-Service-(SaaS).aspx

Here is the general blog site:

http://www.intertech.com/Blog/

Not moving just yet

2010-02-05T17:22:00.001-06:00

I am having some technical difficulties getting images posted to my new blog site so I’ll revise my statement. Very soon I will be blogging on an internally managed blog site at Intertech (http://www.intertech.com/blog/). I will not be moving existing content but I will continue to update the links on my design and code review check list until it is complete.

Consider composition over inheritance

2010-02-05T17:19:00.001-06:00

This week I want to discuss another bullet from my code review checklist.

Composition is a method we use to combine simple objects into more complex objects. With composition we have an owner class that changes behavior by delegating the implementation of certain behaviors to smaller and simpler objects. When we destroy the owner object, all of these smaller objects the owner uses are also destroyed. If we were to use inheritance to achieve this same goal (changing behavior) we would use a subclass to change the behavior of the base class. As I mentioned in my last post, the base class and subclass are tightly coupled and this can tend to be a bit brittle.

Consider the very real case where we are writing an application that needs to work with both Oracle and SQL Server. We could use inheritance to define a base class and have one subclass for SQL Server and another for Oracle. Our application can figure out which object to instantiate at runtime and that will work pretty well. Here is what our class diagram might look like:

If we take a little different approach and use composition instead we might have a class diagram similar to the following.

The CompositionDatabaseWriter does not need to implement IDatabaseWriter but I did that because I think it makes the example easier to understand. The application will use the CompositionDatabaseWriter to do database work and CompositionDatabaseWriter will determine whether to use SqlServerDatabaseWriter or OracleDatabaseWriter at runtime perhaps by using a configuration file entry. When one of the CompositionDatabaseWriter methods is called, CompositionDatabaseWriter simply calls the corresponding method on the Sql Server or Oracle object.

Both designs allow us to interact with an oracle or Sql Server database which was our goal. Now here is where the flexibility of composition comes in; Suppose we now need to support a MySql database. If we use inheritance to solve this problem, at a minimum we must create a MySqlDatabaseWriter subclass, recompile, test, and deploy our data layer. If we use composition instead we can create a MySqlDatabaseWriter in a new assembly and all we have to do to use it is deploy this single assembly and change a config file. Very powerful, because we used composition we can change the behavior at runtime via configuration.

The fact of the mater is that our sample is so simple we didn’t even use composition at all so imagine the considerably more complex scenario where what we are doing is creating a persistence object that must transactionally work with the file system and a database. We define the persistence object and within the persistence object we delegate the responsibility of dealing with the file system to one class, and dealing with the database to another. The persistence object is composed of a FileSytemWriter and a DatabaseWriter. Our Persistence object has only one concern – coordinating database and file persistence. Our FileSystemWriter has only one concern – managing File System interactions, and finally our DatabaseWriter is only concerned about interacting with a database of one type. We have decomposed a fairly complex problem into a few smaller more managable problems, we came up with a nice robust design thanks to composition and we have managed to do it in such a way that there are no SRP violations either!

Moving my blog.

2010-01-24T10:33:00.001-06:00

As of today I will be blogging on an internally managed blog site at Intertech (http://www.intertech.com/blog/). I will not be moving existing content but I will continue to update the links on my design and code review check list until it is complete.

Design Review and Delegation Vs. Inheritance

2009-12-26T11:02:00.001-06:00

This week I want to discuss another bullet from my code review checklist.

Consider delegation over inheritance. I have had some pretty heated debates on this topic in the past and I will even take it a step further and say the rule should state that we should favor delegation over inheritance. Let’s consider the following classic (and intuitive) person/student/teacher example. A class diagram might look something like this

Person is our base class; Teacher and student derive from person. We can say that a student Is A person and that a Teacher Is A person.

The up-side of this design is it is simple, intuitive, and it will perform well. The down side of this approach is that there is a tight coupling between the derived classes and the base class, we are breaking encapsulation by making the functionality of the derived class dependent on the functionality in the base class, and we may even break encapsulation on our Person class by using protected or public access modifiers where we normally wouldn’t do so.

The problem with breaking encapsulation is that making a change to one class (our base class) can cause unintended changes in other consuming classes (our derived classes). I can’t begin to tell you how many times I have seen a seemingly small change to a base class break huge pieces of an application.

Now let’s consider using delegation rather than inheritance. We will change our class diagram to look like the following:

We can say a teacher Has A person and similarly student Has A person.

The down-side of this design is that we have to write more code to create and manage the person class and thus the code will not perform as well (though in most cases I suspect the performance hit is negligible). We also cannot use polymorphism - we cannot treat a student as a person and we cannot treat a teacher as a person. The up-side of this design is that we can decrease coupling by defining a person interface and using the interface as the return type for our Person property rather than the concrete Person class, and our design is more robust. When we use delegation we can have a single instance of a person act as both a student and a teacher. Try that in C# using the inheritance design!

Technorati Tags: Design Review,inheritance,delegation c# code review

Design Review and the DRY Principle

2009-12-12T10:53:00.001-06:00

DRY in the DRY principle is an acronym for Don’t Repeat Yourself. While we are going to focus on applying the principle to code, it can and should be applied to more than just code. The can be applied to database schemas, tests, documentation, test plans, design documents, build scripts and more. Any time we start duplicating our work we are signing up for parallel maintenance and chances are we will eventually have the items fall out of synch.

We can use several techniques to avoid duplicate code. Some obvious things we can do include using classes and methods to organize common code. We can write an abstract or base class to implement common behaviors for multiple derived classes.

We can use properties to perform a validation in one place rather than performing the validation anywhere we want to use a member variable:

Code Snippet



         [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
         int aComplexInteger;
         public int AComplexInteger
         {
             get { return aComplexInteger; }
             set 
             {
                 if (value == 0)
                     throw new ArgumentOutOfRangeException("AComplexInteger");
                 if (value != aComplexInteger)
                 {
                     aComplexInteger = value;
                     //Maybe raise a value changed event
                 }
             }
         \

One of my favorite techniques is constructor chaining. If we have multiple constructors that perform similar logic , we should use constructor chaining to avoid duplicating code:

Code Snippet



 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
 namespace CicMaster
 {
     class BetterConstructorLogic
     {
         #region WhyItIsBetter
         //No duplicate code, this is called constructor chaining
         //step through this
         #endregion
         string someString = string.Empty;
         int someInteger = 0;
         List<int> myIntegers = new List<int>();
 
         public BetterConstructorLogic():this("A Default Value")
         {
             //someString = "A Default Value";
             System.Diagnostics.Debug.WriteLine("In Default Constructor");
         }
 
         public BetterConstructorLogic(string aString):this(aString,123)
         {
             //someInteger = 123;
             System.Diagnostics.Debug.WriteLine("In one param constructor");
         }
 
         public BetterConstructorLogic(string aString, int anInteger)
         {
             System.Diagnostics.Debug.WriteLine("In two param constructor");
 
             someString = aString;
             someInteger = anInteger;
             myIntegers.Add(someInteger);
             myIntegers.Add(someInteger ^ 3);
             myIntegers.Add((int)(2 * 3.14 * someInteger));
         }
     }
 }
 

The final technique I would like to mention is use a factory to create all but the simplest objects. The following (admittedly nonsensical) code needs to execute maybe a half dozen lines of code to construct an Order object.

Code Snippet



 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 
 namespace BusinessLayer
 {
     class ObjectContext
     {
         public ObjectContext(String username)
         {
             //Look up the user permissions
         }
         public bool IsInTranaction { get; set; }
         public bool BeginTransaction()
         {
             //do some transaction logic
             return true;
         }
     }
     class Order
     {
         public Order(ObjectContext theContext)
         {
 
         }
 
     }
     class Consumer
     {
         public Consumer()
         {
             ObjectContext ctx = new ObjectContext(Thread.CurrentPrincipal.Identity.Name);
             if (!ctx.IsInTranaction)
             {
                 if (ctx.BeginTransaction())
                 {
                     //...
                 }
             }
             Order order = new Order(ctx);
 
         }
     }
 
 }
 

Duplicating these few lines of code in a couple places is not that difficult. Now say the application is enhanced and grows for a few years and suddenly we see this code duplicated dozens or hundreds of times. At some point it is likely that we want to change the construction logic, finding and changing all the code we use to create the order is difficult, time consuming, and a QA burden.

A better approach would be to encapsulate the logic required to build a new order. Here is an implementation using a simple factory. It is much easier to find, change, and test this code:

Code Snippet



     static class OrderFactory
     {
         public static Order GetOrder()
         {
             ObjectContext ctx = new ObjectContext(Thread.CurrentPrincipal.Identity.Name);
             if (!ctx.IsInTranaction)
             {
                 if (ctx.BeginTransaction())
                 {
                     //...
                 }
             }
             return new Order(ctx);
         }
     }
     class DryConsumer
     {
         public DryConsumer()
         {
             Order order = OrderFactory.GetOrder();
         }
     \

If we recognize that we are duplicating even a few lines of code over and over we need to take a serious look at the code and figure out a way to encapsulate the logic.

My design review checklist

Technorati Tags: DRY,Design Review,Agile principles,Don't Repeat Yourself

Silverlight 3, the CollectionViewSource and sorting

2009-11-27T17:34:00.001-06:00

In my previous post we were introduced to the CollectionViewSource. We have multiple ItemSources binding to the same collection using a CollectionViewSource – very powerful. Now what if we want to sort the items displayed in one of our grid cells? We will focus on row one and column one for the rest of this post.

I’ve added some more default data to the Control’s constructor to make things a little more interesting and also notice I have added a few buttons to the bottom of our control:

The Sort by Name button adds a sort description to the CollectionViewSource

theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeName",ListSortDirection.Ascending));

This code tells the CollectionViewSource to sort the items in it’s view by the SomeName property in ascending order. Click the button and we see the following:

Click the Clear Sort Descriptions button.

The Sort By Value button tells the CollectionViewSource to sort the items in the view by the SomeValue Property in ascending order.

theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeValue", ListSortDirection.Ascending));

Click the button to see the following:

This time our list is sorted by the SomeValue property.

Where things get interesting is that you can add multiple sort descriptions. Try clearing the filter, then adding the name and value filter (in that order) and we see the following:

The collection is first sorted by name, then by value.

Clear the filter and click the Value, then name button and we see this:

The collection is first sorted by SomeValue, then by SomeName.

The order is important! If you want to add a sort description to the top of the sort order, simply use the Insert method as follows:

theDataContext[0].Column1.View.SortDescriptions.Insert(0,new SortDescription("SomeValue", ListSortDirection.Ascending));

Here is the modified XAML:

Code Snippet

       
        
<UserControl xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data" x:Class="SilverlightApplication1.MainPage"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">            
    <UserControl.Resources>
        <Style TargetType="Button">
            <Setter Property="FontSize" Value="9"/>
        </Style>
    </UserControl.Resources>
  <Grid x:Name="LayoutRoot">
        <ScrollViewer VerticalScrollBarVisibility="Auto">
            <StackPanel Orientation="Vertical">
            <data:DataGrid x:Name="TheMainDataGrid" AutoGenerateColumns="False" ItemsSource="{Binding}" HeadersVisibility="Column">
                <data:DataGrid.Columns>
                    <data:DataGridTemplateColumn Header="Column 1">
                        <data:DataGridTemplateColumn.CellTemplate>
                            <DataTemplate>
                                <ListBox MinHeight="15" ItemsSource="{Binding Path=Column1.View}" >
                                    <ListBox.ItemTemplate>
                                        <DataTemplate>
                                            <StackPanelOrientation="Horizontal">
                                                <TextBlockMargin="10" Text="{Binding Path=SomeName}" />
                                                <TextBlockMargin="10" Text="{Binding SomeValue}" />
                                            </StackPanel>
                                        </DataTemplate>
                                    </ListBox.ItemTemplate>
                                </ListBox>
                            </DataTemplate>
                        </data:DataGridTemplateColumn.CellTemplate>
                    </data:DataGridTemplateColumn>
                    <data:DataGridTemplateColumn Header="Column 2">
                        <data:DataGridTemplateColumn.CellTemplate>
                            <DataTemplate>
                                <ListBox MinHeight="15" ItemsSource="{Binding Path=Column2.View}" >
                                    <ListBox.ItemTemplate>
                                        <DataTemplate>
                                            <StackPanel Orientation="Horizontal">
                                                <TextBlockMargin="10" Text="{Binding SomeName}" />
                                                <TextBlock Margin="10" Text="{Binding SomeValue}" />
                                            </StackPanel>
                                        </DataTemplate>
                                    </ListBox.ItemTemplate>
                                </ListBox>
                            </DataTemplate>
                        </data:DataGridTemplateColumn.CellTemplate>
                    </data:DataGridTemplateColumn>
                </data:DataGrid.Columns>
            </data:DataGrid>
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
                <TextBlock Margin="5" Text="Name:"/>
                <TextBox x:Name="tbNAme" Margin="5" Width="100"></TextBox>
                <TextBlock Margin="5" Width="100" Text="Value:"/>
                <TextBox x:Name="tbValue" Margin="5" Width="100"></TextBox>
                <Button x:Name="AddButton" Margin="5" Content="Add" Click="AddButton_Click"/>
            </StackPanel>
            <StackPanel HorizontalAlignment="Left">
                <Button x:Name="ChangeNameButton" Width="150" Content="Change Name" Click="ChangeNameButton_Click"/>
                <Button x:Name="ChangeValueButton" Width="150" Content="Change Value" Click="ChangeValueButton_Click"/>
                <Button x:Name="refresh" Width="150" Content="Refresh CVS" Click="refresh_Click" />
                <Button x:Name="AddNameSort" Width="150" Content="Sort by Name" Click="AddNameSort_Click"/>
                <Button x:Name="AddValueSort" Width="150" Content="Sort by Value" Click="AddValueSort_Click"/>
                <Button x:Name="ClearSort" Width="150" Content="Clear Sort Descriptions" Click="ClearSort_Click"/>
            </StackPanel>
        </StackPanel>
            </ScrollViewer>
  </Grid></
UserControl>

        

Here is the modified code behind:

Code Snippet

       
        
using System.Collections.ObjectModel;
using System.Windows.Controls;
using System.Windows.Data;
using System.ComponentModel;
namespace SilverlightApplication1
{
    public partial class MainPage : UserControl
    {
        ObservableCollection<TestClass> theMainCollection ;
        ObservableCollection<TheRowClass> theDataContext;
        public MainPage()
        {
            InitializeComponent();
            theMainCollection = new ObservableCollection<TestClass>()
                { new TestClass() {SomeName="A",SomeValue=11},
                    new TestClass() {SomeName="A",SomeValue=12},
                    new TestClass() {SomeName="A",SomeValue=10},
                    new TestClass() {SomeName="AB",SomeValue=21},
                    new TestClass() {SomeName="A",SomeValue=13},
                    new TestClass() {SomeName="B",SomeValue=13},
                    new TestClass() {SomeName="B",SomeValue=14},
                    new TestClass() {SomeName="AB",SomeValue=11},
                    new TestClass() {SomeName="BC",SomeValue=22},
                    new TestClass() {SomeName="AB",SomeValue=23},
                    new TestClass() {SomeName="BC",SomeValue=24}
                };
           
            theDataContext = new ObservableCollection<TheRowClass>();
            theDataContext.Add(new TheRowClass(theMainCollection));
            theDataContext.Add(new TheRowClass(theMainCollection));
            TheMainDataGrid.DataContext = theDataContext;
            AddFilter(theDataContext[0].Column1, 1, 1);
            AddFilter(theDataContext[0].Column2, 1, 2);
            AddFilter(theDataContext[1].Column1, 2, 1);
            AddFilter(theDataContext[1].Column2, 2, 2);
            
        }
        private void AddFilter(CollectionViewSource cvs, int row, int column)
        {
            cvs.Filter += delegate(object o, FilterEventArgs eArgs)
            {
                //Simple filter saying if column = 1 look for an A in the SomeName property
                //Else look for a B.  If we are in Row 1 look for a 1 in the SomeValue property
                //Else look for a 2
                string columnFilter;
                if (row == 1)
                    columnFilter = "A";
                else
                    columnFilter = "B";
                if ((eArgs.Item as TestClass).SomeValue.ToString().Contains(column.ToString()) && (eArgs.Item as TestClass).SomeName.Contains(columnFilter))
                    eArgs.Accepted = true;
                else
                    eArgs.Accepted = false;
            };
        }
        private void AddButton_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            TestClass tc = new TestClass();
            tc.SomeName = tbNAme.Text;
            tc.SomeValue = int.Parse(tbValue.Text);
            theMainCollection.Add(tc);
        }
        private void ChangeNameButton_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            theMainCollection[theMainCollection.Count-1].SomeName = "B";
        }
        private void ChangeValueButton_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            theMainCollection[theMainCollection.Count - 1].SomeValue = 25;
        }
        private void refresh_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            theDataContext[0].Column1.View.Refresh();
            theDataContext[1].Column1.View.Refresh();
            theDataContext[0].Column2.View.Refresh();
            theDataContext[1].Column2.View.Refresh();
        }
        private void AddNameSort_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeName",ListSortDirection.Ascending));
        }
        private void AddValueSort_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            theDataContext[0].Column1.View.SortDescriptions.Add(new SortDescription("SomeValue", ListSortDirection.Ascending));
        }
        private void ClearSort_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            theDataContext[0].Column1.View.SortDescriptions.Clear();
        }
    }
}
           
        

See my previous post to get the supporting code.

Technorati Tags: Silverlight 3,CollectionViewSource,ObservableCollection,DataGrid,SortDescription

Silverlight 3 and the CollectionViewSource

2009-11-23T20:55:00.001-06:00

I have been working on a really cool Silverlight application for the last several weeks. The application is a graphically intensive businesses application with some pretty challenging lists nested in a grid and some very cool drag and drop functionality. Here is the scenario:

When the app starts up we make a call to a WCF service and get several hundred to several thousand objects back in an observable Collection. We slice, dice, and manipulate the ObservableCollection<T> and now the challenge is we have to present several dozen to several hundred different views into this same data. Throwing several hundred different views of the same data at a user all at once is not particularly useful so the views are stored in cells of a scrollable grid. As I mentioned, each cell in the grid is a list of items that needs to be generated based on some attributes of the column and row in the grid. Conceptually I want to break my original collection into a bunch of smaller collections but I didn’t want to physically break the collection into multiple collections because the drag and drop functionality I spoke of would force me to get into the business of removing an item from one collection and adding it to another. Additionally once the items are placed where we want them I would have to reassemble the master collection and send it back to the server. Using a single ObservableCollection<T>) collection is a good fit. How do we get multiple independent views into this ObservableCollection<T>) ?

Enter the CollectionViewSource. The CollectionViewSource allows us to set a source property (in our case the ObservableCollection<T> we got from the WCF call) then set one or many filters and finally we bind each cell to the View property of the CollectionViewSource to allow us to get a list of objects that satisfy our filter criteria.

Let’s whip up a very simple application and demonstrate the behavior.

Here is the screen: We have a grid with 2 rows and 2 columns. Each Cell represents a list of type TestClass. TestClass has two properties, SomeName – a string property, and SomeValue an integer property. Below the grid we have two text boxes and and add button. This will allow us to demonstrate that we can add items to the observable collection and have the UI automatically update. Ignore the bottom 3 buttons for the moment.

Rather than make a WCF call we are building the “Main” collection of objects in the MainPage constructor:

Code Snippet



             theMainCollection = new ObservableCollection<TestClass>()
                 { new TestClass() {SomeName="A",SomeValue=11},
                     new TestClass() {SomeName="A",SomeValue=12},
                     new TestClass() {SomeName="B",SomeValue=13},
                     new TestClass() {SomeName="B",SomeValue=14},
                     new TestClass() {SomeName="AB",SomeValue=21},
                     new TestClass() {SomeName="BC",SomeValue=22},
                     new TestClass() {SomeName="AB",SomeValue=23},
                     new TestClass() {SomeName="BC",SomeValue=24}
                 };

Now we need to create a collection for the grid to bind to. Remember, what we want is for each grid cell to be a view into our “main” collection. In our Example we are using a DataGrid object to display our views and we want the DataGrid to automatically update if we add an object to or remove an object from the main collection . What we need here is an ObeservableCollection of objects with a CollectionViewSource property for each column. In our example we have called the object TheRowClass. TheRowClass has two properties of type CollectionViewSource; Column1 and Column2.

Here is the code I use to initialize the ObservableCollection<TheRowClass>:

Code Snippet

             theDataContext = new ObservableCollection<TheRowClass>();
             theDataContext.Add(new TheRowClass(theMainCollection));
             theDataContext.Add(new TheRowClass(theMainCollection));

We have two items in the ObservableCollection<TheRowClass>, each item has two properties of type CollectionViewSource for a total of four CollectionViewSource objects – one for each cell. We are passing the main collection into the constructor and using it as the Source property for all of our CollectionViewSources. All we have left to do is add a filter to each of these collections. The filter we are adding is very simple:

if TestClass.SomeName contains the letter A and TestClass.SomeValue contains the number 1 display the item in row 1, column 1

if TestClass.SomeName contains the letter A and TestClass.SomeValue contains the number 2 display the item in row 1, column 2

if TestClass.SomeName contains the letter B and TestClass.SomeValue contains the number 1 display the item in row 2, column 1

if TestClass.SomeName contains the letter B and TestClass.SomeValue contains the number 2 display the item in row 2, column 2

Here is the code to pull that off:

Code Snippet



             AddFilter(theDataContext[0].Column1, 1, 1);
             AddFilter(theDataContext[0].Column2, 1, 2);
             AddFilter(theDataContext[1].Column1, 2, 1);
             AddFilter(theDataContext[1].Column2, 2, 2);

And the AddFilter method:

Code Snippet



         private void AddFilter(CollectionViewSource cvs, int row, int column)
         {
             cvs.Filter += delegate(object o, FilterEventArgs eArgs)
             {
                 //Simple filter saying if column = 1 look for an A in the SomeName property
                 //Else look for a B.  If we are in Row 1 look for a 1 in the SomeValue property
                 //Else look for a 2
                 string columnFilter;
                 if (row == 1)
                     columnFilter = "A";
                 else
                     columnFilter = "B";
                 if ((eArgs.Item as TestClass).SomeValue.ToString().Contains(column.ToString()) && (eArgs.Item as TestClass).SomeName.Contains(columnFilter))
                     eArgs.Accepted = true;
                 else
                     eArgs.Accepted = false;
             };
 
         \

Run the app, notice that the item with SomeName=’AB’ and SomeValue=21 is in all of the cells, this is because that item satisfies the filter criteria for each CollectionViewSource in each cell. Very cool.

Add the letter ‘A’ to the first textbox and 111 to the second textbox and click the add button. Notice that an item is added to column 1 and row 1 of the grid without doing anything more than making a call to Collection.Add.

Play around with a few more combinations and see how the grid updates.

Now let’s look at the bottom 3 buttons, the first button changes the SomeName value of the last item in the main collection to “B”. Here is the event handler:

theMainCollection[theMainCollection.Count-1].SomeName = "B";

Again, add the letter ‘A’ to the first textbox and 111 to the second textbox and click the add button. Now click the Change Name button. Notice that nothing happens. I assure The item has changed.

Now click the Change Value button. Notice that the last item in row 1 cell 1 has changed, the value has become 25.

We changed the SomeValue property to 25 in the button click event handler. Here is the event handler:

theMainCollection[theMainCollection.Count - 1].SomeValue = 25;

Why did SomeValue change while SomeName remained the same? Take a look at the TestClass and you will notice that it implements the INotifyPropertyChanged interface and in the SomeValue setter we call NotifyPropertyChanged which raises an event. Silverlight has a Pub/Sub eventing system that the UI uses to determine when to update databound objects. With just a few lines of code we were able to wire TestClass into this eventing system and force the UI to update anytime our SomeValue property changes.

This is all fine and good, call that event for SomeName and we are good to go, well…almops. We still have a problem with the UI! The last item in cell 1 column 1 is displaying an incorrect SomeName value, and since we changed SomeValue to 25 it should no longer be visible in this cell. What is happening is that the Filter on the collection view source is applied when an item is added to or removed from the collection but NOT when an item changes. To manually reapply the filter call CollectionViewSource.View.Refresh (for each CollectionViewSource) and you will see the grid display correctly. Click the Refresh CVS button to see this functionality in action:

Below is all of the source code.

Click here to see how to sort the grid cells.

Here is the XAML:

Code Snippet



 <UserControl xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"  x:Class="SilverlightApplication1.MainPage"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
     mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">
     <UserControl.Resources>
 
     </UserControl.Resources>
   <Grid x:Name="LayoutRoot">
         <StackPanel Orientation="Vertical">
             <data:DataGrid x:Name="TheMainDataGrid"   AutoGenerateColumns="False" ItemsSource="{Binding}" HeadersVisibility="Column">
                 <data:DataGrid.Columns>
                     <data:DataGridTemplateColumn Header="Column 1">
                         <data:DataGridTemplateColumn.CellTemplate>
                             <DataTemplate>
                                 <ListBox MinHeight="15" ItemsSource="{Binding Path=Column1.View}" >
                                     <ListBox.ItemTemplate>
                                         <DataTemplate>
                                             <StackPanel Orientation="Horizontal">
                                                 <TextBlock Margin="10" Text="{Binding Path=SomeName}" />
                                                 <TextBlock Margin="10" Text="{Binding SomeValue}" />
                                             </StackPanel>
                                         </DataTemplate>
                                     </ListBox.ItemTemplate>
                                 </ListBox>
                             </DataTemplate>
                         </data:DataGridTemplateColumn.CellTemplate>
                     </data:DataGridTemplateColumn>
                     <data:DataGridTemplateColumn Header="Column 2">
                         <data:DataGridTemplateColumn.CellTemplate>
                             <DataTemplate>
                                 <ListBox MinHeight="15" ItemsSource="{Binding Path=Column2.View}" >
                                     <ListBox.ItemTemplate>
                                         <DataTemplate>
                                             <StackPanel Orientation="Horizontal">
                                                 <TextBlock Margin="10" Text="{Binding SomeName}" />
                                                 <TextBlock Margin="10" Text="{Binding SomeValue}" />
                                             </StackPanel>
                                         </DataTemplate>
                                     </ListBox.ItemTemplate>
                                 </ListBox>
                             </DataTemplate>
                         </data:DataGridTemplateColumn.CellTemplate>
                     </data:DataGridTemplateColumn>
                 </data:DataGrid.Columns>
             </data:DataGrid>
             <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
                 <TextBlock Margin="5" Text="Name:"/>
                 <TextBox x:Name="tbNAme" Margin="5" Width="100"></TextBox>
                 <TextBlock Margin="5" Width="100" Text="Value:"/>
                 <TextBox x:Name="tbValue" Margin="5" Width="100"></TextBox>
                 <Button x:Name="AddButton" Margin="5" Content="Add" Click="AddButton_Click"/>
             </StackPanel>
             <StackPanel HorizontalAlignment="Left">
                 <Button x:Name="ChangeNameButton" Width="100" Content="Change Name" Click="ChangeNameButton_Click"/>
                 <Button x:Name="ChangeValueButton" Width="100" Content="Change Value" Click="ChangeValueButton_Click"/>
                 <Button x:Name="refresh" Width="100" Content="Refresh CVS" Click="refresh_Click" />
             </StackPanel>
         </StackPanel>
   </Grid>
 </UserControl>
 

Here is the code behind:

Code Snippet



 using System.Collections.ObjectModel;
 using System.Windows.Controls;
 using System.Windows.Data;
 
 namespace SilverlightApplication1
 {
     public partial class MainPage : UserControl
     {
         ObservableCollection<TestClass> theMainCollection ;
         ObservableCollection<TheRowClass> theDataContext;
         public MainPage()
         {
             InitializeComponent();
             theMainCollection = new ObservableCollection<TestClass>()
                 { new TestClass() {SomeName="A",SomeValue=11},
                     new TestClass() {SomeName="A",SomeValue=12},
                     new TestClass() {SomeName="B",SomeValue=13},
                     new TestClass() {SomeName="B",SomeValue=14},
                     new TestClass() {SomeName="AB",SomeValue=21},
                     new TestClass() {SomeName="BC",SomeValue=22},
                     new TestClass() {SomeName="AB",SomeValue=23},
                     new TestClass() {SomeName="BC",SomeValue=24}
                 };
            
             theDataContext = new ObservableCollection<TheRowClass>();
             theDataContext.Add(new TheRowClass(theMainCollection));
             theDataContext.Add(new TheRowClass(theMainCollection));
 
             TheMainDataGrid.DataContext = theDataContext;
             AddFilter(theDataContext[0].Column1, 1, 1);
             AddFilter(theDataContext[0].Column2, 1, 2);
             AddFilter(theDataContext[1].Column1, 2, 1);
             AddFilter(theDataContext[1].Column2, 2, 2);
             
 
         }
         private void AddFilter(CollectionViewSource cvs, int row, int column)
         {
             cvs.Filter += delegate(object o, FilterEventArgs eArgs)
             {
                 //Simple filter saying if column = 1 look for an A in the SomeName property
                 //Else look for a B.  If we are in Row 1 look for a 1 in the SomeValue property
                 //Else look for a 2
                 string columnFilter;
                 if (column == 1)
                     columnFilter = "A";
                 else
                     columnFilter = "B";
                 if ((eArgs.Item as TestClass).SomeValue.ToString().Contains(column.ToString()) && (eArgs.Item as TestClass).SomeName.Contains(columnFilter))
                     eArgs.Accepted = true;
                 else
                     eArgs.Accepted = false;
             };
 
         }
 
         private void AddButton_Click(object sender, System.Windows.RoutedEventArgs e)
         {
             TestClass tc = new TestClass();
             tc.SomeName = tbNAme.Text;
             tc.SomeValue = int.Parse(tbValue.Text);
             theMainCollection.Add(tc);
         }
 
         private void ChangeNameButton_Click(object sender, System.Windows.RoutedEventArgs e)
         {
             theMainCollection[theMainCollection.Count-1].SomeName = "B";
         }
 
         private void ChangeValueButton_Click(object sender, System.Windows.RoutedEventArgs e)
         {
             theMainCollection[theMainCollection.Count - 1].SomeValue = 25;
         }
 
         private void refresh_Click(object sender, System.Windows.RoutedEventArgs e)
         {
             theDataContext[0].Column1.View.Refresh();
             theDataContext[1].Column1.View.Refresh();
             theDataContext[0].Column2.View.Refresh();
             theDataContext[1].Column2.View.Refresh();
         }
     }
 }
 

Here is the TestClass Code:

Code Snippet



 using System;
 using System.ComponentModel;
 
 namespace SilverlightApplication1
 {
     public class TestClass:INotifyPropertyChanged
 
     {
         public String SomeName { get; set; }
 
         private int _someValue;
         public int SomeValue
         {
             get
             {
                 return _someValue;
             }
             set
             {
                 if (value != this._someValue)
                 {
                     this._someValue = value;
                     NotifyPropertyChanged("SomeValue");
                 }
             }
         }
 
         #region INotifyPropertyChanged Members
 
         public event PropertyChangedEventHandler PropertyChanged;
 
 
 
         #endregion
 
         private void NotifyPropertyChanged(String info)
         {
             if (PropertyChanged != null)
             {
                 PropertyChanged(this, new PropertyChangedEventArgs(info));
             }
         }
     }
 }
 

Here is TheRowClass:

Code Snippet



 using System.Windows.Data;
 using System.Collections;
 
 namespace SilverlightApplication1
 {
     public class TheRowClass
     {
         public TheRowClass(IEnumerable source)
         {
             Column1 = new CollectionViewSource();
             Column1.Source = source;
             Column2 = new CollectionViewSource();
             Column2.Source = source;
         }
         public CollectionViewSource Column1 { get; set; }
         public CollectionViewSource Column2 { get; set; }
     }
 }
 

Technorati Tags: Silverlight 3,CollectionViewSource,ObservableCollection,DataGrid

Design and Code Review Checklist - scoping

2009-10-30T09:43:00.001-05:00

Here is my scoping/access modifier cheat sheet.

Classes:

Public Class - Access is not restricted.
Private Class - Only valid for nested classes
Internal Class - only visible to the assembly

Members:

Private Member - only available to the containing type
Protected Member - Available to the containing type and anything derived from the containing type.
Internal Member - available to current assembly.
Protected Internal Member - Available to current assembly or anything derived from containing type.
Public Member - Access is not restricted

Valid Member Access Modifiers:

Enum - public
Interface - public
Class - public, private, internal, protected, protected internal
Struct - public, private, internal

Inheritance:

Abstract class - cannot be instantiated. May have abstract and non abstract methods. Derived class must implement all abstract methods.
Sealed Class - Cannot be inherited
Virtual Method - may be overridden
Abstract method - no implementation, must be overridden
Sealed method - Cannot be overridden
Sealed Override Method - No longer may be overridden. Public sealed override MyMeth()

(My design review checklist)

Technorati Tags: Design review,Architecture,Agile principles,YAGNI,c# coding standards,code review

Design and Code Review – Look at the code.

2009-10-30T09:38:00.002-05:00

Many things need to be considered when we do a code review (My design review checklist).

Is the code logically correct?

Are we following best practices?

Are we considering security?

Did we run a code review? If you have a team or enterprise developer edition, the code review may be found in the Analyze menu.

Is the code maintainable?

Is our code unnecessarily complex? I always favor simplicity until forced to do otherwise.

Is the error handling effective?

Will our code perform? I tend to assume it will until proven otherwise.

Are our objects loosely coupled?

Did we follow our coding standards? idesign has a pretty good C# and WCF coding standard freely available on their website (right hand side). http://www.idesign.net/idesign/DesktopDefault.aspx?tabindex=0&tabid=1

Technorati Tags: Design review,Architecture,Agile principles,YAGNI,c# coding standards,code review

Intertech R&D: Share your thoughts!

2009-10-21T22:35:00.001-05:00

James White, who oversees R&D at Intertech, is conducting a survey to help define our 2010 R&D plan. If you complete the survey, you'll be eligible to save $250 on any Intertech course. Intertech R&D Survey.

I have been an Intertech employee for just over a year but I have been an Intertech customer since about 1998. I started with learning COM + ATL and most recently completed the WPF course and there are about 7 other classes I have taken in between. I have been writing software professionally since 1993 and I still take take every chance I get to step into the classroom and keep my skills sharp. The course are terrific and the instructors are the best I have ever seen. I highly recommend Intertech training.

A look at test planning with Microsoft Test and Lab Manager. Part 3, Executing manual tests.

2009-10-20T22:33:00.001-05:00

In part three of my series on using Microsoft Test and Lab Manager we are going to take a look at running and analyzing test results.

Let’s first look at the right hand side of the screen again.

Notice that we have to run a test for each test case and configuration combination so even though we defined 2 test cases we see that we need to execute 5 tests because each of the test cases must be run on more than one configuration.

The tests are grouped by results; in our case we have one test at the ready state, 3 completed tests, and 1 test that has been marked as not ready.

There is a cool visual indicator at the top of the grid so we can quickly assess the state of the test plan.

Finally we have some quick tools that allow us to block, unblock, and reset a test to a ready state. This would be useful if we determine a test is flawed and we want to block the execution of the test until we have a chance to fix it.

If we click on the analyze test runs section we get the following screen. We have a summary section at the top, the middle section is an overview section and the bottom is a fully editable grid view of the test results.

By clicking on the my bugs section we get a list of TFS work items that are assigned to us.

Moving on to the track tab we see the screen where we can assign the build. When we assign the build we get a list of work items that have been fixed and need to be verified.

If we move on to the recommended tests section we can select a build and look at the impact the code changes have on testing. We will discuss in the test impact analysis section.

Technorati Tags: VSTS 2010 beta 1,Microsoft test and lab manager,VSTT 2010,test planning,TFS testing

A look at test planning with Microsoft Test and Lab Manager. Part 5,Test Impact Analysis

2009-10-20T21:53:00.001-05:00

In part five of my series on using Microsoft Test and Lab Manager we are going to take a look at test impact analysis.

I find the test impact analysis feature to be one of the most exciting new features of VSTS. As you read through this blog entry keep in mind this is based on beta 1 (beta 2 was released to MSDN subscribers)

From a high level, following are the steps we need to take to enable test impact analysis.

• Add the test project to source control.

• Create the build definition.

• Make sure “Analyze Test Impacts” in the Process tab is set to “True”.

• Queue a new build.

• Make sure the “Test Impact Collector” option is set in test settings file.

• Run the tests in the test project (this collects the test impact data)

• Change the code.

• Run a new build. (the test impact analysis runs)

• Test manager – Assign the new build

• Test Manager - Track/Recommended tasks

Here is a very good walk through: http://blogs.msdn.com/densto/archive/2009/06/29/test-impact-walk-through.aspx

Once we get things lined up there are a couple places we can see the recommended tests:

1) In the test and lab manager we can see the impacted tests in the Testing Center area - Track tab under the recommended tests section. By comparing the build in use to the previous build, VSTS recommends what tests to run based on the code changes.

2) In Visual Studio the developer can use the test impact view to get a list of tests that will be impacted by a code change before the change is checked in. The idea here is rather than running all unit tests, the developer can run a subset (the impacted tests) of the tests and be confident that the change is safe.

3) The build report will include an interactive list of tests that had been impacted by the code changes in the build. Anybody that gets the build report can get a list of all tests impacted by the changes in the build.

The new test impact analysis is a must use feature. As a former development manager I can’t tell you how many times I was forced to make a decision about how to hot fix a bug while minimizing the possibility of braking anything and all I had to go on was a gut feel and experience. This new feature gives the developer a way to fully understand the potential impact of a change before making it. It also gives a clear set of tests to perform to insure that the released code is of the highest quality possible.

Technorati Tags: VSTS 2010 beta 1,Microsoft test and lab manager,VSTT 2010,test planning,TFS testing,test impact analysis

A couple basic WPF databinding examples.

2009-10-10T16:29:00.001-05:00

The databinding options available to us in WPF are numerous and powerful. We can bind a UI element to an object, a list, another UI element, a collection, an ADO.Net object and the list goes on and on. You can bind declaratively or programmatically. You can bind one way, two way, or one time.

Let’s take a look at just a couple of these databinding options. Say we are creating a user preference page and from this page we want to allow the user to specify the foreground color of a textbox by typing an ARGB number in a textbox. Further, we want the color of the text in the textbox to represent the color that was typed into the textbox. We are trying to bind the foreground property of the textbox to the value of the textbox’s Text property.

Here is what our app looks like:

Here is the code that will pull that off:

Code Snippet



 <Window x:Class="WpfSelfBinding.Window1"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     Title="Window1" Height="300" Width="300">
     <Grid>
         <Label Height="28" Margin="12,47,0,0" Name="label1" VerticalAlignment="Top" 
                HorizontalAlignment="Left" Width="100">Text Color</Label>
         <TextBox x:Name="tbColor" Height="23" Margin="110,49,48,0"  VerticalAlignment="Top" 
                  Foreground="{Binding Text,RelativeSource={RelativeSource Self}}"  >
         </TextBox>
     </Grid>
 </Window>
 

The key bit of XAML we need to focus on is the textbox’s Foreground property:

Foreground="{Binding Text,RelativeSource={RelativeSource Self}}"

This binding is telling the app to bind the Textbox’s Foreground property to the value of the Text property of myself. If you run the App you will notice that as you change the value of the textbox, the color of the text will also change.

Now I can’t get even close to the color I want by using ARGB so let’s see if we can make the user experience a little more pleasant. let’s give the user the option of selecting the color from a color picker. WPF does not have a color picker dialog so we will have to use the Windows Forms library. We’ll modify the app a little bit and add a button that will launch the color picker and populate the textbox with the result.

Here is the new UI:

The new XAML:

Code Snippet



 <Window x:Class="WpfSelfBinding.Window1"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     Title="Window1" Height="300" Width="300">
     <Grid>
         <Label Height="28" Margin="12,47,0,0" Name="label1" VerticalAlignment="Top" 
                HorizontalAlignment="Left" Width="100">Text Color</Label>
         <TextBox x:Name="tbColor" Height="23" Margin="110,49,48,0"  VerticalAlignment="Top" 
                  Foreground="{Binding Text,RelativeSource={RelativeSource Self}}"  >
         </TextBox>
         <Button x:Name="btnColor" Height="23" HorizontalAlignment="Right" Margin="0,49,24,0" 
                 VerticalAlignment="Top" Width="18" Click="btnColor_Click">...</Button>
     </Grid>
 </Window>
 

And the code behind:

Code Snippet



 using System.Windows;
 using System.Windows.Media;
 namespace WpfSelfBinding
 {
     /// <summary>
     /// Interaction logic for Window1.xaml
     /// </summary>
     public partial class Window1 : Window
     {
 
         public Window1()
         {
             InitializeComponent();
 
         }
 
         private void btnColor_Click(object sender, RoutedEventArgs e)
         {
             System.Windows.Forms.ColorDialog colorDialog = new System.Windows.Forms.ColorDialog();
             System.Windows.Forms.DialogResult result = colorDialog.ShowDialog();
             if (result == System.Windows.Forms.DialogResult.OK)
             {
                 tbColor.Text = SysDrawColorWinMediaColor(colorDialog.Color).ToString();
             }
         }
 
         private Color SysDrawColorWinMediaColor(System.Drawing.Color color)
         {
             System.Windows.Media.Color bColor;
             int i = color.ToArgb();
             byte a = (byte)((i >> 24) & 255);
             byte r = (byte)((i >> 16) & 255);
             byte g = (byte)((i >> 8) & 255);
             byte b = (byte)(i & 255);
             bColor = Color.FromArgb(a, r, g, b);
             return bColor;
         }
     }
 }
 

Two things are worth noting in the code. Rather than importing the System.Windows.Forms namespace, we just use the fully qualified class name. This is because there are several conflicts between WPF classes and windows forms classes in the System.Windows.Forms namespace. The second thing we have to do is convert the color returned by the color picker (System.Drawing.Color) to a System.Windows.Media color. We use bit shifting and a bit mask to pull this off in the SysDrawColorWinMediaColor function.

Rather than using the color dialog result to directly set the text property of the textbox let’s say we want to populate an object ( so we can persist the selection to a database or isolated storage). It would be cool if we could bind directly to this class.

The UI looks exactly the same but here is our new class

Code Snippet



 using System.ComponentModel;
 
 namespace WpfSelfBinding
 {
     class BindableColorClass:INotifyPropertyChanged
     {
         private string textColor = "#FF0F0FF0";
         public event PropertyChangedEventHandler PropertyChanged;
         protected void OnPropertyChanged(string name)
         {
             PropertyChangedEventHandler handler = PropertyChanged;
             if (handler != null)
             {
                 handler(this, new PropertyChangedEventArgs(name));
             }
         }
 
         public string TextColor
         {
             get { return textColor; }
             set
             {
                 if (textColor != value)
                 {
                     textColor = value;
                     OnPropertyChanged("TextColor");
                 }
             }
         }
     }
 }
 

The key here is that our class implements INotifyPropertyChanged. We raise the PropertyChanged event when the TextColor property changes. This event is what wires our class into WPF’s Data Change Notification mechanism.

Here is the new Window1 code:

Code Snippet



 using System.Windows;
 using System.Windows.Media;
 namespace WpfSelfBinding
 {
     /// <summary>
     /// Interaction logic for Window1.xaml
     /// </summary>
     public partial class Window1 : Window
     {
         BindableColorClass colorClass = new BindableColorClass();
         public Window1()
         {
             InitializeComponent();
             tbColor.DataContext = this.colorClass;
         }
 
         private void btnColor_Click(object sender, RoutedEventArgs e)
         {
             System.Windows.Forms.ColorDialog colorDialog = new System.Windows.Forms.ColorDialog();
             System.Windows.Forms.DialogResult result = colorDialog.ShowDialog();
             if (result == System.Windows.Forms.DialogResult.OK)
             {
                 colorClass.TextColor = SysDrawColorWinMediaColor(colorDialog.Color).ToString();
             }
         }
 
         private Color SysDrawColorWinMediaColor(System.Drawing.Color color)
         {
             System.Windows.Media.Color bColor;
             int i = color.ToArgb();
             byte a = (byte)((i >> 24) & 255);
             byte r = (byte)((i >> 16) & 255);
             byte g = (byte)((i >> 8) & 255);
             byte b = (byte)(i & 255);
             bColor = Color.FromArgb(a, r, g, b);
             return bColor;
         }
     }
 }
 

There are a couple things to pay particular attention to here. First we have a class variable referencing an instance of our BindableColorClass. Next, notice in our btnColor_Click event we are updating the TextColor of the BindableColorClass, NOT the textbox’s text value. Finally notice that on class construction we are setting the textbox’s DataContext to our instance of the BindableColorClass.

Here is the ne XAML:

Code Snippet



 <Window x:Class="WpfSelfBinding.Window1"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     Title="Window1" Height="300" Width="300">
     <Grid>
         <Label Height="28" Margin="12,47,0,0" Name="label1" VerticalAlignment="Top" 
                HorizontalAlignment="Left" Width="100">Background Color</Label>
         <TextBox x:Name="tbColor" Height="23" Margin="110,49,48,0"  VerticalAlignment="Top" 
                  Foreground="{Binding Text,RelativeSource={RelativeSource Self}}"  >
             <TextBox.Text>
                 <Binding Path="TextColor" Mode="TwoWay"/>
             </TextBox.Text>
         </TextBox>
         <Button x:Name="btnColor" Height="23" HorizontalAlignment="Right" Margin="0,49,24,0" 
                 VerticalAlignment="Top" Width="18" Click="btnColor_Click">...</Button>
     </Grid>
 </Window>
 

The XAML we want to focus on:

<TextBox.Text>
<Binding Path="TextColor" Mode="TwoWay"/>
</TextBox.Text>

This tells WPF to bind the TextBox.Text property to the “TextColor” property. The “TextColor” property of what?? Our background property uses the source property to tell WPF which item’s text property to bind to but we didn’t specify one here. Since we didn’t set the source property, WPF is going to look for a DataContext which we DO set in our code behind.

tbColor.DataContext = this.colorClass;

WPF knows to bind the textbox’s text property to TextColor property of the windows colorClass.

The intention is to persist the BindableColorClass eventually so we need the TextColor property to be changed either from the color picker or by typing the ARGB color into the TextBox. To pull this off all we have to do is set the binding Mode to TwoWay. Set a break point on the TextColor getter and setter to see when they fire. If you are typing the ARGB color into the textbox by hand you will need to tab out of the textbox to get the change to take place. This is the default textbox binding behavior.

Technorati Tags: C#,WPF,databinding,TwoWay,RelativeSource,Self,INotifyPropertyChanged

A look at test planning with Microsoft Test and Lab Manager. Part 2, test planning.

2009-10-03T10:47:00.001-05:00

In part two of my series on using Microsoft Test and Lab Manager we are going to take a look at test planning.

The Testing Center Area

From a high level the testing center is where we create and execute our test plans, track our testing progress, assign builds, and determine our recommended tests.

Plan Tab

In the contents view of the plan tab we have a split screen. The left hand side is used for managing and organizing requirements. The right hand side is for managing test cases. Let’s drill into some other plan concepts before we explore the plan contents screen.

Plan - Properties

Each test plan has some properties associated to it. These properties include the test plan name and description, the TFS project it is associated to, some default test settings and configurations, build information, and some tracking info such as owner, state, and dates.

If we drill into the test settings we see the following:

The general tab is used to name and describe the settings as well as set some options regarding how the tests will be run.

The data and diagnostics tab is where we configure what we want to collect during a test run.

Action recording and log is used to record and play back the test as well as capturing a textual description of what is happening during the test. Have a look at this log the descriptions are good, we could record an exploratory type test and then copy paste entries from this log into the steps of a more specific test case.

ASP.Net profiler is used to collect asp.net performance data during a test run.

Collecting code coverage data allows us to track how much of the code we are covering during our test runs.

Diagnostic trace collector captures events and call stack information for the historical debugger.

When we collect the event log information, any new event log entry created during a test run is attached to the test run.

Network Emulation is used to emulate different qualities of network such as T1, DSL and dial up.

By collecting the system information with the test run we are attaching the OS version, amount of ram, CPU speed, and a handful of other details to our test results.

The test impact is a really cool feature. If we collect this information during a test run, TFS can tie the test to the code paths that are being executed. This information is later used during a build to allow TFS to actually suggest which tests to run. Or at development time to tell developers what tests will be impacted by changes to code. Important: we may not collect test impact data at the same time as we collect code coverage data.

Collecting the video recording will attach a video of exactly what the tester is doing during a test run. Developers can later replay this video to see exactly how a bug was produced.

Plan – Set Plan Context

This is the screen we use to manage our list of test plans and set our plan context. The list of plans in this screen is limited to all plans associated to the TFS project displayed in the title bar. Select the plan we want to work with and click the set context icon.

Plan - Contents

We find ourselves back at the plan contents screen. Remember, the context of this screen is determined by the plan we selected in the last step. We’ll explore the left side of the screen first. This is the place we select and organize user stories (requirements) and ultimately associate them to the test cases on the left hand side. I want to mention that Microsoft has introduced the notion of a suite. A suite is a generic bucket used to build a hierarchy any way we want. Think of them as folders in windows explorer, they are just used to group and associate our user stories.

To start things out we need some user stories to exist in TFS. If we bounce over to team explorer we can see an example of the default user story template. The QA team is not typically responsible for entering user stories.

Once the user stories exist in TFS, we can click the add requirement button in the test and lab manager and we will get a list of the user stories associated to the team project.

If we select Import we can copy the user stories and test cases from an existing test plan. This copy may be individual user stories, suites (groups of user stories), or all of the stories in the entire test plan. There is even a nice feature that allows us to configure a query based suite. In a query based suite, the test case list is dynamic. As test cases are added to TFS that match the query parameters, the list of test cases in the suite will change dynamically.

Now let’s take a look at the right hand side of the plan contents screen. This is the test case area.

From here we can add an existing test case. The following screen is used to search our TFS project for existing test cases.

We can also add new test cases from the plan contents screen. Following is the default test case work item template. Notice at the bottom of the test case I have configured 3 steps. From here I can also configure variables for data binding and insert shared steps.

If we click on the configurations button in the plan contents screen we get the following screen. Here we configure which tests run against which configuration. In my example I have 2 test cases, the first is configured to run on; a Vista machine with the 3.5 version of the .Net framework installed and a Vista machine with the 4.0 version of the .Net framework installed. The second case runs against both of those configurations and additionally needs to run on a machine with Vista and IE7 installed. The cool thing about this is the configurations have a multiplier effect. When it comes time to execute these two test cases 5 tests will be created, one for each configuration.

The last screen I want to look at in this post is the “Assign Testers” screen. To get here we click the assign button from the test contents screen. This is where we assign TFS users to each individual test (a combination of a test case + a configuration).

Technorati Tags: VSTS 2010 beta 1,Microsoft test and lab manager,VSTT 2010,test planning,TFS testing

YAGNI – You ain’t gonna need it

2009-10-01T22:52:00.001-05:00

The YAGNI principle states that programmers should not implement functionality until it is necessary. It is a pretty simple principle but oddly enough it is a difficult principle to follow.

I’ll take a crack at what I think the upside of breaking this rule is.

It seems to me the biggest benefit to breaking this principle is that we can architect and design our code by taking into account both current and future features thus implementing a more robust design.
Another big argument is that by implementing this feature our software will be more useful. If our software is more useful we may sell more licenses or we may be more productive.

Let’s look at the most obvious negatives of implementing a feature before you need it. This is a longer list.

If we don’t need it yet, maybe we should be spending our time and money implementing something we do need now.
If we implement a feature we should have some corresponding documentation describing the feature – this takes time.
If we implement something we need to test it -every release and this takes a lot of time.
When we add a feature in an agile/TDD shop, we need to write unit tests for the feature so we can automatically test it every release. Writing the tests can take as long as or longer than writing the feature and anyone who has to run unit tests before a check in will probably agree that adding time to this automated process is not good.
When we add a feature we need to train the support crew and user base on how to use the feature.
A feature is hard enough to implement correctly when it is needed, how do we expect to implement it optimally when we are still guessing whether or not we need it?

A quick summary of the negatives: We are spending time writing code for something we might need. We are writing the feature the way we think we will need it in the future. We are spending time and money documenting and testing a feature that we are guessing we will need and by the way we are also guessing how to best implement it.

If all of those (mostly financial) arguments aren’t enough to convince you, let’s take a look at some down sides from an architect or developer’s point of view.

If code is in a release you have to assume it is being used. When it comes time to change the code you think you needed, you are going to spend time figuring out how to change it without breaking the (imagined?) user base. This might involve migrating data, configurations, backup procedures, reports, integration work flows etc. When it comes time to change the code you really do need you must consider all of the code. This includes the code you don’t realize that you don’t need – if it is in production, how can you be confident in saying “oh, we really don’t need that code”. This really stifles our ability to modernize our code. Even if you do find a way to refactor the bloated code base not only will you have to change the existing code but you will have to change the tests, documentation, and training materials.

Let the business analysts, user base, and marketing folks decide what features your product needs and when it needs it. I would rather architect and design a system based on things that are known. I don’t ever want to tell somebody that the system is the way it is because I thought we needed some functionality that turns out to be useless. When we do a good job of designing and reviewing our system we can be confident that we can refactor our code to implement major functional changes when they are understood, needed, and the highest priority.

My design review checklist

Technorati Tags: Design review,Architecture,Agile principles,YAGNI

WPF Styles and Animations

2009-09-24T06:55:00.003-05:00

I have been working with WPF lately and I’m really impressed with the style capabilities. From a high level our goal when using styles is to be able to set some standard properties of various controls one time in one place and have them affect many or all of the controls of that type in our window or application.

Let’s start with a really basic window and a hand type a few controls.

Code Snippet



<Window x:Class="Lesson1Styles.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Window1" Height="300" Width="300">
<Grid>
<Label Margin="0,25,0,0" VerticalAlignment="Top" >
Style Driven Label
</Label>
<TextBox Margin="0,100,0,0" VerticalAlignment="Top">
Style Driven TextBox
</TextBox>
<Button Margin="0,175,0,0" VerticalAlignment="Top" >
Style Driven Button
</Button> 
</Grid>
</Window>

One of the reasons for hand typing the controls is that I chose to only set the margin and alignment of the controls and I didn’t want the designer to add any height and width properties. If we run the application now here is what we see.

Now let’s create a style for each of our controls by adding a Window.Resources element.

Code Snippet



<Window.Resources>
<Style TargetType="TextBox">
<Setter Property="Background" Value="Yellow"/>
<Setter Property="Foreground" Value="Purple"/>
<Setter Property="BorderBrush" Value="Purple"/>
<Setter Property="Width" Value="135"/>
<Setter Property="Height" Value="30"/>
</Style>
<Style TargetType="Label">
<Setter Property="Foreground" Value="Purple"/>
<Setter Property="Background" Value="Yellow"/>
<Setter Property="Width" Value="135"/>
<Setter Property="Height" Value="33"/>
</Style>
<Style TargetType="Button">
<Setter Property="Background" Value="Yellow"/>
<Setter Property="Foreground" Value="Purple"/>
<Setter Property="Width" Value="135"/>
<Setter Property="Height" Value="30"/>
</Style>
</Window.Resources>

Our new window now looks like this:

Note - I did not have to set a style property on any of the UI Elements. This is because I set the TargetType property in each style and the runtime knew to apply each style to their corresponding controls. Any label, button, or textbox you add to the window will inherit these styles unless you explicitly override the style or individual properties of the style.

It would be highly unusual (ok…ugly) for us to want our labels, buttons, and textboxes to have the same size and color scheme but if we did, it would be nice to not have to duplicate these attributes for each control.

With style inheritance we can do just that. We declare a base style with a TargetType of Control and move all of the common properties into this style. The following refactored code will render the window exactly as we see above.

Code Snippet



<Window.Resources>
<Style x:Key="baseStyle" TargetType="Control">
<Setter Property="Background" Value="Yellow"/>
<Setter Property="Foreground" Value="Purple"/>
<Setter Property="BorderBrush" Value="Purple"/>
<Setter Property="Width" Value="135"/>
<Setter Property="Height" Value="30"/>
</Style>
<Style TargetType="TextBox" BasedOn="{StaticResource baseStyle}">
</Style>
<Style TargetType="Label" BasedOn="{StaticResource baseStyle}">
</Style>
<Style TargetType="Button" BasedOn="{StaticResource baseStyle}">
</Style>
</Window.Resources>

Let’s look at how we can override a portion of the style. If we want our textbox style to have a different height and width than the base style we can simply duplicate the height and width property setter in the style for the textbox and set the value to whatever we want. For example, if we change the textbox style as follows:

Code Snippet



<Style TargetType="TextBox" BasedOn="{StaticResource baseStyle}">
<Setter Property="Width" Value="60"/>
<Setter Property="Height" Value="60"/>
</Style>

Our window looks like this:

We can even override these properties at the control level. Let’s add a Height property to our textbox control.

Code Snippet

<TextBox Margin="0,100,0,0" VerticalAlignment="Top" Width="200">
Style Driven TextBox
</TextBox>

Now when we run, the textbox width is based on the property we set in the control – we override the style defined for the Button which in turn overrides the style we have set for all Controls.

To close things out let’s take a look at adding triggers to a style. If we want all labels to change their background color when the mouse is over the label we can add a Dependency Property Trigger to the style.

Code Snippet



<Style TargetType="Label" BasedOn="{StaticResource baseStyle}">
<Style.Triggers>
<Trigger Property="IsMouseOver" Value="True">
<Setter Property="Background" Value="Gray"/>
</Trigger>
</Style.Triggers>
</Style>

If we want to animate the textbox when the mouse is over the control we can add a Dependency Property Trigger with a StoryBoard and Animation defined. This animation changes the Font Size, height, width, and background color of the textbox.

Code Snippet



<Style TargetType="TextBox" BasedOn="{StaticResource baseStyle}">
<Setter Property="Width" Value="60"/>
<Setter Property="Height" Value="60"/>
<Style.Triggers>
<Trigger Property="IsMouseOver" Value="True">
<Trigger.EnterActions>
<BeginStoryboard Name="story1">
<Storyboard Duration="0:0:5">
<DoubleAnimation Storyboard.TargetProperty="FontSize" To="20"/>
<ColorAnimation Storyboard.TargetProperty="(Background).(SolidColorBrush.Color)" To="Gray"/>
<DoubleAnimation Storyboard.TargetProperty="Height" To="50"/>
<DoubleAnimation Storyboard.TargetProperty="Width" To="270"/>
</Storyboard>
</BeginStoryboard>
</Trigger.EnterActions>
<Trigger.ExitActions>
<StopStoryboard BeginStoryboardName="story1"/>
</Trigger.ExitActions>
</Trigger>
</Style.Triggers>
</Style>

Finally we’ll add a Routed Event trigger to the button just to demonstrate the different trigger options.

Code Snippet



<Style TargetType="Button" BasedOn="{StaticResource baseStyle}">
<Style.Triggers>
<EventTrigger RoutedEvent="Mouse.MouseEnter" >
<BeginStoryboard Name="story3">
<Storyboard Duration="0:0:2">
<DoubleAnimation
Duration="0:0:0.2"
Storyboard.TargetProperty="Height"
To="90" />
</Storyboard>
</BeginStoryboard>
</EventTrigger>
<EventTrigger RoutedEvent="Mouse.MouseLeave" >
<BeginStoryboard Name="story34">
<Storyboard Duration="0:0:2">
<DoubleAnimation
Duration="0:0:0.2"
Storyboard.TargetProperty="Height" />
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Style.Triggers>
</Style>

We could do all of the styling and animation in code if we want but the good thing about doing this declaratively is if we are not happy with our Minnesota Viking look and feel, we can have a UI designer use a tool like Expression Blend to make things look nice without requiring that they understand code or XAML.

Try adding some other textboxes, labels, and buttons to see what style properties are inherited.

Here is the XAML in it’s entirety:

Code Snippet



<Window x:Class="Lesson1Styles.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Window1" Height="300" Width="300">
<Window.Resources>
<Style x:Key="baseStyle" TargetType="Control">
<Setter Property="Background" Value="Yellow"/>
<Setter Property="Foreground" Value="Purple"/>
<Setter Property="BorderBrush" Value="Purple"/>
<Setter Property="Width" Value="135"/>
<Setter Property="Height" Value="30"/>
</Style>
<Style TargetType="TextBox" BasedOn="{StaticResource baseStyle}">
<Setter Property="Width" Value="60"/>
<Setter Property="Height" Value="60"/>
<Style.Triggers>
<Trigger Property="IsMouseOver" Value="True">
<Trigger.EnterActions>
<BeginStoryboard Name="story1">
<Storyboard Duration="0:0:5">
<DoubleAnimation Storyboard.TargetProperty="FontSize" To="20"/>
<ColorAnimation Storyboard.TargetProperty="(Background).(SolidColorBrush.Color)" To="Gray"/>
<DoubleAnimation Storyboard.TargetProperty="Height" To="50"/>
<DoubleAnimation Storyboard.TargetProperty="Width" To="270"/>
</Storyboard>
</BeginStoryboard>
</Trigger.EnterActions>
<Trigger.ExitActions>
<StopStoryboard BeginStoryboardName="story1"/>
</Trigger.ExitActions>
</Trigger>
</Style.Triggers>
</Style>
<Style TargetType="Label" BasedOn="{StaticResource baseStyle}">
<Style.Triggers>
<Trigger Property="IsMouseOver" Value="True">
<Setter Property="Background" Value="Gray"/>
</Trigger>
</Style.Triggers>
</Style>
<Style TargetType="Button" BasedOn="{StaticResource baseStyle}">
<Style.Triggers>
<EventTrigger RoutedEvent="Mouse.MouseEnter" >
<BeginStoryboard Name="story3">
<Storyboard Duration="0:0:2">
<DoubleAnimation
Duration="0:0:0.2"
Storyboard.TargetProperty="Height"
To="90" />
</Storyboard>
</BeginStoryboard>
</EventTrigger>
<EventTrigger RoutedEvent="Mouse.MouseLeave" >
<BeginStoryboard Name="story34">
<Storyboard Duration="0:0:2">
<DoubleAnimation
Duration="0:0:0.2"
Storyboard.TargetProperty="Height" />
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Style.Triggers>
</Style>
</Window.Resources>
<Grid>
<Label Margin="0,25,0,0" VerticalAlignment="Top" >
Style Driven Label
</Label>
<TextBox Margin="0,100,0,0" VerticalAlignment="Top" Width="200">
Style Driven TextBox
</TextBox>
<Button Margin="0,175,0,0" VerticalAlignment="Top" >
Style Driven Button
</Button>
</Grid>
</Window>

Technorati Tags: WPF,Style,Style Trigger,Windows PResentation Foundation

VSTS 2010 Test Run recording

2009-09-19T09:50:00.001-05:00

In part four of my series on using Microsoft Test and Lab Manager we are going to take a look at test runner.

Here is the recording I showed at the VSTS MN user group. By way of setting things up I am executing a single manual test that results in a failure in our expected result. It is the first time I ran (and recorded) the test so when test runner comes up I do not have the option of executing the recorded test. Here is a screen grab of what it would look like if I had the recording in place:

Of special note is the very powerful Start test and play option. This will allow you to execute each step via the recording (no room for mistakes) and enter the results as each step is finished.

In my video I run through creating a bug and then click through what things were attached to the bug based on my run settings.

Microsoft Test and Lab Manager. Test planning and execution.

2009-09-19T09:07:00.001-05:00

I was the presenter at the Minnesota VSTS Users Group this week. The topics I discussed included; test planning and execution with Microsoft Test and Lab Manager, test impact analysis, coded UI testing, and historical debugger. You can get a PDF version of my slide deck here. I had a couple presentation gremlins when I was introducing the historical debugger so I added a couple new slides explaining the configuration necessary to get the behavior I was describing during the presentation.

The slides themselves will do little more than wet your appetite so I’ll do a series of posts and add some narration describing what we are seeing and how it fits into the QA process.

Part 1, Getting organized.

Part 2, Test planning

Part 3, Executing manual tests

Part 4, the test run.

Part 5, Test impact analysis.

I’ll cover the Coded UI test and Historical debugger elsewhere.

A look at test planning with Microsoft Test and Lab Manager. Part 1, getting organized

2009-09-19T08:42:00.001-05:00

Let’s start with a high level look at the Test and Lab Manager. Test and Lab Manager is broken into 3 different areas; Lab Center, Test Center, and Organize. I’m not going to go into the lab center, I’m primarily going to look at the area of the product that a QA professional would use on a day to day basis.

The Lab Center:

This is where you manage environments, test run settings, environment templates and test controllers. We’ll drill into a couple of these concepts later.

The Organize area:

Test Plan tab.

The Test Plan tab of the organize area is where you manage test plan definitions and their context. This page contains a list of all plans associated with a TFS project.

Configuration tab.

The configuration tab is used to manage the different configurations you want to use during testing. In our example we have defined 4 configurations;

Vista with .Net framework 3.5

Vista with .Net framework 4.0

Vista with the Firefox browser

Vista with IE 7

The configuration variables are just name value pairs which may be managed by drilling into this tab.

Test Cases tab

Test Cases may be created copied and edited here. This is a place QA can go to create test cases rather than using team explorer and visual studio. The list is all test cases associated to the configured team project. Note: the context at the top center of the screen is a link that may be used to change your team project.

Shared Steps tab:

The idea of a shared step is that you may define commonly executed testing steps in this one place (login for example). When defining other tests that include these common steps, you may reference this shared step rather than duplicating the steps necessary to perform the common task. Not only is it less work to create tests when you use shared steps (less typing) but maintaining this common logic is much simpler as a change to the common task only needs to be made in the shared step – not in every test that calls it.

The shared steps tab is the place you would go to create, edit, copy, and record a shared step. Like test plans and test cases, the list is all shared steps associated to a team project.

In future posts I’ll go into more detail about creating the plans and tests as well as cover executing the test plans.

Technorati Tags: VSTS 2010 beta 1,Microsoft test and lab manager

Design and Code Review Checklist

2009-09-08T17:29:00.001-05:00

I have been blogging about some of the principles I use in design/code reviews reviews. Here is the full list of topics I look for, I’ll create links as I blog about more individual items in the future.

Review Unit Tests
Is the code in the right place?
Does the name space make sense? http://blogs.msdn.com/brada/articles/361363.aspx
Is the class / procedure / variable scope correct.
Are the Classes, methods, and variables named correctly? http://blogs.msdn.com/brada/articles/361363.aspx
Are the methods, and variables typed correctly?
Look at the code.
Review for OCP (open closed principle - Open for extension closed for modification)
Review for DRY Principle (Don't Repeat Yourself - abstract common things and put in single place).
Review for SRP (Single Responsibility Principle - every object has a single responsibility. All the object's services should be focused on that responsibility).
Review for LSP (Liskov Substitution Principle Subtypes must be substitutable for their base types).
Consider delegation over inheritance. If you don't need to change base class behavior, consider delegating (handing over responsibility of a task) rather than inheritance.
Consider Composition over inheritance. Similar to delegation except the owner class uses a set of behaviors and chooses which one to use at runtime. When the delegating class is destroyed, so are all the child classes.
Aggregation. Similar to composition except when the delegating class is destroyed, the child classes are not.
Consider Polymorphism. Make a group of heterogeneous classes look homogeneous
Consider generics.
Testability considerations?
YAGNI (You aint gonna need it) When in doubt, leave it out!
Does object wake up in a known good state (constructor)
Consider Security.

Technorati Tags: C#,Architecture,Code Review,Design Review

Design Review – Liskov Substitution Principle

2009-09-05T11:51:00.001-05:00

The (Barbara) Liskov Substitution principle states:

If for each object o1 of type S there is an object o2 of type T such that for all programs P defined in terms of T, the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T.

That hurts my head. Let’s again go with the definition from “Agile Principles, Patterns, And Practices in C#” Robert C Martin and Micah Martin: Subtypes must be substitutable for their base type.

There are two angles from which I want to look at this principle. Let’s look at it first from a structural standpoint. I’m going to reuse the refactored code from my last post with a slight change. Rather than having the conditions and actions implement the ISupportRules interface, they will be derived from an abstract class named RuleBase. This means our RulesEngine’s ExecuteRules method needs to accept a generic list of RuleBase.

The Code:

We have our enums :

Code Snippet



 
 namespace OpenClosePrinciple
 {
     public enum Actions
     {
         CreateOrder,
         CreateBackorder,
         CloseOrder,
         ShipOrder,
         StoreOrder,
         ReduceInventory
     }
     public enum Conditions
     {
         IsComplete,
         IsInStock,
         CanShip
     }
     public enum RuleType
     {
         Condition,
         Action
     }
 }
 

An Action derived from RuleBase:

Code Snippet



 
 namespace OpenClosePrinciple
 {
     public class CreateOrderAction:RuleBase
     {
         #region ISupportRules Members
 
         public override bool Execute()
         {
             return true;
         }
 
         public override RuleType TypeOfRule()
         {
             return RuleType.Action;
         }
 
         #endregion
     }
 }
 

A Condition derived from RuleBase:

Code Snippet



 
 namespace OpenClosePrinciple
 {
     public class CanShipCondition:RuleBase
     {
         #region ISupportRules Members
 
         public override bool Execute()
         {
             return true;
         }
 
         public override RuleType TypeOfRule()
         {
             return RuleType.Condition;
         }
 
         #endregion
     }
 }
 

RuleBase:

Code Snippet



 
 namespace OpenClosePrinciple
 {
     public abstract class RuleBase
     {
         public virtual bool Execute()
         {
             return true;
         }
 
         public abstract RuleType TypeOfRule();
     }
 }
 

The Rule Engine.

Code Snippet



 using System;
 using System.Data.SqlClient;
 using System.Collections.Generic;
 namespace OpenClosePrinciple
 {
     public class RefactoredRuleEngine
     {
 
         public void ExecuteRules(List<RuleBase> rules)
         {
             bool executing = true;
             int ruleIndex = 0;
             while (executing)
             {
                 if (rules[ruleIndex].TypeOfRule() == RuleType.Action)
                 {
                     executing = rules[ruleIndex].Execute();
                     ruleIndex++;
                 }
                 else
                 {
                     if (rules[ruleIndex].Execute())
                     {
                         ruleIndex++;
                         executing = true;
                     }
                     else
                     {
                         ruleIndex += 2;
                         executing = true;
                     }
                 }
                 //Implement some exit strategy here
             }
 
         }
     }
 }
 

Our Base class simply supports an Execute and a RuleType Method. Both our condition and Action class derive from RuleBase and may be “passed around” as a RuleBase and therefore we have satisfied the structural idea of being able to substitute a derived class for it’s base class.

The second angle I want to look at this principle is from a behavioral perspective. Most examples I read demonstrating an LSP violation use the Rectangle base class and the square subclass. Proof of the LSP violation is based on setting the length and width of the Square to unique values then discovering that an assert in a unit test that calculates a rectangles area returns an incorrect result.

I agree that this is a violation. I believe the problem lies in the claim that a square “is-a” rectangle. Now don’t go running to a dictionary and grab the definition of a rectangle and tell me that a square fits the definition of a rectangle – I’m not talking about the English language.

The classic implementation of the rectangle when discussing the LSP principle is to expose a Width and a Height property and a CalculateArea method which returns Width X Height. This makes sense. The problem in claiming that the Square “is-a” Rectangle is that with a Square there is not a notion of a Width and a Height that are different. The Width and Height must be the same. It doesn’t make sense to expose 2 properties, it is misleading and a consumer can logically assume that they would be independent properties. But in the implementation of the square this is not the case. Our Square is not (logically) a Rectangle because it does not have a Length and Width that are independent of each other.

To consider whether our design above has violated LSP from a behavior standpoint we have to take a look at the RuleEngine. At a glance it looks like we have a violation, notice that we have some logic in the engine that concerns itself with the RuleType.

if (rules[ruleIndex].TypeOfRule() == RuleType.Action) …

This does have the “smell” of bad code that we need to constantly look for but I maintain that if we take a closer look this is NOT a violation. When we cooked up the notion of the RuleEngine we decided we would support 2 types of rules, Conditions and Actions. It is reasonable to do this. We would never get our code out the door if we didn’t put some constraints on the types of rules we could support. The line of code in question is simply executing code based on whether it is a condition or an action.

An example of code that would violate LSP or OCP would be as follows:

if (TypeOf(rules[ruleIndex]) == CanShipCondition)

Here we are trying to execute logic based on the derived type which is a violation of OCP and LSP. The consumer of the base class would not have to worry about the derived type if the derived type was substitutable for it’s base class and by worrying about derived types, the rules engine is no longer open for extension.

My design review checklist

Calling a WCF Service from JavaScript

2009-08-29T10:17:00.001-05:00

I spent the last couple of days working with SketchUp, WCF, and JavaScript. SketchUp is a really cool tool for creating, modifying, and sharing 3D models. I am certainly not a modeling expert but I do have some experience working with 3D models and I have to say I am was impressed with the free version. The pro version is only $500. While this is not a trivial sum of money, it is very affordable compared to some of the packages I have seen.

My job was to create a web service that could be called using JavasSript. I will mention that this was a proof of concept and I specifically did not address security. The following code will work but there is no security of any kind so if the resulting service is exposed to the internet, anybody can call it.

The first thing I did was use the create WCF project wizard. I wasn’t particularly worried about passing complex data types at this point so I defined a simple Service Contract.

Code Snippet



 using System.ServiceModel;
 using System.ServiceModel.Web;
 
 namespace WcfModelService
 {
     [ServiceContract(Namespace = "WcfModelService")]
     public interface IModel
     {        
         [OperationContract]
         [WebGet]
         string GetData(int value);
 
         [OperationContract]
         [WebGet]
         string HelloWorld();
 
         [OperationContract]
         [WebGet]
         string HelloSomeone(string message);
     }
 
 }
 

When you apply the WebGet attribute to a service contract decorated with the OperationContract attribute you are adding some extra metadata to the operation. This metadata doesn’t actually do anything unless a service behavior is looking for it.

Here is the implementation:

Code Snippet



 using System.ServiceModel.Activation;
 namespace WcfModelService
 {
     [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
     public class Model : IModel
     {
         #region IModel Members
         public string GetData(int value)
         {
             return string.Format("You entered: {0}", value);
         }
 
         public string HelloWorld()
         {
             return "Hello World.";
         }
 
         public string HelloSomeone(string message)
         {
             return "Hello World and " + message + " too.";
         }
 
         #endregion
     }
 }
 

As I mentioned, adding the WebGet attribute doesn’t actually have any effect on our ability to call the service via JavaScript unless we have a service behavior that will use the metadata. In our configuration file we add the AjaxBehavior. Notice the enableWebScript element in the behavior. This is logically equivalent to adding the ScriptService attribute to an ASMX service. The final thing we need to do is to expose an endpoint using the webHttpBinding.

Code Snippet



     <system.serviceModel>
     <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>
     <services>
             <service  name="WcfModelService.Model">
                 <endpoint address="" binding="webHttpBinding" contract="WcfModelService.IModel" behaviorConfiguration="AjaxBehavior">
                 </endpoint>
             </service>
         </services>
         <behaviors>
             <endpointBehaviors>
                 <behavior name="AjaxBehavior">
           <enableWebScript/>
                 </behavior>
             </endpointBehaviors>
         </behaviors>
     </system.serviceModel>

All we have left to do now is to call the service from JavaScript. We will keep things simple and add a ScriptManager with a ServiceReference to the Model service. Now in JavaScript create the service proxy:

var proxy = new WcfModelService.IModel()

and call an operation:

proxy.HelloSomeone(s2, onSuccess, onFail, null);

Code Snippet



 <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WcfTest.aspx.cs" Inherits="WcfModelService.Test" %>
 
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
     <title>Wcf AJAX Service Client Page</title>
 
     <script type="text/javascript">
 
 
     // This function creates an asynchronous call to the service
     function makeCall(operation){
         var n1 = document.getElementById("num1").value;
         var s2 = document.getElementById("string1").value;
 
         
         
             // Instantiate a service proxy
         var proxy = new WcfModelService.IModel();
 
             // Call correct operation on proxy       
             switch(operation){
                 case "Data":
                     proxy.GetData( parseInt(n1),  onSuccess, onFail, null);            
                 break;
                 
                 case "Hello":
                     proxy.HelloWorld( onSuccess, onFail, null);                        
                 break;
                 
                 case "Someone":
                     proxy.HelloSomeone(s2, onSuccess, onFail, null);            
                 break;
                 
 
             
             }
         
     }
 
     // This function is called when the result from the service call is received
     function onSuccess(callResult){
         document.getElementById("result").value = callResult;
     }
 
     // This function is called if the service call fails
     function onFail(){
         document.getElementById("result").value = "Error";
     }
 
     // ]]>
     </script>
 
     <style type="text/css">
         #num1
         {
             width: 303px;
         }
         #string1
         {
             width: 317px;
         }
         #result
         {
             width: 333px;
         }
         #btnData
         {
             width: 118px;
         }
         #btnHelloWorld
         {
             width: 99px;
         }
     </style>
 
 </head>
 <body>
     <h1>
         Wcf AJAX Service Client Page</h1>
     <p>
         A Number:
         <input type="text" id="num1" /></p>
     <p>
         A String:
         <input type="text" id="string1" /></p>
     <input id="btnData" type="button" onclick="return makeCall('Data');" 
         value="Get Data" />
     <input id="btnHelloWorld" type="button" onclick="return makeCall('Hello');" 
         value="Hello" />
     <input id="btnHelloSomeone" type="button" 
         onclick="return makeCall('Someone');" value="Hello Someone" />&nbsp;
     <p>
       Result:
         <input type="text" id="result" /></p>
     <form id="aForm" action="" runat="server">
     <asp:ScriptManager ID="ScriptManager" runat="server" >
         <Services>
             <asp:ServiceReference Path="~/Model.svc" />
         </Services>
 
     </asp:ScriptManager>
     </form>
 </body>
 </html>
 

Here is an ASMX version of the same service.

Code Snippet



 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Web.Services;
 using System.Web.Script.Services;
 namespace AsmxModelService
 {
     /// <summary>
     /// Summary description for AsmxModelService
     /// </summary>
     [WebService(Namespace = "WcfModelService")]
     [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
     [System.ComponentModel.ToolboxItem(false)]
     // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line. 
     [System.Web.Script.Services.ScriptService]
     public class AsmxModelService : System.Web.Services.WebService
     {
         [WebMethod]
         [ScriptMethod(UseHttpGet = true,ResponseFormat = ResponseFormat.Json)]
         public string GetData(int value)
         {
             return string.Format("You entered: {0}", value);
         }
         
         [WebMethod]
         [ScriptMethod(UseHttpGet = true, ResponseFormat = ResponseFormat.Json)]
         public string HelloWorld()
         {
             return "Hello World";
         }
 
         [WebMethod]
         [ScriptMethod(UseHttpGet = true, ResponseFormat = ResponseFormat.Json)]
         public string HelloSomeone(string message)
         {
             return "Hello World and " + message + " too.";
         }
 
     }
 }
 

If you need to secure the call, we could force the user to login before accessing the aspx page containing the JavaScript service call. An Authentication cookie will now be passed to the application with each request.

By setting aspNetCompatibilityEnabled=true we can access the identity using a call to HttpContext.Current.User.Identity.Name. Each operation should now verify the user is authorized to make the call before executing the operation logic.

Reference:

http://msdn.microsoft.com/en-us/magazine/cc793961.aspx#id0070025

Extraction Rules

2009-08-15T07:41:00.001-05:00

Adding an Extraction Rule

Right click the request and select Add Extraction Rule…

Fill out the properties in the popup. And select Ok.

Using an Extracted parameter

You can use an extracted parameter in requests following the request where the parameter was extracted. You can do several things with this extracted value for example add a query string variable to a request or add a form post parameter:

Technorati Tags: VSTT,VSTS Team Test,Extraction Rules

Creating an ASMX web service web test with VSTS 2008

2009-08-09T16:04:00.002-05:00

Right click on the test project and select Add > Web Test…

IE will be opened with the Web Test Recorder available on the left side.

Click the stop button.

Right Click on the webtest node and select Add Web Service Request.

Fill out the properties in the properties window.

If you include the full path to the web method under test, the web method query variable will be extracted and created for you.

(example: http://localhost/VSTSLoadTest/VstsLoadTestWebService.asmx?op=ReverseTheString).

Assemble the soap request (I suggest using Internet Explorer to browse the web service and capture a sample soap request.

Drill down into the web request to fill out the String Body properties.

Set the content type to text/XML.

Click the ellipses button on the string body.

Paste the soap request into the popup – make sure and modify the placeholders with actual values.

Staying current

2009-08-03T00:40:00.002-05:00

As an Intertech consultant I am asked to do all kinds of things. Architect applications, code in C#, code in VB.Net, write SSRS reports, write TFS Team build test scripts, work with VSTS GDR database scripts the list goes on and on and that suites me just fine. Jumping around and doing so many different things is a challenge and once I get up the learning curve on something I don’t want to lose it. Here are a couple things I do to keep my skills sharp.

I recently earned my MCPD Enterprise Application Developer on the 3.5 framework. Even if you don’t think much of certifications, the real value for me was reading all of the 4500 or so pages of the Microsoft training kits and doing a couple hundred exercises. I was introduced to some things I would never have considered had I not gone through this process. Another great way to stay sharp is going to local users groups.

I’m a big fan of VSTS Test Edition but that sort of work only comes along every couple months. To stay sharp in this area I have gotten active on the Web test and load test forums (TimJim is my display name; you will also find me on the General Architecture and WCF forums). I try to answer a question that has gone unanswered for a while every day or so. It keeps me sharp and it is a great way to help the user community. The user base seems to be relatively small right now and this is a tool I don’t want to see go away. I was blown away by the preview I got of the 2010 version and I expect the user base to grow substantially with that release. I also keep my VSTS skills sharp by frequenting the VSTS Minnesota users group.

Finally, I have a massive book collection. I try to read 4 or 5 technical books a year but good old classroom education is hard to beat. Back in my days as a manager I always budgeted some training dollars but we only seemed to actually see the inside of a classroom every few years. At Intertech I am required (yes required!) to get 40 hours of training per year. A couple weeks ago I took Intertech’s WPF class and went through our Silverlight training material. I had the opportunity to do some Silverlight work right away. I was delighted with how well the class prepared me for the actual work I had to do and I definitely hit the ground running. I also have to say I was pleasantly surprised to find out how feature rich Silverlight is. I’m sure I’ll be blogging on these subjects soon.

More VSTS 2008 Team Test Edition Tips and tricks.

2009-08-02T23:49:00.003-05:00

It has been about a month since I posted any VSTS Test edition tips or tricks. Here is a few I think are particularly important.

BEST PRACTICE: Can we copy/paste (and rename) web tests if we want to? What effect does this have on the data source? Is it advisable from a source control standpoint?

Doing a copy, paste, or rename operation is totally fine. The data source will have to be added again to copied tests. Consider using extract web test rather than copy. Extracting a webtest is a way of grouping a request or requests into another callable web test. This is a very powerful feature. If you make 3 copies of a web test and the test has to change, you will have to modify all three copies of that test. Rather than doing a copy paste, use the extract web test functionality.

Go to the test editor window
Select the first request you want to include in the test
Right click and select Extract Web Test…
Enter a meaningful name in the text box
The top drop down will contain the first request to include in the test
Use the second drop down to select the final request you want to include in the test
Check both check boxes at the bottom of the dialog
Select OK

In the Test Editor you will see that the requests that you extracted are removed and replaced with a single request that points to another web test.

Now if you need to change that test you change it in one single place. This test may also be included in any other web test by right clicking in the test editor and selecting Insert Call to Web Test…

Can a web test record pop-ups?

If you are having difficulty recording pop-ups using the web recorder, try using Fiddler to capture the HTTP traffic. Once you are done executing your test and capturing the http traffic in fiddler,

highlight the requests,
Right click and select save select Session(s) select as Visual Studio Web Test (http://blogs.msdn.com/vstsqualitytools/archive/2006/12/21/testing-web-applications-with-pop-ups.aspx)

BEST PRACTICE: Use validation levels

During a standalone web test you want to run all validations but during a load test you want to only run the most critical validations so you can leave the client or agents to do the work they are intended to do – load the server. Execution of validation rules in a load test has impact on performance.

The default validation rule level of a request is “high”. When you create a load test you can specify what level of validation rules you want to execute under the Run Settings node. The default rule validation level of the load test is “low” therefore if you do nothing with validation levels no validations will be executed during a load test.

If you want to run a validation rule during a load test you want to change the validation level on the most critical rules to ‘‘low’’. In this case low means that it is a low-level, or fundamental, verification; low does not refer to the priority of the verification. Setting the level to ‘‘high’’ means that it will only be run if the load test has been set to a validation level of ‘‘high’’.

Load test level	Validations that will run
Low	Low
Medium	Low, Medium
High	Low, Medium, High

Bootlegging

2009-07-25T16:26:00.002-05:00

Remember back in the days of prohibition when a person wanted a beer they had to know the secret knock to get into the backroom of a club concealed by a false bookcase? Me neither. I’m talking about permitted bootlegging in the business sense of the word.

As I mentioned in my bio I spent 8 or 9 years of my career managing a team of developers. One of the first policies I implemented as a manager was permitted bootlegging. I encouraged every one of my developers to spend 10% of their time working on a software project of their choice that had nothing to do with the standard product we were building. I got the idea from my dad who worked for 3M. Software Developers can be odd ducks (to other people – us developers think you are the odd duck) and like most development organizations we had several kinds of developers. I’m going to use a broad brush and group them into 3 categories.

We had people that insisted on pounding out code 12 hours a day 7 days a week. These folks could do amazing things in short periods of times. They could get a late project back on track or whip out a feature in no time. It is a luxury to have one or two of these people on your team as nobody can reasonably ask for anyone to work these kinds of hours. The difficulty in managing this sort of person was if you pointed them in the wrong direction look out! They were a bit like rhinos in that they would very quickly blaze a trail through the code base doing all kinds of “damage”. Check in with these folks early and often to make sure they are doing what you think they are doing. They don’t like to undo hours upon hours of work because of a miscommunication and who can blame them? It is also quite a challenge keeping them busy. We’ll call this group the rhinos.

Another group of developers wanted to be told exactly what to do, when to have it done, and to be left alone. They will let you know if they have a problem and won’t tend to try to move forward with something they don’t understand – it is just not in their nature. They don’t care too much about what they are assigned to work on as long as it is in their comfort zone. These are the people that can tend to fly under the radar so make sure and share credit for your success with these folks. You need a lot of these people on your team. We’ll call this group the workhorses.

The final group of people I want to talk about could probably best be described as the mad scientists. These are the kinds of people that are not happy unless they are challenged. These are the folks you want working on critical parts of the framework. You would go over a problem with them in painful detail and turn them loose. They would disappear into their dark laboratory only to return days, weeks, or months later when they were done. Schedule means very little to these folks because…well…it is not done until it is done! You want one or maybe two of these people on your team but you can not afford more – you’d never get anything built. The challenge with managing this type of person was that it was hard to schedule their activities and you don’t always have an interesting problem for them to work on. Let’s call this group the Einsteins.

By way of an apology for pigeonholing these good people I will admit that the personality of every individual I managed really fit into all 3 of these groups to one degree or another (well maybe not the Einstein group). My job was to figure out a way to get this crew to build software. I had to ask the Einsteins to write mundane code, I had to keep the rhinos from running further ahead than we could test, I had to ask the workhorses to do work they weren't comfortable with. So how do I keep the Einsteins challenged when they are doing mundane work, how do I keep the Rhinos out of the code during the definition phase and how do I get the workhorses to get comfortable doing something they have never been asked to do before? That is where bootlegging comes in.

The role that bootlegging played for the Einsteins was that it kept things interesting all the time. I never had to encourage these folks to spread their wings and learn something new. I used bootlegging as a way to keep them from leaving the company. They knew that, I knew that, they appreciated it, and most importantly they never left the team. For the rhinos I used bootlegging as a way to keep them busy during slow times. At the end of the day what drives the rhino is they just want to be busy doing something useful. Their bootleg projects were usually related to productivity tools. Tools that made the development team more productive but had nothing to do with our product. Workhorses were not wild about bootlegging. I would really have to push a project onto a workhorse. I would try to recognize a new technology or feature coming up in the project and use the bootlegging task as a way to introduce them to it. To be honest, the bootleg projects didn’t mean much to these folks but it was always there if they wanted to use it.

As a manager I was very proud of the fact that I never had a developer leave my team to join another team. I think giving each team member the freedom to work on whatever software project they wanted with 10% of their time was a big part of it.