samedi 31 août 2013

Tutoriel 1: Les bases

Création du projet

Dans les différents tutoriels que je vous proposes, j'utiliserai comme exemple une application qui permet de gérer une collection de films.
Commençons tout d'abord par créer dans Visual Studio une application WPF. Ajouter ensuite dans les références, la bibliothèque DBLib.dll
Créer ensuite un dossier nommé Schemas, y ajouter une classe nommée Films (au pluriel). 
De la même façon, créer un dossier Rows, y ajouter une classe Film (au singulier).
 

Note: J'essaye d'organiser et de nommer les fichiers de façon la plus pédagogique possible, cependant, vous êtes libre d'adapter le code selon vos propres conventions.

Définition de la classe Films

Cette classe représente le schéma d'une table de films.

public class Films:Table<Film>
{
     public static UniqueIDColumn<Film> FilmID = new UniqueIDColumn<Film>("FilmID");
     public static ValueColumn<Film, Text> Title = new ValueColumn<Film, Text>("Title");
     public static ValueColumn<Film, short> Year=new ValueColumn<Film,short>("Year");
}

 Elle contient la définition de trois colonnes:
  • FilmID: Cette colonne contiendra une valeur unique pour chaque film.
  • Title: Cette colonne contiendra le titre du film.
  • Year: Cette colonne contiendra l'année de sortie du film.
Vous remarquerez que la structure de la classe est très proche d'un schéma de table de bases de données.

La définition des colonnes est statique et utilise des génériques:
  • Le premier paramètre indique que la colonne appartient aux objets du type Film.
  • Le second paramètre (si présent), indique le type de la valeur contenue. Il doit obligatoirement être un type de valeur.
  • Le constructeur de chaque champ nécessite au moins un paramètre, qui précise le nom de la colonne.

Note: J'utilise dans mon framework la structure personnalisée Text, car la classe string n'est pas un type de valeur.

Réalisons quelques ajustements...

public class Films:Table<Film>
{
     public static UniqueIDColumn<Film> FilmID = new UniqueIDColumn<Film>("FilmID");
     public static ValueColumn<Film, Text> Title = new ValueColumn<Film, Text>("Title") { DefaultValue = "New film" };
     public static ValueColumn<Film, short> Year=new ValueColumn<Film,short>("Year");
     public static ValueColumn<Film, Text> Description = new ValueColumn<Film, Text>("Description",true);
}

J'ai ajouté une valeur par défaut pour Title, et une nouvelle colonne Description. Le second paramètre du constructeur, indique que la valeur NULL est autorisée dans ce champ.

Définition de la classe Film

Cette classe représente un film de notre collection.

public class Film:Row
{
     public Guid? FilmID
     {
          get { return Films.FilmID.GetValue(this); }
     }
     public Text? Title
     {
          get { return Films.Title.GetValue(this); }
          set { Films.Title.SetValue(this, value); }
     }
     public short? Year
     {
          get { return Films.Year.GetValue(this); }
          set { Films.Year.SetValue(this, value); }
     }
     public Text? Description
     {
          get { return Films.Description.GetValue(this); }
          set { Films.Description.SetValue(this, value); }
     }
}

La classe expose des propriétés, qui retournent les valeurs des colonnes définies dans la table.
La propriété FilmID n'a pas d'accesseur set, car comme une clé primaire, cet ID unique n'a pas de raison de changer.

Chaque propriété retourne un type Nullable<T>, où T est le type défini dans la colonne correspondante.

Note: Le nom de la propriété doit être identique au nom de la colonne spécifiée dans le constructeur.

La base de données

Créons maintenant une base de données, qui contiendra nos tables. Pour cela, ajouter une classe Collections (au pluriel) dans le dossier Schemas, et une classe Collection dans la racine du projet.
La classe Collections, représente le schéma de la base de données.

public class Collections : Schema<Collection>
{
     public static readonly Films Films = new Films();
}

Ce schéma déclare une seule table (celle des films). Les règles de déclaration des tables sont similaires à celles de déclaration des colonnes.
Dans le cas des tables, si un nom n'est pas spécifié dans le constructeur, le framework utilisera le nom du type de la classe.

La classe Collection représente une instance de notre base de données.

public class Collection : Database
{
     public override byte Version
     {
          get { return 1; }
     }
     
     public RowCollection<Film> Films
     {
          get { return Collections.Films.GetValue(this); }
     }
}

Elle doit hériter du type Database, et doit fournir au minimum, la propriété Version. Cette valeur pourra être utilisée plus tard, pour la compatibilité ascendante.

Elle expose aussi une liste de films, récupérée à travers le champ statique du schéma.

Conclusion

Nous avons terminé de déclarer nos classes. J'ai sciemment fait le choix d'utiliser des données fortement typées, et explicitement déclarées dans le code c#, contrairement par exemple, aux dataset de l'espace de noms System.Data. Ceci me garantie l'intégrité de mes données, et m'évite les erreurs de frappe dans le code, ou dans les déclarations XAML.
La mécanisme de déclaration des tables et des colonnes et largement inspiré des DependencyProperty, mais propose des mécanisme supplémentaires.

Nous verrons dans le prochain article comment intégrer ces données dans notre interface utilisateur.

Télécharger le projet Visual Studio

vendredi 30 août 2013

Présentation

Un peu de nostalgie

Dans le monde du logiciel, les interfaces utilisateur tiennent une place importante. Aux débuts de l’informatique, lorsque les capacités des machines étaient modestes, les UI (User Interface) étaient de simples terminaux connectés à un serveur central. Puis sont apparus les ordinateurs personnels dont le système d’exploitation proposait une CLI (Command Line Interface).
Ces CLI n’étaient pas très faciles à utiliser par les néophytes en informatique, et pouvaient en rebuter plus d’un. Puis les éditeurs de logiciels ont compris que la simplicité d’utilisation était un élément déterminant dans le succès d’un produit.
Sont alors apparues les premières interfaces « intuitives »:
  • Certaines en mode texte TUI (Text User Interface). Je me souviens du Framework « Turbo Vision » de Borland, ou bien du logiciel PC Tools sous Ms-DOS, qui permettait de réaliser des opérations courantes sur les disques locaux.

Turbo Vision


  •  Certaines en mode graphique GUI (Graphical User Interface). Par exemple sur le premier Macintosh ou bien le système Amiga OS.
Amiga OS
j     Aujourd’hui, à l’heure où la concurrence informatique est rude, au delà de la performance brute d’un logiciel, la qualité d’une interface utilisateur est déterminante dans le choix d’une application.
Je pourrais citer par exemple le cas des logiciels de compression. D’innombrables freewares existent sur le net, il est naturel que l’utilisateur oriente son choix vers l’application la plus fluide, et la plus ergonomique.
Je tiens à noter que la ligne de commande reste très utile, notamment pour la création de batchs et l’automatisation de tâches, cependant je considère que son utilisation concerne un public plus restreint.

Mon framework personnalisé

J’ai utilisé dans le paragraphe précédent le terme ergonomie. Qui aimerait travailler sur un bureau bancal ou avec un outil trop lourd à manipuler ?
Certaines choses apparaissent évidentes lorsqu’on parle d’ergonomie, cependant l’ergonomie logicielle est souvent négligée (notamment dans les logiciels destinés aux professionnels)
Il m’est souvent arrivé de me battre contre des fenêtres non redimensionnables qui dépassent de l’écran, ou a contrario, d’un ascenseur sans fin dans une fenêtre minuscule. Il est plutôt rare de rencontrer des logiciels qui proposent une impression correctement paginée (en dehors des visionneurs/éditeurs de documents bien entendu).
Il est aisé de critiquer, mais il faut admettre qu’il n’est pas simple de créer une bonne interface utilisateur. Cela demande un investissement de temps et souvent d’argent.
Développant moi-même régulièrement des logiciels, je me heurte naturellement à ces problématiques.
J’ai donc décidé de créer un framework personnalisé, je me suis fixé le cahier des charges suivant :
  • Il doit être développé sur la plateforme .net. WPF se prête très bien à la création d’interfaces riches.
  • Il doit être portable (sous forme d'une ou plusieurs DLL)
  • Il doit nécessiter le moins de code possible pour l’utilisateur
  • Son intégration doit être la plus élégante et transparente possible
Il doit proposer les fonctionnalités essentielles d’une interface utilisateur:
  • Les éléments de l’interface doivent s’adapter dynamiquement à la taille de la fenêtre et de l’écran (bon, ça c’est quand même la base)
  • Il doit supporter l’annulation et le rétablissement de toutes les actions
  • Il doit prendre en charge la sélection multiple et l’édition en groupe
  • La mise à jour des données doit s’afficher en temps réel dans l’application (je n'aime pas les boutons de rafraîchissement)
De façon complémentaire :
  • Il doit être possible de charger ou de sauvegarder les informations dans une base de données (ex MS SQL).
  • Il doit être possible de charger ou de sauvegarder les informations dans un fichier (ex XML)
  • Dans le cas d’une mise à jour vers un serveur distant (SQL ou autre), seules les données modifiées ou ajoutées doivent être prises en compte. Par exemple, si un utilisateur modifie un seul nom dans un annuaire téléphonique, il serait très pénalisant de pousser l’ensemble de l’annuaire dans la base de données.
  • Il doit être gratuit (tant qu’à faire autant en faire profiter les autres)

Mise en pratique

Mes recherches initiales sur le sujet m’on amenées à étudier la méthode MVVM (Model, View, View Model). Cependant j’ai trouvé que cette dernière présente plusieurs inconvénients :
  • Beaucoup de code nécessaire. L’utilisateur doit créer un ViewModel pour chaque Model.
  • L’intégration des commandes utilisateurs au sein du ViewModel limite l’interaction avec la vue. Par exemple, dans le cas ou nous aurions besoin d’afficher un message de confirmation lors de la suppression d’un élément. En principe, le ViewModel ne doit jamais avoir connaissance de la vue qui le présente.
  • La synchronisation des données entre le modèle et le ViewModel. Ceci devient un vrai cauchemar lorsqu’on décide d’implémenter l’annulation/rétablissement
  • La sélection multiple, ce sujet sera traité dans les articles dédiés.
J’ai cependant apprécié la philosophie générale de cette méthode, je l’ai donc adapté à mes besoins.
Mon implémentation est loin d’être parfaite. Lecteur trouvera au fil des articles quelques limitations. Par exemple, mon implémentation n’est pas adaptée pour la manipulation d’énormes quantités de données. Ces dernières sont toutes chargées en mémoire, non pas dynamiquement ni à la demande. Cependant je trouve que mon travail se prête à la majorité des besoins quotidiens.
Dans les articles suivants je vais essayer d’expliquer progressivement comment utiliser mon framework. Ces tutoriels supposent que le lecteur dispose déjà des connaissances générales en développement C# et de WPF.
J’utilise Visual Studio 2010 Express pour réaliser mes exemples, le code de chaque projet est disponible en téléchargement dans l'article post associé.