Another .NET Blog

By default, Caliburn Micro (CM) doesn't contain the action filters which belong to Caliburn (C). There is a recipe on how to implement them back in CM, but unfortunately it doesn't cover all the initial functionalities which are in C.

One feature missing, and that I needed, is the possibility to depend on "properties of properties".

With the recipe, you can add a dependency between the property of a view-model (VM) and another property of this same VM. Thus, when the latter property is changed, the PropertyChanged event of the VM is fired, resulting in the update of the availability of the action on which the Dependencies attribute is put. But what it doesn't allow you to do, is to define something like:

[Dependencies("OtherProperty.ChildProperty")]

This would update the availability of the action if OtherProperty implements INotifyPropertyChanged and if the ChildProperty is modified. You could even use something like:

[Dependencies("OtherProperty.*")]

which would update the availability if any of the properties of OtherProperty is modified.

But let me show you how I implemented this feature on top of the recipe, with the great use of the Reactive Extensions.

Pour clore le chapitre sur l'utilisation de Rx pour mon application de gestion de mises à jour, je vais terminer comme annoncé par vous montrer comment je lance les exécutables téléchargés de manière asynchrone, afin de ne pas bloquer le thread de la vue pendant l'installation.

On continue avec la petite série d'articles Rx avec cette fois une nouvelle résolution de "problème". On a vu lors de l'article précédent comment ignorer les erreurs lorsque des adresses de téléchargement étaient invalides ou injoignables. Nous allons voir cette fois-ci comment lancer tous les téléchargements simultanément et comment attendre qu'ils soient tous terminés avant de les exécuter les uns après les autres pour les installer.

J'ai déjà parlé à plusieurs reprises des reactives extensions, que l'on appelle plus familièrement Rx. Je me suis dit que ce serait une bonne idée que de vous les présenter plus en détail. Je ne vais pas écrire un article qui va tout vous expliquer depuis le début, car il existe déjà beaucoup de ressources. (ici, ici, ou bien ici, ou même encore là) Je me suis donc dit que ça serait peut-être une meilleure idée que de vous expliquer comment ça peut fonctionner grâce à un exemple concret. Et comme j'avais déjà un article expliquant comment réaliser une opération asynchrone en utilisant la TPL, j'ai repris cet exemple, en utilisant cette fois Rx.

Ça fait quelques temps que je vois fleurir sur internet des références de plus en plus nombreuses aux Reactive Extensions, plus communément appelé Rx. Je ne savais pas trop ce que c'était (j'en sais un peu plus maintenant, mais le sujet a l'air d'être... disons, vaste), et c'est 2 posts (ici et là) sur le blog de Jon Skeet qui m'ont enfin décidé à aller voir sur devlabs de quoi il en retournait.

Et je dois bien dire que je suis bluffé. Mais vraiment. Je crois bien que l'on a ici un framework qui devrait radicalement changer notre manière de travailler. Alors bien sûr j'en ai vu trop peu pour être réellement objectif et constructif sur le sujet, et je vais regarder quelques vidéos sur Channel9 sur le sujet avant de m'en faire une idée précise, mais je suis déjà sous le choc.

Pour vous faire une idée de ce qu'est la "bête", je vous recommande plus que chaudement de commencer par cette vidéo, où l'un des développeurs de la librairie (accessoirement aussi l'un des co-fondateurs de LINQ, ça aide) nous explique grossièrement l'objectif de Rx. Et avant de regarder la pléthore de vidéos disponibles sur Channel9 ( ce que je dois encore faire également), jetez tout de suite un oeil à cette vidéo, qui est un cas concret du fonctionnement de Rx, et où on se rend compte de sa puissance à travers un exemple concret: comment implémenter du drag 'n drop d'un contrôle WPF dans une fenêtre au runtime.

Mais je dois vous laisser, j'ai encore BEAUCOUP de vidéos à aller regarder, là, maintenant ;)