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

Winforms: Cross-thread operation not valid.

Posted on August 24, 2010 by Kristof

Hi all,

I sometimes get this error when I forget that controls cannot be accessed across threads:

What many people do is this:

private void UpdateLabel(string text)
{
    this.Invoke(new Action(() => this.someLabel.Text = text));
}

This is not the right pattern. You don’t always HAVE to invoke. You are better off by checking if you have to invoke it on the underlying thread, and if not, just execute it directly. It’s all about correctness

The right pattern would be:

private void UpdateLabel(string text)
{
    if(this.InvokeRequired)
    {
        this.Invoke(new Action(() => this.UpdateLabel(text)));
        return;
    }
 
    this.someLabel.Text = text;
}

Use Control.InvokeRequired

Good luck

-Kristof

LINQ 2 SQL and WCF, the definitive guide

Posted on August 22, 2010 by Kristof

In my last project I had the assignment to create a client server application. Not that hard. We chose to use WCF for the communication itself, because that was easy, straightforward and well supported with .NET 3.5SP1 (and Visual Studio 2008 of course).

As we didn’t have the time to create our own mapper to map the database to code, nor did we have time to study another mapper (nHibernate came to the question) we choose for something we already knew. LINQ 2 SQL.

Now we all used it in a connected environment. But as you all know, WCF is not connected. The DataContext is lost upon transmitting the entity to the client.

Now that’s the problem, change tracking is lost and LINQ 2 SQL doesn’t play well with reattaching detached entities.

Transmitting an entity from server to the client was no problem, with the DataContext.LoadOptions we were able to eager load all the entities required and transmit them to the client. And we didn’t want to use a third party template or baseclass because those weren’t approved by management .

In order to make LINQ to SQL add DataMember and DataContract properties to your classes you need to set the Serialization Mode to Unidirectional (as shown below):

In code you can now see attributes like this:

and this:

But the DataMemberAttribute is not applied on EntityRef, only EntitySet.

EntityRef is used to lazy-load a reference to 1 entity. EntitySet is used for a list of lazy-loadable entities.

Let me explain with an example (I’m using the Northwind database).

A Product has 1 category and a Category has multiple Products.

This means that a Category has an EntitySet<Product> (as shown below, notice the DataMemberAttribute):

While a Product has only 1 Category (notice the absence of the DataMemberAttribute):

When working in a connected environment the absence of those attributes is not a problem. But on WCF it is. Since you cannot do lazy loading when the entity is transmitted to the client you need to make sure you load everything in front.

While you can create DataLoadOptions for a Product.Category link the absence of the DataMemberAttribute prevents the WCF serializer from serializing the Category Entity.

using (NorthwindDataContext northwindDataContext = new NorthwindDataContext())
{
    var dataLoadOptions = new DataLoadOptions();
 
    dataLoadOptions.LoadWith<Product>(p => p.Category);
 
    northwindDataContext.LoadOptions = dataLoadOptions;
 
    return northwindDataContext.Products.Where(p => p.ProductID == 1).SingleOrDefault();
}

When invoking this method on the client you will see that the received Product’s Category is null.

First of all: why is there no DataMemberAttribute on the EntityRef in LINQ2SQL?

Imagine me having a Category, and eager (opposite of lazy) loading all the Product entities. All those products have 1 category, and they if I set the Product.Category to eager load… think about it, this will cause an infinite loop:

Category –> x Products, for each of those products load their category, for each of those categories, load their products and so on.

Boom, the WCF XML serializer cannot handle this.

How do we solve this?

In the LINQ2SQL designer take the Product.Category (or Category.Products if you will) link, and set the Child Property to false.

This will remove the Category.Products property and generate a DataMemberAttribute on the Product.Category. Of course now you cannot get all the products in a category through a Category link this:

But you have to do something like this:

This generates the same SQL statement on the backend and now you can properly sent those entities to your client.

Signing off,

Kristof

Windows Phone 7, adding and displaying icons.

Posted on August 2, 2010 by Kristof

Hi all,

I tried to display an icon in my Windows Phone 7 application:

<shell:ApplicationBarIconButton x:Name="appbar_button1" IconUri="/Images/appbar.feature.settings.rest.png" Text="Settings" />

By default, when you add an image to the solution folder it sets the build action as Resource, as shown below:

But when you run the application with the Build Action as Resource you will get a result looking like this:

While I really meant an icon looking like this:

How do we fix it?

Set the Build Action to Content!

And this is the result:

Visual Studio 2010 Pro Power Tools and closing square bracket problem on AZERTY

Posted on July 6, 2010 by Kristof

There seems to be a problem with the default keyboard mapping of the so called ‘Align Assignments’ found in the Visual Studio 2010 Pro Power Tools.

The default shortcut is mapped to Control + Alt + ]. While this is not a problem on a QWERTY these keystrokes are used to type a square bracket on a AZERTY keyboard:

As you can see the character on the lower right corner needs to be accessed with Ctrl + Alt + key or the Alt Gr + key. This way you trigger the ‘Edit.AlignAssignments’ on your keyboard. Thus the ‘]’ doesn’t appears on screen, it merely aligns the current line.

Solution: remove or remap the shortcut.

Thanks to Gill Cleeren for pointing out this problem.

M	T	W	T	F	S	S
« Jan
		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

Kristof's blog

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

Author Archives: Kristof

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

Winforms: Cross-thread operation not valid.

LINQ 2 SQL and WCF, the definitive guide

Windows Phone 7, adding and displaying icons.

Visual Studio 2010 Pro Power Tools and closing square bracket problem on AZERTY