Techie things

Links for 2010-09-06 [del.icio.us]

2010-09-07T00:00:00-07:00

Use the Spike to Copy and Paste Text in Word

Links for 2010-09-02 [del.icio.us]

2010-09-03T00:00:00-07:00

An index to Maoni's blog posts about the GC

Links for 2010-08-30 [del.icio.us]

2010-08-31T00:00:00-07:00

Periodic Table of the Elements - Josh Duck
HTML5 tags

Links for 2010-08-29 [del.icio.us]

2010-08-30T00:00:00-07:00

Dirpy - Internet DVR - YouTube to Mp3 Converter and YouTube Video Downloader

Links for 2010-08-23 [del.icio.us]

2010-08-24T00:00:00-07:00

Beginner's Guide to Linkers

Kew Gardens [Flickr]

2010-08-05T03:33:48-07:00

artur02 posted a photo:

Metro [Flickr]

2010-07-16T12:34:41-07:00

artur02 posted a photo:

Metro construction

Metro [Flickr]

2010-07-16T12:33:00-07:00

artur02 posted a photo:

Metro construction

Metro [Flickr]

2010-07-16T12:31:54-07:00

artur02 posted a photo:

Metro construction

Metro [Flickr]

2010-07-16T12:30:23-07:00

artur02 posted a photo:

Metro construction

Links for 2010-07-06 [del.icio.us]

2010-07-07T00:00:00-07:00

Parallel Programming: Task Schedulers and Synchronization Context - C# ...

Links for 2010-07-01 [del.icio.us]

2010-07-02T00:00:00-07:00

Free delivery worldwide on all books from The Book Depository

CAL and AutoMapper

2010-05-19T18:28:00.001+02:00

I’m using Composite Application Library (CAL) in a project. I decided to use AutoMapper as well. I put AutoMapper’s Mapper.CreateMap<source, dest>() calls into one of the Bootstrapper.cs methods. I got an InvalidOperationException in the ModuleCatalog’s InnerLoad() function.

Reason

AutoMapper creates an in-memory assembly and CAL tries to read all the assemblies’ Location property. This property raises an InvalidOperationException in case of in-memory assemblies.

Solution

Insert AutoMapper mappings right after the Bootstrapper.Run() call. In my case I call this in App.xaml.cs, so you can write the following:

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);

    // Run bootstrapper
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();

    // AutoMapper mappings
    Parallel.Invoke(CreateAutoMapperMappings);
}

/// <summary>
/// Creates the AutoMapper mappings.
/// </summary>
private static void CreateAutoMapperMappings()
{
    Mapper.CreateMap<Source, Dest>();
}

F#: Piping and Composition

2010-05-14T23:31:00.001+02:00

Piping and compositions are very expressive tools in F#. It significantly improves code readability.

Let’s have the following functions:

> let square x = x*x;;
val square : int -> int

> let negate x = -x;;
val negate : int –> int

Function square returns the square of x, while negate returns the negated value of x.

We can calculate square(negate(10)) as follows:

> let x = negate 10;;
val x : int = –10

> let x = square x;;
val x : int = 100

Or a simpler way:

> let x = square (negate 10);;
val x : int = 100

Piping

We can define piping as symbol-named function definition that simply applies two functions in reverse order:

let (|>) f x =
x f

The example with piping:

> 10 |> negate |> square;;
val it : int = 100

That means ((10 negate) square) –> (square (negate 10)). I used an integer (10) as f.

Composition

Composition is a reverse-order function composition:

let (>>) f g x =
g(f x)

The example with composition:

> (negate >> square) 10;;
val it : int = 100

That means ((negate square) 10) –> (square (negate 10)).

Usage

The examples above are very simple ones. The real benefits of piping and composition reveal in case of function definitions and usage.

Pipes can reverse parameter definition orders (like in 10 |> negate) and can help type inferring. When F# infers types, it evaluates from upper left corner to lover right corner of the text file, so sometimes it doesn't know the type of a function parameter. Pipe brings parameters forward.

Composition can help omitting function parameter declaration. If the first function expects a parameter, the composed function expects it’s parameter.

Database Comparison

2010-05-04T21:09:00.001+02:00

I' am very interested in open source database comparisons. I found two interesting blog posts:

Sukhvinder Singh wrote about the comparison of H2, HSQLDB, DERBY, PostgreSQL, MySQL.
Thirdstage wrote about the comparison of about HSQLDB, H2, SQLite

Link: H2, HSQLDB, DERBY, PostgreSQL, MySQL
Link: HSQLDB, H2, SQLite

Get WPF DataGrid row and cell

2010-05-02T11:54:00.001+02:00

There are no simple built-in methods for accessing individual rows or columns in WPF DataGrid. The following code samples will provide simple methods for accessing these items.

First of all we need a helper function for selecting a visual child:

public static T GetVisualChild<T>(Visual parent) where T : Visual
{
    T child = default(T);
    int numVisuals = VisualTreeHelper.GetChildrenCount(parent);
    for (int i = 0; i < numVisuals; i++)
    {
        Visual v = (Visual)VisualTreeHelper.GetChild(parent, i);
        child = v as T;
        if (child == null)
        {
            child = GetVisualChild<T>(v);
        }
       if (child != null)
       {
           break;
       }
   }
       return child;
}

There is a simple method for getting the current (selected) row of the DataGrid:

public static DataGridRow GetSelectedRow(this DataGrid grid)
{
    return (DataGridRow)grid.ItemContainerGenerator.ContainerFromItem(grid.SelectedItem);
}

We can also get a row by its indices:

public static DataGridRow GetRow(this DataGrid grid, int index)
{
    DataGridRow row = (DataGridRow)grid.ItemContainerGenerator.ContainerFromIndex(index);
    if (row == null)
    {
        // May be virtualized, bring into view and try again.
        grid.UpdateLayout();
        grid.ScrollIntoView(grid.Items[index]);
        row = (DataGridRow)grid.ItemContainerGenerator.ContainerFromIndex(index);
    }
    return row;
}

Now we can get a cell of a DataGrid by an existing row:

public static DataGridCell GetCell(this DataGrid grid, DataGridRow row, int column)
{
    if (row != null)
    {
        DataGridCellsPresenter presenter = GetVisualChild<DataGridCellsPresenter>(row);

        if (presenter == null)
        {
            grid.ScrollIntoView(row, grid.Columns[column]);
            presenter = GetVisualChild<DataGridCellsPresenter>(row);
        }

        DataGridCell cell = (DataGridCell)presenter.ItemContainerGenerator.ContainerFromIndex(column);
        return cell;
    }
    return null;
}

Or we can simply select a row by its indices:

public static DataGridCell GetCell(this DataGrid grid, int row, int column)
{
    DataGridRow rowContainer = grid.GetRow(row);
    return grid.GetCell(rowContainer, column);
}

The functions above are extension methods. Their use is simple:

var selectedRow = grid.GetSelectedRow();
var columnCell = grid.GetCell(selectedRow, 0);

View source on Google Code (unformatted selection possible)

Mixed mode assemblies on .NET 4.0

2010-04-17T16:31:00.001+02:00

Mixed mode assembly is built against version 'v2.0.50727' of the runtime and cannot be loaded in the 4.0 runtime without additional configuration information.

I got this message when I tried to start a project migrated from .NET 3.5 to .NET 4.0. I case of migration, migration wizard inserts a <startup></startup> tag into the app.config file.

Solution: insert the

useLegacyV2RuntimeActivationPolicy="true"

attribute into the startup tag. Application should work now.

Reason: .NET 4.0 changed mixed mode assembly loading mechanisms.

NHibernate session management

2010-04-17T14:36:00.001+02:00

When you start working with NHibernate, you will see code examples like this one:

int userID = 1234;

using( ISession session = sessionFactory.OpenSession() )

using( session.BeginTransaction() ) {

    User user = session.Get<User>(userID);

    session.Transaction.Commit();

You get a session object, start a transaction and finally commit that. This is fine when you work in a simple one-layer application or you are OK with tight coupling. When you have multiple layers, or working with binding like in WPF, things get complicated.

Session management strategies

Session per application
Simplest approach. Just one session for the whole application, typically returned by a singleton.
Problem: Async calls can interfere with each other, cache size grows, unrecoverable exceptions, stale data
Session per screen
New session for every form/view/… There are multiple concurrent sessions.
Problem: You can keep a screen opened for a long time, so stale data is expectable.
Session per data access
Every single data access uses a new session object.
Problem: Lazy loading won’t work, problem with 1st level cache…
Session per use-case
You create a new session for every use-case. There will be concurrent sessions.

Firs try: Following examples – Session per data access

I’ve created an application with the simplest solution possible. I followed the examples and whenever I tried to access data, I created a session and a transaction. Everything was fine, until I tried to employ lazy loading. It simply did not work. There was no open sessions the lazy loader proxy could have used.

Second try: Session per application

I modified the application. I created a singleton that returned a session object. Every single data access used this session. The application worked fine – for a while. I used SQLite as DBMS, and SQLite has not the best threading support. So I got exceptions randomly. Sometimes a control was empty, sometimes it was filled with data. Exceptions happened about 1 out of 15 tries. I suspected a threading issue and it seems it was.

Third try: Session per use-case

I had to implement a session per use-case (business transaction) solution to solve the problems above. A business transaction is a user-initiated action involving multiple complicated operations (steps). All operations (and the transaction itself) are either successful or unsuccessful. The state of the involved members are well-defined and consistent at the end of the transaction.

We have to be able to keep alive the NHiberanate ISession object over multiple operations. The solution is the unit of work pattern. It encapsulates the ISession object, so we can pass it around and implement the IDisposable pattern. The class implementing the unit of work pattern can expose ISession functionality. See the example UML class diagram below.

This is an example of calling the UnitOfWork object instance:

using (UnitOfWork unitOfWork = database.CreateUnitOfWork())

    PropertiesRepository propertiesRepository = new PropertiesRepository(unitOfWork);

    properties = propertiesRepository.Current;

You can use a simple factory (it is the database object here) to create a new UnitOfWork instance. This instance should be passed to all the classes accessing NHibernate functionality. This is important, so design your data access and manipulating classes according to this constraint!

Link: Rich-client NHibernate session management
Link: Unit of Work

CodePlex TFS from VS2010

2010-04-17T13:03:00.001+02:00

Visual Studio 2010 Professional has a built-in Team Foundation Server (TFS) client. There are some user interface changes on the Add Team Foundation Server screen. When you are connecting to the CodePlex TFS, you need to specify the following information:

Name or URL of TFS: tfs<number>.codeplex.com
Connection details

Path: tfs
Port number: 443
Protocol: HTTPS

There is no need to specify Project name anywhere on this screen.

Refresh WPF DataGrid

2010-01-24T19:57:00.001+01:00

I am using WPF DataGrid for displaying a list of items. I had to modify an item, but the item had no INotifyPropertyChanged event on that property (it was a collection).

So my first idea was:

Update the list behind ItemsSource
Set ItemsSource property to null to force unbinding
Set ItemsSource property to the new collection
Set the SelectedItem to the new item
Call ScrollIntoView() on the new item

Well, I got a huge exception at step 5. There must be a simpler solution. And there is.

The DataGrid generates a view of the ItemsSource. All I have to do is call the Items.Refresh() method, and it will rebind to the ItemsSource. Everything will be rebound, all updates will be visible. Selected item kept, visibility kept.

DispatcherPriority

2010-01-18T15:33:00.001+01:00

I had a very tough problem today. The following code did not work correctly:

var books = _bookRepository.All;

Dispatcher.Invoke(

    new ThreadStart(delegate

                            foreach (Book book in books)

                                CatalogItems.Add(new BookViewModel(book));

                            OnLoaded(this, EventArgs.Empty);

                            OnPropertyChanged("CatalogItems");

}),

    DispatcherPriority.ApplicationIdle);

When I run the code above the first time, the debugger didn’t even break into the dispatched code. The subsequent calls were fine.

Finally I realized that DispatcherPriority.ApplicationIdle should be changed to DispatcherPriority.Normal – and everything was fine. Don’t forget to check the DispatcherPriority value of the dispatcher! It’s hard to debug and hard to recognize.

These are the possible dispatcher priority levels:

Priority	Description
Inactive	Work items are queued but not processed.
SystemIdle	Work items are only dispatched to the UI thread when the system is idle. This is the lowest priority of items that are actually processed.
ApplicationIdle	Work items are only dispatched to the UI thread when the application itself is idle.
ContextIdle	Work items are only dispatched to the UI thread after higher-priority work items are processed.
Background	Work items are dispatched after all layout, rendering, and input items are processed.
Input	Work items are dispatched to the UI thread at the same priority as user input.
Loaded	Work items are dispatched to the UI thread after all layout and rendering are complete.
Render	Work items are dispatched to the UI thread at the same priority as the rendering engine.
DataBind	Work items are dispatched to the UI thread at the same priority as data binding.
Normal	Work items are dispatched to the UI thread with normal priority. This is the priority at which most application work items should be dispatched.
Send	Work items are dispatched to the UI thread with the highest priority.

Link: Build More Responsive Apps With The Dispatcher (MSDN)

Events with anonymous delegate

2010-01-11T10:55:00.001+01:00

I subscribed to an event with an anonymous delegate. Later I was in need for a solution to be able to unsubscribe this delegate. This is a simple solution for the problem:

public class ClassName

    MouseButtonEventHandler eventHandler;

    public ClassName()

        eventHandler = delegate

                                            // operations

};

    void Functionality()

        if (_subscribe)

            _object.MouseLeftButtonDown += eventHandler;

        else

            _object.MouseLeftButtonDown -= eventHandler;

NHibernate and SQLite in-memory database

2010-01-09T12:50:00.002+01:00

I’m implementing and in-memory database-based unit test framework for an application. I hope it speeds up unit tests. Unfortunately I have to redesign my entity repositories to support in-memory behavior. As far as I can learn from SUT behavior, SQLite will create a brand new database when

you close the session
you commit or close a transaction

It means you can’t use using(ISession) and using(ITransaction transaction){ … transaction.Commit() } constructs in the repository.

Web-style WPF popup

2009-12-16T13:47:00.001+01:00

I like modal web dialogs, especially when they dim the background. Here is an example:

The background is dimmed, not clickable, and the dialog box is in the foreground. The work area is visible at first site, you must focus on the current content.

I wanted something similar in WPF. Here is my example application:

How it works?

There are two parts of the window. There is a DataGrid in the left pane and a ListBox in the right pane. The same data is loaded into both controls. When you select an item in the grid, the popup will appear over the grid, displaying the selected name. Clicking on the popup will close that. You can’t click through the popup. The right pane demonstrates that you can do anything with other controls. The popup resizes itself (drag the grid splitter to test it).

About adorners

The key component to the popup control is the adorner class of WPF. The definition of adorners from MSDN:

An Adorner is a custom FrameworkElement that is bound to a UIElement. Adorners are rendered in an AdornerLayer, which is a rendering surface that is always on top of the adorned element or a collection of adorned elements. Rendering of an adorner is independent from rendering of the UIElement that the adorner is bound to. An adorner is typically positioned relative to the element to which it is bound, using the standard 2-D coordinate origin located at the upper-left of the adorned element.

There are three types of adorners:

Adorner: An abstract base class from which all concrete adorner implementations inherit.

AdornerLayer: A class representing a rendering layer for the adorner(s) of one or more adorned elements.

AdornerDecorator: A class that enables an adorner layer to be associated with a collection of elements.

The code

The code of the popup adorner is the following:

   1: using System.Windows;

   2: using System.Windows.Documents;

   3: using System.Windows.Media;

   4: using System.Windows.Controls;

5:

   6: namespace AdornerTest1

   7: {

   8:     public class PopUp : Adorner

   9:     {

  10:         private VisualCollection _Visuals;

  11:         private ContentPresenter _ContentPresenter;

12:

  13:         /// <summary>

  14:         /// Initializes a new instance of the <see cref="PopUp"/> class.

  15:         /// </summary>

  16:         /// <param name="adornedElement">The element to bind the adorner to.</param>

  17:         /// <exception cref="T:System.ArgumentNullException">Raised when adornedElement is null.</exception>

  18:         public PopUp(UIElement adornedElement)

  19:             : base(adornedElement)

  20:         {

  21:             _Visuals = new VisualCollection(this);

  22:             _ContentPresenter = new ContentPresenter();

  23:             _Visuals.Add(_ContentPresenter);

  24:         }

25:

  26:         /// <summary>

  27:         /// Initializes a new instance of the <see cref="PopUp"/> class.

  28:         /// </summary>

  29:         /// <param name="adornedElement">The adorned element.</param>

  30:         /// <param name="content">The content.</param>

  31:         public PopUp(UIElement adornedElement, Visual content)

  32:             : this(adornedElement)

  33:         { Content = content; }

34:

  35:         /// <summary>

  36:         /// Implements any custom measuring behavior for the adorner.

  37:         /// </summary>

  38:         /// <param name="constraint">A size to constrain the adorner to.</param>

  39:         /// <returns>

  40:         /// A <see cref="T:System.Windows.Size"/> object representing the amount of layout space needed by the adorner.

  41:         /// </returns>

  42:         protected override Size MeasureOverride(Size constraint)

  43:         {

  44:             _ContentPresenter.Measure(constraint);

  45:             return _ContentPresenter.DesiredSize;

  46:         }

47:

  48:         /// <summary>

  49:         /// When overridden in a derived class, positions child elements and determines a size for a <see cref="T:System.Windows.FrameworkElement"/> derived class.

  50:         /// </summary>

  51:         /// <param name="finalSize">The final area within the parent that this element should use to arrange itself and its children.</param>

  52:         /// <returns>The actual size used.</returns>

  53:         protected override Size ArrangeOverride(Size finalSize)

  54:         {

  55:             _ContentPresenter.Arrange(new Rect(0, 0,

  56:                  finalSize.Width, finalSize.Height));

  57:             return _ContentPresenter.RenderSize;

  58:         }

59:

  60:         /// <summary>

  61:         /// Overrides <see cref="M:System.Windows.Media.Visual.GetVisualChild(System.Int32)"/>, and returns a child at the specified index from a collection of child elements.

  62:         /// </summary>

  63:         /// <param name="index">The zero-based index of the requested child element in the collection.</param>

  64:         /// <returns>

  65:         /// The requested child element. This should not return null; if the provided index is out of range, an exception is thrown.

  66:         /// </returns>

  67:         protected override Visual GetVisualChild(int index)

  68:         { return _Visuals[index]; }

69:

  70:         protected override int VisualChildrenCount

  71:         { get { return _Visuals.Count; } }

72:

  73:         /// <summary>

  74:         /// Gets or sets the content.

  75:         /// </summary>

  76:         /// <value>The content.</value>

  77:         public object Content

  78:         {

  79:             get { return _ContentPresenter.Content; }

  80:             set { _ContentPresenter.Content = value; }

  81:         }

  82:     }

  83: }

You can set a content for the popup adorner, and that is all what I want. The VisualCollection is responsible for rendering the content on screen, and the ContentPresenter is responsible for storing the popup’s content.

There is a BackgroundShade user control to represent the dimmed background. The code is very short and simple:

   1: <UserControl

   2:     [...]

   3:     Background="Black"

   4:     Opacity="0.705">

5:

   6:     <Grid x:Name="LayoutRoot"/>

   7: </UserControl>

I set the background to black at line 3 and I set the opacity of the control to 70% at line 4.

The Main window layout:

   1: <Window

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:     xmlns:Custom="http://schemas.microsoft.com/wpf/2008/toolkit" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:AdornerTest1="clr-namespace:AdornerTest1"

   5:     x:Class="AdornerTest1.MainWindow"

   6:     x:Name="Window"

   7:     Title="Popup with shaded background sample"

   8:     Width="640" Height="480" mc:Ignorable="d">

9:

  10:     <Window.Resources>

  11:         <DataTemplate x:Key="ItemTemplate">

  12:             <StackPanel>

  13:                 <TextBlock Text="{Binding Name}" Background="Black" Foreground="White"/>

  14:                 <TextBlock Text="{Binding Phone}"/>

  15:                 <TextBlock Text="{Binding Note}" Margin="0 0 0 8"/>

  16:             </StackPanel>

  17:         </DataTemplate>

  18:     </Window.Resources>

19:

  20:     <Grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource SampleDataSource}}">

  21:         <Grid.ColumnDefinitions>

  22:             <ColumnDefinition/>

  23:             <ColumnDefinition MinWidth="10" Width="Auto"/>

  24:             <ColumnDefinition/>

  25:         </Grid.ColumnDefinitions>

  26:         <Custom:DataGrid x:Name="Grid" ItemsSource="{Binding Collection}"  AutoGenerateColumns="True" SelectionChanged="Grid_SelectionChanged" />

  27:         <GridSplitter HorizontalAlignment="Stretch" Grid.Column="1"/>

  28:         <ListBox x:Name="List" Grid.Column="2" ItemTemplate="{DynamicResource ItemTemplate}" ItemsSource="{Binding Collection}" d:LayoutOverrides="GridBox"/>

  29:     </Grid>

  30: </Window>

There is a Grid as layout root with 3 columns. There is a DataGrid in the left pane, a GridSplitter in the middle pane, and a ListBox in the right pane.

The Main window code:

   1: using [...]

2:

   3: namespace AdornerTest1

   4: {

   5:     public partial class MainWindow : Window

   6:     {

   7:         public MainWindow()

   8:         { [...] }

9:

  10:         BackgroundShade shade;

  11:         PopUp adorner;

12:

  13:         private void Grid_SelectionChanged(

  14:             object sender, SelectionChangedEventArgs e)

  15:         {

  16:             // Create adorner

  17:             AdornerLayer layer = AdornerLayer.GetAdornerLayer(Grid);

  18:             adorner = new PopUp(Grid);

19:

  20:             // Close adorner

  21:             adorner.MouseLeftButtonDown += delegate

  22:                                        {

  23:                                            layer.Remove(adorner);

  24:                                        };

  25:             ((FrameworkElement) adorner.AdornedElement).

  26:                 SizeChanged += AdornedElement_SizeChanged;

27:

  28:             // Create shaded background

  29:             shade = new BackgroundShade();

  30:             AdornedElement_SizeChanged(this, null);

31:

  32:             // Create text

  33:             TextBlock text = new TextBlock();

  34:             text.Foreground = Brushes.White;

  35:             // Bind text to selected item

  36:             Binding binding = new Binding("Name");

  37:             binding.Source = Grid.SelectedItem;

  38:             text.SetBinding(TextBlock.TextProperty, binding);

  39:             // Register text

  40:             shade.LayoutRoot.Children.Add(text);

41:

  42:             // Display adorner

  43:             adorner.Content = shade;

  44:             layer.Add(adorner);

  45:         }

46:

  47:         /// <summary>

  48:         /// Adorned element's size changed

  49:         /// </summary>

  50:         void AdornedElement_SizeChanged(object sender, SizeChangedEventArgs e)

  51:         {

  52:             shade.Width = adorner.AdornedElement.RenderSize.Width;

  53:             shade.Height = adorner.AdornedElement.RenderSize.Height;

  54:         }

  55:     }

  56: }

The implementation details are in the comments. One interesting thing: I couldn’t simply bind the AdornedElement’s RenderSize to the shade’s width property, so it seems simpler to convert the AdornedElement to FrameworkElement and attach an event handler to the SizeChanged event.

You can download the source and the binaries from Google code, or you can simply browse source at the same place. Links are below.

Link: Demo source [Google Code]
Link: Demo executable [Google Code]
Link: Browse source [Google Code]

NUnit and Microsoft Contracts library

2009-12-13T13:41:00.001+01:00

I’m using NUnit and Microsoft Code Contracts library to implement unit tests and code contracts (mostly preconditions).

Unfortunately Contracts library throws a generated (internal) exception class that can’t be used as Assert.Throws<ContractException>(…).

Contracts documentation suggests the following code for MSTest framework:

[TestClass]

public  class  Test

    [AssemblyInitialize]

    public  static  void   AssemblyInitialize (TestContext tc)

        Contract. ContractFailed+= (sender, e) => {

            e.SetHandled();

            e.SetUnwind(); // cause code to  abort  after  event

            Assert.Fail(e.FailureKind.ToString() + ":" + e.DebugMessage);

};

I wrote the following code to mimic this functionality:

[TestFixtureSetUp]

public void SetUpFixture()

    Contract.ContractFailed +=

    (sender, e) =>

        e.SetHandled();

        e.SetUnwind();

        Assert.Fail(string.Format("{0}:{1}", e.FailureKind.ToString(), e.Message));

};

Well, it did not work, I couldn’t make the Assert.Throws structure work. I always got the ContractException exception. Finally I found a blog entry (in German) with a classic solution:

use try/catch block
check exception type name

So here is the working code:

try

    // Method under test

catch (Exception ex)

    Assert.True(ex.GetType().Name == "ContractException");

    return;

Assert.Fail("ContractException has not been thrown.");

NDepend

2009-12-07T13:05:00.001+01:00

I've started using NDepend Pro on my open-source project. I will try to outline some important features and explain some ideas that differenciate this tool from others like FXCop or ReSharper rules.

What is NDepend?

For me NDepend is a tool for monitoring and improving code quality. It uses software metrics and .NET IL characteristics to help us understand, analyze, visualize and compare different code bases and builds. We learnt code coverage, cohesion, coupling and other code metrics at university, but we hardly had the chance to employ this knowledge (or even understand deeper them). Who wants to calculate them for hundreds of code lines? Well, NDepend just does it instead of us. We can see the internals of code structure and dependencies with just one click!

Costs

NDepend is a free tool for academic and open-source projects. Unfortunately it comes with a cost: you will be restricted with CQL (creating custom code metrics queries) usage, won’t be able to compare builds, won’t be able to integrate test metrics into the dataset and (almost) won’t have Visual Studio integration. I think it’s OK for an open-source project.

Where to start?

NDepend is not an easy tool. Easy to use, but it takes time to learn and understand the metrics and find the proper threshold limits for your project. NDepend team knows it, so they set up a lot of preset thresholds and built-in CQL queries. There are useful demo videos and there is a metrics library. So it’s easy to start using it.

How do I use it?

I use NDepend as a guard. I use other tools (like Resharper, Team System Tools or FXCop) in Visual Studio to check against naming conventions and some other rules. Visual NDepend helps me to understand the structure of my application and recheck some rules, mainly with built-in CQL queries.

I found a circular call in one of my assemblies. It was not trivial to me, I couldn’t have found that without NDepend.

Link: NDepend
Link: software metrics
Link: Inheritance Depth in CQL

Pin m3u to taskbar

2009-11-15T17:33:00.001+01:00

I wanted to pin (keep permanently) some .m3u files to my taskbar. A lot of radios publish their live streams in .m3u files and I could have listened to them with just one click.

It is really simple in case of Windows 7. Just drag and drop the .m3u files to the taskbar (to an empty area) and these files will appear in the pin list of their default program. In my case this program is Media Player Classic.

This is a great feature of Windows 7!

AvalonDock Layout Persistance

2009-11-14T21:20:00.001+01:00

Persisting layout using AvalonDock is quite simple. Just call the following methods:

DockingManager.SaveLayout(path)
DockingManager.RestoreLayout(path)

It’s simple, but it did not work for me. My fault was also simple. You must define the x:Name=”name” attribute on the DockableContents and everything will work fine.

Logging proxy

2009-10-30T18:25:00.001+01:00

I learnt today that I can create a proxy that intercepts calls to an object, do anything with the call and forward the call to the appropriate object. The same is true for the results. The whole thing is implemented by using a RealProxy implementation. I will demonstrate the functionality with .NET Remoting.

The common interface

namespace Common
{
    public interface IServer
    {
        int Add(int a, int b);
    }
}

The server implementation

using Common;

namespace Server
{
    class ServerImpl: MarshalByRefObject, IServer
    {
        #region IServer Members

        public int Add(int a, int b)
        {
            return a + b;
        }

        #endregion

        public override object InitializeLifetimeService()
        {
            return null;
        }
    }
}

The server loop

static void Main()
{
    // Windows Forms settings
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);

    // Remoting loop
    RemotingServices.Marshal(new SzerverImplementacio(), "Server");
    ChannelServices.RegisterChannel(new TcpChannel(8080), false);

    // Windows Froms Window
    Application.Run(new Form1());
}

The logging proxy

using System.Runtime.Remoting.Proxies;

using System.Runtime.Remoting;

using System.Runtime.Remoting.Messaging;

using System.Runtime.Remoting.Channels;

using System.Collections;

namespace Kliens

    public class LogProxy : RealProxy

        String uri;

        MarshalByRefObject obj;

        IMessageSink _sinkChain;

        public LogProxy(Type type, string uri) : base(type)

            this.uri = uri;

            IChannel[] registeredChannels = ChannelServices.RegisteredChannels;

            foreach (IChannel chnl in registeredChannels)

                if (chnl is IChannelSender)

                    IChannelSender chnlSender = (IChannelSender)chnl;

                    _sinkChain = chnlSender.CreateMessageSink(uri, null, out uri);

                    if (_sinkChain != null)

                        break;

            if (_sinkChain == null)

                throw new Exception("No channel has been found for " + uri);

        public override IMessage Invoke(IMessage msg)

            Console.WriteLine("LogProxy.Invoke Start");

            Console.WriteLine("");

            // Set message URI

            msg.Properties["__Uri"] = uri;

            // List call properties

            Console.WriteLine("Call properties:");

            foreach (var key in msg.Properties.Keys)

                Console.WriteLine("{0}: {1}", key, msg.Properties[key]);

                if (key.ToString() == "__Args")

                    Console.WriteLine("Arguments:");

                    object[] args = (object[])msg.Properties[key];

                    foreach (var arg in args)

                        Console.WriteLine("arg: {0}", arg);

            // Process the request mesage

            IMessage retMsg = _sinkChain.SyncProcessMessage(msg);

            // List return properties

            Console.WriteLine("Return properties:");

            foreach (var key in retMsg.Properties.Keys)

                Console.WriteLine("{0}: {1}", key, retMsg.Properties[key]);

            // Process the return message

            return retMsg;

Call the server from the client

// Without logging proxy:

// IServer server = (IServer)Activator.GetObject(typeof(IServer), "tcp://localhost:8080/Server");

TcpChannel chnl = new TcpChannel();

ChannelServices.RegisterChannel(chnl, false);

LogProxy prx = new LogProxy(typeof(IServer), "Tcp://localhost:8080/Server");

IServer server = (IServer)prx.GetTransparentProxy();

MessageBox.Show(server.Add(2, 3).ToString());

Result

All the call end response properties will be listed in the Output window (or in the Console). The call will happen as there were no proxy class taking part in the call.

Apart Remoting this is a good solution for generating any kind of proxies:

Virtual proxies
Security proxies
…

RealProxy is a good extension point for an application.

Hiding XAML designer by default

2009-10-29T18:45:00.001+01:00

I hate Visual Studio 2008 XAML Designer. It’s slow and can be easily killed (I mean XAML Designer can’t be displayed, just an error message instead). I prefer Expression Blend 3 for GUI design.

So here are the steps to hide the designer and go straight to the text editor:

Open Tools/Options
Select Text Editor/XAML/Miscellaneous
Under ‘Default View’ select ‘Always open documents in full XAML view’

After setting this option, you will still be able to change to designer using a tab, but the editor will be the default view for XAML files. Faster loading an (hopefully) less crashes.

XAML Combobox SelectedItem binding

2009-10-29T18:35:00.001+01:00

Combobox SelectedItem binding in XAML did not work for me at first.

This is the XAML for binding:

<ComboBox x:Name="format" DisplayMemberPath="Text" SelectedItem="{Binding Format}" IsEditable="False"   />

This is the code behind:

PublishingFormatRepository pf = new PublishingFormatRepository(Current.BookshelfPath);
List<PublishingFormat> publishingFormats = pf.All as List<PublishingFormat>;
format.ItemsSource = publishingFormats;
if (publishingFormats != null) format.SelectedItem = publishingFormats[0];

set
{
    _book = value;
    DataContext = _book;
}

It’s simple, it should work. I attached a binding tracer to the binding extension but there was no problem. After a while something came on my mind: object equality. I checked something like this:

_book.Format == publishingFormats[0]

It should have been true but it was false.

So the solution is simple:

[Serializable]
    public class PublishingFormat : IEquatable<PublishingFormat>
    {
        ////////////////
        // Members here
        ////////////////

        public override bool Equals(object obj)
        {
            return Equals(obj as PublishingFormat);
        }

        #region IEquatable<PublishingFormat> Members

        public virtual bool Equals(PublishingFormat other)
        {
            if (ReferenceEquals(null, other)) return false;
            if (ReferenceEquals(this, other)) return true;
            return other.Id.Equals(Id);
        }

        #endregion

        public override int GetHashCode()
        {
            return Id.GetHashCode();
        }

        public static bool operator ==(PublishingFormat left, PublishingFormat right)
        {
            return Equals(left, right);
        }

        public static bool operator !=(PublishingFormat left, PublishingFormat right)
        {
            return !Equals(left, right);
        }
    }

The class implements the IEquatable interface and overrides the Equals function and the ==, != operators. In my case the equality will be evaluated by comparing the Id fields of the classes.

Now the simple XAML expression above works.

Link: How to: Define Value Equality for a Type (C# Programming Guide) [MSDN]

Inheritance depth

2009-10-18T17:39:00.001+02:00

I’m developing an application and I’m controlling code quality with NDepend. There is a CQL rule for checking inheritance depth. The built in rule is the following:

WARN IF Count > 0 IN 
    SELECT TOP 10 TYPES 
    WHERE DepthOfInheritance >= 6 
    ORDER BY DepthOfInheritance DESC

The project is a WPF-based application, so I got a lot of warning. I have controls and windows, all of them starting at inheritance level 9. So I rewrote the CQL query as follows:

WARN IF Count > 0 IN 
SELECT TOP 10 TYPES 
WHERE 
(
    (DepthOfInheritance >= 6 AND 
    ! DeriveFrom  "System.Windows.Controls.UserControl" AND 
    ! DeriveFrom "System.Windows.Window"  ) 
) 
OR ( DepthOfInheritance >= 12 ) 
ORDER BY DepthOfInheritance DESC

This rule will warn me if

the component is not derived from UserControl or Window and the inheritance level is higher than 6 or
the inheritance level is higher than 12.

In other words I allow 3 inheritance level for user controls and windows and 6 for others.

Autofill TFS password on Codeplex

2009-10-15T14:03:00.001+02:00

I hate filling in TFS credentials every time I connect to TFS server on Codeplex. I’ve just found an easy way to automate it.

Microsoft Windows Vista and Windows 7 have a new component called Credential Manager. You can store Windows, Certificate-based and Generic credentials. It means these credentials can be automatically provided by Windows on request. So you just simply don’t have to type them in every time you log on somewhere.

Codeplex

These are the steps to automate the Codeplex login process:

Open Credential Manager
Choose Add a Windows credential
Specify the Codeplex server name at Internet or network address, fill in the rest
Click OK
Open your TFS project

You won’t be prompted for credentials anymore.

WPF MVVM pattern

2009-10-08T15:45:00.001+02:00

I’m using the WPF Model-View-ViewModel(MVVM) pattern in one of my projects. I will tell a few words about the implementation.

The first step is to create an entity class, the Model. This class stores only data. To support binding and data validation in WPF, it also implements the IDataErrorInfo interface. Entity classes can be generated by object-relational mapping (ORM) tools like NHibernate or Microsoft Entity Framework. Or you can implement them yourself using e.g. Active Record, Data Mapper, Row Data Gateway, or Table Data Gateway patterns. The entity class don’t have to implement INotifyPropertyChanged interface, this functionality will be provided by the ViewModel.

Next you create the ViewModel. This class will be the link between the Model and the View – between the data and the user interface elements. It will store and update the Model data, and it will transform the data to be displayed on the user interface. ViewModel has the same properties as the Model (or a subset of it). ViewModel can provide calculated fields to be displayed as well. All properties signal their change, so ViewModel implements INotifyProperyChanged interface and fires the appropriate event in case of property value change.
ViewModel can react on commands. It can save its content into the database (using ORM functionality or something like that. ) While you should implement every single commands if you implemented ICommand on its own, you can introduce the RelayCommand class.

        1: public class RelayCommand : ICommand

       2:     {

       3:         readonly Action<object> _execute;

       4:         readonly Predicate<object> _canExecute;

       5:  

       6:         /// <summary>

       7:         /// Creates a new command that can always execute.

       8:         /// </summary>

       9:         /// <param name="execute">The execution logic.</param>

        public RelayCommand(Action<object> execute)

            : this(execute, null)

        {

        }

  

        /// <summary>

        /// Creates a new command.

        /// </summary>

        /// <param name="execute">The execution logic.</param>

        /// <param name="canExecute">The execution status logic.</param>

        public RelayCommand(Action<object> execute, Predicate<object> canExecute)

        {

            if (execute == null)

                throw new ArgumentNullException("execute");

  

            _execute = execute;

            _canExecute = canExecute;

        }

  

  

        #region ICommand Members

  

        /// <summary>

        /// Defines the method that determines whether the command can execute in its current state.

        /// </summary>

        /// <param name="parameter">Data used by the command.  If the command does not require data to be passed, this object can be set to null.</param>

        /// <returns>

        /// true if this command can be executed; otherwise, false.

        /// </returns>

        [DebuggerStepThrough]

        public bool CanExecute(object parameter)

        {

            return _canExecute == null ? true : _canExecute(parameter);

        }

  

        /// <summary>

        /// Occurs when changes occur that affect whether or not the command should execute.

        /// </summary>

        public event EventHandler CanExecuteChanged

        {

            add { CommandManager.RequerySuggested += value; }

            remove { CommandManager.RequerySuggested -= value; }

        }

  

        /// <summary>

        /// Defines the method to be called when the command is invoked.

        /// </summary>

        /// <param name="parameter">Data used by the command.  If the command does not require data to be passed, this object can be set to null.</param>

        public void Execute(object parameter)

        {

            _execute(parameter);

        }

  

        #endregion

    }

RelayCommand simplifies the ICommand implementation to the following few lines:

public ICommand SaveCommand
{
    get
    {
        if(_saveCommand == null)
        {
            _saveCommand = new RelayCommand(
                param => Save(),
                param => CanSave);
        }
        return _saveCommand;
    }
}

View is simply a user interface component, like a DataGrid. You can bind your ViewModel to the view and the view will update itself in case of data modification (or can update data in case of two-way binding). You can bind a control to the command of ViewModel and the control will enable/disable itself if the command behind the control cannot be executed (e.g. you can’t save the data because the model data contains errors).

MVVM pattern is complicated at first sight and you will have to create much more complicated architecture and classes, but it worths to understand and implement.

NHibernate error ‘Index was out of range. Must be non-negative and less than the size of the collection. Parameter name: index’

2009-10-04T11:45:00.002+02:00

I got the following NHibernate error when I tried to commit an entity class using a transaction:

Index was out of range. Must be non-negative and less than the size of the collection. Parameter name: index

I figured out that two fields in the .hbm.xml mapping file reference the same column in a table. Simple bug, but complicated to debug.

Unity constructor parameters

2009-10-02T20:06:00.001+02:00

I use Microsoft Unity in a project to create several objects. Most of the classes have constructor parameters. Unity uses the most detailed constructor signature (the constructor with the most number of parameters, greedy) to create the object. It’s common you don’t have all the objects registered, so you want to specify some constructor parameters. There are two ways to resolve the object with the proper parameters:

You can put an [InjectionConstructor] attribute on the constructor to mark the default constructor.
You can create a child container and register the types there.

An example of a child container:

IUnityContainer childCtr = parentCtr.CreateChildContainer();

The child container contains all the registered objects of the parent container. You can freely modify the child container, the parent won’t change. So you can register multiple objects into the child container; they will be the parameters. Finally resolve the desired class using the child container. Unity will automatically inject the previously registered types into the constructor parameters. They will work like local variables.

One huge problem with child container method: you can’t specify different objects for different parameters with the same type. You can resolve one object for one type.

Testing with Unity

2009-10-02T19:49:00.001+02:00

I’m developing a test framework for component interaction testing. It’s a legacy application and developers did not keep testability in mind when they were designing the architecture.

One main problem is coupling, mainly efferent coupling. Let’s say we have class A. It creates class B. Class B creates class C. If we want to inject a mock or stub of B or C into the system, it’s probably impossible without code modification.

You are lucky if you have a factory method that produces B or C. Usually they are just local variables of a method. Sometimes you can override the virtual method containing such references, but in this case you will loose existing code.

One of the easiest methods is employing Microsoft Unity (Application Block). You can find the following definition of Unity on MSDN:

The Unity Application Block (Unity) is a lightweight, extensible dependency injection container with support for constructor, property, and method call injection. It provides developers with the following advantages:

It provides simplified object creation, especially for hierarchical object structures and dependencies, which simplifies application code.

It supports abstraction of requirements; this allows developers to specify dependencies at run time or in configuration and simplify management of crosscutting concerns.

It increases flexibility by deferring component configuration to the container.

It has a service location capability; this allows clients to store or cache the container. This is especially useful in ASP.NET Web applications where the developers can persist the container in the ASP.NET session or application.

So Unity can create objects automatically by defining just the interface of the desired class. You can freely change implementation class. E.g. you can inject a complete communication layer class (which implements a communication functionality over TCP) into the production code, and you can easily inject a mock class (which just emulates the communication) into the test framework.

An example of class registration:

myContainer.RegisterType<IMyService, CustomerService>();

An example of creating a concrete class:

IMyService myServiceInstance = myContainer.Resolve<IMyService>();

Now you can inject mock or stub classes into the testing framework without production code modifications. I think it’s a nice solution.

Link: Unity Application Block
Link: Unity documentation
Link: (Efferent) coupling