Développement

Répondre au problème d’affichage des contrôles Xamarin.Forms sur les applications UWP

Lorsque vous développez des applications Windows 10 (UWP) par l’intermédiaire de Xamarin.Forms et que vous compilez en release ou que vous publiez vos applications sur le store l’option « Compiler avec la chaîne de l’outil du code natif » (ou « Compile with .NET Native tool chain » en anglais) est activée afin d’améliorer les performances de votre application. Lorsque cette option -obligatoire pour la publication sur le store- est active, il peut arriver que Xamarin.Forms ne parvienne pas à charger les éléments de certaines assemblies, en particulier les classes de rendu. Vous pouvez par exemple être confronté à une carte qui ne s’affiche pas sur l’application publiée ou à une levée d’exceptions lors de l’instanciation de la carte si vous êtes en release dans Visual Studio.

L’article « Adding a Universal Windows Platform (UWP) App » de la documentation officielle Xamarin détaille la solution de contournement :

Target Invocation Exception » when using « Compile with .NET Native tool chain »
If your UWP app is referencing multiple assemblies (for example third party control libraries, or your application itself is split into multiple PCLs), Xamarin.Forms may be unable to load objects from those assemblies (such as custom renderers).

This might occur when using the Compile with .NET Native tool chain which is an option for UWP apps in the Properties > Build > General window for the project.

You can fix this by using a UWP-specific overload of the Forms.Init call in App.xaml.cs as shown in the code below (you should replace ClassInOtherAssembly with an actual class your code references):

// you'll need to add `using System.Reflection;`
List assembliesToInclude = new List();

//Now, add in all the assemblies your app uses
assembliesToInclude.Add(typeof (ClassInOtherAssembly).GetTypeInfo().Assembly);

//Also do this for all your other 3rd party libraries

Xamarin.Forms.Forms.Init(e, assembliesToInclude);
// replaces Xamarin.Forms.Forms.Init(e);
Add a reference to each assembly that is referenced by the app.

Dependency Services and .NET Native Compilation
Release builds using .NET Native compilation can fail to resolve dependency services that are defined outside the main app executable (such as in a separate project or library).

Use the DependencyService.Register() method to manually register dependency service classes. Based on the example above, add the register method like this:

Xamarin.Forms.Forms.Init(e, assembliesToInclude);
Xamarin.Forms.DependencyService.Register(); // add this

Pour continuer sur l’exemple de la carte, la classe à cibler est Xamarin.Forms.Maps.UWP.MapRenderer et non Xamarin.Forms.Maps.Map. La solution qui fonctionne est donc la suivante :

using System.Reflection;

var rendererAssemblies = new []
{
    typeof(Xamarin.Forms.Maps.UWP.MapRenderer).GetTypeInfo().Assembly
};

Xamarin.Forms.Forms.Init(e, rendererAssemblies);

Source : Forums Xamarin

Vous trouverez plus d’informations sur les articles MSDN « Compilation d’applications avec .NET Native » et « Prise en main de .NET Native »

Facebooktwitterlinkedinmail

La transformation de configuration avec ASP.NET

Explorateur de fichiers - Web.configJe me suis récemment penché sur un sujet qui m’intéresse depuis longtemps : la transformation de configuration avec ASP.NET. Ce terme abstrait n’évoque peut être rien de familier au premier abord, mais vous y aviez sûrement déjà songé si vous ne vous en servez pas encore. Il s’agît tout simplement d’automatiser le changement de paramétrage suivant l’environnement de déploiement en se basant sur le fichier Web.config. Par défaut, Visual Studio propose deux profils (Debug et Release) ainsi que les fichiers Web.Debug.config et Web.Release.config qui les accompagnent, mais il possible d’en rajouter.

A quoi ça sert ?

Pour mieux comprendre prenons par un exemple un système de log. Si votre application est équipée d’un tel dispositif (et elle devrait l’être, si ce n’est pas encore le cas je vous recommande l’excellent log4net), il est fort probable que vous souhaitiez enregistrer d’avantage d’informations sur les environnements de développement et de test que sur ceux de productions. Vous utiliserez donc des niveaux de logs permettant de choisir le niveau d’information que vous souhaitez enregistrer. Mais gérer ce type de paramètre manuellement en fonction de l’environnement de publication serait vite contraignant et source d’erreur. C’est là qu’intervient la transformation de configuration avec ASP.NET.

Comment le mettre en place ?

Nous l’avons vu avant, les fichiers Web.Debug.config et Web.Release.config sont déjà créés par Visual Studio et placés sous la racine que représente le Web.config que vous avez déjà l’habitude d’utiliser. Ces fichiers sont tous trois des fichiers XML, mais les fichiers de Web.Deubg.config et Web.Release.config vont s’appuyer sur un référentiel XDT (XML Document Transform, sorte XSLT revisité par Microsoft) pour transformer le fichier Web.config d’origine.

Ce dernier ne sera donc pas automatiquement remplacé ou écrasé par un autre fichier mais bien transformé suivant les indications présentes dans les fichiers spécifiques. Autre particularité, votre application doit faire l’objet d’un déploiement pour que les fichiers Web.Deubg.config et Web.Release.config, une simple génération sur l’IIS Express de votre environnement de développement ne sera pas suffisante.

Concrètement si vous souhaitez modifier un couple clé-valeur présent dans les appSettings de votre Web.config lorsque votre applicaiton tourne en Release, vous pourriez utiliser le code ci-dessous dans votre fichier Web.Release.config. Celui-ci va rechercher la correspondance sur la clé d’un élément contenu dans les appSettings (attribut xdt:Locator= »Match(key) ») puis procéder à son remplacement complet (attribut xdt:Transform= »Replace »).

<?xml version="1.0" encoding="utf-8"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  <appSettings>
    <add key="LogLevel" value="ERROR" xdt:Transform="Replace" xdt:Locator="Match(key)" />
  </appSettings>
  <system.web>
    <compilation xdt:Transform="RemoveAttributes(debug)" />
  </system.web>
</configuration>

J’ai bien dit vous « pourriez » car il existe plusieurs façons (plus ou moins adaptées suivant les cas d’utilisation) de transformer le Web.config. Tous les attributs de transformation sont listés sur le MSDN, libre à vous de rechercher et d’utiliser le plus adpté à vos besoins.

Fichiers Web.config

J’ai précédemment évoqué le fait que le IIS Express de votre environnement de développement n’appliquait pas les transformations peut importe le mode de génération choisi, il existe bien entendu des solutions de contournement, la plus simple étant de placer sa configuration de développement dans le Web.config qui lui est toujours pris en compte, laissant les autres configurations pour les cas où vous effectuerez une réelle publication.

Si vous souhaitez plus d’information sur la transformation de configuration avec ASP.NET, je vous invite à consulter la documentation officielle.

Pour une gestion plus complète du cycle de vie de l’application (ALM), vous pouvez envisager l’utilisation de Release Management pour Visual Studio.

Facebooktwitterlinkedinmail

Contenu multimédia & Responsive design

Si vous travaillez régulièrement sur des sites web utilisant du contenu multimédia (comprenez images et vidéos), vous avez obligatoirement été confronté à la problématique de redimensionnement des éléments que vous affichez. Et l’arrivée du responsive design n’a pas arrangé les choses.

Les images

La solution concernant les images est relativement simple puisqu’elle tient en une seule ligne de CSS grâce à la propriété « max-width » qui fixera la largeur maximale de l’élément concerné (en l’occurrence l’image) à la largeur de son parent (ci-dessous le paragraphe).

p img {
    max-width: 100%;
}

On pourrait songer à appliquer le même principe sur une vidéo et techniquement parlant ce n’est pas faux, malheureusement cela aura une incidence sur la présence d’éventuelles bords noirs supplémentaires sur la vidéo car la taille du lecteur ne sera plus adaptée au ratio de la vidéo affichée.

Les vidéos

Les plus ingénieux penseront immédiatement à une solution en JavaScript pour adapter dynamiquement la hauteur de la vidéo à la largeur occupée, mais il existe une technique full CSS relativement simple pour palier à ce problème : le padding ! En effet, si on créé un élément conteneur pour la vidéo est qu’on y applique un padding-bottom correspondant au ratio de la vidéo (56,25% pour du 16:9), on obtient une vidéo qui se comportera de façon parfaitement responsive.

.video-container {
    width: 100%;
    height: 0;
    padding-bottom: 56.25%;
    overflow: hidden;
    position: relative;
    background: #000000;
}

    .video-container iframe {
        width: 100%;
        height: 100%;
        position: absolute;
        top: 0;
        left: 0;
    }

L’exemple ci-dessus fonctionne pour les vidéos YouTube qui utilisent des iframes, mais on peut utiliser la même technique pour les sites qui incrustent leurs vidéos dans des balises de type « object » ou « embedded ».

Facebooktwitterlinkedinmail

Agile Tour 2014 – Strasbourg

Avant d’expliquer ce qu’est l’Agile Tour, il peut être intéressant d’effectuer une piqûre de rappel sur les méthodes agiles. Ces dernières trouvent leur fondement dans l’Agile Manifesto, il s’agît de méthodologies recensant différentes pratiques applicables pour la gestion de projet de développement informatique. La plus connue des méthodes agiles est probablement Scrum, il n’est d’ailleurs pas rare qu’une personne parle en réalité de Scrum lorsqu’elle évoque un projet avec une approche agile.

L’Agile Tour est une série d’événements à but non-lucratif ayant pour objectif de promouvoir les méthodes agiles auprès des professionnels impliqués dans des projets informatiques. Ces événements se déroulent chaque année d’Octobre à Décembre, tout autour du monde. En cette après-midi du jeudi 23 septembre 2014, il était donc possible d’assister gratuitement à plusieurs conférences sur le sujet pour ma part voici le programme que j’ai suivi :

  • 13h00 : Arrivée sur place
  • 13h30 : Les différentes conférences proposées nous ont été présentées par les speakers
  • 13h45 : Conférence « Outiller son processus et rester Agile ? C’est possible ! » par Etienne MARGRAFF très bien illustrée par l’histoire fictive de John un responsable de projet un peu fou qui souhaite créer un réseau social pour les chats.
  • 14h30 : Cédric LEBLOND présente « Ma stack d’outils agiles, tout un programme ! » avec de nombreux outils utiles dans un contexte Agile.
  • 15h30 : Petite pause autour d’un café
  • 16h00 : Une approche participative et collective (coding-dojo) très intéressante pour la conférence « Apprendre le TDD en coding-dojo » réalisée par Xavier NOPRE
  • 18h00 : Retour à la maison après une après-midi très enrichissante.

Vous l’aurez compris, j’ai grandement apprécié cette après-midi et je ne peux que vous encourager à y assister l’an prochain en espérant que cet événement perdure comme c’est le cas depuis 2008.

Facebooktwitterlinkedinmail

Développeurs VS Interfaces

La réalisation des interfaces : une lourde responsabilité, sur laquelle repose souvent le succès du logiciel, du moins pour le grand public. Vous pouvez avoir les meilleurs algorithmes du monde, si l’interface de votre application n’allie pas l’esthétique à l’utilisabilité, il y a de grandes chances pour que l’utilisateur aille voir ailleurs. Il y a quelques années, quand je développais mes premières applications je réalisais généralement mes icônes moi-même ou j’en choisissais au hasard sur le net, je ne faisais pas de maquettes (au sens large) avant de commencer le développement. Le résultat en plus d’être affreux, se composait parfois d’éléments que je n’aurais pas pu utiliser si j’avais souhaité publier mes travaux (quelqu’un a parlé de licence ?).

Vous l’aurez compris, comme tout développeur, le design et la création d’interfaces ne sont pas mes compétences premières. Mais sur beaucoup de projets les développeurs sont amenés à travailler seuls sur ces aspects. Au fil des années j’ai découvert différents outils et ressources qui permettent à un développeur de réaliser quelque chose de potable et surtout d’éviter la catastrophe en l’absence d’une personne compétente sur ces domaines. Bien entendu cette liste est très loin d’être exhaustive alors n’hésitez pas à me faire découvrir de nouveaux éléments qui auraient leur place dans cet article.

Réaliser des maquettes

Bien que les phases de conception de l’interface soient bien plus complexe, la maquette est le premier élément qui permet de visualiser l’aspect d’une future application. Bien entendu il existe différents types de maquettes présentant des intérêts complémentaires (wireframes, maquettes d’intégration, …). Ce sujet est très vaste et je ne suis probablement pas le mieux placé pour en parler, en revanche, je peux vous présenter certains outils que j’utilise lors de cette étape.

Photoshop
Même si Adobe est en train d’adopter la démarche cloud, Photoshop reste l’arme ultime pour réaliser des maquettes. De nombreux templates, y compris ceux proposé par Microsoft pour les applications Windows sont délivrés au format .psd. Photoshop présente tout de même deux inconvénients : le temps de prise en main et le prix, ce qui peut être rédhibitoire dans beaucoup de cas, même si Photoshop peut servir à bien plus que réaliser de simples maquettes.

Gimp
Heureusement il existe d’autres solutions qui fonctionnent tout aussi bien et lorsqu’on cherche un équivalent gratuit à Photoshop, beaucoup pensent à Gimp. Personnellement, je n’ai jamais réussi à accrocher avec ce logiciel, je n’en ferais donc pas de grandes lignes d’élloges bien qu’il permette amplement d’effectuer le travail nécessaire.

Paint.NET
Paint.NET est un outil gratuit que j’apprécie énormement. Certes il n’est pas aussi poussé que Photoshop ou Gimp, mais dans la majorité des cas il sera suffisant et sa prise en main est très rapide. Avec son système de calques et ses fonctionnalités de retouche simples à mettre en oeuvre, Paint.NET est un outil tout indiqué pour les développeurs et même pour le grand public.

PowerPoint
Maintenant que nous avons enfoncé les portes ouvertes en citant les classiques, attardons-nous sur des outils moins traditionnels mais tout aussi efficaces. Si vous disposez de PowerPoint 2007 ou ultérieur ainsi que de Visual Studio Premium 2013, Ultimate 2013 ou Test Professional 2013, vous pourrez bénéficier de l’outil de « Création de plan conceptuel ». Celui-ci se présente sous la forme d’un onglet supplémentaire dans PowerPoint et vous permet de schématiser très rapidement une interface en mettant à disposant une bibliothèque d’éléments relativement complète.

Outil de Création de plan conceptuel de PowerPoint

Balsamiq
J’ai beaucoup utilisé Balsamiq (aussi appelé Balsamiq Mockup) par le passé, quand il était gratuit (mais en bêta il me semble). La société Balsamiq Studios qui commercialise Balsamiq propose maintenant deux versions de cet outil : la première en application desktop, la second sur le cloud. A l’heure où j’écris ces lignes leurs tarifs ne sont pas exorbitants donc la solution mérite qu’on s’y intéresse.

Cacoo
L’outil cloud que je préfère reste Cacoo, même si l’ergonomie et la fluidité ne font pas vraiment partie des points forts de cet outil, il reste simple à prendre en main. Nulab, son éditeur, propose plusieurs formules dont les tarifications restent raisonnables et surtout une offre gratuite avec quelques fonctionnalités bridées, mais qui n’empêche en rien d’utiliser cet outil pour les petits projets.

Cacoo

Créer une palette de couleurs

Pour créer une interface, il ne suffit pas de réaliser des croquis noir et blanc, avoir un ensemble de couleurs harmonieuses sur les maquettes (comme sur le produit final) est tout aussi important. Mais quand on ne dispose pas d’une fibre artistique très développée, mieux vaut se faire aider par des outils.

Kuler
Kuler commence à être connu, je rencontre régulière des personnes qui utilisent cet outil en ligne proposé gratuitement par Adobe. Les utilisateurs ont la possibilité de créer ou de rechercher des palettes de couleurs, de les adapter à leur convenance en jouant sur différents paramètres. On y trouve des palettes de 5 couleurs, ce qui correspond aux recommandations habituelles en matière de création d’interface.

Kuler

La boite à couleur
Egalement très populaire, cette petite application permet de récupérer n’importe quelle couleur intéressante présente sur votre écran, plutôt pratique pour ceux qui souhaitent travailler avec précision.

Colour Code
Colour Code se rapproche beaucoup de Kuler, il très bien pensé et permet également de partager vos palettes de couleurs avec un permalien. Seule ombre au tableau il semble qu’il n’y ai pas de galerie pour visualiser les réalisations des autres utilisateurs.

Hex Color Tool
Un autre outil que je souhaitais vous présenter est Hex Color Tool, à partir d’une couleur de base, celui-ci peut vous proposer des déclinaisons plus claires ou plus sombres. Grâce à cet outil en ligne plus de problème pour créer les ombres ou matérialiser les interactions des éléments cliquables.

Ajouter des icônes

Les maquettes et les couleurs ne sont pas les points les plus délicats, le grand ennemi du développeur est l’icône. Lorsqu’une personne avec une dominante technique commence à se pencher sur un domaine où un certain sens artistique est nécessaire, on court souvent à la catastrophe (même si certaines personnes arrivent à combiner les deux avec brio). Heureusement il existe des solutions que les développeurs pourront mettre en place sans trop risquer de dénaturer l’interface de leur application.

Bootstrap
Bootstrap est le Framework CSS et JS mis au point pas Twitter, il propose donc tout un ensemble d’éléments permettant de construire très rapidement une interface web. Parmi ces éléments on trouve un set de glyphicons (gratuites quand elles sont utilisées avec Bootstrap). Ces icônes sont en réalité une police de caractères, ce qui présente deux avantages : l’aspect vectoriel et la légèreté (réduction du temps de chargement). J’en profite d’ailleurs pour faire une petite parenthèse dév’ car certains d’entre vous préférerons peut être utiliser Bootstrap par l’intermédiaire d’Initializr qui permet d’y ajouter quelques éléments pratiques (Modernizr, avertissement pour les anciens navigateurs, robots.txt, …).

Font Awesome
Font Awesome est un excellent complément aux glyphicons de Bootstrap si ces dernières ne vous suffisent pas. Cette police d’icônes fonctionne exactement sur le même principe que celle de Bootstrap. De plus Font Awesome est disponible par CDN ce qui permet d’améliorer encore un peu plus les performances (étant donné que la police de caractères restera en cache pour l’ensemble des sites qui utilisent le CDN).

Iconmoon
Iconmoon propose également des packs d’icônes reposant sur une police de caractères. Attention tout de même : le pack de base avec 450 icônes est gratuit, mais les packs plus étoffés sont payants. Il en va de même si vous souhaitez qu’Iconmoon héberge vos icônes.

Fontello
Fontello vous permet de combiner les icônes de différents sets présent sur internet. Vous disposerez ainsi d’une police de caractère qui comporte juste les éléments dont vous avez besoin (ce qui allège également le poids des fichiers et le temps de chargement). En bonus Fontello vous propose de personnaliser les noms et les codes associés à chacune des icônes, plutôt pratique pour être familier avec son set d’icônes.

Fontastic
Fontastic propose des fonctionnalités similaires à celles de Fontello, mais permet également de télécharger les icônes au format .svg pour ceux qui souhaiteraient les retravailler facilement avec Inkscape par exemple.

Iconmonstr
Les outils précédents sont plutôt orientés web, même si ils pourraient également être utilisés dans une application classique. Iconmonstr propose simplement des sets d’icônes gratuits au format .svg et .png avec la possibilité de personnaliser les tailles et les couleurs.

Metro Studio
Une fois n’est pas coutume, Metro Studio est un client lourd proposant plus de 2500 icônes dans le style Modern UI. Cette application permet de créer des packs à partir des icônes fournies par l’éditeur ou en les important à partir de polices de caractères installées sur votre ordinateur. Il est ensuite possible de voir le code XAML correspondant à chaque icône et d’exporter les packs en tant que sprites ou ResourceDictionary.

Metro Studio

Icon Finder
Si vous ne trouvez pas votre bonheur parmi toutes les ressources présentées ci-dessus, vous pouvez opter pour le moteur de recherche Icon Finder et générer vous-même vos sprites grâce à Stitches.

J’espère que cet article vous aura fait découvrir quelques outils utiles, si jamais vous connaissez d’autres ressources intéressantes, n’hésitez pas à m’en parler !

Facebooktwitterlinkedinmail

Les fonctions parent() et parents() de jQuery

En JavaScript, les possibilités de manipulation des contenus et des styles d’une page HTML sont quasiment infinies. En ajoutant un peu de jQuery, la tâche devient beaucoup plus aisée. Bien que la documentation de jQuery soit très complète et propose des exemples concrets, il m’arrive régulièrement de m’interroger sur le comportement de certaines fonctions dans des cas très particuliers. Aujourd’hui, je me suis amusé avec les fonctions parent() et parents(), je vous partage donc cette petite expérimentation :

Voir la démo – Fonctions parent() et parents() de jQuery

Extrait du code HTML :

<div class="level1 impact">
	Div level 1 (impact)
	<div class="level2">
		Div level 2
		<div class="level3 impact">
			Div level 3 (impact)
			<div class="level4" id="last-tag">
				Div level 4
			</div>
		</div>
	</div>
</div>

Extrait du code JavaScript :

// CAS n°1
// En partant de la balise portant l'id "last-tag"
// pour tous les parents portant la classe "impact"
// fixer la hauteur maximale des blocs à 10px (propriété non-héritée)
$("#last-tag").parents(".impact").css("height", "10px"); // Effet sur la balise sélectionnée uniquement

// CAS n°2
// En partant de la balise portant l'id "last-tag"
// pour tous les parents portant la classe "impact"
// fixer la largeur des blocs à 50% (propriété héritée)
$("#last-tag").parents(".impact").css("width", "50%"); // Effet sur la balise sélectionnée et ses enfants		

// CAS n°3
// En partant de la balise portant l'id "last-tag"
// si le premier parent porte la classe "level2"
// changer la couleur de fond en bleu (propriété non-héritée)
$("#last-tag").parent(".level2").css("background", "blue"); // Aucun effet (#last-tag n'a pas de parent direct .level2)

// CAS n°4
// En partant de la balise portant l'id "last-tag"
// pour le premier parent portant la classe "impact"
// changer la couleur de la bordure en vert (propriété non-héritée)
$("#last-tag").parents(".impact").first().css("border-color", "green"); // Effet sur la balise sélectionnée uniquement

// CAS n°4 BIS
// L'utilisation de closest() à la place de parents().first() produit un comportement similaire
// attention tout de même car closest() part de la balise courante, tandis que parents() part de balise parente
 $("#last-tag").closest(".impact").css("border-color", "green");

Pour le cas n°1, on cherche l’ensemble des parents portant la classe impact et on fixe leur hauteur à 10px. Etant donné que la propriété de hauteur n’est pas héritée par défaut, seuls les blocs level1 et level3 qui portent la classe impact sont affectés. Pour le cas n°2, on réalise la même opération, mais sur une propriété héritable (la largeur), l’ensemble des blocs sous-jacents au bloc impacté de plus haut niveau sont donc affecté. Ici le bloc de plus haut niveau impacté est le level1, ce sont donc tous les blocs qui seront réduit à la moitié de la largeur de leur parent.

Dans la cas n°3, la fonction cherche un parent direct portant la classe level2, comme aucun le parent direct ne rempli pas ce critère, aucune action n’est effectuée. Pour les cas n°4 et 4 bis, on cherche à impacter uniquement le premier parent correspondant au critère de sélection. Attention tout de même, car il existe une différence subtile entre l’utilisation de closest() et parents() : la première fonction partira de l’élément courant, tandis que la deuxième partira de l’élément parent.

Télécharger le fichier source – jquery-parent-parents.html

Vous pouvez retrouver toutes les fonctions de parcours du DOM sur le site de jQuery

Facebooktwitterlinkedinmail

Appréhender LINQ

LINQ pour Language INtegrated Query est un composant du Framework .NET qui permet de requêter à peu prêt tout et n’importe quoi (Objet, XML, Base de données, Entité, …), mais pas toujours évident de s’y retrouver. Alors par où commencer ? Comme toute techno Microsoft qui se respecte, LINQ dispose d’un Getting Started pour C# (ou pour VB) sur le MSDN et les fonctionnalités proposées bénéficient du support de l’IntelliSense dans Visual Studio.

Mais pourquoi LINQ est-il tellement intéressant ? Prenons un petit exemple à travers une simple application console en C# :

public class Etudiant
{
    public string Prenom { get; set; }
    public string Nom { get; set; }
    public List<int> Notes { get; set; }
}

public class Program
{
    static void Main(string[] args)
    {
        // Création de la liste d'étudiants
        var etudiants = new List<Etudiant> {
            new Etudiant {Prenom="Mike", Nom="DOE", Notes=new List {20, 10, 15}},
            new Etudiant {Prenom="Albert", Nom="DURAND", Notes=new List {11, 3, 8}},
            new Etudiant {Prenom="Hans", Nom="MULLER", Notes=new List {11, 13, 15}},
            new Etudiant {Prenom="Juan", Nom="FERNANDEZ", Notes=new List {14, 12, 16}}
        };

        Console.WriteLine("Parcours de la liste telle qu'elle a été créée");
        // Parcours de la liste telle qu'elle a été créée
        foreach (var etudiant in etudiants)
        {
            Console.WriteLine(etudiant.Prenom + " " + etudiant.Nom);
        }

        // Requête LINQ renvoyant la liste des étudiants qui ont une moyenne supérieure ou égale à 10 en les classant par ordre alphabétique
        var requeteLinq = from e in etudiants orderby e.Prenom where e.Notes.Average() >= 10 select new { e, Moyenne = e.Notes.Average() };

        Console.WriteLine();
        Console.WriteLine("Parcours de la liste issue de la requête LINQ");
        // Parcours de la liste issue de la requête LINQ
        foreach (var resultat in requeteLinq.ToList())
        {
            Console.WriteLine(resultat.e.Prenom + " " + resultat.e.Nom + " a " + resultat.Moyenne + " de moyenne.");
        }

        Console.Read();
    }
}

Dans l’extrait de code ci-dessus, la requête LINQ à la ligne 29, nous permet de récupérer les étudiants qui ont une moyenne supérieure ou égale à 10 en les classant par ordre alphabétique (d’après leur prénom) et tout cela en une seule ligne. Bien entendu LINQ dispose de beaucoup d’autres fonctionnalités, et quelque soit votre source de données, vous pourrez la requêter de la même manière.

Télécharger la Solution pour Visual Studio 2013 – TestLinq.zip

Avant de vous laisser vous aventurer dans les profondeurs du code pour découvrir plus en détails les possibilités de LINQ, j’aimerais vous présenter deux logiciels qui pourront vous être utiles. Le premier d’entre eux est LINQPad, cet outil permet de requêter directement une source de données en LINQ. Une fois vos connexions ajoutées (en rouge), vous pouvez sélectionner celle de votre choix (en bleu), puis saisir votre requête LINQ (en jaune) avant de l’exécuter (en vert). Les résultats apparaissent alors dans partie basse (en violet) et il est par exemple possible de voir le code SQL généré (en orange).

LINQPad

Si comme moi, vous êtes plus familier avec SQL qu’avec LINQ, Linqer devrait vous plaire. Il s’agît d’un outil permettant de traduire vos requêtes SQL en LINQ. Il est malheureusement payant, mais les 20 jours proposés gratuitement par la version d’essai devraient être suffisant pour découvrir LINQ. Sur Linqer nous retrouvons l’ajout des connexions (en rouge) et le choix de la connexion courante (en bleu), la zone de saisie pour la requête SQL (en jaune), sa commande d’exécution (en vert) et celle de traduction (en orange). La zone de résultat est elle aussi dans la partie basse (en violet).

Linqer

J’espère que ce premier article un peu plus orienté technique vous a plu, n’hésitez pas à commenter, à donner votre avis ou des vos idées pour de prochains articles.

Facebooktwitterlinkedinmail