cogimator.net

Une ligne à la fois...

Implémentation naive d'un Serializer en C# - Partie 4

Après avoir implémenté le support de la sérialisation des tableaux,  le code est devenu moins lisible. En effet, toute la logique pour le choix du type d'objet à sérialiser se faisait dans une seule méthode,  bardée de ifs. Le but de cette implémentation étant de m'amuser, je ne pouvais laisser cette situation perdurer.

Pour simplifier le code, j'ai choisi d'implémenter une interface ISubSerializer plus spécialisée. Le principe est simple, chaque implémentation de ISubSerializer est applicable pour un type d'objet donné, et sait comment le sérialiser/déserialiser. Ces instances sont organisées de manière hiérarchique, chacune pouvant avoir des ISubSerializer enfant.

public interface ISubSerializer
{
    bool CanApply(Type type);
    void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType);
    object Deserialize(ExtendedBinaryReader source, object target, Type type);
}

Le serializer racine, quant à lui, se charge d'appeler le ISubSerializer adéquat, en fonction du type d'objet à sérialiser.

public void SerializeBase(Type sourceType, object source, ExtendedBinaryWriter writer)
{
    var serializers = this.SubSerializers ?? this.Root.SubSerializers;

    foreach (var s in serializers)
    {
        if (s.CanApply(sourceType))
        {
            s.Serialize(writer, source, sourceType);
            return;
        }
    }
}

Par exemple, dans le cas des types nullables, la class ObjectSerializer se charge uniquement de sérialiser un boolean indiquant si l'objet est null ou non.

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    // always write a boolean indicating if object is null or not
    var hasValue = source != null;
    writer.Write(hasValue);

    if (hasValue)
    {
        this.SerializeBase(sourceType, source, writer);
    }
}

Ensuite, la classe NullableSerializer va appeler le serializer racine pour sérialiser le type valeur sous-jacent.

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    this.SerializeBase(sourceType.GetGenericArguments().First(), source, writer);
}

De cette manière,  ajouter le support pour de nouveaux types devient l'affaire d'implémenter un nouveau ISubSerializer et de le déclarer dans le serializer racine.

Le code source est disponible sur GitHub : https://github.com/mathieubrun/Cogimator.Serialization/blob/master/Cogimator.Serialization/

Implémentation naive d'un Serializer en C# - Partie 3

Cette semaine, l'itération suivante de notre serializer supporte les tableaux d'objets.

Avec la propriété Array.Rank ainsi que la méthode Array.GetLength(int), je peux déterminer le nombre de dimensions du tableau, ainsi que la taille de celles-ci. Ces valeurs seront sérialisées dans le flux binaire pour reconstruire le tableau lors de la désérialisation.

La méthode Array.GetValue(int[]) permet de récupérer la valeur dans le tableau en fonction des indices passés en paramètre. Le calcul de tous les indices se fait en deux étapes. Dans un premier temps, il faut déterminer les indices possibles pour chaque dimension du tableau, en fonction de sa longueur. Ensuite, il reste à calculer le produit cartésien de tous ces indices. Cet ensemble servira à sérialiser l'ensemble des valeurs du tableau.

La désérialisation est simplement le procédé inverse.

Le code source est disponible sur GitHub : https://github.com/mathieubrun/Cogimator.Serialization/blob/master/Cogimator.Serialization/ReflectionSerializer.cs

Implémentation naive d'un Serializer en C# - Partie 2

Pour la suite de cette série, je vais vous présenter le fonctionnement de la 1ere itération du serializer. Cette version supporte les types de base, nullables ou non, ainsi que les graphes d'objets simples (pas de cycles, pas de tableaux).

Dans un premier temps, le serializer va détecter le type de l'objet passé en paramètre. Si il s'agit d'un type valeur standard, celui ci est écrit dans le flux.

Si il s'agit d'un objet, celui ci sera inspecté. Cette inspection servira a déterminer si il s'agit d'un Nullable, ou d'un autre type d'objet. Dans les deux cas, on écrira dans le flux un booléen indiquant si l'objet est null.

L'écriture dans le flux se fait au travers de la classe BinaryWriter, étendue pour gérer les cas spécifiques. La classe BinaryWriter de base ne supportant les chaines nulles, la méthode Write(string) est surchargée pour gérer ce cas.

La désérialisation suit le même principe, le flux d'octets est lu à l'aide d'une implémentation spécifique de la classe BinaryReader, et l'objet est reconstitué.

Le code source est disponible sur GitHub : https://github.com/mathieubrun/Cogimator.Serialization/blob/master/Cogimator.Serialization/ReflectionSerializer.cs

Implémentation naive d'un Serializer en C# - Partie 1

Cet article sera le premier d'une série qui me démangeait depuis quelque temps, sur l'implémentation d'un serializer en C#. Le but de cette implémentation n'est pas de rivaliser avec un protobuf-net, mais plutôt l'occasion d'écrire un peu de code plus bas niveau que d'habitude.

Pour commencer, le but est d'obtenir le même niveau de fonctionnalité que le BinaryFormatter du Framework. Voilà pour nos spécifications fonctionnelles détaillées !

Au niveau de l'implémentation, j'ai choisi de commencer par une approche naïve basée sur la reflection. Cette première étape permettra la mise en place des tests unitaires automatisés servant à vérifier le bon fonctionnement du Serializer.

Ce bon fonctionnement s'appuie sur deux phases : durant la sérialisation, notre objet est transformé en tableau d'octets. Durant la désérialisation, ce même tableau d'octets sert à recomposer notre objet. Il faut dont choisir un format de stockage pour les différentes données présentes. J'ai choisi de rester le plus simple possible : les membres des notre objet sont sérialisés dans l'ordre alphabétique. 

Ceci a pour implication, tout comme le BinaryFormatter, de ne permettre de désérialiser uniquement dans le même objet: si des définitions de champs sont modifiées, le processus ne fonctionnera plus.

Les champs de notre objet étant sérialisés dans l'ordre alphabétiques, dans un premier temps les champs de type valeur sont convertis en tableau d'octets et placés les uns a la suite des autres. Pour les string, les octets représentant la chaîne seront précédés de la longueur de celle ci.

Pour les autres types de champs (object, nullables, ...) ce sera l'objet de l'article suivant.

Implémenter simplement un formulaire dynamique avec WPF

En s'appuyant sur les DataTemplates et les capacités de binding de WPF, on peut très facilement mettre en place des formulaires dynamiques. La première étape est de définir les classes qui serviront à définir les éléments de notre formulaire :

Ensuite, on va définir les DataTemplates qui vont permettre leur affichage :

Et pour finir, il reste juste a ajouter les éléments dans un conteneur :

Tout le reste est géré par le WPF, qui, au travers des DataTemplates et du Binding affichera les contrôles nécessaires pour remplir nos éléments.

Le code source complèt est disponible sur : https://github.com/mathieubrun/Cogimator.Samples