Archive for the ‘Uncategorized’ Category

WPF NotifyIcon 1.0.8 released

April 1st, 2016

I just published a maintenance release of my WPF NotifyIcon control. The update fixes an issue with potential null references during initialization.

Links and downloads as usual on the control’s project page. Happy coding!

Author: Categories: Uncategorized Tags:

WPF NotifyIcon 1.0.6 released

March 21st, 2016

I just published a maintenance release of my NotifyIcon control, which addresses a potential null reference issue, and optionally removes the double-click delay, which allows the NotifyIcon to react to single clicks immediately.

Links and downloads as usual on the control’s project page. Happy coding!

Author: Categories: Uncategorized Tags:

We’re hiring: WPF UI Developer (Swiss Office)

March 12th, 2014

XAML UI designer / developer? We’re hiring!


My work at Vistaprint is focused on the UI architecture of the distributed software system that runs in our factories. Today, we process more than 120,000 individually customized pieces in over 70,000 shipments per day, with diverse human-machine interaction taking place while produced items are making their way through the plant. This includes desktops, touch panels, handhelds, or dashboards. And we are currently trying to rethink the way our UIs should work – which is where YOU come in: A brilliant UI designer, XAML wizard, UX geek, who wants to make a difference and join us in implementing an exciting, cutting edge UI infrastructure that will support both our stakeholders on the factory floor as your fellow developers all around the globe. Recognize yourself? Come join us in our beautiful, and slightly chaotic Winterthur office in Switzerland!


Job details here:

Take the wording on the posting with a grain of salt. We really are looking for a Blend wizard more than a Visual Studio crack. This is all about creating exciting user interfaces, and evangelizing / teaching UI goodness to a globally distributed team.


Author: Categories: Uncategorized Tags:

WPF NotifyIcon – Bugfix and WinForms Support

September 22nd, 2009

I released an update to my WPF NotifyIcon, which fixes two issues:

  • Interactive Popups should now fully support all control types.
  • The control can now be used in Windows Forms projects, if you need more functionality than the built-in component.

The solution now comes with an additional WinForms sample project, which shows how to display a WPF user control as an interactive popup.



    Download link and further information can be found on the control’s home page:

    Author: Categories: Uncategorized Tags:

    Twitter Debut

    May 5th, 2009

    imageI’ve been somewhat hesitant, but being able to quickly exchange thoughts with the community just sounds too good – I have to try this out.


    Follow me @

    Author: Categories: Uncategorized Tags:

    From Lambda Dependencies to Lambda Bindings

    April 3rd, 2009

    Lambda-based binding for the business layer or your View Model 🙂

    I’ve had this on the shelf for quite a while, but Kent Boogaart’s article on POCOs vs. DependencyObjects finally got me to cleaning things up a little. Kent is coming up with a similar approach that looks very promising, so you should keep your eyes on his blog, too.

    Lambda Bindings are built on top of the Lambda Dependencies project I published a while ago. The original Lambda Dependencies allow you to observe object graphs for changes using simple LINQ expressions. Lambda Bindings leverage this pattern by not just publishing a change event but synchronizing target properties or fields automatically.

    This provides you with a generic binding framework that can be used wherever you want to synchronize objects. Let’s have a first example:


    public void TestBinding(Student student)
      string cityName = "";
      //synchronize the cityName field with the City property of the school's address
      var binding = LambdaBinding.BindOneWay(
          () => student.School.Address.City,
          () => cityName);
      //change the property on the School object
      student.School.Address.City = "Sin City";
      //the binding expression updated the local variable
      Assert.AreEqual("Sin City", cityName);

    What’s happening in the snippet above is that I created a binding between a nested property of a referenced object and a local field. As soon as the binding source (the City property of a school’s address) is changed, the local cityName field is being updated as well.


    However, the Lambda Dependencies not only cover the source properties but the whole object graph. Accordingly, exchanging the whole School (or the Student instance) also triggers an update. In the snippet below, the cityName variable is being updated twice:


    public void Updating_Intermediary_Object_Should_Update_Target(Student student)
      string cityName = "";
      //synchronize the cityName field with the City property of the school's address
      var binding = LambdaBinding.BindOneWay(
          () => student.School.Address.City,
          () => cityName);
      //change bound City property -> triggers update of the local variable
      student.School.Address.City = "Paris";
      Assert.AreEqual("Paris", cityName);
      //create a completely different school instance
      School englishSchool = new School();
      englishSchool.Address = new Address {City = "London"};
      //assign the new school to the student
      student.School = englishSchool;
      //setting the School property also triggered the binding
      Assert.AreEqual("London", cityName);


    Value Conversion

    You can do simple value conversion by just submitting a converter to the binding expression. This allows you to intercept the binding pipeline or bind objects of different types together. If you’re coming from WPF, this feels natural anyway, but the solution here does not require you to implement a value converter – a simple Func<TSource, TTarget> is sufficient.

    Here’s a simple sample that performs a conversion of a boolean flag to into a corresponding Visibility enum value:


    public void Boolean_Should_Be_Converted_To_Visibility()
      //create a hidden window
      Window window = new Window { Visibility = Visibiliy.Collapsed };
      //create a view model
      MyViewModel viewModel = new MyViewModel { IsVisible = false };
      //create binding that casts the Visibility into a boolean
          () => viewModel.IsVisible,
          () => window.Visibility,
          b => b == true ? Visibility.Visible : Visibility.Collapsed;
      //a change in the ViewModel shows/hides the window
      viewModel.IsVisible = true;
      Assert.AreEqual(Visibility.Visible, window.Visibility);  



    Two way binding works too, of course:

    public void Updates_Should_Work_Both_Ways()
      //create two-way binding
      var binding = LambdaBinding.BindTwoWay(
        () => FirstStudent.Name,
        () => SecondStudent.Name);
      //change property on source
      FirstStudent.Name = "Peter";
      Assert.AreEqual("Peter", SecondStudent.Name);
      //change property on target
      SecondStudent.Name = "Parker";
      Assert.AreEqual("Parker", FirstStudent.Name);

    In case you need to perform type conversion, you need to supply two converter functions for forward / reverse conversion:

    //bind a boolean property to a control's Visibility property
    var binding = LambdaBinding.BindTwoWay(
        () => ModelItem.IsEnabled,
        () => MyControl.IsVisible,
        b => b == true ? Visibility.Visible : Visibiliy.Collapsed
        v => v == Visibility.Visible ? true : false);


    Default Values

    In case the object graph is being broken (e.g. because the School was set to null), the target node will be automatically set to its default value (null for an object, 0 for an int etc.). However, you can also specify a default value of your own:

    //a local field to be updated
    private string schoolCity;
    public void Breaking_The_Chain_Should_Assign_Default_Value_To_Target_If_Specified()
      var binding = LambdaBinding.BindOneWay(
          () => Student.School.Address.City,
          () => schoolCity,
          "[No City]");
      //break the source chain
      Student.School = null;
      //the default value was assigned to the target
      Assert.AreEqual("[No City]", schoolCity);

    (btw: the above snippet also shows you that you can easily bind to a field rather than a property).


    Weak References

    The underlying Lambda Dependencies only use weak references so you’re not at risk of creating memory leaks. However, LambdaBinding implements IDisposable, so the proper way to clean things up would be to dispose your binding.

    Things to Consider

    Remember that that the underlying Lambda Dependencies rely on the INotifyPropertyChanged interface, so don’t expect source binding to fields (or properties that do not fire a PropertyChanged event) to magically update your targets.




    kick it on