Un changement de couleur ? l'HSL (ou TSL) à votre secours

HSL (ou TSL en français) représente une formulation des composantes d'une couleur, il s'agit de la teinte (Hue) exprimée en degré, la saturation (Saturation) souvent exprimée en pourcentage et la luminance (Luminosity), elle aussi exprimée en pourcentage. Pour de plus amples détails je vous suggère cet article de Wikipédia http://fr.wikipedia.org/wiki/Teinte_saturation_lumi%C3%A8re

Lire la suite de Un changement de couleur ? l'HSL (ou TSL) à votre secours

Navegar - Navigation WPF avec MVVM Light & SimpleIoC

 

Dans un précédent article, Navigation avec MVVM Light et SimpleIoc pour WPF, je vous avait déja parlé d'une classe dont j'ai eu besoin pour la réalisation d'une application WPF.

Afin de pouvoir facilement gérer cette navigation, j'ai mis au point Navegar.

Navegar va vous permettre de créer une navigation au sein d'une application WPF utilisant MVVM Light et SimpleIoC

Vous pouvez retrouver Navegar ainsi que le code source sur CodePlex



// coding with fun

Visual Studio 11 RC nouvelle interface

Cette nuit l'équipe du blog Visual Studio a présenté une nouvelle vision de la future interface de Visual Studio 11 RC, qui s'appuie sur les remarques remontées suite à la publication de la version beta de VS11 et de son interface monochrome.

Au rang des changements :

  • interface orientée plus Metro
  • un peu plus de couleur pour la distinction des éléments
  • une amélioration que je trouve particulièrement intéressante, c'est la colorisation de la barre d'état afin de suivre le processus de compilation et d'exécution d'un projet. C'est vrai que cette zone n'est pas forcément très lisible pour savoir où en est la compilation par exemple. Le fait de jouer sur les couleurs pourra être plus agréable

Même si je ne suis pas un fervent détracteur de cette interface monochrome à laquelle je me suis très bien fait, j'avoue avoir hâte de tester cette nouvelle version. J’espère également qu'ils auront amélioré l'éditeur XAML, qui chez moi a très souvent tendance à "geler" tout Visual Studio 11.

Si vous voulez vous faire votre propre idée sur cette nouvelle version de l'interface, allez lire l'article de Monty Hammontree http://blogs.msdn.com/b/visualstudio/archive/2012/05/08/visual-studio-11-user-interface-updates-coming-in-rc.aspx



// coding with fun

Message générique avec CallBack sur MVVM Light

Adepte de l'excellent MVVM Light de Laurent Bugnion (@lbugnion), et notamment du Messenger, il me fallait un type de message me permettant de passer un objet en paramètre, ainsi qu'une fonction de CallBack, besoin dont je n'ai pas trouvé trace de solution dans le framework (je m'excuse d'avance si ce besoin est déjà comblé par la bibliothèque).

Lire la suite de Message générique avec CallBack sur MVVM Light

Downcasting d'objet en C#

Il peut parfois s'avérer utile, notamment lorsque l'on souhaite ajouter une propriété à une classe, d'utiliser le downcasting, malheureusement celui-ci n'est pas autorisé en .NET, la compilation sera faite mais une exception de type System.InvalidCastException sera générée à l'exécution. Le mécanisme d'extension de classes ne peut être utilisé ici et si la classe à étendre n'est pas partial, il ne reste plus que le mécanisme de l'héritage. Or parfois l'on se retrouve avec un ensemble d'objets déjà définis, objets que l'on a étendu à l'aide de l'héritage. Il faudrait donc arrivé à effectuer un cast de ces objets ClassBase en ClassDerived

idéalement

ClassDerived derivedObject = (ClassDerived)baseObject;

mais .NET ne le permet pas, on ne peut caster en effet que du sens enfant vers parent

ClassBase baseObject = (ClassBase)derivedObject;

Ceci se comprend aisément puisque effectuer un cast dans le sens parent vers enfant reviendrait à dire que toutes les propriétés ajoutées à l'enfant ne peuvent pas être initialisées avec une valeur provenant du parent puisqu'il n'en a aucune connaissance. Pourtant la création d'un objet dérivé va initialiser les valeurs de ces propriétés à leur valeur par défaut, on peut donc utiliser ce mécanisme pour "caster" l'objet parent en enfant.
En effet la technique va consister à créer un objet enfant puis à recopier toutes les valeurs des propriétés de l'objet parent, qui se trouvent dans l'objet enfant puisque celui-ci hérite de l'objet parent, dans les propriétés de l'objet enfant puis à renvoyer ce nouvel objet créé.
Pour réaliser cela, je vous propose une classe statique helper contenant la fonction de downcasting en générique.


using System.Collections.Generic;
using System.Reflection;

public static class GenericHelper
{
    /// <summary>
    /// Convertir un objet TFrom en TTo, TTo héritant de TFrom
    /// </summary>
    /// <example>
    /// Appel à la fonction
    /// <code>
    /// GenericHelper.DownCastingObject<TypeCible, TypeSource>(objetSource)
    /// </code>
    /// </example>
    /// <typeparam name="TTo">
    /// <c>Type</c> cible de la conversion
    /// </typeparam>
    /// <typeparam name="TFrom">
    /// <c>Type</c> source de la conversion
    /// </typeparam>
    /// <param name="data">
    /// Objet à convertir
    /// </param>
    /// <returns>
    /// Un nouvel objet TTo
    /// </returns>
    public static TTo DownCastingObject<TTo, TFrom> (TFrom data) where TTo : TFrom, new()
    {
        var objet = new TTo();
        foreach (PropertyInfo prop in typeof(TFrom).GetProperties())
        {
            objet.GetType().GetProperty(prop.Name).SetValue(objet, prop.GetValue(data, null), null);
        }
        return objet;
    }

    /// <summary>
    /// Convertir une List<TFrom> en List<TTo>, TTo héritant de TFrom
    /// </summary>
    /// <example>
    /// Appel à la fonction
    /// <code>
    /// GenericHelper.ConvertListTo<TypeCible, TypeSource>(listeDonnees)
    /// </code>
    /// </example>
    /// <typeparam name="TTo">
    /// <c>Type</c> cible de la conversion
    /// </typeparam>
    /// <typeparam name="TFrom">
    /// <c>Type</c> source de la conversion
    /// </typeparam>
    /// <param name="datas">
    /// Données à convertir
    /// </param>
    /// <returns>
    /// Une nouvelle List<TTo>
    /// </returns>
    public static List<TTo> ConvertListTo<TTo, TFrom>(List<TFrom> datas) where TTo : TFrom, new()
    {
        var list = new List<TTo>();
        if(typeof(TTo).BaseType == typeof(TFrom))
        {
            foreach (var data in datas)
            {                    
                var o = (TTo)DownCastingObject<TTo, TFrom>(data);
                list.Add(o);
            }
        }
        return list;
    }
}

Le downcasting s’effectue donc de la façon suivante


var baseObject = new ClassBase
            {
                Libelle = "Classe de base"
            };

var derivedObject = GenericHelper.DownCastingObject<ClassDerived, ClassBase>(baseObject);

Le helper contient également une fonction de conversion d’une List<> d’objets de base en une List<> d’objets dérivés, à utiliser de la façon suivante


var listDerived = GenericHelper.ConvertListTo<ClassDerived, ClassBase>(listBase);

L'ensemble des sources est à retrouver sur mon skydrive



// coding with fun