cogimator.net

Une ligne à la fois...

Mise en cache intelligente des templates AngularJS

Avant de rentrer dans le vif du sujet, petit rappel sur le fonctionnement du cache du navigateur.

Lorsque le navigateur demande une ressource (index.html par exemple) au  serveur, celui ci lui renvoie plusieurs éléments :

  • un statut HTTP (200 SUCCESS ici)
  • le contenu du fichier index.html
  • un ensemble d’en-têtes http

Parmi ces en-têtes, on retrouvera (en fonction de la configuration du serveur) :

  • un ETAG, qui est un checksum calculé selon le contenu renvoyé au navigateur
  • une date d’expiration, qui indique au navigateur la durée de vie de la ressource demandée

Il est à noter que les valeurs dans l’en-tête sont purement prescriptives, charge au navigateur de les respecter.

Lorsque le navigateur refait une requête au serveur pour le fichier index.html, il adjoindra également des en-têtes à sa requête. L’en-tête ETAG permettra de répondre au navigateur par un statut 304 NOT MODIFIED, dans le cas ou le fichier n’aurait pas changé.

L’en-tête date d’expiration permet au navigateur d’éviter d’envoyer des requêtes au serveur : tant que la date d’expiration n’est pas atteinte, le navigateur utilise la copie en cache.

Les templates AngularJS sont chargés au travers du service $http, qui se base sur xmlHttpRequest, qui lui même bénéficie du cache du navigateur.

Imaginons le scénario suivant :

  • le matin a 8h, le navigateur du client A demande le fichier index.html
  • le serveur lui renvoie, avec un ETAG “ABCD”, et une date d’expiration fixée au lendemain 8h
  • lors de l’utilisation de l’application, le navigateur va se baser sur la version en cache du fichier, tant que la date d’expiration est atteinte
  • a 12h, une nouvelle version de l’application est mise en ligne

Jusqu’au lendemain 8h, le client A utilisera une version potentiellement obsolète du fichier index.html.

Pour eviter cela, je vais mettre en place un mécanisme permettant d’assurer le bon fonctionnement du cache, tout en utilisant les derniers fichiers disponibles de l’application.

Dans un premier temps, il faut fournir un numéro identifiant l’application déployée. J’ai choisi d’utiliser la date de création d’un assembly du projet Web. Pour cela, j’ai intégré une simple balise script déclarant une constante AngularJs :

<script type="text/javascript">
    angular.module('SampleApplication.Config', [])
        .constant('SampleApplicationVersion', '<%: Version %>');
</script>

La suite de l’implémentation est aisée, grâce au système de HttpInterceptors fourni par AngularJs. Ces HttpInterceptors permettent de modifier les requêtes envoyées et reçues par le service $http.

.factory('SmartCacheInterceptor', ['$q', 'SampleApplicationVersion', function ($q, SampleApplicationVersion) {
    return {
        request: function (config) {
            if (config.url.indexOf(".htm") > -1) {
                var separator = config.url.indexOf("?") === -1 ? "?" : "&";
                config.url = config.url + separator + "v=" + SampleApplicationVersion;
            }
            return config || $q.when(config);
        }
    };
}]);

Voici les résultats dans fiddler. Les requêtes sur l’url “/” correspondent a un rafraichissement de la page du navigateur. Le serveur web utilisé est IIS Express, sans paramétrage spécifique.

image

Le code source est disponible sur github.

Indicateur de chargement AngularJs

Depuis la version 1.2.0 de AngularJs, le service $resource retourne des promise lors des appels aux méthodes get, query, save... Ceci ouvre des possibilités intéressantes, notamment la mise en place rapide d'indication de chargement.

Pour ce faire, j'ai choisi d'implémenter une directive, afin de pouvoir déclarer mon Loader ainsi :

<div loader="data">
    {{data | json}}
</div>

Ceci va donc orienter la déclaration de la directive, pour utiliser la transclusion et un scope isolé :

.directive('loader', ['$q', function ($q) {
    return {
        transclude: true,
        templateUrl: 'app/loader/loader.html',
        scope: {
            source: '=loader'
        },
        link: function (scope, elem, attrs) {
            
        }
    }
}])

Ensuite il faut écrire la fonction link pour réagir aux évènements du promise :

.directive('loader', ['$q', function ($q) {
    return {
        transclude: true,
        templateUrl: 'app/loader/loader.html',
        scope: {
            source: '=loader'
        },
        link: function (scope, elem, attrs) {
            scope.$watch("source", function (val) {
                scope.status = 0;
                val.$promise.then(function (success) {
                    scope.status = 200;
                }, function (err) {
                    scope.status = err.status;
                });
            });
        }
    }
}])

Le $watch permet de réagir à une assignation de la valeur en chargement, notamment lors de l'appel à une fonction de rechargement de données. Pour obtenir une référence sur l’objet promise renvoyé par $resource, il faut passer par la propriété $promise de celui-ci

Enfin, pour afficher tout ça, il nous faut un template :

<div>
    <div ng-hide="status==200"  ng-switch="status">
        <div ng-switch-when="0">
            <span><i class="fa fa-2x fa-spin fa-spinner"></i> Loading</span>
        </div>
        <div ng-switch-default>
            <span>Error from server : {{status}}</span>
        </div>
    </div>
    <div ng-show="status==200" ng-transclude></div>
</div>

Le code est disponible sur github .

De 0 a un package Nuget

En préparant un projet de démo AngularJS + Bootrap + Web Api (article a venir !), j’ai eu besoin de générer des données de test. Après quelques recherches infructueuses, j’ai donc choisi de monter mon petit projet. Ca tombe bien, j’avais envie de coder un petit projet “utilitaire”, et de me faire plaisir avec une API de type “Fluent”.

Une première version est dores et déjà disponible sur github : https://github.com/mathieubrun/Cogimator.SampleDataGenerator. J’aurais l’occasion de vous en reparler dans un article à venir (ca commence a faire beaucoup d’articles à venir…).

Apres l’avoir référencé “manuellement” dans mon projet de démo AngularJS, je me suis demandé comment optimiser le déploiement de mon générateur de données. Ca tombe bien, j’avais envie de créer un package nuget.

 

Etape 1 : création du projet

Rien d’exceptionnel, une solution Visual Studio standard, avec l’option “Activer la restauration des packages nuget” activée, ceci afin d’avoir un nuget.exe accessible facilement en ligne de commande depuis le dossier de la solution.

Etape 2 : création d’un compte Nuget.org

Ici, toujours rien de complètement fou, on s’enregistre, et on note bien l’api Key, pour l’activer sur le poste de développement.

 

Etape 3 : création du fichier .nuspec

Ici, les choses peuvent un peu se compliquer, selon le temps que l’on souhaite consacrer à la documentation Nuget. Pour faire simple, il faut initialiser un fichier .nuspec avec la commande suivante

.nuget\nuget.exe spec

Ensuite, il faut déplacer ce fichier dans le dossier du projet qui va servir a générer le package, et lui donner le même nom que le .csproj :

image

Enfin, il ne reste plus qu’a modifier le contenu du fichier nuspec pour l’adapter a votre projet.

Etape 4 : publication manuelle

La création du package est maintenant possible, avec la commande

.nuget\nuget.exe pack Cogimator.SampleDataGenerator\Cogimator.SampleDataGenerator.csproj

Nuget s’appuiera sur les .csproj et .nuspec pour générer le package.

Il ne reste plus qu’a l’uploader sur nuget.org.

Etape 5 : le serveur d’intégration continue

J’ai choisi TeamCity pour remplir ce rôle, principalement en raison de sa simplicité, et aussi parce qu’il est développé par JetBrains (auteurs de ReSharper, donc pas vraiment des amateurs).

Je ne rentre pas dans les détails de l’installation, du type next, next, next. Comme j’exécute TeamCity sur mon poste de travail, J’ai juste changé le compte d’exécution des services pour “System account”. Sur un serveur dédié j’aurais crée un user spécifique (car c’est très mal de faire tourner des services avec System account !)

Une fois le serveur installé, il ne reste plus qu’a se rendre sur l’adresse http://localhost (avec le port spécifique si vous l’avez configuré ainsi) pour finaliser l’installation.

Ensuite, il faut créer un nouveau projet, avec un configuration associée. Ici, les valeurs par défaut feront très bien l’affaire.

Une fois le projet créer, il faut lui associer un contrôle de code source. TeamCity supporte git nativement, l’url présente sur la home de votre projet doit être reprise :

image

Petite subtilité, j’ai repris l’exécutable fourni avec le client github (dans ) et je l’ai copié dans un dossier spécifique :

image

Les étapes de build sont également aisées à configurer (je repense au temps passé a pondre du xml pour CruiseControl.NET…). La première étape est la compilation. Si vous avez bien paramétré le contrôle de code source, vous pouvez déjà choisir le fichier .sln avec le picker a droite du champ “solution file path” :

image

Nous arrivons maintenant aux étapes concernant nuget. L’ajout d’une tache “Nuget pack” vous aménera a l’écran suivant :

image

Ici, il faut bien penser à aller dans “Nuget settings” pour télécharger un client nuget pour TeamCity. Il est également possible de publier les packages nuget dans un feed local au serveur teamcity. Ce qui peut s’avérer plutôt pratique pour les développements en entreprise… Il est aussi à noter que le package sera généré avec un numéro de version correspondant par défaut au numéro de build. Ce qui s’avère pratique pour les mises à jour du package.

Enfin, la publication se fait avec la tache “Nuget publish” :

image

Une fois le build complété avec succès, on peut vérifier la présence du package sur nuget.org :

image

Implémentation naïve d'un Serializer en C# - Partie 7

La dernière ligne droite dans l’implémentation de ce Serializer était d’avoir des performances similaires (ou meilleures!) à celles du BinaryFormatter du Framework .Net. En utilisant uniquement la reflection, ce n’était pas gagné d’avance.

foreach (var prop in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).OrderBy(x => x.Name))
{
    var v = this.DeserializeBase(prop.FieldType, destination, source);

    prop.SetValue(destination, v);
}

En effet, a chaque serialisation de la meme classe, ce code va récupérer les champs, encore et encore, ce qui n'est de loin pas efficace.

L’optimisation que j’ai choisi a été de remplacer l’utilisation de la reflection par la création de LambdaExpression basées sur les champs des objets a sérialiser.

gettersForType = new List<Tuple<Type, Func<object, object>>>();

// create getter list from fields
foreach (var prop in sourceType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public))
{
    var getters = CreateGetter(prop);

    gettersForType.Add(Tuple.Create(prop.FieldType, getters));
}

Ici, la reflection sera utilisée une fois pour obtenir la liste des champs, et générer les Getters qui permettront d'en lire les valeurs.

La méthode CreateGetter va retourner un Func après avoir crée et compilé une LambdaExpression.

private static Func<object, object> CreateGetter(FieldInfo field)
{
    var fieldType = field.DeclaringType;

    // the input parameter for the lambda
    var sourceParameter = Expression.Parameter(typeof(object), "source");

    // as the parameter is of object type, a cast or conversion may be required
    var castedSource = GetExpressionAsTypeIfNeeded(sourceParameter, fieldType);

    // get field value
    var fieldExpression = Expression.Field(castedSource, field);

    // as the return parameter is of type object, a cast or conversion may be required
    var castedField = Expression.TypeAs(fieldExpression, typeof(object));

    // the lambda expression for accessing a field on an object
    var expr = Expression.Lambda<Func<object, object>>(castedField, sourceParameter);
    return expr.Compile();
}

Les éléments clés dans cette méthode sont :

  • La déclaration d’un paramètre pour la LambdaExpression, de type object, qui sera casté ou converti dans le bon type. En effet, comme on ne connait pas en avance le type de l’objet que l’on va désérialiser, la signature de la lambda expression est Func<object,object>.
  • La récupération d’une expression renvoyant la valeur du champ
  • Le cast de cette valeur en object pour la renvoyer.

De la même manière, j’avais implémenté une méthode CreateSetter, qui elle renvoyait un Action<object,object>. Cette méthode, créée a la volée pour un champ donné, prenait en paramètre l’objet en cours de désérialisation, ainsi que la valeur a assigner au champ.

private static Action<object, object> CreateSetter(FieldInfo field)
{
    var fieldType = field.DeclaringType;

    // the input parameter for the lambda
    var destinationParameter = Expression.Parameter(typeof(object), "destination");
    var valueParameter = Expression.Parameter(typeof(object), "fieldValue");

    var castedDestination = GetExpressionAsTypeIfNeeded(destinationParameter, fieldType);
    var castedValue = GetExpressionAsTypeIfNeeded(valueParameter, field.FieldType);

    // get field value
    var fieldExpression = Expression.Field(castedDestination, field);

    // as the return parameter is of type object, a cast or conversion may be required
    var assign = Expression.Assign(fieldExpression, castedValue);

    // the lambda expression for accessing a field on an object
    var expr = Expression.Lambda<Action<object, object>>(assign, destinationParameter, valueParameter);
    return expr.Compile();
}

Le souci de cette méthode est quelle renvoie un Action<object,object>. Or si les types valeurs “basiques” comme int, long, float, ne posent pas de souci, comme ils sont gérés par un sérializer a part, les structs, qui sont également passés par valeurs, ne sont pas désérialisés !

En effet, la méthode va agir sur une copie de l’instance en cours de désérialisation, dont les champs garderont les valeurs par défaut.

J’ai donc choisi d’implémenter une méthode plus complète, qui va non seulement générer le code pour définir les valeurs des champs, mais également prendre en charge la création de l’instance qui va être désérialisée. Cette méthode renvoie une fonction, qui prend en paramètre le flux dans lequel lire les valeurs a désérialiser, l’instance de l’objet sur laquelle seront définies les champs, et qui retourne l’instance désérialisée.

Dans le cas des types valeurs, la fonction générée se charge de la création de l’instance, et la retourne. De ce fait, on ne souffre plus des problèmes posés par l’implémentation précédente.

private Func<ExtendedBinaryReader, object, object> CreateSetters(Type type)
{
    // the input parameters of the generated lambda : the destination instance on which the setters will be applied
    var destinationParameter = Expression.Parameter(typeof(object), "destination");

    // the BinaryReader from which to get the data
    var binaryReaderParameter = Expression.Parameter(typeof(ExtendedBinaryReader), "source");

    // a variable to hold the destination instance
    var deserializedType = Expression.Variable(type, "destination");

    var expressionBlock = new List<Expression>();

    if (!type.IsValueType)
    {
        // if the type is not a value type the instance given as a parameter is used, or a new instance is created
        var coalesce = Expression.Coalesce(GetExpressionAsTypeIfNeeded(destinationParameter, type), Expression.New(type));

        // the first "line" of the lambda is to assign the destination variable
        expressionBlock.Add(Expression.Assign(deserializedType, coalesce));
    }
    else
    {
        // for a value type, a "new" instance is created
        expressionBlock.Add(Expression.Assign(deserializedType, Expression.New(type)));
    }

    var thisAsMethodTarget = Expression.Constant(this);

    var methodToCall = typeof(FastDefaultObjectSerializer).GetMethod("DeserializeBase");
    var deserializedTypeAsObject = Expression.TypeAs(deserializedType, typeof(object));

    foreach (var field in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public))
    {
        // access to the field on the instance being deserialized
        var fieldExp = Expression.Field(deserializedType, field);

        var fieldType = Expression.Constant(field.FieldType);

        // a methood call expression
        var call = Expression.Call(
            thisAsMethodTarget,
            methodToCall,
            fieldType,
            deserializedTypeAsObject,
            binaryReaderParameter);

        // the result of the method call is converted to the field type if needed ...
        var callResultAsFieldType = GetExpressionAsTypeIfNeeded(call, field.FieldType);

        // ... and is assigned to the field
        var assignToField = Expression.Assign(fieldExp, callResultAsFieldType);

        expressionBlock.Add(assignToField);
    }

    // the return part of the lambda
    var returnTarget = Expression.Label(typeof(object));
    var returnExpression = Expression.Return(returnTarget, deserializedTypeAsObject, typeof(object));
    var returnLabel = Expression.Label(returnTarget, deserializedTypeAsObject);

    expressionBlock.Add(returnExpression);
    expressionBlock.Add(returnLabel);

    var block = Expression.Block(new ParameterExpression[] { deserializedType }, expressionBlock);

    var lambda = Expression.Lambda<Func<ExtendedBinaryReader, object, object>>(block, binaryReaderParameter, destinationParameter);

    return lambda.Compile();
}

Dans cette méthode, les points clés sont :

  • le test sur le type de l’objet a désérialiser : si il s’agit d’un type valeur, la méthode va le créer, et le retourner. Si non, la méthode utilisera l’instance passée en paramètre.
  • l’appel a la méthode DeserializeBase, afin de s’appuyer sur les mécanismes implémentés précédemment pour la désérialisation
  • la génération d’un bloc de code pour la désérialisation de chaque champ

Cette optimisation a permi de diviser par 3 le temps de serialisation/deserialisation (10000 iterations) d’une classe simple.

Comme toujours, le code est disponible sur github : https://github.com/mathieubrun/Cogimator.Serialization

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

Une des dernières parties de cette série d’article concerne la sérialisation correcte des graphes d’objets, et surtout de leurs références. En effet, le tableau déclaré dé la manière suivante :

var instance = new TestReference() { Str = "3" };
var array = new TestReference[] { instance, instance, instance, instance };

Ne doit pas sérialiser l’objet “Instance” quatre fois, mais une seule. La résolution de ce problème permettra également d’aborder les références cycliques :

var t1 = new TestReference() { Str = "1" };
var t2 = new TestReference() { Str = "2" };

t1.Reference = t2;
t2.Reference = t1;

Dans un premier temps, il faut pouvoir identifier les objets de manière unique. Dans un premier temps, j’ai régardé du coté de la classe GCHandlepour obtenir l’adresse mémoire des objets. Cette méthode ne s’est pas avérée adaptée : le Garbage Collector pouvant déplacer les objets et donc changer leur adresse mémoire.

En fait, le framework offre une classe toute faite pour identifier les objets : ObjectIDGenerator, qui permet d’obtenir un identifiant unique pour chaque objet passé en paramètre à la méthode GetId. Et en bonus, cette méthode indique même si il s’agit d’une instance déjà identifiée.

La modification de la classe DefaultObjectSerializer s’avère donc simple :

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    bool firstTime;

    // generate unique id for object, in order not to save same object multiple times
    var key = idGenerator.GetId(source, out firstTime);

    writer.Write(firstTime);
    writer.Write(key);

    if (firstTime)
    {
        // inspect object
        foreach (var prop in sourceType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).OrderBy(x => x.Name))
        {
            this.SerializeBase(prop.FieldType, prop.GetValue(source), writer);
        }
    }
}

public override object Deserialize(ExtendedBinaryReader source, object target, Type type)
{
    var firstTime = source.ReadBoolean();
    var key = source.ReadInt64();

    if (!firstTime)
    {
        return cache[key];
    }
    else
    {
        var destination = Activator.CreateInstance(type);

        // add instance to cache before deserializing properties, to untangle eventual cyclic dependencies
        cache.Add(key, destination);

        // inspect object
        foreach (var prop in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).OrderBy(x => x.Name))
        {
            var v = this.DeserializeBase(prop.FieldType, destination, source);
            prop.SetValue(destination, v);
        }

        return destination;
    }
}

En résumé, pour la sérialisation, on identifie chaque objet sérialisé, et si il est connu, on ne sérialise que son identifiant. Pour la désérialisation, on place les objets et leur identifiant dans un dictionnaire faisant office de cache.

La subtilité concerne les références cycliques : il faut placer l’objet dans le cache juste après sa création, car lorsque l’on va désérialiser les propriétés de l’objet, on pourrait rencontrer une référence vers un objet que l’on n’aurait pas encore désérialisé.

Comme toujours, les tests unitaires permettent de valider que les modifications n’entrainent pas de régressions.

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

Après avoir refactorisé le code du Serializer, j'ai choisi d'implémenter la sérialisation des implémentations d'interfaces. En effet, si un objet possède des propriétés de type interface (IList<T> par exemple), ce n'est pas pour autant qu'il ne doit pas pouvoir être sérialisable.

L'implémentation de la classe InterfaceSerializer s'est avérée plus simple que prévue : dans le principe, si un type de propriété est une interface, et que la valeur de cette propriété est non nulle, le type de la valeur (via GetType()) est sérialisé.

Ensuite, on appelle simplement le sérializer racine, en lui substituant le type de l'interface par le type de l'instance qui l'implémente.

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    var st = source.GetType();

    // write implemented type
    writer.Write(st);

    // continue with implemented type and not interface
    base.Serialize(writer, source, st);
}

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.