Frédéric Mélantois
Comprendre les bases de Linq to objects
La meilleure façon de comprendre le fonctionnement de Linq est sans doute de réaliser soi-même un petit développement similaire en C# 2.0 et de le faire évoluer sous C# 3.0 en intégrant chaque nouveauté du langage.
Par Frédéric Mélantois publié le 21/10/2007 à 22:53, lu 6351 fois, 6 pages
commentaire(s) 1 commentaire(s) tag(s)Tags: C#, Linq
 3 | Déductions de types et expressions Lambda
Déductions de types et expressions Lambda
Piste verte
Reprenons le code à notre disposition pour le faire évoluer sous Visual Studio 2008 et C# 3.0. Notre classe statique « ComplementEnumerable » est la suivante :

public delegate TResult Func<TSource, TResult>(TSource source);

 

public static class ComplementEnumerable

{

  public static IEnumerable<TResult> Select<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult> selector)

    {

        foreach (TSource s in source)

 

            yield return selector.Invoke(s);

    }

 

    public static float Average(IEnumerable<float> source)

    {

        double num1 = 0;

        long num2 = 0;

        foreach (float num3 in source)

        {

            num1 += num3;

            num2++;

        }

        return (float)(num1 / (double)num2);

    }

 

    public static float Average<TSource>(IEnumerable<TSource> Source, Func<TSource, float> selector)

    {

        return ComplementEnumerable.Average(ComplementEnumerable.Select<TSource, float>(Source, selector));

    }

 

    public static IEnumerable<TSource> Where<TSource>(IEnumerable<TSource> source, Func<TSource, bool> selector)

    {

        foreach (TSource s in source)

            if (selector.Invoke(s))

                yield return s;

    }

}

Pour toute création de fichiers de code C# dans Visual Studio, veillez bien à mettre en commentaire la ligne « using System.Linq ; » afin que nous puissions mener notre démonstration à bien sans l'utilisation du Framework Linq mais uniquement avec les nouveautés du compilateur C# 3.0.
Une très grande avancée du langage C# dans sa version 3.0 est la déduction de type. Elle se généralise grâce à l'évolution du compilateur C# 3.0. L'expression suivante :

IEnumerable<IEnumerable<NoteENT>> t = ComplementEnumerable.Select<EleveENT, IEnumerable<NoteENT>>(l,

                            delegate(EleveENT c) { return c.Notes; });

devient :

var t = ComplementEnumerable.Select<EleveENT, IEnumerable<NoteENT>>(l, delegate(EleveENT c) { return c.Notes; });

Le mot clé "var" nous permet de réaliser une économie syntaxique confortable puisque la partie gauche d'une affectation n'est plus nécessaire. Il ne s'agit aucunement d'un « variant », comme on le connaît dans d'autres langages.
Piste rouge
Comme je l'ai montré dans l'article « C# 3.0 Beta, déclarations et initialisations simplifiées, regardons sous le capot ! », il n'existe pas de différence au niveau de l'IL (Intermediate Langage), que le type soit renseigné ou que la syntaxe soit simplifiée par le mot clé « var ».
Piste verte
Le typage implicite offert par le compilateur C# 3.0 mais aussi par l'intellisence de Visual Studio 2008 va beaucoup plus loin que la prise en compte du nouveau mot clé « var ». Il permet encore de simplifier la syntaxe de l'expression précédente. En effet, les parties génériques de cette dernière peuvent être déduites par le compilateur. De sorte que l'on peut écrire :

var u = ComplementEnumerable.Select(l, delegate(EleveENT c) { return c.Notes; });

Par exemple si nous prenons l'expression compliquée suivante :

IEnumerable<IEnumerable<float>> t = ComplementEnumerable.Select<EleveENT, IEnumerable<float>>(l, delegate(EleveENT c)

            {

                return ComplementEnumerable.Select<NoteENT, float>(ComplementEnumerable.Where<NoteENT>(c.Notes,

                    delegate(NoteENT n)

                        { return n.Date >= new DateTime(2007,4,1); }), delegate(NoteENT n)

                            { return n.Note; }

                    );

                   });

Celle-ci se trouve très allégée :

var r = ComplementEnumerable.Select(l, delegate(EleveENT c)

    {

        return ComplementEnumerable.Select(ComplementEnumerable.Where(c.Notes, delegate(NoteENT n)

        { return n.Date >= new DateTime(2007,4,1); }), delegate(NoteENT n)

        { return n.Note; }

    );

    });

La déduction de type par le compilateur apporte donc un véritable confort du point de vue de la syntaxe dans l'utilisation de types à base de génériques. L'environnement de Visual Studio 2008 possède une intellisence prenant parfaitement en compte cette simplification.
Piste rouge
A ce stade de notre exposé, il serait intéressant de comparer l'IL généré par le compilateur C# 2.0 concernant le code présenté dans le premier chapitre et l'IL généré par le compilateur C# 3.0 dans ce chapitre. Pour cela, vous pouvez utiliser l'utilitaire « ILDASM » fourni par le Framework ou bien l'utilitaire Reflector dont vous limiterez l'affichage uniquement au code IL. Vous aurez la surprise de constater que le code IL est identique dans les deux cas. C'est donc que les nouveautés C# 3.0 présentées jusqu'à présent et notamment les simplifications d'écriture n'ont pas induit de changement en ce qui concerne l'IL. Pour vous en persuader complètement, je vous invite à recompiler le code IL issu des sources C# 3.0, en changeant les assemblies de références vers celles du framework 2.0. Utilisez pour cela l'utilitaire « ILASM » du SDK 2.0. La compilation se passe correctement.
Piste verte
Si par les déductions de types, la syntaxe a été très fortement simplifiée, les méthodes anonymes restent encore assez lourdes à écrire. A partir de cette constatation, l'équipe en charge de C# 3.0 a donc imaginé une simplification d'écriture en expression Lambda. C'est ainsi que :

delegate(NoteENT n) { return n.Note; }

devient

(NoteENT f) => f.Note

A partir de cet allégement, on peut donc commencer à modifier la syntaxe de l'expression suivante :

var r = ComplementEnumerable.Select(l, delegate(EleveENT c)

    {

        return ComplementEnumerable.Select(ComplementEnumerable.Where(c.Notes, delegate(NoteENT n)

        { return n.Date >= new DateTime(2007,4,1); }), (NoteENT f) => f.Note);

 

    });

en :

var r = ComplementEnumerable.Select(l, c =>

                ComplementEnumerable.Select(ComplementEnumerable.Where(c.Notes, n =>

                n.Date >= new DateTime(2007,4,1)),f => f.Note)

            );

Ce code montre de façon évidente que la déduction de type par le compilateur combinée à l'utilisation des expressions Lambda, oeuvre vers une grande simplification d'écriture.
Piste rouge
Une nouvelle fois, j'invite le lecteur à comparer l'IL généré dans le cadre du premier chapitre et l'IL généré par le compilateur C# 3.0 après avoir ajouté les expressions lambda à notre code. Vous constaterez encore qu'il n'y a pas de différence ! C'est donc que l'emploi d'une méthode anonyme ou d'une expression Lambda produit le même code IL.
Piste verte
Bien que la déduction de types par le compilateur et l'emploi d'expressions Lambda nous fassent bénéficier d'une grosse simplification de l'écriture C#, la réduction du code avec la nouvelle version de C# 3.0 n'est pas encore totalement complète. Nous pouvons encore réduire l'écriture ! C'est ce que nous allons voir au prochain chapitre.
 
» Démarrer une discussion
 
Discussion démarée par Matthieu Mezil le 22/10/2007 à 11:37, 1 commentaire(s).