.NET natural sort, a possible solution.

Posted on March 19, 2011 by Kristof

You have a list of items, let’s say 20 elements, starting at 1, until 20 (inclusive). We shuffle the list and we try to sort it.

List<string> normalDotNetSort = GiveMeANewList();

The code to create the list:

private static List<string> GiveMeANewList()
{
    List<string> list = new List<string>();
 
    for (int i = 1; i <= 20; i++)
    {
        list.Add(string.Format("{0}", i));
    }
 
    return list.MixList();
}

MixList just shuffles the list.

We’re using a normal Generic List and to sort, let’s use the Sort method, and write it to the console:

normalDotNetSort.Sort();
normalDotNetSort.ForEach(Console.WriteLine);

What would be the result?

1
10
11
12
13
14
15
16
17
18
19
2
20
3
4
5
6
7
8
9

That’s not what we wanted, but it is what we told the code to do. It first sorts on the first character, and then on the second (and so on…). That’s why 19 takes precedence of 2, since 1 < 2.

How do we fix this?

There is a little gem in the shlwapi.dll, namely StrCmpLogicalW. Since this is a native function we need to do a DllImport to expose the function to our C# code:

public static class SafeNativeMethods
{
    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
    public static extern int StrCmpLogicalW(string psz1, string psz2);
}

Now we can use this function in our own string comparer:

public sealed class NaturalStringComparer : IComparer<string>
{
    #region IComparer<string> Members
 
    public int Compare(string x, string y)
    {
        return SafeNativeMethods.StrCmpLogicalW(x, y);
    }
 
    #endregion
}

And use this comparer to sort our list:

List<string> interopSort = GiveMeANewList();
interopSort.Sort(new NaturalStringComparer());
interopSort.ForEach(Console.WriteLine);

And the result:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Much better no?

Dictionary<TKey, TValue> finding key: try/catch vs TryGetValue

Posted on March 17, 2011 by Kristof

Today I saw some code where the developer accessed a dictionary like this:

void Foo(int keyToFindInDictionary)
{
    Dictionary<int, string> dictionary = new Dictionary<int, string>();
 
    try
    {
        DoSomethingWithTheResult(dictionary[keyToFindInDictionary]);
    }
    catch (KeyNotFoundException)
    {
        // fallback
    }
}
 
private void DoSomethingWithTheResult(string s)
{
    // do something
}

As you can see he catches the exception to handle the fact that the given key was not found in the dictionary.

I told him that there was a better way, i.e. Dictionary<TKey, TValue>.TryGetValue.

And then the curious part of me started thinking, how much better is it? Is it faster? Slower?

So I wrote the following small piece of code to test my statement that TryGetValue is better than catching the KeyNotFoundException.

namespace DictionaryTryGetValueVersusException
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
 
    internal class Program
    {
        private static void Main()
        {
            // create a dictionary with some values
            Dictionary<string, string> dictionary = new Dictionary<string, string>();
 
            // add 10,000 items
            for (int i = 0; i < 10000; i++)
            {
                if (i == 5000)
                {
                    // skip
                    continue;
                }
 
                dictionary.Add(string.Format("Key{0}", i), string.Format("Value{0}", i));
            }
 
            Stopwatch stopwatch = new Stopwatch();
 
            stopwatch.Start();
 
            const string keyToFindInDictionary = "Key5000";
 
            for (int i = 0; i < 10000; i++)
            {
                // 5000 does not exist
                try
                {
                    // execute a method on the variable, so that he compiler doesn't optimize it.
                    dictionary[keyToFindInDictionary];
                }
                catch (Exception)
                {
                    // ignore
                }
            }
 
            stopwatch.Stop();
            Console.WriteLine("Dictionary lookup with try/catch took: {0}", stopwatch.ElapsedTicks);
 
            stopwatch.Restart();
 
            for (int i = 0; i < 10000; i++)
            {
                string notFound;
                // 5000 does not exist
                dictionary.TryGetValue(keyToFindInDictionary, out notFound);
            }
 
            stopwatch.Stop();
            Console.WriteLine("Dictionary lookup with TryGetValue took: {0}", stopwatch.ElapsedTicks);
 
            Console.WriteLine("Done, press enter to exit");
            Console.ReadLine();
        }
    }
}

As you can see we add 10,000 items to the dictionary, skipping the 5000th item, and then we do a lookup in the dictionary, 10,000 times, on the key that doesn’t exist, to measure the performance difference between the 2 previously discussed methods.

To run this test I did a Release Build in Visual Studio 2010, .NET 4.0, Any CPU, and this is the result:

Dictionary lookup with try/catch took: 1069625
Dictionary lookup with TryGetValue took: 864
Done, press enter to exit

As you can see there is a HUGE difference. The TryGetValue-way was about 1237 faster!

Exception throwing is very heavy! Don’t forget that. It doesn’t mean that you need to program without exceptions, but when you EXPECT that a Key is not present in a given dictionary, don’t use the exception. Use the TryGetValue. If you always expect it to be there then it’s normal to catch the exception, because it’s exceptional that the key was not found.

PS: I tried the code again by skipping the 9999th item, and the results were about the same, take or leave a few milliseconds. So searching in the dictionary is very performant (close to O(1), as written in the Remarks section on this page.)

TemplateBinding, what is it?

Posted on January 30, 2011 by Kristof

I spent ages on trying to comprehend what it means.

It’s just this:

{TemplateBinding Content}

Equals

{Binding Content, RelativeSource={RelativeSource Path=TemplatedParent}}

http://msdn.microsoft.com/en-us/library/ms742882.aspx

MSDN FTW!

Stopping Casini before (re)building website in Visual Studio revisited

Posted on January 30, 2011 by Kristof

This is an update of an older post of mine on stopping Casini.

The code posted in the previous article (yes, read it!) only stops Webdev.Webserver, which is included in Microsoft Visual Studio 2010.

Now the problem is that when you’re using Blend and accidently run the app from there (which I hate, I’d prefer it to switch to Visual Studio).

This shortcut will allow you to quickly kill the webdev server of Blend (and that of Visual Studio too). So just keep it as a shortcut.

C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe Stop-Process -Name @('WebDev.WebServer*', 'Microsoft.Expression.Web*')

Good luck

Enum dependency property caveat

Posted on January 30, 2011 by Kristof

Hi all,

A while ago I was creating a custom control in Silverlight with an enum Dependency property.

It looked like this:

public partial class SomeCustomControl
{
    public static readonly DependencyProperty OnOrOffDependencyProperty = DependencyProperty.Register("OnOrOff", typeof (OnOff), typeof (SomeCustomControl), new PropertyMetadata(-1, OnPropertyChangedCallback));
 
    public SomeCustomControl()
    {
        this.InitializeComponent();
    }
 
    public OnOff OnOrOff
    {
        get
        {
            return (OnOff) this.GetValue(OnOrOffDependencyProperty);
        }
        set
        {
            this.SetValue(OnOrOffDependencyProperty, value);
        }
    }
 
    private static void OnPropertyChangedCallback(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SomeCustomControl instance = (SomeCustomControl) o;
 
        instance.UpdateBackgroundColor((OnOff) e.NewValue);
    }
 
    private void UpdateBackgroundColor(OnOff newValue)
    {
        switch (newValue)
        {
            case OnOff.On:
                this.Rectangle.Fill = new SolidColorBrush(Colors.Green);
                break;
            case OnOff.Off:
                this.Rectangle.Fill = new SolidColorBrush(Colors.Red);
                break;
        }
    }
}

The enum itself was quite simple:

public enum OnOff
{
    On,
    Off
}

The control just changes background color when you set the enum to On (green), or Off (red). Very simple.

The problem is that the dependency property will take the enum member with number 0 as default, OnOff.On that is. And when setting the value in XAML (or code for that matter) will not update the property backing the dependency property:

The code to render this is found here:

<EnumProblem:SomeCustomControl OnOrOff="On"
                                       Grid.Row="1">
        </EnumProblem:SomeCustomControl>
        <EnumProblem:SomeCustomControl OnOrOff="Off"
                                       Grid.Row="1"
                                       Grid.Column="1">

As you can see the left one is NOT green.

This is because the default is OnOff.On (value 0), and setting it (again) to On doesn’t trigger the execution of OnPropertyChangedCallback.

We can solve this (of course, otherwise what would be the point of writing this? )

The first solution you might think about is setting the default value of the Dependency Property’s default value. Maybe –1 for example, so that at least the engine can detect a change.

public static readonly DependencyProperty OnOrOffDependencyProperty = DependencyProperty.Register("OnOrOff", typeof (OnOff), typeof (SomeCustomControl), new PropertyMetadata(-1, OnPropertyChangedCallback));

Running the app like this will cause an exception, since it cannot convert the –1 to the OnOff enum.

The other solution is setting the value of the first member to a positive value, which makes the code work:

public enum OnOff
{
    On = 1,
    Off
}

Now you might think: What’s the difference, the first time it tries to convert –1 to OnOff, and the second time it tried to convert 0 to OnOff, and it both cases it the value doesn’t exist in the enum.

The reason here is that you can have an enum that starts at 1, but you can still set create an instance of that enum with a value of 0.

But creating the enum with a value of –1 doesn’t work:

This is why setting –1 to the default value of the dependency property doesn’t work (unless you of course have a –1 value in the enum!)

If you want the source, and you know a good place to upload it, please mail me

Stopping Casini before (re)building website in Visual Studio

Posted on October 22, 2010 by Kristof

Hi ya’ll,

I sometimes use Casini to debug local web applications. Casini is easy to configure, no need to create a virtual directory, it’s gone after you close Visual Studio so it’s easy.

The problem is that sometimes when changing some code, Casini’s caches aren’t cleared. So you get a stale version of your webpage (or Silverlight or …).

While playing with Powershell I found a little gem called Stop-Process. It even accepts wildcards! Which is nice, since there are 2 WebDev.Webservers. One for .NET 2.0 and one for .NET 4.0.

How can we link this to Visual Studio? Easy. Go to your web project and double-click properties:

Then go to Build Events, and enter the following text in the Pre-Build event command line (as shown on the picture):

powershell Stop-Process -name webdev.webserver*

Next time when you rebuild, Casini will be stopped, and you will always start from a clean page

Enjoy.

-Kristof

Visual Studio 2010 PowerTools

Posted on September 11, 2010 by Kristof

Hi All,

Since I’ve installed Visual Studio 2010 PowerTools I’ve had the following problem:

Entering shift+enter didn’t break the line anymore.

This is because of the autocomplete braces function of the PowerTools.

You can disable this function by clicking Options in the Tools Menu:

And then click ‘Productivity Power Tools’ on the left:

In that window set ‘Automatic Brace Completion’ to ‘Off’.

Now restart your Visual Studio 2010 (Important!)

Unfortunately this doesn’t restore the shortcut in the keyboard settings of Visual Studio 2010.

To fix this go to your keyboard settings in Visual Studio 2010:

And enter this string in the search box: ‘Edit.BreakLine’ (without the quotes).

As you can see only ‘Enter’ is mapped to BreakLine.

Now set focus to the ‘Press shortcut keys’ textbox and press Shift+Enter. And then hit Assign.

This is the end result:

There we go

Take it easy,

Kristof

Windows Phone 7 TextBox, binding and ApplicationButton

Posted on August 28, 2010 by Kristof

Consider a Windows Phone 7 application with a textbox and an ApplicationButton.

UI:

<Canvas x:Name="ContentGrid" Grid.Row="1" Height="545" Width="480">
    <TextBlock Text="Enter text here" Canvas.Left="6" Canvas.Top="187" />
    <TextBox x:Name="myTextBox" Text="{Binding Test, Mode=TwoWay}" Height="69" Width="480" Canvas.Left="0" Canvas.Top="209" />
</Canvas>

Backend:

namespace WindowsPhoneApplication1
{
    using System;
    using System.ComponentModel;
    using System.Windows.Controls;
    using Microsoft.Phone.Controls;
 
    public partial class MainPage : PhoneApplicationPage, INotifyPropertyChanged
    {
        private string _test;
        // Constructor
        public MainPage()
        {
            this.InitializeComponent();
 
            this.DataContext = this;
        }
 
        public string Test
        {
            get
            {
                return this._test;
            }
            set
            {
                if (value != this._test)
                {
                    this._test = value;
                    this.PropertyChanged(this, new PropertyChangedEventArgs("Test"));
                }
            }
        }
 
        #region INotifyPropertyChanged Members
 
        public event PropertyChangedEventHandler PropertyChanged;
 
        #endregion
 
    }
}

The textbox is bound to a property on the backend (two way binding) and when you click the bottom button the text is saved/send/encrypted/whatever.

Now the problem is that clicking the button doesn’t do a UI –> source binding update as it would do with a normal button.

I enter the text ‘test’ on the TextBlock and IMMIDIATLY click the ApplicationButton. I don’t do anything else. This is a common user practice, he changes something and clicks the save/send/whatsoever button.

This is the result:

Check the Watch 1. As you can see the value is still null. The value is not sent to the _test value. How do we solve this?

You can add the following line to the click event handler:

this.myTextBox.GetBindingExpression(TextBox.TextProperty).UpdateSource();

So the result will look like this:

private void AppbarButton1Click(object sender, EventArgs e)
{
    this.myTextBox.GetBindingExpression(TextBox.TextProperty).UpdateSource();
 
    // handle save/send/encrypt/whatever here
}

There are 3 downsides I think:

You need to name your TextBlock which (I think) unnecessarily clutters your scope with otherwise unused variables (that’s why we use bindings too!)
Your UI and ViewModel (in my case) aren’t decoupled 100% anymore. In Windows Phone 7 this is no issue though, since WP7 has no ICommand and I have to couply my UI and ViewModel anyway
You need to remember to write this line! Which can be quite cumbersome with a lot of application buttons.

And items in a ApplicationBar.MenuItems (ApplicationBarMenuItem) have the same problem. The UI doesn’t push the update to the ViewModel.

I hope this will be fixed in the final version, and I will post this to Microsoft Connect. If anybody has a better solution please feel free to share it.

A more general INotifyPropertyChangedHandler extension method for strongly typed reflection

Posted on August 24, 2010 by Kristof

static class ExtensionMethods
{
    public static void Raise<TValue>(this PropertyChangedEventHandler handler, Expression<Func<TValue>> propertySelector)
    {
        var memberExpression = propertySelector.Body as MemberExpression;
 
        if (handler == null || memberExpression == null)
        {
            return;
        }
 
        var sender = ((ConstantExpression)memberExpression.Expression).Value;
        handler(sender, new PropertyChangedEventArgs(memberExpression.Member.Name));
    }
}

Use this as an extension method like this on a class that implements INotifyPropertyChanged

class SomeClass : INotifyPropertyChanged
{
    private string _someProperty;
 
    public string SomeProperty
    {
        get
        {
            return this._someProperty;
        }
        set
        {
            if (value != this._someProperty)
            {
                this._someProperty = value;
                this.PropertyChanged.Raise(() => this.SomeProperty);
            }
        }
    }
 
    public event PropertyChangedEventHandler PropertyChanged;
}

Good luck

-Kristof

MvvmLight: strongly typed INotifyPropertyChanged

Posted on August 24, 2010 by Kristof

Since MvvmLight exposes it’s own ViewModelBase you cannot use this little script to raise the INotifyPropertyChangedEventHandler, because .NET doesn’t allow you to raise events in derived classes. This is because the compiler generates a private delegate (it’s in VB.NET but that doesn’t matter).

And since the ViewModelBase only exposes a protected RaiseProperty(string propertyName) I cannot use strongly typed reflection.

So I found some code, and rewrote it like this.

Now you can create a class that inherits from ViewModelBase, and make your ViewModels inherit from your just created class.

Now you have a pattern like this:

ViewModelBase <—DefaultViewModel <—MainPageViewModel

And your DefaultViewModel should look like this:

public abstract class DefaultViewModel : ViewModelBase
{
    protected void RaisePropertyChanged<TValue>(Expression<Func<TValue>> propertySelector)
    {
        var memberExpression = (propertySelector.Body as MemberExpression);
 
        if (null != memberExpression)
        this.RaisePropertyChanged(memberExpression.Member.Name);
    }
}

And your MainPageViewModel (for example):

public class MainPageViewModel : DefaultViewModel
{
    private decimal _remainingCredits;
 
    /// <summary>
    /// Remaining credits of the current account
    /// </summary>
    public decimal RemainingCredits
    {
        get
        {
            return this._remainingCredits;
        }
 
        set
        {
            if (this._remainingCredits != value)
            {
                this._remainingCredits = value;
 
                this.RaisePropertyChanged(() => RemainingCredits);
            }
        }
    }
}

You can use the form of RaisePropertyChanged(() => NameOfProperty);

This way, when you rename a variable in your code the refactor engine picks it up and renames it accordingly. (it forget strings

Good luck,

Kristof

Kristof's blog

A blog on my experiences in programming, work, and life!

Author Archives: Kristof

.NET natural sort, a possible solution.

Dictionary<TKey, TValue> finding key: try/catch vs TryGetValue

TemplateBinding, what is it?

Stopping Casini before (re)building website in Visual Studio revisited

Enum dependency property caveat

Stopping Casini before (re)building website in Visual Studio

Visual Studio 2010 PowerTools

Windows Phone 7 TextBox, binding and ApplicationButton

A more general INotifyPropertyChangedHandler extension method for strongly typed reflection

MvvmLight: strongly typed INotifyPropertyChanged

May 2012
M	T	W	T	F	S	S
« Mar
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31