David Sackstein's Blog

Clean Code or Working Code?

David Sackstein — Tue, 21 Dec 2010 22:11:01 GMT

I was working on a legacy project with a friend and I sorely bemoaned the messiness of the code.

Later, the friend sent me this link and warmly recommended I keep the balance in life.

If you cant be bother to read the article, the short of it is that we developers should have more respect for legacy code that works.

I acknowledge the underlying truth presented in the article, but I don’t think it gives the whole picture.

Just because you can make catastrophic mistakes while disrespectfully accusing code of being a mess, that doesn’t mean that the code isn’t a mess.

Just because the code is rock solid because it has accumulated valuable fixes over the years doesn’t mean to see that the guy who wrote the fix shouldn’t have been fired reprimanded for writing it the way he did.

And … just because there is some really messy code out there that works too, it doesn’t mean to say that the only way to get code to work is to make it messy.

I think this article (and Bob Martin’s book on Clean Code) offer a better balance between working code and clean code.

This article also mocks the notion of a “Grand Redesign in the Sky”, but it also proposes ways to avoid such traps altogether.

Moreover, in his book Martin also talks about the practicalities of cleaning up legacy code reliably, because, as we all know, most of the work done by programmers is work on legacy code.

That's no excuse not to write beautiful, clean code.

Visual Studio 2010 and Eclipse

David Sackstein — Sun, 12 Dec 2010 20:43:35 GMT

From time to time I do some work in C++ for Linux using Eclipse. Many developers say that Eclipse is the state of the art IDE for C++ development on Linux.

From my experience, I can say that Eclipse simply pales in comparison with Visual Studio 2010 when it comes to an integrated, streamlined development experience out of the box.

Rather than compare the pros and cons of both IDEs I would like to share with you a VS 2010 experience that I enjoy that is often taken for granted by Windows developers and should leave Eclipse developers in awe.

I just completed developing a project that contains the following components:

COM objects on a server written in C++.
WCF Services written in C# that expose the functions of the COM objects to web clients.
Silverlight application running in a browser written in C#.
Javascript code running in the browser.

It was easy for me to set breakpoints and debug code in all of these components in one debugging session.

Visual Studio 2010 never crashed, always stopped at breakpoints, always displayed the appropriate views for each code environment and all this works out of the box. No plug-ins, no scripts, no prayers.

Chapeau, Microsoft!

MVVM : Injecting INotifyPropertyChanged Into an Existing Class

David Sackstein — Sat, 11 Dec 2010 02:32:00 GMT

Download the source code for this post here.

Using MVVM in Silverlight and WPF I often encounter the following problem.

I have a business class that needs to be exposed through the ViewModel. For this, it needs to implement INotifyPropertyChanged or expose Dependency properties.

I take the side of those who prefer to keep WPF dependencies out of the ViewModel, so I usually take the path of writing a proxy that delegates properties to the business object and implementing INotifyPropertyChanged.

I am not comfortable with this duplication, and I usually pay a price for it when I refactor the business class, but I still do it because the separation of View and Model is so important and justifies the extra work.

However, it would be nice, if INotifyPropertyChanged would be generated automatically.

The Unity framework from the Patterns and Practices group can do this for you.

It's a little tricky, and the sample provided by the group is not entirely generic.

I implemented a factory class that uses Unity to generate an INotifyPropertyChanged implementation for any interface implementation pair at run time. I demonstrate configuration in code or using a configuration file.

The solution includes the following Test project that injects INotifyPropertyChanged to a BusinessObject class called BusinessObjects.Customer that implements BusinessObjects.ICustomer.

using System.ComponentModel;
using BusinessObjects;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using NotifyPropertyChangedInjectionFactory;
namespace TestProject
{
    [TestClass]
    public class UnitTests
    {
        [TestMethod]
        public void TestInjectionWithCode()
        {
            Factory factory = new Factory();
            ClassDescriptor classDescriptor = new ClassDescriptor
            {
                TypeFrom = typeof(ICustomer),
                TypeTo = typeof(Customer),
                ConstructorArguments = new object[] { "Bill", 34 }
            };
            factory.RegisterWithCode(classDescriptor);
            VerifyImplementation(factory);
        }
        [TestMethod]
        public void TestInjectionFromConfigFile()
        {
            Factory factory = new Factory();
            factory.RegisterFromConfigFile();
            VerifyImplementation(factory);
        }
        private static void VerifyImplementation(Factory factory)
        {
            ICustomer customer = factory.Create<ICustomer>();
            Assert.IsInstanceOfType(customer, typeof(INotifyPropertyChanged));
            INotifyPropertyChanged propChanged = customer as INotifyPropertyChanged;
            int notificationCount = 0;
            string newName = "Fred";
            int newAge = 25;
            Assert.IsFalse(customer.Name == newName);
            Assert.IsFalse(customer.Age == newAge);
            propChanged.PropertyChanged += (s, e) =>
            {
                notificationCount++;
                if (e.PropertyName == "Name")
                    Assert.IsTrue(customer.Name == newName);
                if (e.PropertyName == "Age")
                    Assert.IsTrue(customer.Age == newAge);
            };
            customer.Name = newName;
            customer.Age = newAge;
            Assert.IsTrue(customer.Name == newName);
            Assert.IsTrue(customer.Age == newAge);
            Assert.IsTrue(notificationCount == 2);
        }
    }
}

The limitation here is that the object returned by the factories Create method is not a Customer. In this implementation I used the InterfaceInterception mechanism, but TransparentProxyInterception has the same drawback.

For more information I recommend reading this section of the Unity Framework documentation.

How to Bind to the Index of a Collection in WPF

David Sackstein — Sat, 17 Apr 2010 07:34:43 GMT

Let's say you have a customer class and you are binding a DataGrid to a collection of customers.

You would like the index of the customer in the collection to appear in the first column, like so:

One way to do this might be to add an Index property to the Customer class and bind to that.

I prefer not to go that way because it would pollute our business layer with presentation layer constraints.

Solution

Here is a different approach using a MultiBinding.

You can download the source code for this example from here.

This is our DataAccess Layer:

    public class Customer
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
 
    public class DataAccess
    {
        static private List<Customer> customers;
        static public List<Customer> Customers
        {
            get
            {
                if (customers == null)
                {
                    customers = new List<Customer>
                    {
                        new Customer { Name="Bill", Age=40},
                        new Customer { Name="Alice", Age=35},
                        new Customer { Name="Fred", Age=30},
                        new Customer { Name="Tom", Age=20}
                    };
                }
                return customers;
            }
        }
    }

and here is the XAML:

<DataGrid Name="dg"
         AutoGenerateColumns="False"
         CanUserAddRows="False">
    <DataGrid.Resources>
        <local:IndexConverter x:Key="indexConverter" />
    </DataGrid.Resources>
    <DataGrid.Columns>
        <DataGridTextColumn Header="Index">
            <DataGridTextColumn.Binding>
                <MultiBinding Converter="{StaticResource indexConverter}">
                    <Binding />
                    <Binding RelativeSource=
                                "{RelativeSource AncestorType={x:Type DataGrid}}"
                            Path="ItemsSource"></Binding>
                </MultiBinding>
            </DataGridTextColumn.Binding>
        </DataGridTextColumn>
        <DataGridTextColumn Header="Name"
                           Binding="{Binding Name}"></DataGridTextColumn>
        <DataGridTextColumn Header="Age"
                           Binding="{Binding Age}"></DataGridTextColumn>
    </DataGrid.Columns>
 </DataGrid> 

Here is the IndexConverter:

    class IndexConverter : IMultiValueConverter 
    {
        public object Convert(
            object[] values, Type targetType, 
            object parameter, System.Globalization.CultureInfo culture)
        {
            var customer = values[0] as Customer;
            var customers = values[1] as List<Customer>;
            return customers.FindIndex(c => c == customer).ToString();
        }
 
        public object[] ConvertBack(
            object value, Type[] targetTypes, 
            object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    } 

and finally, the binding operation in the Loaded event:

        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            dg.ItemsSource = DataAccess.Customers;
        }

Hierarchical Grid with WPF

David Sackstein — Sat, 17 Apr 2010 05:57:45 GMT

A TreeView handles hierarchical data well, and a DataGrid handles tabular data. But what about hierarchical tabular data?

A simple example of such a source is a System.IO.DirectoryInfo. Each item can have zero or more children of the same type, enumerated by EnumerateDirectories.

I would like to have it displayed like this:

Solution

You can download the source code for this solution here.

The inspiration for this solution came from Delay's Blog by David Anson. I think David's idea of measuring the indentation at each level and compensating for it in the template for that level is clever indeed.

In this solution, I offer two improvements over the SimpleTreeGridUX presented in the article:

Every level in the hierarchy uses the same template (a problem raised by David in the article).
The number of levels may be arbitrary (not hardcoded in the XAML).

As in SimpleTreeGridUX, I use an empty TreeViewItem to measure the incremental indentation at every level. However, instead of adding a varying number of columns in the template of each level to compensate, I add one column whose width is bound to a function of the level.

The function is implemented in a MultiValueConverter called LevelConverter.

To demonstrate how it works, here is the solution with ShowGridLines=True for all grids:

As you can see, the width of the second column on each row depends on the level of that row in the tree.

To review the code, lets start with the DirectoryRecord which is my ViewModel representation of a DirectoryInfo.

Apart from some rather obvious code that extracts file and folder information from DirectoryInfo, I added two properties that are needed by the LevelConverter.

       #region Level
 
        // Returns the number of nodes in the longest path to a leaf
 
        public int Depth
        {
            get
            {
                int max;
                if (Items.Count == 0)
                    max = 0;
                else
                    max = (int)Items.Max(r => r.Depth);
                return max + 1;
            }
        }
 
        private DirectoryRecord parent;
 
        // Returns the maximum depth of all siblings
 
        public int Level
        {
            get
            {
                if (parent == null)
                    return Depth;
                return parent.Level-1;
            }
        }
 
        #endregion

The level converter uses the Level and the size of the measured TreeViewItem to return the Width of the column that compensates for the indentation. Here is the code:

    public class LevelConverter : DependencyObject, IMultiValueConverter
    {
        public object Convert(
            object[] values, Type targetType, 
            object parameter, CultureInfo culture)
        {
            int level = (int)values[0];
            double indent = (double)values[1];
            return indent * level;
        }
 
        public object[] ConvertBack(
            object value, Type[] targetTypes, 
            object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    } 

Here is the XAML for the solution:

    <Grid Grid.IsSharedSizeScope="True"
         Name="treeGrid">
        <Grid.RowDefinitions>
            <!-- Header row -->
            <RowDefinition Height="Auto" />
            <!-- Row for data -->
            <RowDefinition />
        </Grid.RowDefinitions>
 
        <Grid.Resources>
 
            <!-- Converts the level in the tree to the width of the spacer column -->
            <local:LevelConverter x:Key="levelConverter" />
 
            <!-- Template for directory information at all levels -->
            <HierarchicalDataTemplate ItemsSource="{Binding Items}"
                                     DataType="{x:Type local:DirectoryRecord}">
                <Grid ShowGridLines="False">
 
                    <!-- All column widths are shared except for column 1 which is sized
                         to compensate for different indentation at each level -->
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition SharedSizeGroup="rowHeaderColumn"/>
                        <ColumnDefinition></ColumnDefinition>
                        <ColumnDefinition SharedSizeGroup="column1"/>
                        <ColumnDefinition SharedSizeGroup="column2"/>
                    </Grid.ColumnDefinitions>
                    <TextBlock Grid.Column="0"
                              Text="{Binding Info.Name}"></TextBlock>
                    <Rectangle Grid.Column="1">
                        <Rectangle.Width>
                            <MultiBinding Converter="{StaticResource levelConverter}">
                                <Binding Path="Level"></Binding>
                                <Binding ElementName="treeViewItemToMeasure"
                                        Path="ActualWidth"></Binding>
                            </MultiBinding>
                        </Rectangle.Width>
                    </Rectangle>
                    <TextBlock Grid.Column="2"
                              Text="{Binding Info.LastAccessTime}"></TextBlock>
                    <TextBlock Grid.Column="3"
                              Text="{Binding Files.Count}"></TextBlock>
                </Grid>
            </HierarchicalDataTemplate>
        </Grid.Resources>
 
        <!-- Tree view with one item for the header row -->
 
        <TreeView BorderThickness="0"
                 ScrollViewer.HorizontalScrollBarVisibility="Disabled">
            <TreeViewItem>
                <TreeViewItem.Header>
                    <Grid ShowGridLines="False">
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition SharedSizeGroup="rowHeaderColumn"/>
                            <ColumnDefinition />
                            <ColumnDefinition SharedSizeGroup="column1"/>
                            <ColumnDefinition SharedSizeGroup="column2"/>
                        </Grid.ColumnDefinitions>
                        <TextBlock Grid.Column="0"
                                  Text="Name"></TextBlock>
                        <TreeViewItem Grid.Column="1">
                            <TreeViewItem.Header>
                                <TreeViewItem Name="treeViewItemToMeasure"
                                             Padding="0"></TreeViewItem>
                            </TreeViewItem.Header>
 
                            <!-- Set the width of Column 1 to the same width as the top level 
                                 in the data -->
                            <TreeViewItem.Width>
                                <MultiBinding Converter="{StaticResource levelConverter}">
                                    <Binding Path="Level"></Binding>
                                    <Binding ElementName="treeViewItemToMeasure"
                                            Path="ActualWidth"></Binding>
                                </MultiBinding>
                            </TreeViewItem.Width>
                        </TreeViewItem>
                        <TextBlock Grid.Column="2"
                                  Text="LastAccessTime"></TextBlock>
                        <TextBlock Grid.Column="3"
                                  Text="File Count"></TextBlock>
                    </Grid>
                </TreeViewItem.Header>
            </TreeViewItem>
        </TreeView>
 
        <!-- Tree view that will display hierarchical data rows -->
 
        <TreeView Grid.Row="1"
                 BorderThickness="0"
                 ItemsSource="{Binding}"></TreeView>
    </Grid>

Finally, this is the code that sets the data context for the mark up:

        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            string folder = @"..\..\";
            DirectoryRecord root = new DirectoryRecord(new DirectoryInfo(folder));
            treeGrid.DataContext = new DirectoryRecord[] { root };
        } 

Enjoy!

Project Packager Add-In for Visual Studio 2010

David Sackstein — Mon, 12 Apr 2010 13:55:01 GMT

This Add-In for Visual Studio 2010 will package up your solution (actually, any folder you choose) into a zip file excluding any files with extensions you specify and any folders whose names you specify.I cant upload msi files to this blog, so in order to install you will need to build the project.

I packaged up the Add-In solution using the Add-In itself and uploaded it here.

Download the solution, open with Visual Studio 2010 and Build All.
Right click the setup project and select Install.
Close Visual Studio 2010 and restart.
In the Tools menu item –> Add-in Manager click the PackagerAddIn check box.

To use the Add-In, go to Tools –> PackagerAddIn

Motivation

After completing a project, either as a demo in class, or for a customer, I often need to zip up a solution send it by email or store it somewhere.

But even simple projects with Visual Studio 2010 create many binary files that increase the size of the package and contribute nothing to the recipient. Moreover, the baggage, once delivered is usually never deleted for fear that it is essential to to the solution. Once added to the source code control system it will slow down every check out and build for life. Moreover, it makes the project unnecessarily daunting for less experienced developers to learn.

I have tried using "Clean Solution" from the Build menu to remove the baggage, and, yes, it kinda works. But it is not quite as flexible as I need. For instance, though you can configure which file extensions will be deleted, you can't configure it to delete folders even if they are empty after the clean. "Clean Solution" also wont zip up the solution for you when you are done.

Rather than delete the files myself, and run the risk of deleting something important, I would like to copy all the important files without the baggage to a separate location, then zip up that folder and then delete the folder. This way, even if I forget an important file in the process, the original still exists and can be added.

I thought that this was an ideal justification for building an Add-In to Visual Studio 2010.

Solution Description

The solution contains two projects. One is the Add-In, the other is a setup project. Here are the highlights of the Add-In project:

Created the Add-In using the Extensibility Wizard choosing to add a Menu Item for the Add-In in the Tools menu.
Developed the Packager class to handle the work of packaging and zipping a folder.
Used the open source ICSharpCode.SharpZipLib zip library for the Zip functionality. You can download the source code and find more information about the library here.
Developed the PackagerForm using WindowsForms. PackagerForm is a Dialog that is shown when the Add-In is invoked. It collects information from the user and calls the Packager class in a BackgroundWorker.
Implemented a delegate that writes logging information to a "Packager" pane in the Visual Studio Output Window.

In Visual Studio 2010, the Extensibility templated does not include a Setup project. However it is simple to add. This is how I created it.

Add a new setup project to the solution.
Add the Primary Output of the Add-In Project to the Application Folder.
Add the PackagerAddIn.AddIn file to the Application Folder.
Set the default location of the Application folder to [PersonalFolder]\Visual Studio 2010\Addins

The Extensibility environment is a bit tough to get into, but I think that this Add-In will save me a lot of time (and headache) from now on.

I hope it does for you too.

John Bryce Lab Zone at Developer Academy 4

David Sackstein — Tue, 23 Mar 2010 01:36:54 GMT

Today, John Bryce hosted a very successful Lab Zone at Developer Academy 4.

This year's zone was larger than ever before with 40 computers installed with 11 labs on the latest and greatest Microsoft technologies!

Over 1600 people attended the conference, and many of them came to the Lab Zone to get invaluable hands on experience with Windows Azure, SharePoint 2010, Windows 7, WCF 4, WPF 4 and Silverlight 4.

For further study, I recommend you take a look at John Bryce's site for a list of courses that cover these and many other technologies.

Here also is a list of all the labs and links to download them.

Enjoy!

Lab Name	Link to Download
Building a Data-Driven Master/Detail Business Form using Visual Studio 2010	VS2010TrainingKitFebruarySetup
Introduction to Creating Coded UI Tests with Visual Studio 2010	VS2010TrainingKitFebruarySetup
Introduction to Windows Azure	WindowsAzurePlatformKit.Setup
What's New in WCF 4?	VS2010TrainingKitFebruarySetup
Introduction To StreamInsight and Complex Event Processing	SQL2008R2TrainingKit.Setup.20100202
SharePoint 2010 Developer Roadmap	SharePoint2010Developer
Technical Feature Overview	Silverlight4.Setup
Use the Architecture Explorer in Visual Studio 2010 Ultimate to Analyze Your Code	VS2010TrainingKitFebruarySetup
Introduction to Workflow 4.0	VS2010TrainingKitFebruarySetup
Introduction To AppFabric Cache	VS2010TrainingKitFebruarySetup
Taskbar	VS2010TrainingKitFebruarySetup

Windows 7 and WPF 4 at Developer Academy 4

David Sackstein — Tue, 23 Mar 2010 00:20:05 GMT

Today at Developer Academy I gave a demonstration session called Capture the Windows 7 User Experience with Windows Presentation Foundation 4.

In the demo I showed how to integrate the following Windows 7 taskbar features into Windows applications using WPF 4:

Specifying the area of the application visible in the Thumbnail Preview
Controlling the Progress Bar overlay in the Task Bar
Adding Taskbar Buttons to an application on the Task Bar
Adding Icon Overlays
Adding Jump List items to the context menu of an application on the Task Bar

You will be able to hear the recording of all Developer Academy sessions shortly, m meanwhile, here is the source code of the demo.

Top Tips for Rapid Application Development

David Sackstein — Fri, 02 Oct 2009 13:53:53 GMT

In recent weeks I have been busy on a number of projects with very tight, almost impossible schedules.

When schedules are tight, there is simply not enough time to implement all the steps of a formal development procedure. But I have found that some good practices shine through as time savers every time. Not only do they save time, but they also help produce exensible, maintainable code – which also saves time in the long run.

So here are my top tips for Rapid Application Development.

Document the requirements succintly. Avoid using document templates that you can’t fill.
Define and assign responsibilities, develop by contract and work in parallel.
Keep interfaces simple. Use patterns commonly found in the framework you are using.
Beware of generalizing unnecessarily.
Provide prototypes frequently.
Use functionality provided by the framework (e.g. Base Class Library in .Net, STL in C++)
Unit test rigorously. You should have at least as much testing code as production code.
Provide succint, useful inline documentation.
Refactor constantly. Review, simplify, reorganize, rewrite, throw away.
Document the features, bug fixes and known bugs of each version you provide and provide adequate installation utilities.
Encourage tester feedback and provide quick, reliable responses to each report.

It is important to note that these tips only work well for proficient programmers, for whom the development environment is a tool and not a challenge. You need to know the environment well for points 3 and 6 and, if rewrites take too long, point 9 will not just not be practical.

The good news is that Visual Studio 2008 and the .Net framework provide inherent support for RAD.

You can learn so much about the environment from intellisense without even leaving your project. You can use snippets and autocompletions to boost your typing speed 10x and you can use Visual Studio’s refactoring tools to relieve you of the more tedious tasks associated with rewrites.

These tools are easily accessible and extremely reliable.

Good luck on your rapid application development!

Received my MCT Credentials Today

David Sackstein — Thu, 03 Sep 2009 06:22:14 GMT

Earlier this year I completed the MCPD certification - today I earned my MCT !

Over the year I have trained classes on C++, .Net 2.0, WPF, WF, WCF, Silverlight and Design Patterns.

This has just got to be the fastest and most effective way to learn : )

WPF Explorer View with TreeView

David Sackstein — Wed, 02 Sep 2009 17:19:16 GMT

In this post we will see how to use WPF’s TreeView with the WPF Tookit’s DataGrid to present an Explorer-like view of a file system folder. We will use databinding with the HierarchicalDataTemplate, a sprinkling of LINQ and as little code as possible.

You can download the source code here.

User Interface Layout

As in Explorer, we will present a window with two vertical panes. The left pane will show the directory structure as a tree; the right pane will show the files in the folder that is selected in the left pane.

The layout is very simple. It contains a Grid with three columns: the left and right panels and a GridSplitter in the middle. The left panel contains a TreeView (directoryView) to represent the directory structure, the right panel contains a DataGrid (fileView), from the WPF Toolkit, to represent the list of files in the selected directory.

Left Pane : Directory View

Here is the markup for the TreeView:

      <TreeView Grid.Column="0" Name="directoryView">
         <TreeView.Resources>
            <HierarchicalDataTemplate DataType="{x:Type local:DirectoryRecord}"
                                     ItemsSource="{Binding Directories}" >
               <TextBlock Text="{Binding Info.Name}"/>
            </HierarchicalDataTemplate>
         </TreeView.Resources>
      </TreeView>

As you can see I have used the HierarchicalDataTemplate to format the nodes of the TreeView. See also this post about HierarchicalDataTemplate. Each node binds to an instance of the DirectoryRecord, which is a wrapper of the DirectoryInfo class. The wrapper is required in order to expose the GetFiles and GetDirectories methods as properties.

Here it is:

    class DirectoryRecord
    {
        public DirectoryInfo Info { get; set; }
 
        public IEnumerable<FileInfo> Files
        {
            get
            {
                return Info.GetFiles();
            }
        }
        public IEnumerable<DirectoryRecord> Directories
        {
            get
            {
                return from di in Info.GetDirectories("*", SearchOption.AllDirectories)
                       select new DirectoryRecord { Info = di };
            }
        }
    }

Right Pane: File View

This is the markup for the DataGrid

      <wf:DataGrid Grid.Column="2"
          Name="fileView"
          ItemsSource="{Binding ElementName=directoryView, 
                        Path=SelectedItem.Files}"></wf:DataGrid>

The databinding is interesting. I have bound the ItemsSources to the Files property of the DirectoryRecord that is selected in the directoryView.

The default value of AutoGenerateColumns is true, but I filter the columns with the following delegate which is attached to the AutoGeneratingColumn event of directoryView

        private void fileView_AutoGeneratingColumn(
            object sender, DataGridAutoGeneratingColumnEventArgs e)
        {
            List<string> requiredProperties = new List<string>
            {
                "Name", "Length", "LastWriteTime"
            };
            if (!requiredProperties.Contains(e.PropertyName))
                e.Cancel = true;
            else
            {
                e.Column.Header = e.Column.Header.ToString().MixedCaseToSpace();
            }
        }

Finally, I added some styling for the DataGrid as follows:

   <Window.Resources>
      <Style TargetType="{x:Type wf:DataGrid}">
         <Setter Property="Background" Value="White"></Setter>
         <Setter Property="GridLinesVisibility" Value="Vertical"></Setter>
         <Setter Property="RowHeaderWidth" Value="0"></Setter>
         <Setter Property="VerticalGridLinesBrush"
                Value="{Binding ElementName=splitter, Path=Background}"></Setter>
      </Style>
   </Window.Resources>

Putting It All Together

In the constructor of the Window we install events for Loaded and the AutoGeneratingColumn of the fileView.

        public Window1()
        {
            InitializeComponent();
 
            this.Loaded += Window_Loaded;
            fileView.AutoGeneratingColumn += fileView_AutoGeneratingColumn;
        }
 

The folder to be viewed in the window is currently hard coded. You can easily add a browse button to allow the user to select the folder to view.

In the Loaded event we create the root node and bind it to the directoryView.

        string folder = @"..\..\";
 
        void Window_Loaded(object sender, RoutedEventArgs e)
        {
            var root = new ObservableCollection<DirectoryRecord>{
                new DirectoryRecord { 
                    Info = new DirectoryInfo(folder) 
                }
            };
            directoryView.ItemsSource = root;
            Title = "Explorer View (" + Path.GetFullPath(folder) + ")";
        }
 

Da Da!

Performance

I think you will agree that the we have achieved quite a lot with very little code.

However, if you try to use the application to view the contents of your entire c: drive, you will wait a long time until the TreeView is filled.

Does anyone have any simple ideas to improve the performance?

Silverlight Client With Sockets - Barebones Sample

David Sackstein — Sun, 23 Aug 2009 07:30:08 GMT

Dan Wahlin wrote an excellent article on Silverlight Client with Sockets - accompanied by a sample application.

My objective in this post is simply to reduce Dan’s application to the bare minimum so that it is easier to reuse.

You can download my reduced sample here.

Changes

These are the differences between my sample and Dan’s.

There are now only three projects: The Silverlight control, the hosting Web site and the server.
I reduced the Silverlight client to contain a single text box displaying a counter whose value is pushed from the server.
Accordingly I deleted all business objects (Teams, Scores etc) from the client and the server.
Then I merged the PolicySocketServer (which provides the cross-domain policy file) and the CounterSocketServer (which does the real work of pushing new counter values to clients) into one executable. As they both block while listening for connections, I ran them both in separate threads.
I reduced all customized logging to good old Console.Write.
I fixed a bug (I think it was a bug).
In PolicySocketServer.OnSendComplete there was a call to client.Client.EndSendFile. I replaced it with a call to client.Client.EndSend to correspond with client.Client.BeginSend.

Summary

I recommend you read Dan’s article to get the complete picture. I offer you use of this reduced sample to make it easier to reuse the techniques.

Cross-Domain Policy Files for Flash and Silverlight with WCF

David Sackstein — Sat, 15 Aug 2009 04:53:23 GMT

Introduction

In an earlier blog I described my motivation for upgrading an ASMX Web Service to WCF in a particular project.

In that project the client was a Flash client hosted in a web page. The upgrade was simple and, as long as I ran the client from within Flex Builder, it had no problem consuming the new self-hosted WCF service instead of the ASMX.

Allowing Cross-Domain Access

However, once I deployed the package outside the Flex Builder, all calls to the service failed. The reason was that the domain from which I had loaded the web page was not the same as the domain of the WCF service.

RIA applications like Flash and Silverlight regard such cross-domain accesses as potential security risks and block them - unless cross-domain policies on the server explicitly allow them. This requirement is relaxed in the development environment and enforced in a production environment, which explains why I had no problem during development.

So what if, like me, you would like certain services to serve clients even if they are loaded from other domains?

Well, the solution is to specify such permissions in a file called a Cross Domain Policy File and to make it accessible to clients at the domain URL. For instance, if your service resides at www.mycompany.com/Services/ProductsService.svc the file should be accessible as www.mycompany.com/crossdomain.xml.

Both Flash and Silverlight try to download such a file before accessing applications in the domain. By default they will look for a file called crossdomain.xml at the root of the domain. The Adobe cross-domain file specification can be found here. Tim Heuer shows how to create policy files for Silverlight here.

Problem: Exposing Cross-Domain Policy Files for a Self-Hosted WCF Service

When your service is being hosted by IIS it is easy to make the crossdomain.xml file accessible to clients, because it is straightforward to expose files using IIS. But, alas if you are using a self-hosted WCF service, it would seem that you are out of luck. Unless the WCF host delivers the crossdomain.xml file itself, it will not be accessible to remote clients.

Solution: Using WCF’s REST Support

Think about it, all we really need is to be able to respond to an HTTP Get request for the URL (such as www.mycompany.com/crossdomain.xml) by sending an HTTP response containing the contents of the cross-domain file.

WCF can easily support this with its support for RESTful services that I described in an earlier post.

Here are the configuration file and code snippets adapted where necessary for the task at hand.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="ProductsService" 
               behaviorConfiguration="ProductsServiceBehavior">
        <endpoint address="ProductsService.svc" 
                  binding="basicHttpBinding"
                  contract="IProductsService" />
        <endpoint address=""
                  binding="webHttpBinding"
                  behaviorConfiguration="WebBehavior"
                  contract="IRestfulOperations" />
        <host>
          <baseAddresses>
            <add baseAddress="http://www.mycompany.com/" />
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="WebBehavior">
          <webHttp />
        </behavior>
      </endpointBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

and here is the code (adapted from an answer by Carlos Figueira here).

    public partial class ProductsService : IProductsService, IPolicyRetriever
    {
        #region IPolicyRetriever Members
 
        public Stream GetPolicy()
        {
            string result = @"<?xml version=""1.0""?>
                <!DOCTYPE cross-domain-policy SYSTEM 
                     ""http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd"">
                <cross-domain-policy>
                    <allow-access-from domain=""*"" />
                    <allow-http-request-headers-from domain=""*"" headers=""SOAPAction""/>
                </cross-domain-policy>";
            WebOperationContext.Current.OutgoingResponse.ContentType = "application/xml";
            return new MemoryStream(Encoding.UTF8.GetBytes(result));
        }
 
        #endregion
    }

Summary

In this post I described how you can use WCF’s REST support to have a self-hosted service expose the cross-domain policy file required by Silverlight and Flash when calling into Web services.

This is one more proof that WCF is extremely versatile interoperable and can be used in applications with a variety of requirements, including RIA in applications such as Flash and Silverlight.

Enabling RESTful Services with WCF

David Sackstein — Sat, 15 Aug 2009 03:49:52 GMT

I came across a number of sources that describe how to support RESTful Services with WCF, but unfortunately, I couldnt find one source that had all the small print. So, here it is – all in one place.

Objective

Let’s say you have a WCF Web Service exposed at an endpoint with this address: www.mycompany.com/Services/ProductsService.svc. And let’s say that in addition to speaking sophisticated SOAP with some clients you would also like to respond to GET requests from simple clients that need to retrieve all the information in XML (or JSON) form. For instance, you might like to respond to this URL: www.mycompany.com/productlist.xml with the contents of the productlist.xml file.

Solution

This is possible using WCF, and as you might expect, it involves defining an additional endpoint. There are actually three things you need to do:

Define an additional end point using the webHttpBinding with a webHttp behavior.
Add a ServiceContract with an OperationContract decorated with the [WebGet] attribute.
Implement the OperationContract by returning a Stream with the contents of the required file.

1. Additional EndPoint with a webHttp Behavior

A configuration file is worth a thousand lines of code, so here is a rather minimilistic service-side configuration file that shows what you need.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="ProductsService" 
               behaviorConfiguration="ProductsServiceBehavior">
        <endpoint address="Services/ProductsService.svc" 
                  binding="basicHttpBinding"
                  contract="IProductsService" />
        <endpoint address=""
                  binding="webHttpBinding"
                  behaviorConfiguration="WebBehavior"
                  contract="IRestfulOperations" />
        <host>
          <baseAddresses>
            <add baseAddress="http://www.mycompany.com/" />
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="WebBehavior">
          <webHttp />
        </behavior>
      </endpointBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

2. Add an OperationContract with the [WebGet] Attribute

The code in this and the next section is based on responses by Carlos Figueira here.

Here is the new ServiceContract with the decorated OperationContract:

    [ServiceContract]
    public partial interface IRestfulMethods
    {
        [OperationContract, WebGet(UriTemplate = "/ProductList.xml")]
        Stream GetProductList();
    }

I advise you take a look at the documentation for more information on WebGet parameters. In particular, take a look at the UriTemplate which allows you to pass in parameters for the decorated method as part of the URL. WCF will extract the parameters and pass them as arguments to the method.

3. Implement the OperationContract

    public partial class ProductsService : IProductsService, IRestfulMethods
    {
        #region IRestfulMethods Members
 
        public Stream GetProductList()
        {
            string result = @"<?xml version=""1.0""?>
                <Products>
                    <Garden Chair>
                        <Quantity>2</Quantity>
                        <Price>100</Price>
                    <Garden Chair>
                    <Magic Wand>
                        <Quantity>1</Quantity>
                        <Price>50</Price>
                    </Magic Wand>
                </Products>";
            WebOperationContext.Current.OutgoingResponse.ContentType = "application/xml";
            return new MemoryStream(Encoding.UTF8.GetBytes(result));
        }
 
        #endregion
    }

For this to work you need to add a reference to the System.ServiceModel.Web assembly as well as to System.ServiceModel and to add a using statement for the System.ServiceModel.Web namespace.

Putting It All Together

Now, when a client makes a GET request to the URL www.mycompany.com/ProductList.xml, the new endpoint with the webHttpBinding responds by calling the GetProductList method. The GetProductList retrieves the data from the file (or generates it some other way), encapsulates it as a Stream and returns the Stream. WCF then writes the contents of the Stream to the HTTP Response.

Summary

In this post I demonstrated the three basic steps you need to implement to have a WCF service serve RESTful clients. You do this by mapping the RESTful requests to an OperationContract decorated with the WebGet attribute and that is exposed at an endpoint that uses the webHttpBinding binding with a webHttp behavior.

Case Study: Upgrading from ASMX to WCF

David Sackstein — Fri, 14 Aug 2009 22:21:56 GMT

Introduction

In this post I will share my considerations for upgrading an ASMX Web Service to WCF in an existing product. Following the upgrade I encountered a little hitch with Flash and cross domain policies. In this later post I demonstrate how overcome the hitch with WCF.

Motivation for the Upgrade

When I started working on the project, the architecture had been set and a first version of the product had already been released. A Flash client interacted with an ASMX Web Service hosted by ASP.NET. My part was to make additions to the UI, but I couldn’t help reviewing the architecture to see what I could learn and improve.

An important first observation was that the Flash-ASMX combination works. Microsoft and Adobe are fierce competitors, so I think that deservers mention. Having said that, there are some limitations in the Flash support for SOAP Web Services which were disappointing.

For instance, in a Web Service you can define enums, and through the WSDL, these can be treated as enums on a Microsoft client. However enums are not supported by Flash clients. See the bug report here. Trivial as that may seem, the impact on design is significant. It encouraged the original designers to use strings and integers in the interface. With very little strong-typing in the API, maintenance and debugging became difficult indeed.

Quite early on I decided to upgrade the ASPX Web Service to WCF. I had three reasons for this:

WCF supports multiple concurrent end-points.
WCF implements singleton behavior with a mere attribute, saving coding.
WCF can be self-hosted and doesn’t require IIS.

Multiple end-points

The need for multiple end-points in this project was due to the internal architecture on the Server. The service actually had two clients. One was the RIA hosted in Web page, invoked from a remote client, another was a Windows Service running on the Server. The original solution involved an additional Remoting server with the same interface as the Web Service with which the Web Server and the local client interacted. Managing multiple servers, contracts and implementations was tough.

This problem is a natural fit for WCF: All I needed to do was implement one server with WCF and to add endpoint definitions to a configuration file. I defined a standard endpoint for the Flash client using basicHttpBinding and an efficient, proprietary endpoint for the local client using NetNamedPipeBinding.

One contract, one service implementation – just two endpoints.

Singleton Behavior

In the original design, the designers created the service as a Singleton and syncronized accesses to the service from the two clients in code. Rather than clutter the code with locks I preferred to use WCF’s ServiceBehavior attribute with InstanceContextMode.Single and ConcurrencyMode.Single. WCF handles the implementation.

Self-Hosting - No Need for IIS

Actually, this reason was not in my original list. But then, as I approached the design review for the new GUI, the Product Manager of the product and the Technical Writer asked me if they could get a mock-up of the application to review and to document following the review.

This wouldn’t usually be a problem, because, following good practice in GUI development, I was developing against an interface and not a real server. I had already implemented the Web Service contract with a Mock so there would be no need to install any business layer components with the mock-up.

But there was still one hitch. In order to run the mock-up, I needed IIS to host the ASMX web service. My clients would have to install IIS, or I would have to do it for them. What a pain : )

Well, with WCF that was easy to solve – a simple Console Application could host the service in 1-2-3 (or should I say A-B-C).

Summary

In this post I described some very practical reasons why I upgraded an ASMX Web Service to WCF in an existing product. In the next post I will show you how I used WCF to solve a cross-domain problem that I encountered with the Flash client.