Wilfried Woivré & .Net

4 novembre 2009

C# 4.0 : Le mot clef dynamic et la Reflexion

Classé dans : .Net, C#, F#, Interoptabilité — Mots-clefs :, , , — Wilfried Woivre @ 23:31
 

Comme vous avez du en entendre parler une des grandes nouveautés de la version 4 du framework est le mot clef dynamic. Celui-ci permet de simplifier l’utilisation de la réflexion dans les applis .Net.

On va voir dans cet article les différentes façon d’utiliser la réflexion entre la 2.0 et la 4.0. Pour l’exécution de ces diverses méthodes, nous allons utiliser la réflexion sur une DLL, réalisé en F#, dont le contenu fortement complexe est le suivant :

 

module Module1

type Multiplication(val1, val2) =
    let result = val1 * val2
    member obj.Result = result

 

Commençons donc par le tout début, c’est à dire avec un bon vieux InvokeMember, comme on peut le voir ci-dessous :

Type Module = Assembly.LoadFrom("CalcLibrary.dll").GetType("Module1");
Type Multiplication = Module.GetNestedType("Multiplication");
object multiplication = Activator.CreateInstance(Multiplication, new object[2] { val1, val2 });
PropertyInfo propertyResult = multiplication.GetType().GetProperty("Result");
txbResult.Text = propertyResult.GetValue(multiplication, null).ToString();

On obtient donc dans notre jolie interface le bon résultat comme on peut le voir aussi, et heureusement j’ai envie de dire :

 image

Bon malgré le fait que cette réflexion ne soit pas trop poussé, on se rappelle tout de suite que c’est toujours très verbeux. Heureusement, le mot clef dynamic arrive.

 

On voit donc qu’on charge toujours notre DLL, que l’on crée une instance, non pas cette fois dans une variable de type object, mais de type dynamic, grâce à laquelle on a directement accès à la propriété Result.

 

Type Module = Assembly.LoadFrom("CalcLibrary.dll").GetType("Module1");
Type Multiplication = Module.GetNestedType("Multiplication");
dynamic multiplication = Activator.CreateInstance(Multiplication, new object[2] { val1, val2 });
txbResult.Text = multiplication.Result.ToString();

Et notre fenêtre donne toujours le bon résultat :

image

Bien entendu, le mot clef dynamic est à utiliser à bon escient, mais je suppose que je n’ai pas besoin de vous le rappeler ! Donc surtout dans les phases de réflexion, et l’interopérabilité avec le monde COM

Donc pas de solution cette fois-ci encore, tout le code est là ! Je tâcherais de vous faire une petite présentation de F# bientôt (si j’ai un peu de temps …)

19 octobre 2009

Visual Studio 2010 Beta 2

Classé dans : .Net, Outils, Visual Studio — Mots-clefs :, , — Wilfried Woivre @ 21:19

 

Alors pour tous les abonnées MSDN ou Technet qui ne l’auraient pas encore vu, la nouvelle mouture de Visual Studio 2010 est sortie ! Comment mieux commencer la semaine je dirais.

image

image

Alors déjà petit changement, le nom, on ne voit aucune Team Suite à l’horizon, mais une version “Ultimate” que je me suis bien entendu empresser d’installer, surtout avec un ISO d’à peine 2,3Go. Lors de l’installation on peut voir qu’il y a enfin des plugins intéressants intégrés dans l’application, soit ASP.Net MVC 2 et Silverlight 3. Oui bon on a vu, je suis toujours un développeur Web, et j’installe toujours tout en full.

Maintenant que nous avons installé nos quelques Gigaoctets d’application, nous pouvons voir une interface similaire à celle de la Beta , cependant celle ci est beaucoup plus claire comme on peut le voir

image

Voilà, cependant je vous laisse découvrir le reste, je ne veux absolument pas vous gâcher la surprise. Je tâcherais cependant de vous donner des impressions plus poussé après une utilisation intensive de cette version.

Notons tout de même, que la version RTM de Visual Studio 2010 est lancé officiellement le 22 mars 2010.

1 octobre 2009

Trucs et astuces : Le débuggeur Visual Studio

Classé dans : Divers, Visual Studio — Mots-clefs :, — Wilfried Woivre @ 17:51

Alors je suppose que comme tout le monde qui passe par ici, vous devez utiliser comme IDE Visual Studio, cet outil que vous trouvez probablement magique, tant au point de vu de la facilité d’utilisation, et surtout à l’utilitaire de Debug intégré en natif à cet IDE.

Mais connaissez-vous toutes les possibilités que vous avez sur ce logiciel, sûrement que non. Et moi aussi d’ailleurs, et pourtant j’ai beau l’utiliser tous les jours, je ne suis même pas sûr d’utiliser plus de 50% de ces capacités.

Alors, je voulais vous faire partager une petite astuce qui je pense vous simplifieras grandement la vie, du moins pendant vos longues heures de debuggage. Il s’agit de personnaliser l’affichage de votre debuggeur dans vos fenêtres espions. En effet, je suppose, que vous êtes comme moi susceptibles de créer vos propres classes, si ce n’est pas le cas, un cours sur la POO ne vous ferait pas de mal, enfin bref, du coup, par défaut vos espions ressemblent souvent à ceci :

image

Bon là comme on voit, malgré le fait que l’on sache ce que contient les objets p1 et p2 vu que c’est écrit au dessus, il sera tout de même pratique de faire comme pour la liste de personnes afficher des éléments de l’objet Personne afin d’avoir rapidement un aperçu de celui dans notre débuggeur.

Et bien heureusement, Visual Studio est là pour nous aider, il nous faut ajouter cet attribut à la classe Personne :

[DebuggerDisplay("Nom : {Nom}, Prénom : {Prenom}")]
public class Personne
{
    public String Nom { get; set; }
    public String Prenom { get; set; }
    public int Age { get; set; }
}

Alors notre chaine de caractère en attribut permet d’afficher les valeurs des propriétés Nom et Prenom dans notre débuggeur. La syntaxe est assez simple, il faut écrire “{PropertyName}” pour afficher la valeur de PropertyName.

On a donc comme résultat à l’exécution :

image

On peut donc voir que cela permet de visualiser très facilement nos entités sans avoir à déployer les détails de celle-ci.

Et voilà une astuce utile qui j’espère vous servira dans vos développements futurs.

18 septembre 2009

LINQPad : L’éditeur LINQ par excellence

Classé dans : Divers, Outils — Mots-clefs :, , — Wilfried Woivre @ 08:48

Alors LINQPad est un utilitaire gratuit que vous pouvez retrouver sur le site : http://linqpad.net

C’est un logiciel, bien entendu gratuit, on peut néanmoins l’acheter pour avoir une option supplémentaire (l’intellisense)

Vous pouvez via ce logiciel ajouter diverses connexions, que ce soit base de données SQL, un schéma Linq To Sql, ou un schéma Entity Framework. De plus, il comporte de multiples exemples pour vous familiariser avec la syntaxe Linq, dont ceux de Linq In Action.  Voici une petite image de l’interface.

image

Pour ma part, j’utilise ce logiciel pour créer la plupart de mes requêtes assez complexes (les simples à force je connais) qui se trouvent dans des couches inférieures de mes applications. Voilà, amusez vous bien avec cet outil.

16 septembre 2009

Entity Framework 4 : Générer des scripts Sql

Classé dans : C#, Entity Framework, Sql — Mots-clefs :, , , — Wilfried Woivre @ 08:28

/* Ce post a été écrit avec la version Visual Studio 2010 Beta et la CTP1 d’Entity Framework, il se peut donc qu’il ne soit plus valable lorsque vous le lirez */

Dans la version actuelle du Framework, soit la 3.5 SP1, Microsoft nous a offert Entity Framework qui est certes très puissants, mais tout de même incomplet au niveau de certaines fonctionnalités. Bien entendu, je pense à la création du script Sql ou de la base de données associée au schéma que nous avons créé. Heureusement la version 4 approchant à grand pas, avec son lot de fonctionnalité pour nous faciliter la vie, surtout sur ce point de vue.

 

Avant tout vous pouvez télécharger la version de EF4 CTP1 à cette adresse : http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=7fd7164e-9e73-43f7-90ab-5b2bf2577ac9

Et il vous faudra bien entendu Visual Studio 2010 Beta et un Sql Serveur 2008 pour que cette fonctionnalité puisse fonctionner correctement. N’oublions pas que c’est une CTP, nous n’avons qu’à espérer qu’il supporte aussi les anciennes versions de Sql (2000 & 2005)

Alors commençons par créer une application console afin d’effectuer cette démonstration, puis rajoutons notre fichier edmx en utilisant un modèle vide. Nous avons donc le designer de notre fichier vierge, ou nous pouvons ajouter les éléments que l’on souhaite. On va donc créer ici nos différents objets que l’on se servira dans notre application.

Alors prenons un modèle assez simple tel que celui ci :

image

On peut donc voir une relation n-aire entre des employés et leur entreprise, de plus on voit ici l’apparition du champ Adresse qui est un type complexe que j’ai crée comme on peut le voir dans ces propriétés :

image

Ce champ complexe contient divers autres champs. Cette possibilité aussi arrivé avec EF4 vous permettra d’extraire différents champs communs à vos tables afin de créer un objet associés à ceux ci sans pour autant à avoir à créer une table pour ceux ci. Comme typiquement ce champ adresse qui peut se retrouver aussi bien chez un contact, un employé, une entreprise, un fournisseur et qui pourtant n’a aucun lieu dans le modèle à être séparé de ces tables. image

Maintenant que nous nous sommes crée notre schéma qui va bien, que nous avons modifié certaines propriétés de notre modèle, tel que par exemple notre Entity Set Name, nous pouvons passer à la génération du script. Donc comme je l’aime bien dans Visual Studio, cette opération se trouve fortement complexe, et n’est pas disponible à ceux qui ne fouillent pas dans l’application. Mais sinon faites un clic droit et “Generate Database Script from Model …”

 

image

Donc après vous avoir choisi votre base de données, il vous génère votre fichier sql , il ne vous reste plus qu’à l’exécuter et vérifier le résultat :

image

On voit donc bien nos deux tables avec notre type complexe inclus à l’intérieur de chacune d’elle.

 

Alors pour conclure, on peut dire que cette possibilité de génération était une chose tant attendu à Entity Framework, puisque effectivement ça manquait encore à sa panoplie de compétence. Mais ceci est réglé à présent ! De plus, cela peut permettre de construire des bases de données avec une notion beaucoup plus objets grâce aux types complexes ! Cette nouvelle mouture d’Entity Framework correspond bien à l’ancienne, innovante, pratique, et bientôt indispensable pour toutes les applications.

22 août 2009

Silverlight 3 : le contrôle DataForm

Classé dans : C#, Silverlight, XAML — Mots-clefs :, , , , — Wilfried Woivre @ 10:25

Dans cet article, je vais vous présenter les fonctionnalités du DataForm, vous pouvez trouver ce composant dans le Silverlight Toolkit présent sur codeplex

Alors commençons par notre entité que nous allons afficher :

public class Personne
 {
     public string Nom { get; set; }
     public string Prenom { get; set; }
     public int Age { get; set; }
     public string Mail { get; set; }
 }

Donc jusque là une entité classique que l’on peut retrouver dans beaucoup d’application (surtout celle de démonstrations ….)

Et un code XAML de ce type :

  <UserControl.Resources>
      <local:Personne Age="23"
                      Nom="Woivré"
                      Prenom="Wilfried"
                      Mail="wilfried.woivre@gmail.com"
                      x:Key="MaPersonne" />
  </UserControl.Resources>
<Grid x:Name="LayoutRoot" Width="400" Height="400">
  <dataFormToolkit:DataForm CurrentItem="{StaticResource MaPersonne}"></dataFormToolkit:DataForm>
</Grid>

On obtient donc rien qu’avec cela une fenêtre éditable de mon entité personne, comme on peut le voir sur l’image ci dessous

image

Maintenant, c’est bien beau, mais actuellement, notre DataForm a lié l’intégralité de notre entité, qui est donc modifiable par l’utilisateur, on peut donc se service des attributs Editable et Display pour personnaliser notre DataForm. ATTENTION, dans les anciennes versions de Silverlight Toolkit, ces attributs étaient présent sous la nom de Bindable.

[Display(AutoGenerateField=false)]
public string Nom { get; set; }
[Editable(false)]
public string Prenom { get; set; }
public int Age { get; set; }
[Display(Name="E mail")]
public string Mail { get; set; }

L’élément Display contient divers arguments pour personnalisez comme vous le souhaiter votre DataForm.

image

On obtient donc le résultat suivant à l’affichage

image

Maintenant, pour savoir lorsque notre entité change ou est en train de changer, on peut bien entendu s’abonner aux différents évènements du DataForm pour exécuter nos différentes opérations. Cependant on peut aussi utiliser l’interface IEditableObject sur notre entité comme ceci :

public class Personne : IEditableObject
{
    #region Properties

    [Display(AutoGenerateField=false)]
    public string Nom { get; set; }
    [Editable(false)]
    public string Prenom { get; set; }
    public int Age { get; set; }
    [Display(Name="E mail")]
    public string Mail { get; set; }

    #endregion

    #region IEditableObject Members

    public void BeginEdit()
    {
    }

    public void CancelEdit()
    {
    }

    public void EndEdit()
    {
    }

    #endregion

On peut donc gérer notre entité directement ainsi pour gérer nos opérations sur cette entité en question.

Maintenant voyons comment se comporte le DataForm avec une liste d’objet que l’on peut déclarer de la sorte :

public ObservableCollection<Personne> MesPersonnes { get; set; }
public MainPage()
{
    InitializeComponent();
    MesPersonnes = new ObservableCollection<Personne>()
    {
        new Personne(){
            Nom = "Woivré",
            Prenom = "Wilfried",
            Age = 23,
            Mail ="wilfried.woivre@gmail.com"
        },
        new Personne(){
            Nom = "Pera",
            Prenom = "Alexis",
            Age = 22
        },
        new Personne(){
            Nom = "Payet",
            Prenom = "Patrick",
            Age = 26
        }
    };

    this.Loaded += new RoutedEventHandler(MainPage_Loaded);
}

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
    this.DataContext = this;
}
<Grid x:Name="LayoutRoot" Width="400" Height="400">
  <dataFormToolkit:DataForm ItemsSource="{Binding MesPersonnes}"></dataFormToolkit:DataForm>
</Grid>

Notre DataForm va donc nous créer une liste d’objet dans laquelle on pourra naviguer grâce aux différents boutons situés sur le header du composant comme on peut le voir.

image

Donc comme on peut le voir, on peut bien entendu naviguer, mais aussi rajouter des éléments ou en supprimer.

Alors voilà un petit tour sur les possibilités du DataForm, je vous rappelle que ce contrôle est dans le Silverlight Toolkit ( de la version de  juillet, dans ce cas ), il est donc susceptible d’évoluer encore un peu !

Ressource :

Une petite vidéo de Mike Taulty sur le DataForm : http://silverlight.net/learn/learnvideo.aspx?video=187317 dans une version précédente celle de juillet, donc il y a quelques changements à effectuer si vous voulez reproduire la démonstration !

12 août 2009

Silverlight 3.0 et les .Net RIA Services

Classé dans : ASP.Net, C#, Entity Framework, Silverlight — Mots-clefs :, , , , , — Wilfried Woivre @ 06:48

Dans la continuité d’un de mes articles sur Silverlight et les différents moyens d’accéder aux données soit via l’utilisation du JSon, ou par des services Web (WCF …). Il en manquait inévitablement un sur les .Net RIA Services.

 

Alors les .Net RIA Services en deux mots, qu’est-ce que c’est, c’est une nouvelle mouture d’ADO.Net pour Silverlight. En effet, lors de la conception d’application Silverlight, on avait vu que cela péchait pour récupérer les données, vu que Silverlight est une technologie cliente. Il fallait donc, comme le montre le schéma ci-dessous  pour accéder aux données contenues dans notre base depuis notre interface, passer par le code métier et ensuite, via un service arrivé à notre base de données pour effectuer la requête. C’est donc ce que l’on appelle une architecture n-tiers, facile à implémenter et facilement maintenable.

 image

Cependant ce découpage est bien souvent pas respecté pour beaucoup de projets, il n’est donc pas rare de voir les différentes parties clientes mélangées, ainsi que le côté serveur pour des questions de rapidité de développement. On a donc généralement une architecture de ce type pour finir.

image

Cette facilité de développement, j’avoue peut être intéressante dans l’instant lorsque l’on n’a absolument pas l’habitude de bien séparer les diverses couches d’une application, ou que l’on ne veut pas implémenter de Design Pattern (comme le MVVM) dans son projet en plus. Néanmoins, la reprise de tel projet par la suite est d’autant plus dur …

 

Alors maintenant, voyons comment nous structurons nos données avec .Net RIA Services

image

Bon maintenant que nous avons vu comment est construit une application Silverlight utilisant les .Net RIA Services, on va pouvoir en faire une.

Alors pour base de données, je vais prendre celle de NorthWind non modifié, vous pouvez la trouver à ce lien si vous ne l’avez pas.

Alors pour commencer nous allons créer une nouvelle application Silverlight de type Business Application. Ce type d’application est ajouté après avoir installer les .Net RIA Services.

 

Maintenant que notre projet est créé, nous allons accéder à notre base, donc dans notre projet ASP.Net, nous allons créer cet accès avec Entity Framework,  avec lequel nous allons récupérer tous les employés de la base Northwind. Donc jusque là, rien de bien anormal par rapport à un autre projet Silverlight que vous auriez pu faire avant.

Maintenant, toujours dans le projet ASP.Net, nous allons créer un nouvel item qui s’appelle “Domain Service Class”, on peut le trouver dans la partie Web, comme on peut le voir ci dessous :

image

Maintenant, nous avons un deuxième écran qui nous demande quels éléments seront disponibles du côté client. Pour la démonstration, nous allons donc choisir les “Employees”, et la possibilité d’éditer ceux-ci.

image

Cette classe nous génère donc entre autre ce code ci :

    // Implements application logic using the NorthwindEntities context.
    // TODO: Add your application logic to these methods or in additional methods.
    [EnableClientAccess()]
    public class NorthwindDomainService : LinqToEntitiesDomainService<NorthwindEntities>
    {

        // TODO: Consider
        // 1. Adding parameters to this method and constraining returned results, and/or
        // 2. Adding query methods taking different parameters.
        public IQueryable<Employees> GetEmployees()
        {
            return this.Context.Employees;
        }

        public void InsertEmployees(Employees employees)
        {
            this.Context.AddToEmployees(employees);
        }

        public void UpdateEmployees(Employees currentEmployees)
        {
            this.Context.AttachAsModified(currentEmployees, this.ChangeSet.GetOriginal(currentEmployees));
        }

        public void DeleteEmployees(Employees employees)
        {
            if ((employees.EntityState == EntityState.Detached))
            {
                this.Context.Attach(employees);
            }
            this.Context.DeleteObject(employees);
        }
    }
}

Comme on peut le voir, cette action nous permet de générer tous ce qu’il faut pour lire et modifier des employés de la base, bien entendu rien ne vous empêche d’en rajouter, pour des questions de performances, comme par exemple, une partie qui ne retourne seulement 10 employés de la base au lieu de toute la base.

L’autre partie qui est généré sont les metadatas nécessaire pour le bon fonctionnement de la communication avec les .Net RIA Services.

Donc maintenant qu’on a crée notre partie accès aux données, ainsi que notre code métier, et le service pour accéder à nos données, nous n’avons plus qu’à gérer le côté client en Silverlight.

Alors commençons par la partie XAML, pour notre exemple, nous allons afficher les noms et les prénoms des employés de la base de données :

                <ListBox ItemsSource="{Binding}" Margin="0,50,0,0" Height="300">
                    <ListBox.ItemTemplate>
                        <DataTemplate>
                            <StackPanel Orientation="Horizontal" >
                                <TextBlock Text="{Binding FirstName}"
                           Width="250" />
                                <TextBlock Text="{Binding LastName}" />
                            </StackPanel>
                        </DataTemplate>
                    </ListBox.ItemTemplate>
                </ListBox>

 

Nous allons maintenant charger les données depuis la base grâce aux RIA Services :

private void Page_Loaded(object sender, RoutedEventArgs e)
{
    var context = new NorthwindDomainContext();
    DataContext = context.Employees;
    context.Load(context.GetEmployeesQuery());
}

Nous chargeons les données de façon assez simple, grâce à une requête Linq, ou à la méthode context.GetEmployeesQuery() qui renvoie ceci :

public EntityQuery<Employees> GetEmployeesQuery()
{
    return base.CreateQuery<Employees>("GetEmployees", null, false, true);
}

Soit toutes les données de la table Employees.

Bien entendu, toutes ces opérations avec .Net RIA Services sont asynchrone afin que l’application reste fluide pour l’utilisateur.

 

Alors pour conclure sur cet article, et sur cette technologie, les .Net RIA Services sont très puissant pour toutes les applications Business, néanmoins la faille que je vois par rapport à un service classique en WCF, c’est que les .Net RIA Services sont orientés uniquement pour Silverlight, alors qu’un service WCF permet de partager l’accès aux services entre divers types d’application.

 

Voilà bien entendu je vous fournis le code source de l’application, il faudra bien entendu changer la chaine de connexion à la base de données.

image

Ressouces :

Un très bon lien sur .Net RIA Services que je vous conseille : http://blogs.msdn.com/brada/archive/tags/RIAServices/default.aspx

31 juillet 2009

MVVM Template en WPF et Silverlight

Classé dans : C#, Design pattern, Silverlight, WPF, XAML — Mots-clefs :, , , , , , — Wilfried Woivre @ 23:53

Bonjour à tous,

Alors je publie cet article vu le nombre de personne qui visitent mon blog pour les données sur le MVVM, j’espère avant tout qu’elles vous sont précieuses !

En fait durant mes différentes recherches sur le MVVM, principalement sur des projets de template pour réaliser des démonstrations, ou pour créer des projets plus rapidement avant de décider à implémenter mon propre projet de Template qui sera peut être publié un jour (si vous êtes sages !)

 

Vous pouvez donc retrouver un très bon Template sur le MVVM sur le site de codeplex à l’adresse : http://wpf.codeplex.com

 

Maintenant pour Silverlight et WPF, vous avez celui sur le site de Galasoft : http://www.galasoft.ch/mvvm/install/publish.html 

Alors rapidement avant que je ne vois des gens choqués sur mon blog, ces deux templates référence une dll de Galasoft, qui gère le MVVM, néanmoins si vous n’avez pas besoin de changer le comportement de son Toolkit, il suffit amplement pour des projets d’entreprise et de démonstration entre autre. Cependant voici un aperçu de sa dll : http://www.galasoft.ch/mvvm/getstarted/

 

Et voilà, en espérant que cela vous sera utile pour des développements futurs !

C# et les méthodes d’extensions

Classé dans : C# — Mots-clefs :, — Wilfried Woivre @ 22:49

Alors pour ceux qui me connaissent du moins dans le monde du travail, vous savez que je n’aime pas redévelopper la roue à chaque projet.

Depuis la version 3 de C#, le langage s’est doté d’un outil que je trouve très puissant, ce sont les méthodes d’extensions. Le but en 2 lignes c’est de permettre d’ajouter des méthodes à des classes existantes du Framework ou de librairies que vous intégrez dans votre code.

Enfin le mieux est un petit exemple, je pense !

 

Imaginons que pour une sauvegarde quelconque, vous ayez besoin, d’enlevez tous les espaces, et tous les accents d’une chaîne saisie par l’utilisateur.

Bon l’on peut trouver sur Internet très rapidement cette fonction :

/// <summary>
/// Fonction de conversion de chaîne accentué en chaîne sans accent
/// http://www.csharpfr.com/codes/CONVERTIR-CHAINE-CARACTERES-CHAINE-SANS-ACCENT_34235.aspx
/// </summary>
/// <param name="chaine">La chaine à convertir</param>
/// <returns>string</returns>
private string convertirChaineSansAccent(string chaine)
{
    // Déclaration de variables
    string accent = "ÀÁÂÃÄÅàáâãäåÒÓÔÕÖØòóôõöøÈÉÊËèéêëÌÍÎÏìíîïÙÚÛÜùúûüÿÑñÇç";
    string sansAccent = "AAAAAAaaaaaaOOOOOOooooooEEEEeeeeIIIIiiiiUUUUuuuuyNnCc";

    // Conversion des chaines en tableaux de caractères
    char[] tableauSansAccent = sansAccent.ToCharArray();
    char[] tableauAccent = accent.ToCharArray();

    // Pour chaque accent
    for (int i = 0; i < accent.Length; i++)
    {
        // Remplacement de l'accent par son équivalent sans accent dans la chaîne de caractères
        chaine = chaine.Replace(tableauAccent[i].ToString(), tableauSansAccent[i].ToString());
    }

    // Retour du résultat
    return chaine;
}

Donc dans un projet, on peut supposer que l’on met cette classe en statique dans une bibliothèques “Tools” ou quelque chose de ce genre.

Donc pas de problème, on sait que cette méthode existe, maintenant prenons le cas qu’un autre développeur arrive sur le projet et ne connaissent pas l’existence de cette méthode, ce qu’il fait, c’est soit rechercher dans la documentation technique l’implémentation d’une telle méthode, soit il recherche dans le code avant de développer.

Mais depuis cette nouvelle version de C#, qui certes commence à être assez ancienne, les méthodes d’extensions sont apparus, on peut donc changer le code de la façon suivante :

class Program
{
    static void Main(string[] args)
    {
        String sOut;
        String sIn = "ÀÁÂÃÄÅàáâãäåÒÓÔÕÖØòóôõöøÈÉÊËèéêëÌÍÎÏìíîïÙÚÛÜùúûüÿÑñÇç";
        sOut = sIn.convertirChaineSansAccent();

    }
}

public static class StringExtensions
{
    /// <summary>
    /// Fonction de conversion de chaîne accentué en chaîne sans accent
    /// </summary>
    /// <param name="chaine">La chaine à convertir</param>
    /// <returns>string</returns>
    public static string convertirChaineSansAccent(this String chaine)
    {
        // Déclaration de variables
        string accent = "ÀÁÂÃÄÅàáâãäåÒÓÔÕÖØòóôõöøÈÉÊËèéêëÌÍÎÏìíîïÙÚÛÜùúûüÿÑñÇç";
        string sansAccent = "AAAAAAaaaaaaOOOOOOooooooEEEEeeeeIIIIiiiiUUUUuuuuyNnCc";

        // Conversion des chaines en tableaux de caractères
        char[] tableauSansAccent = sansAccent.ToCharArray();
        char[] tableauAccent = accent.ToCharArray();

        // Pour chaque accent
        for (int i = 0; i < accent.Length; i++)
        {
            // Remplacement de l'accent par son équivalent sans accent dans la chaîne de caractères
            chaine = chaine.Replace(tableauAccent[i].ToString(), tableauSansAccent[i].ToString());
        }

        return chaine;
    }
}

Alors analysons les changements apportés, à priori rien au niveau de l’algorithme, aucun changement apparent.

Nous voyons en fait que c’est le prototype de la méthode qui a surtout changé, en effet la méthode est maintenant static, et l’on voit apparaître comme paramètre :

this String chaine

 

En fait c’est grâce à ce paramètre que l’on peut réaliser une méthode d’extensions sur la classe String.

Et les méthodes d’extensions seront visibles directement dans l’intellisense comme vous pouvez le voir :

image

 

Bien entendu, vous voyez cette méthode d’extensions, si vous avez ajouté le bon namespace à votre classe !

Après pour des raisons de facilité d’organisation des méthodes d’extensions de projet, ce que je fais je nomme ma classe StringExtensions pour les méthodes d’extensions de la classe String. De plus, toutes mes méthodes d’extensions sont dans un projet personnel que je garde, je n’ai qu’à ajouter les dll, ou ce projet à d’autres projets plus conséquents afin de pouvoir l’utiliser dans tout mes développements.

14 juillet 2009

Azure : Les prix US et leurs disponibilités

Classé dans : Windows Azure — Mots-clefs : — Wilfried Woivre @ 22:27

Et bien comme prévu, j’ai dis que je vous donnerai les prix pour Azure, ils sont sorti lors de la Worldwide Partner Conference de cette année.

 

Vous pouvez voir les prix sur l’article de ZeCloud : http://www.zecloud.fr/post/2009/07/14/Azure-Les-prix-US-et-la-disponibilite.aspx

Publié sur WordPress.