WAPTK – Windows Azure Platform Training Kit

La meilleure méthode pour apprendre et comprendre Windows Azure est certainement de parcourir le WAPTK. Il est très régulièrement mis à jour et contient des ressources variées : présentations, démonstrations, exercices. Certains exercices sont complexes et vont bien au-delà d’un “hello, world” sur chaque fonctionnalité.

Windows Azure, méthode OnStart et variables statiques

Avec un Worker Role, la méthode OnStart qui initialise une variable statique et la méthode Run qui utilise cette variable :

Tout se passe comme prévu : Visual Studio s’arrête logiquement dans OnStart, puis dans Run. La variable check récupérée dans Run a bien comme valeur “true”.

Cependant, avec un code similaire pour un Web Role :

Et, depuis une page quelconque :

On voit que notre initialisation de variable “check” est perdue. La raison est simple : dans un Web Role, le processus qui exécute la méthode OnStart (WaIISHost.exe) n’est pas le même que celui de l’instance du Web Role (le “classique” w3wp.exe). Les variables statiques étant partagées entre les threads d’un même processus mais pas entre plusieurs processus, ils ne voient pas la même variable “check”.

Par ailleurs, Visual Studio 2010 donne une indication lors du passage dans le point d’arrêt de la page : un point d’exclamation au niveau du point d’arrêt signale que le processus a changé.

La documentation ne précise pas ce point, mais indique que pour un Web Role, le code d’initialisation peut être placé dans Application_Start plutôt que dans OnStart. Certainement une bonne pratique à suivre !

Méthodes d’extension pour IEnumerable<T>

Une fois passée la période d’adaptation nécessaire pour s’habituer aux méthodes d’extension de System.Linq et aux lambda expressions, la manipulation de collections devient plus facile. Pour appliquer un traitement à une collection, plutôt que de parcourir manuellement la collection au moyen d’une boucle quelconque, une méthode est appelée directement sur l’objet collection et des délégués permettent de spécifier le traitement à appliquer sur chaque élément de la collection.

Ainsi, de nombreuses méthodes (Foreach, Count, Cast, Select, Where etc.), permettent d’adresser la plupart des cas simples, mais on peut très bien imaginer en ajouter de nouvelles très simplement. Des exemples de nouvelles méthodes :

• For, pour appliquer un traitement à la collection en disposant de l’index
• DoWhere, pour appliquer un traitement uniquement sur les éléments satisfaisant une certaine condition, sans modifier la collection elle-même
• DoWhile, pour appliquer un traitement tant que les éléments satisfont une certaine condition, sans modifier la condition elle-même.

Ce qui donne :

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<TSource> For<TSource>(
            this IEnumerable<TSource> source,
            Action<TSource, int> todo)
        {
            int i = 0;
            foreach (TSource item in source)
            {
                todo(item, i);
                i++;
            }
            return source;
        }

        public static IEnumerable<TSource> DoWhere<TSource>(
            this IEnumerable<TSource> source,
            Action<TSource> todo,
            Predicate<TSource> condition)
        {
            foreach (TSource item in source)
            {
                if (condition(item))
                {
                    todo(item);
                }
            }
            return source;
        }

        public static IEnumerable<TSource> DoWhile<TSource>(
            this IEnumerable<TSource> source,
            Action<TSource> todo,
            Predicate<TSource> condition)
        {
            foreach (TSource item in source)
            {
                if (condition(item))
                {
                    todo(item);
                }
                else break;
            }
            return source;
        }
    }
}

namespace TestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> integers = new List<int>()
                {0, 1, 4, 9, 16, 25};
            integers
                .For((value, index) => Console.WriteLine("Index : {0}, value : {1}", index, value))
                .DoWhere(i => Console.WriteLine("{0} modulo 2 = 0", i), i => i % 2 == 0)
                .DoWhile(i => Console.WriteLine("{0} < 10", i), i => i < 10);
        }
    }
}

Et le résultat dans la console :

 

Il est facile d’imaginer un ensemble de nouvelles méthodes utilitaires permettant d’aboutir réellement à un fonctionnement où la collection serait le point de départ de n’importe quel traitement de données. D’ailleurs, certains outils comme le fameux fichier dynamic.cs de Dynamic LINQ proposent exactement ce genre de fonctionnalités.

Extraits de code pour propriétés sous Visual Studio

En passant de Visual Studio 2005 à Visual Studio 2008 ou 2010, on remarque très vite que l’extrait de code “prop” a été remplacé pour implémenter une propriété automatique :

public string Name { get; set; }

Néanmoins, il arrive régulièrement que le champ associé à la propriété doive être déclaré explicitement, comme avec Visual Studio 2005. Modifier le code de la propriété automatique est alors pénible. Dans Visual Studio 2010, on dispose d’un nouvel extrait de code pour cela : “propfull”. On obtient alors le résultat souhaité :

private string name;

public string Name
{
    get { return name; }
    set { name = value; }
}

Pour ceux qui voudrait le même fonctionnement avec Visual Studio 2008, il suffit de rajouter un fichier nommé “propfull.snippet” dans “<Mes Document>/Visual Studio 2008/Code Snippets\Visual C#\My Code Snippets” contenant le code suivant :

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>propfull</Title>
            <Shortcut>propfull</Shortcut>
            <Description>Extrait de code pour la propriété et le champ de stockage</Description>
            <Author>Microsoft Corporation</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Type de propriété</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Nom de la propriété</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>
                <Literal>
                    <ID>field</ID>
                    <ToolTip>La variable qui stocke cette propriété</ToolTip>
                    <Default>myVar</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp"><![CDATA[private $type$ $field$;

    public $type$ $property$
    {
        get { return $field$;}
        set { $field$ = value;}
    }
    $end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

D’une façon générale, écrire un extrait de code est une tâche simple. On peut imaginer les exemples suivants :

• Création de l’ensemble des gestionnaires d’évènements pour une Page ou un UserControl en ASP.NET (Page_Init, Page_Load, etc.)


• Création d’une propriété dont le set teste si la “value” est différente de la valeur existante et qui appelle “NotifyPropertyChanged”, dans le cas typique d’applications WPF ou Silverlight


• D’une façon plus générale, création de classes ou de membres respectant les recommandations élaborées par l’architecte dans le cadre d’un projet. Il peut s’agir par exemple de créer une nouvelle classe de service devant implémenter certaines interfaces et déclarant un membre représentant le contexte de données en l’initialisant dans le constructeur par défaut.

Débogage de code source du Framework .NET

La fonction de débogage de code source du Framework .NET est disponible depuis longtemps dans Visual Studio, mais reste méconnue. Elle peut néanmoins être utile dans certaines situations. A titre d’exemple, lors de l’utilisation des classes de System.IO, de nombreuses exceptions peuvent être levées. Même si la documentation donne des informations utiles, il est parfois difficile d’identifier précisément la cause du problème.

L’option permettant de déboguer des classes du Framework .NET n’est pas activée par défaut, sans doute parce qu’elle peut entraîner une perte de performance du débogueur. Pour l’activer, il suffit d’aller dans Outils –> Options –> Débogage –> Général et de cocher la case correspondante :

Visual Studio 2010 vous prévient que ceci nécessite le téléchargement des fichiers .pdb correspondants aux assemblies du Framework .NET, par exemple :

 

Même si tous les fichiers de symboles ne sont pas disponibles pour toutes les assemblies du Framework .NET, les assemblies principales sont disponibles :

Pour permettre au débogueur de parcourir les classes du Framework, une dernière action est nécessaire : le chargement des symboles pour l’assembly souhaitée (ici, mscorlib) :

Le pas-à-pas détaillé permet de se rendre directement dans le constructeur de FileInfo :

Utiliser un diagramme de couches pour interdire l’utilisation d’un type particulier

Etant donné que, dans les diagrammes de couches de Visual Studio 2010, une couche peut être liée à n’importe quel élément de code, la présence d’un type dans le diagramme sans aucun lien provenant d’une autre couche permet d’interdire l’utilisation d’un type en particulier.

Par exemple, supposons qu’on veuille interdire l’utilisation de la classe ArrayList, en vue typiquement d’inciter l’utilisation de sa version générique List<T>. Le navigateur de l’architecture permet d’aller chercher dans l’assembly mscorlib.dll (par la fonction “sélectionner les fichiers…”) le type ArrayList, et de créer la couche correspondante à cette classe par simple drag&drop :

 

Valider l’architecture sur le code :

permet d’obtenir l’erreur attendue :

Feature Pack 2 de Visual Studio 2010

L’arrivée du Feature Pack 2 de Visual Studio 2010 repousse encore un petit peu plus loin les fonctionnalités disponibles, notamment pour la version Ultimate. Il est désormais possible d’utiliser le Test Manager avec Silverlight 4, et des améliorations ont été apportées aux diagrammes des projets de modélisation.