Mise en contexte

Le 7 mars 2017 nous a amené la version 2017 de Visual Studio, toujours disponible en version Community, Professional et Enterprise.

Voici donc les fonctionnalités qui ont retenu notre attention et qui vont fort probablement vous aider dans vos projets.

L’installation

Avant même de parler de ce que Visual Studio 2017 va vous apporter, on peut parler de l’installateur, qui a été complètement refait. Il est maintenant plus facile de sélectionner individuellement les composantes que nous avons besoin, ou encore de les ajouter via des “Workloads”, qui sont essentiellement des regroupements de composantes nécessaires selon certains besoins. Par exemple, et vous pouvez le constater avec les captures d’écran ci-bas, le workload “Universal Windows Platform development” nous sélectionnera les versions du framework, le compilateur et tous les outils nécessaires à ce type de projet.

Workloads

Composantes

Un autre élément qu’on peut noter (que vous pouvez voir sur les captures) est qu’il est possible de donner un “nickname” à notre installation. Puisqu’il est possible d’installer deux versions de Visual Studio 2017 sur le même ordinateur (Community et Professional, par exemple), il est donc possible de donner un surnom à l’installation, pour permettre de facilement les distinguer dans le menu de démarrage.

Améliorations de l’IDE

Une des plus grandes améliorations qu’on peut voir dans cette nouvelle version est la performance. Un gros travail d’optimisation a été fait pour réduire le temps de démarrage et le temps de chargement des solutions. Selon Microsoft, le temps de démarrage serait 50% plus rapide qu’avant lors de la première utilisation.

Pour bien le constater, j’ai fait le test de comparer l’ouverture d’une solution sur laquelle j’ai travaillé récemment, qui contenait 15 projets. Pour un temps d’ouverture d’environ 10 secondes avec Visual Studio 2015, on passait à seulement 6 secondes avec la version 2017.

Malgré cette différence assez notable, je me suis demandé si l’option de “Lightweight Solution Load”, qui a été ajoutée pour permettre de charger plus rapidement et pour mieux utiliser la mémoire, pourrait me permettre d’améliorer ce temps. J’ai donc activé l’option pour ma solution (cette option n’est pas activée par défaut) et refait le test, pour en arriver à un temps d’ouverture de 3 secondes.

L’idée en arrière de cette option est de ne pas totalement charger les projets de la solution tant qu’on ne commence pas à les utiliser. La navigation à travers le code pourra donc se faire très rapidement après le démarrage, et il ne sera pas nécessaire d’atteindre que nos 15 projets soient chargés avant de commencer à travailler dans celui où nous voulons faire du code.

Je vous laisse le soin de faire le test avec vos solutions, mais je crois qu’on peut considérer l’objectif de performance comme atteint !

Page de démarrage

Beaucoup de changements sur cette page qui nous est offerte à l’ouverture de l’application. Un premier changement, quoique mineur, est la possibilité de cacher la section “Developer News”. Pour ceux qui ne consultent pas ces nouvelles, cela permettra de laisser toute la place aux récents projets et à la création de nouveaux.

Parlant de nouveaux projets, nous avons là un changement qui sera selon moi le bienvenue pour beaucoup de gens. Dans les versions précédantes de Visual Studio, la création d’un nouveau projet nous ouvrait tout simplement le dialogue de sélection de gabarit de projet.

Avec 2017, une section de la page est maintenant dédiée à la création de projets, en nous permettant de choisir parmis les gabarits de projets récemment utilisés

ou encore avec la barre de recherche de gabarit.

Dans la majorité des cas, il sera donc possible de démarrer un nouveau projet directement à partir de cet écran.

Navigation de code

Beaucoup de choses ont été mises en place pour améliorer la navigation dans notre code.

Go To All

La première est la fonction de “Go To All”, qui nous amène ce dialogue de recherche:

Il est donc possible à partir de cette barre de recherche de chercher à travers tous les types, membres, fichiers et d’accéder à la classe. Plus besoin de naviguer vers la classe en passant par l’explorateur de solution, tout pourra se faire sans que nos doigts quittent le clavier.

Find All References

Le panneau pour trouver toutes les références est fréquemment utilisé pour avoir une liste de toutes les références à une classe ou un objet. Jusqu’à Visual Studio 2017, cette liste de résultats pouvait nous donner l’information sur le projet et le fichier où la référence était, mais simplement par le texte contenu dans la ligne affichée sur la référence.

Souhaitons donc la bienvenue à ce panneau, version améliorée:

On peut tout d’abord remarquer qu’il est possible de grouper les résultats de la recherche. Cette capture montre un groupement par projet puis par définition, mais plusieurs autres options s’offrent à nous pour grouper selon nos besoins. On remarque aussi la colorisation des résultats, pour aider à comprendre le contexte de la référence qui nous est affichée, qu’on retrouve également dans l’affichage de l’extrait du code entourant la référence.

Structure Guide Lines

Dans sa plus simple utilisation, cette fonctionnalité nous permet d’avoir un indicatif visuel pour nous aider à visualiser la strucutre de notre code. La valeur ajoutée de ceci nous vient lorsqu’on dépose le curseur de notre souris sur ces lignes. En effet, une info-bulle nous sera affichée, avec le début de notre bloc de code et de ses blocs parents. Il est donc possible de voir facilement le contexte de notre bloc de code, sans avoir à naviguer de bas en haut et de haut en bas dans notre fichier.

Ouverture de dossiers

La polyvalence faisant partie intégrale de notre métier, il arrive parfois que nous devons travailler sur autre chose qu’une solution faite en .NET. Avec cette nouvelle version de Visual Studio, il nous est maintenant possible d’ouvrir le dossier de ces projets (un projet PHP par exemple), et d’y travailler, avec surbrillance de la syntaxe et beaucoup de fonctionnalités comme la navigation et la recherche à travers le dossier.

Il est même possible d’ouvrir un dossier dans Visual Studio directement à partir de l’explorateur de fichier, avec une nouvelle commande ajoutée au menu contextuel.

Actions rapides et refactoring

Plusieurs options de refactoring se sont ajoutées avec cette nouvelle version, dont certaines reliées aux changements que C#7 apporte. En voici quelques-unes qui ont retenu mon attention, puisqu’avant, il nous était seulement possible de bénéficier de celles-ci avec l’aide d’un outil additionnel comme Resharper.

Simplifier l’initialisation de variables avec un initialiseur

Lorsqu’on a un objet à initialiser avec plusieurs propriétés, il est préférable d’utiliser l’initialiseur, pour vraiment encapsuler l’initialisation de notre variable, et pour éviter de répéter le nom de la variable inutilement. L’option de refactoring vient donc nous aider à rapidement mettre ceci en place, comme vous pouvez le voir avec cette capture d’écran:

Déplacer les variables “out” inline

Une des nouvelles fonctionnalités de C#7 est de pouvoir déclarer les variables “out” directement dans la fonction l’utilisant (un TryParse, par exemple). L’option de refactoring nous est donc offerte par Visual Studio pour simplifier ceci:

Utilisation des expressions de Throw

Une autre des nouvelles fonctionnalités de C#7 est de pouvoir directement lancer une exception avec l’opérateur de fusion Null (null-coalescing), au lieu du traditionnel “if” qui vérifie si la variable est nulle. Visual Studio nous offre donc l’option de faire le refactoring là-dessus, comme démontré ci-dessous:

Déplacer un type vers un fichier correspondant

Il nous arrive parfois, dans le feu de l’action, de déclarer plus d’un type à l’intérieur du même fichier. Avant Visual Studio 2017, pour le déplacer, nous devions passer par l’ajout d’un item dans notre projet, nommé de la même manière que le type en question, couper notre type déclaré et le coller à l’intérieur du nouveau fichier créé, écrasant la déclaration vide. Maintenant, il nous suffit d’utiliser l’option de refactoring que Visual Studio nous offre et le tout se fera automatiquement.

Synchroniser le nom d’un fichier et d’un type

Il nous arrive tous à un moment ou un autre de devoir renommer une classe, et pour garder le nom du fichier identique, il fallait manuellement renommer le fichier au niveau de l’explorateur de solution. Nous avons maintenant la possibilité de faire l’opération de synchroniser les deux, d’un côté comme de l’autre, directement à partir des options de refactoring:

Conversion de String.Format en interpolation de chaîne

C#6 nous avait amené la fonction d’interpolation de chaîne, qui nous permet d’écrire une chaîne de caractères en y insérant des variables inline, au lieu du traditionnel String.Format:

var name = $"Mon nom est {person.FirstName} {person.LastName}";

Il nous est donc possible d’utiliser ceci depuis quelques temps déjà, mais l’option de refactoring vers l’interpolation n’était pas disponible, à moins d’avoir un outil (et des coûts supplémentaires) comme Resharper. Aujourd’hui, l’option nous est finalement accessible:

Filtres sur l’IntelliSense

Une grande amélioration au niveau de l’IntelliSense nous permet maintenant de filtrer ce qui nous est affiché, pour par exemple voir seulement les classes, les structures, ou encore les variables locales. Ces options de filtres sont d’ailleurs accessibles avec des raccourçis de clavier, donc tout ceci peut se faire sans que nos mains quittent le clavier.

Débogage

Run to click

Le temps est breakpoint temporaires, qui servaient seulement à nous amener à un endroit précis lors de débogages, est révolu. Du moment où nous sommes en état d’arrêt à l’intérieur du code, un icône sera accessible à gauche de n’importe quelle ligne où on met notre curseur, et en un simple clic, l’exécution se fera jusqu’à cette ligne:

Assistant d’exception amélioré

Le premier changement que vous pourrez remarquer avec cette nouvelle version d’assistant d’exception est que la fenêtre n’est plus modale.

Un autre aspect très utile concerne les exceptions imbriquées, qui sont maintenant accessibles directement à partir de l’assistant. Plus besoin d’ouvrir l’objet de l’exception pour aller voir sa propriété InnerException (et potentiellement ses exceptions imbriquées).

Le Roaming Extension Manager

Nous avons tous certaines extensions de Visual Studio que nous utilisons partout où nous allons, qu’il faut réinstaller chaque fois qu’on accède un nouveau poste, ou encore si on doit réinstaller notre ordinateur. Grâce au Roaming Extension Manager, les extensions que nous désignerons pour être “roaming” seront automatiquement synchronisées dans le cloud et réinstallées dès que vous serez connectés à votre compte Visual Studio.

Conclusion

Ces changements ne sont qu’une partie des changements que Visual Studio 2017 nous amène. Mais avec le petit survol que nous venons de faire, je crois qu’il est facile de constater que beaucoup d’efforts ont été mis pour améliorer notre expérience d’utilisation et nous faciliter la vie dans notre travail au quotidien.

Les nouvelles fonctionnalités de C# 7.0 expliquées et commentées

Mise en contexte

Le 7 Mars 2017 Microsoft lançait Visual Studio 2017 et du même coup C# 7.0. Depuis que Microsoft a complètement réécrit le compilateur C# en C# de nouvelles fonctionnalités ne cessent d’être ajouté au langage. Le virage Agile que les groupe de produits de Microsoft ont adopté contribuent également à cette effervescence. De plus, Microsoft code maintenant dans l’open source. Vous pouvez d’ailleurs suivre le projet sur GitHub et même qui sait, y contribuer.

C# 6.0 nous avais déjà apporté son lot de nouveautés mais C# 7.0 pousse la note encore plus loin.

J’aimerais vous présenter les nouveautés de C# 7.0 et mon opinion sur leur utilisation.

Les variables de sortie (out variables)

Pour commencer, j’aimerais vous dire que dans la plupart des cas, c’est une mauvaise pratique que d’utiliser des variables out dans vos méthodes. Il existe cependant un cas de figure classique où il est approprié de les utiliser. Il s’agit du try pattern. Dans ce patron la méthode retourne un booléen pour annoncer la réussite de l’action et elle retourne le résultat du traitement dans une variable out. Le plus classique des cas est dans les méthodes TryParse des différents types du Framework.

int index;
if (Int32.TryParse("1", out index))
{
	Console.WriteLine($"Index is {index}");
}

Avant C# 7.0 nous devions absolument déclarer une variable pour contenir le résultat du paramètre out. Maintenant nous pouvons déclarer la variable au moment de sont passage en paramètre.

if (Int32.TryParse("1", out int index))
{
    Console.WriteLine($"Index is {index}");
}

En plus d’éviter de faire une déclaration sur une ligne sans assigner de valeur à la variable, cette méthode permet de restreindre la portée de la variable. En effet, la variable étant déclaré à l’intérieur de la clause conditionnelle elle a une portée définie uniquement à l’intérieur de celle-ci. Dès la sortie du bloc de code associé à la condition, la variable est relâchée.

Le pattern matching

La notion de patterns introduit dans C# 7.0 est une syntaxe qui permet non seulement de tester pour si une variable est d’un certain type mais également pour en extraire la valeur.

Avant C# 7.0 nous aurions écrit :

object o = 1;
if (o is int)
{
    var i = (int)o;
    WriteLine($"o is int = {i}");
}

Maintenant nous pouvons écrire :

object o = 1;
if (o is int i) WriteLine($"o is int = {i}");

Le pattern matching fonctionne aussi dans les switch case. Je tiens à vous mentionner que je n’approuve généralement pas cette pratique. Il est habituellement déconseiller de faire un switch case sur un type. Je vous présente cette fonctionnalité mais, S.V.P. n’allez pas mettre des switch case partout et surtout pas sur des types. Il y plus souvent qu’autrement de meilleures façon de régler ce genre de problème.

Donc voici un exemple d’utilisation :

switch (shape)
{
    case Circle c:
        WriteLine($"circle with radius {c.Radius}, Area: {c.Area()}");
        break;
    case Rectangle r when (r.Length == r.Height):
        WriteLine($"{r.Length} x {r.Height} square, Area: {r.Area()}");
        break;
    case Rectangle r:
        WriteLine($"{r.Length} x {r.Height} rectangle, Area: {r.Area()}");
        break;
    default:
        WriteLine("<unknown shape>");
        break;
    case null:
        throw new ArgumentNullException(nameof(shape));
}

Choses importantes à remarquer :

1. il est possible d’ajouter une clause when pour raffiner encore plus le matching en fonction de propriété de l’objet.
2. l’ordre des clause a de l’importance. Elle seront évaluées dans l’ordre du code.
3. La clause default sera toujours évaluée en dernier peu import son emplacement.
4. Le case null peut être utiliser pour attribuer un traitement spécial si le case est null. S’il n’est pas gérer, il sera traité par la clause default.
5. Tou comme pour les conditions, les déclaration de variables définies dans les case auront une portée limité à celui-ci. C’est pourquoi dans l’exemple, les deux variable r n’entrent pas en conflit.

Les Tuples

La classe System.Tuple<...> existe déjà depuis un bon moment dans le Framework mais son utilisation n’est pas très explicite. L’objet contient des propriétés typées, naturellement, mais pas nommées. Pour accéder aux valeur il faut utiliser les propriétés Item1, Item2, …

La solution à ce problème est généralement réglé en créant une classe pour contenir les propriété en question. Par exemple :

class ActionResult
{
    public bool IsFailed { get; set; }
    public string Message { get; set; }
}

Cette classe n’as pas vraiment beaucoup de valeur. À part être utilisée comme conteneur de donnée dans l’exemple suivant :

static ActionResult ProcessOld()
{
    return new ActionResult()
    {
        IsFailed = true,
        Message = "Not Found"
    };
}

L’ajout des Tuples en tant que citoyen de premier ordre dans C# 7.0 permet de simplifier le code tout en restant explicite tant au niveau du type de données que du nom. Nous pouvons maintenant écrire :

static (bool IsFailed, string Message) ProcesNew()
{
    return (true, "Not Found");
}

Cette méthode déclare plusieurs valeur de retour typées et nommées. Il y a plusieurs façon d’appeler cette méthode pour en recevoir le contenu.

Un première méthode est de déclarer une variable implicitement typée. Comme cette technique crée un System.Tuple il est possible d’utiliser les propriétés Item1 et Item2 mais C# 7.0 permet également d’utiliser les propriétés IsFailed et Message.

var newResult = ProcesNew();
if (newResult.Item1) WriteLine(newResult.Item2); // tuple standard
if (newResult.IsFailed) WriteLine(newResult.Message); // named properties

Il est également possible de créer une déclaration explicit des types de retour. Cette méthode a l’inconvénient de ne plus permettre d’utiliser les noms de propriété définis par la méthode. Seul les propriétés Item1 et Item2 sont disponibles.

(bool, string) explicitResult = ProcesNew();
if (explicitResult.Item1) WriteLine(explicitResult.Item2);

Par contre, il est possible de créer une déclaration explicit et de renommer les membres du Tuple.

(bool HasFailed, string Reason) renamed = ProcesNew();
if (renamed.HasFailed) WriteLine(renamed.Reason);

Une autre fonctionnalité permet de faire les choses différemment. En utilisant la déconstruction d’objet, que nous verrons plus tard, nous pouvons assigner le retour à des variable locale directement.

(bool hasFailed, string reason) = ProcesNew();
if (hasFailed) WriteLine(reason);

On peut même le faire avec une déclaration implicite si on veut pas avoir à définir les types manuellement.

var (HasFailed, Reason) = ProcesNew();
if (HasFailed) WriteLine(Reason);

Comme vous pouvez le constater, les Tuples offrent pleins de possibilités. Pour l’instant je ne suis pas certains quelle méthode je préfère. Par conséquent, je vous invite à être prudent en utilisant ces nouvelle fonctionnalités. Soyez certains que vous aurez des commentaires de vos collègues de travail qui se demanderons ce que vous essayer de faire avec ça.

NOTE: Pour bénéficier des tuples vou devez ajouter le package NuGet System.ValueTuple

La déconstruction d’objets

La déconstruction d’objet de C# 7.0 permet de séparer un tuple ou n’importe quel objet en ses constituants et les assigner à des variables individuelles.

La déconstruction peut prendre la forme d’une déclaration individuelle des variables:

(string firstName, string _, string lastName) = person;
WriteLine($"{lastName}, {firstName} ({_})");

Le caractère “_” est utilisé pour ignorer un des constituants de la déconstruction. Il peut aussi être utiliser comme une variable sans pour autant entrer en conflit.

L’utilisation de var peut éviter de nommer les types de retour. Cette déclaration peut être utiliser de deux façon différente. À l’intérieur de la déclaration:

(var firstName, var _, var lastName) = person;
WriteLine($"{lastName}, {firstName} ({_})");

ou à l’extérieur:

var (firstName, _, lastName) = person;
WriteLine($"{lastName}, {firstName} ({_})");

On peut évidemment aussi assigner lae résultat de la déconstruction à des variable existante:

string firstName, middleName, lastName;
(firstName, middleName, lastName) = person;
WriteLine($"{lastName}, {firstName} ({_})");

Tout ça est bien beau mais il faut quand même définir comment faire la déconstruction d’un objet. Pour ce faire, vous devez ajouter une méthode nommé Desconstructor. Cette méthode ne dois que déclarer des paramètres out.

public class Person
{
    public string FirstName { get; set; }
    public string MiddleName { get; set; }
    public string LastName { get; set; }

    public Person(string firstName, string middleName, string lastName)
    {
        FirstName = firstName;
        MiddleName = middleName;
        LastName = lastName;
    }

    public void Deconstruct(out string firstName, out string middleName, out string lastName)
    {
        firstName = FirstName;
        middleName = MiddleName;
        lastName = LastName;
    }
}

Il est commun dans ce cas d’avoir un symétrie entre la construction et la déconstruction de l’objet.

Les fonctions locale

Parfois il serait utile de pouvoir définir une fonction d’aide pour simplifier le code. Mais avant C# 7.0 la seule option était de définir une fonction privé, qui sera visible d’ailleurs dans la classe, ou une expression lambda qui peut ne pas être aussi explicit au niveau de la définition.

C# 7.0 permet de créer des fonction locale à même la porté d’une méthode. Cette fonction a accès aux variable déclaré à l’intérieur de sa méthode. Par exemple ici nous essayons de faire un simple tri:

private static void Sort(int[] numbers)
{
    for(int i = 0; i < numbers.Length - 1; i++)
    {
        for (int j = i + 1; j < numbers.Length; j++)
        {
            if (numbers[i] > numbers[j])
            {
                var temp = numbers[j];
                numbers[j] = numbers[i];
                numbers[i] = temp;
            }
        }
    }
}

Pour éviter d’ajouter un commentaire pour expliquer ce qu’on essai de faire à l’intérieur de la condition nous pouvons créer une fonction locale pour exprimer qu’il s’agit d’un swap.

private static void Sort(int[] numbers)
{
    for (int i = 0; i < numbers.Length - 1; i++)
    {
        for (int j = i + 1; j < numbers.Length; j++)
        {
            if (numbers[i] > numbers[j])
            {
                Swap(i, j);
            }
        }
    }

    void Swap(int a, int b)
    {
        var temp = numbers[b];
        numbers[b] = numbers[a];
        numbers[a] = temp;
    }
}

Comme la fonction swap est définie au même niveau que le paramètre number de la méthode Sort, elle a accès à son contenu directement sans avoir à le passer en paramètre.

De meilleures déclarations de valeur littérale

Le caractère “_” peut maintenant être utilisé à l’intérieur de n’importe quelle expression de valeur numérique pour améliorer la lisibilité nombres plus long.

var d = 1_234_567;
var x = 0xAA_BB_CC_DD_EE_FF;

Il peuvent être littéralement utilisé n’importe où (sauf au début et à la fin) et n’ont aucun effet sur la valeur.

var d1 = 1__________2___3____4;
var d2 = 1234;

Ces deux valeurs sont identiques.

C# 7.0 introduit également une nouvelle déclaration littérale pour les nombres binaires.

var b = 0b1010_1011_1100_1101_1110_1111;

Les retour de fonction par référence (Ref returns)

Vous souvenez-vous de vos cours sur les pointeurs. En C# on a peut oublié que ça existait. On a appris qu’il y a des type référence et des types valeur et que c’est ce qui dictait l’effet d’un changement sur une valeur de l’un ou l’autre de ces types.

Mais il semble que dans certaines situation particulière, les jeux par exemple, qu’il soit utile pour un fonction de retourner la référence à une valeur. Prenons par exemple le cas d’une méthode de recherche dans un array qui retourne l’élément trouvé par référence.

public static ref int Find(int number, int[] numbers)
{
    for (int i = 0; i < numbers.Length; i++)
    {
        if (numbers[i] == number)
        {
            return ref numbers[i]; // return the storage location, not the value
        }
    }
    throw new IndexOutOfRangeException($"{nameof(number)} not found");
}

Si on passe un array a cette fonction on peut trouver l’élément et changer sa valeur en assignant une nouvelle valeur à l’élément retourné.

int[] array = { 1, 15, -39, 0, 7, 14, -12 };
ref int found = ref Find(7, array); // aliases 7's place in the array
found = 9; // replaces 7 with 9 in the array

Après cette opération, la variable array contient les éléments 1, 15, -39, 0, 9, 14, -12. L’assignation de la valeur 9 à l’élément trouvé remplace directement la case mémoire de l’array à la position trouvée.

Les corps de membre sous forme d’expression

C# 6.0 a introduit le concept de corp de membre sous forme d’expression pour les méthode et les propriété. Ce fut un succès Microsoft a décidé d’ajouter la possibilité d’utiliser ce concept ailleurs. Nous pouvons maintenant le faire pour les accesseurs, les constructeurs et les finaliseurs.

class Person
{
    private static ConcurrentDictionary<int, string> names = new ConcurrentDictionary<int, string>();
    private int id = names.Count;

    public Person(string name) => names.TryAdd(id, name); // constructors
    ~Person() => names.TryRemove(id, out _);              // destructors
    public string Name
    {
        get => names[id];                                 // getters
        set => names[id] = value;                         // setters
    }
}

L’expression throw

Traditionnellement le mot clé throw a toujours été traité comme un statement. Il est maintenant possible avec C# 7.0 de l’utiliser comme une expression.

class Person
{
    public string Name { get; }
    public Person(string name) => Name = name ?? throw new ArgumentNullException(nameof(name));
    public string GetFirstName() => throw new NotImplementedException();
    public string GetLastName()
    {
        var parts = Name.Split(' ');
        return (parts.Length > 1) ? parts[1] : throw new InvalidOperationException("No space!");
    }
}

Conclusion

C# 7.0 ajoute beaucoup de nouvelles fonctionnalités. Certaines sont bénéfique et d’autre sont pour le moins dangereuse. Je vous invite à explorer ces nouvelles fonctionnalités avec précaution. Elle peuvent vous faire économiser quelque ligne de code mais elle peuvent aussi vous faire appliquer de mauvaise pratique de programmation.

Dans cet épisode, nous parlons du patron de conception le singleton. Bien qu’il existe plusieurs façon de l’implémenter, .NET nous offre une façon facile et sécuritaire de le faire.

Visitez le http://bracketshow.com

https://github.com/BracketShow/SingletonPattern

Dans cet épisode nous verrons ce qu’est le patron de conception “composite” et comment s’en servir avec quelques exemples de code utilisable dans une vraie application.

Visitez le http://bracketshow.com

https://github.com/BracketShow/CompositePatternDemo
https://en.wikipedia.org/wiki/Composite_pattern

Hugo Doyon (https://www.linkedin.com/in/hugodoyon/) nous parle de Protractor, un framework pour écrire vos test web automatisés, et de SauceLabs, un service en ligne pour exécuter vos tests sur plus de 800 combinaision de navigateur, OS et résolution.

Visitez le http://bracketshow.com

Liens mentionnés dans cet épisode:
http://www.protractortest.org
https://saucelabs.com/
https://jasmine.github.io/
http://www.seleniumhq.org/
https://jenkins.io/
https://www.jetbrains.com/teamcity/
https://www.browserstack.com/
https://github.com/HugoDoyon/Angular2-Protractor4-End2EndTesting-Examples
https://github.com/johnpapa/lite-server