Microsoft vient de publier pour les abonnés MSDN et Technet, la RTM de Microsoft Office 2010. Parmi toutes les nouveautés de PowerPoint 2010, l’exportation des présentations en vidéos me plait bien, mais très limité dans sa version actuelle (au niveau de l’interface utilisateur). En effet, il est possible d’exporter uniquement en format WMV9 (VC1), si vous souhaitez un autre format, il vous faudra procéder à un ré encodage de votre vidéo. Et seulement 3 tailles d’images sont disponibles, et il n’est également pas possible de choisir son Frame rate. Pour exporter une présentation en vidéo dans PowerPoint, allez dans le menu Fichier | Enregistrer et envoyer | Créer une vidéo.

Nous allons donc voir comment, et très rapidement, exporter une présentation en vidéo avec des paramètres que nous aurons déterminé.

Les pré-requis sont Visual Studio 2010, PowerPoint 2010, C# 4.0 (dans cet exemple). Dans Visual Studio, créez un projet d’add-in à PowerPoint 2010, créez par exemple un ruban avec un bouton d’export puis dans le code de ce bouton, utilisez la méthode ci-dessous :

Remarquez l’utilisation des paramètres nommés dans l’appel à la méthode CreateVideo.
Lorsque vous cliquez sur le bouton que vous avez créé, vous obtiendrez le message suivant en bas de la fenêtre de PowerPoint.

Paul Vick (Technical Lead de Visual Basic .NET) et Anders Hejlsberg (Technical Fellow in the Developer Division – Chef designer de C#) l’ont annoncé, Visual Basic et C# vont évoluer ensemble, ce qui signifie que toute nouveauté apportée à un langage sera présente dans l’autre. Cette annonce se justifiera dès Visual Basic 10 et C# 4.0.

Après une telle introduction, je ne peux que vous montrer une nouveauté de C# 4.0 qui est présente dans VB depuis longtemps : les paramètres optionnels.

Voilà comment, en VB.NET, écrire une méthode avec des paramètres optionnels. En utilisant le mot clé Optional.

En C# il fallait écrire une méthode, puis faire un nombre de surcharge conséquent :

Mais il n’était pas possible de passer uniquement les paramètres path et bufferSize sans avoir de paramètres encoding et detectEncoding sans avoir a réécrire des surcharges de méthodes…

Nouveauté C# 4.0 : Il est désormais possible d’utiliser les paramètres optionnels en spécifiant simplement les valeurs qui prennent les variables en cas de non affectation de celle-ci lors de l’appel de la méthode.

Passons maintenant à l’appel d’une méthode avec des paramètres optionnels :

Maintenant, je souhaite appeler la même méthode avec les paramètres bufferSize et path, je vais donc devoir utiliser le nommage des paramètres. En effet, il n’est plus obligatoire de respecter l’ordre des paramètres défini dans l’écriture de la méthode.

Pour résumer :

· Pour créer un paramètre nommé, il suffit d’ajouter la valeur par défaut du paramètre dans la signature de la méthode.

· Lors de l’appel de la méthode, il n’est pas obligatoire de donner les paramètres dans l’ordre mais il faut utiliser le nommage des paramètres : « NomParametre: »

· Utiliser des paramètres optionnels permet d’éviter d’utiliser des surcharges de méthodes inutiles.

Le principe des méthodes partielle est identique aux classes partielles, à savoir séparer les méthodes en 2 parties. La différence avec les classes partielle est que pour les méthodes, nous allons séparer la déclaration de la méthode de son corps. Cela sert surtout pour le travail collaboratif, où bien lorsque vous avez des classes très grandes (si vous trouvez une autre utilité, n’hésitez pas à laisser des commentaires), en effet, vous allez pouvoir mettre dans un fichier toutes les déclarations des méthodes et dans un autre, les corps de ces même méthodes.

Comme pour les classes partielles, nous allons utiliser le mot clé : partial.

Attention ! Il est interdit de mettre un modificateur d’accès aux méthodes partielles, celles-ci sont private par défaut. Il est également obligatoire de déclarer vos méthodes partielles dans une classe ou une structure partielle.

// Fichier Voiture_Declarations.cs

public partial class Voiture

{

    // Déclaration de la méthode Avancer()

    partial void Avancer(Int32 vitesse);

}

// Fichier Voiture_Methodes.cs

public partial class Voiture

{

    // Corps de la méthode Avancer()

    partial void Avancer(Int32 vitesse)

    {

        Console.WriteLine("La voiture avance à {0} km/h", vitesse);

    }

}

La migration du blog étant terminé, il ne reste plus qu'à continuer à vous faire partager mes connaissances en développement .NET.

Ce tutoriel vous présentera plusieurs utilisations des types anonymes en C#.
Commençons par le commencement, qu’est ce qu’un type anonyme ?

Un type anonyme, comme son nom l’indique, est un type dont on ne définira pas le nom de manière explicite. (Oui j’ai cherché très longtemps cette définition) Mais est ce que l’on peut s’en servir si l’on ne lui donne pas de nom ? Et bien le compilateur lui donnera un nom, qui ne nous importe peu. Nous allons nous servir de notre variable uniquement pour encapsuler des propriétés en lecture seule. Le but est d’éviter à avoir à créer une classe ou une structure pour utiliser des variables sans importances dans la conception du projet. Pas de problème pour les types des propriétés que nous allons donner à notre variable, le compilateur définira automatiquement les types.

Utilisation simple :

var voiture = new { Marque = "Aston Martin", Modele = "DB9 v12", Puissance = 450 };

Console.WriteLine(voiture.Marque + " " +

                  voiture.Modele + " " +

                  voiture.Puissance + "cv");

Ce qui nous donne :

Vous remarquez que l’IntelliSense fonctionne très bien avec les types anonymes :

Voyons maintenant ce que Reflector nous affiche :

Déchiffrons un peu tout ce code.

· Premièrement le compilateur génère automatiquement (l’attribut [CompilerGenerated] nous l’indique) dans le projet une nouvelle classe (invisible dans Visual Studio).

o Cette classe est Internal (visible uniquement dans le projet) Sealed (non dérivable)

o Elle porte un nom peu commun J mais qui contient la liste des noms de propriétés que nous avons utilisées pour la création de notre objet.

· Ensuite cette classe comporte trois champs (Marque, Modele et Puissance) en lecture seule.

· Le constructeur

· Les méthodes de la classe Object (Equals, GetHashCode et ToString)

· Et enfin les propriétés, toujours en lecture seule.

Utilisation avancée avec LINQ

Commençons par écrire une petite classe Voiture :

public class Voiture

{

    public String Marque { get; set; }

    public String Modele { get; set; }

    public Int32 Puissance { get; set; }

}

Si vous ne comprenez pas l’écriture simplifiée de cette classe, reportez-vous à : Exemple de code : Propriétés automatiques (C# 3.5).

Ensuite passons aux choses sérieuses :

// Création d'une collection de voitures

List<Voiture> voitures = new List<Voiture>()

{

    new Voiture() { Marque = "Aston Martin", Modele = "DB9", Puissance = 450 },

    new Voiture() { Marque = "Ferrari", Modele = "F430 Scuderia", Puissance = 510 },

    new Voiture() { Marque = "Aston Martin", Modele = "Vantage V8 Coupé", Puissance = 557 }, 

    new Voiture() { Marque = "Ferrari", Modele = "360 Modena", Puissance = 400 }

};

// Requête LINQ permettant de filtrer les voitures

var query = from v in voitures

            where v.Puissance > 400

            orderby v.Puissance

            select new { v.Marque, v.Modele };

// Affichage des résultats

foreach (var voiture in query)

    Console.WriteLine(voiture.Marque + " " + voiture.Modele);

Déchiffrons un peu :

· Première étape, créer une collection d’objets de type Voiture. A la place de cette étape, vous auriez pu avoir une base de données, mais pour le tutoriel, faisons au plus simple.

· Ensuite, la requête LINQ (Exemple de code : LINQ to Object) permet de filtrer la collection nommée voitures et de récupérer des objets d’un type anonyme constitué de deux propriétés :

select new { v.Marque, v.Modele };

· La dernière étape consiste à affichez la nouvelle liste de voitures que l’on a filtré.

Pourquoi avoir utilisé un type anonyme plutôt que la classe Voiture ?
Et bien cet exemple peut paraître simple, l’utilisation de la classe Voiture aurait pu être plus judicieuse car peut être plus simple à mettre en place, mais dans le cas d’objets avec beaucoup de propriétés, il peut être préférable d’utiliser un type anonyme qui nous permettra de ne récupérer que les informations dont on a besoin.

Remarquez que l’IntelliSense fonctionne très bien :

Reflector nous affiche :

Ce code correspond au même que précédemment mais avec deux propriétés au lieu de trois.

Et nous avons en sortie :

Liste de liens

Liens MSDN :

· Types anonymes (Guide de programmation C#)

· Mise en route de LINQ en C#

· Expressions de requête LINQ (Guide de programmation C#)

Liens internes :

· Exemple de code : LINQ to Object

· Exemple de code : Propriétés automatiques (C# 3.5)

· Exemple de code : Constructeur de classe (C# 3.5)

Dans cet exemple, nous allons voir comment écrire des requêtes paramètrées. Déjà, pourquoi écrire des requêtes paramètrées ? Et bien d’une part pour ne pas se tromper dans l’écriture de la requête, qui n’a jamais oublié des ‘ dans ses applications ? Ensuite il se pose un problème de sécurité, en effet il peut se produire des failles de SQL Injection.

Prennons une table classique d’utilisateurs :

Une simple table avec trois colonnes : Un identifiant, un nom et un prénom.

   1: // Variables quelconques

   2: String lastname = "Lavocat";

   3: String firstname = "Fabien"; 

   4:  

   5: // Chaîne de connexion à la base de données

   6: String cnxStr = System.Configuration.ConfigurationManager.ConnectionStrings[”cnx”].ConnectionString;

   7: // Requête SQL

   8: String sql = "INSERT INTO Users (user_lastname, user_firstname) VALUES ('" + lastname + "', '" + firstname + "')"; 

   9:  

  10: using (System.Data.SqlClient.SqlConnection cnx = new System.Data.SqlClient.SqlConnection(cnxStr))

  11: using (System.Data.SqlClient.SqlCommand cmd = new System.Data.SqlClient.SqlCommand(sql, cnx))

  12: {

  13:     try

  14:     {

  15:         // Ouverture de la connexion

  16:         cnx.Open(); 

  17:         

  18:         // Exécution de la requête sur la base de données

  19:         cmd.ExecuteNonQuery();

  20:     }

  21:     catch (Exception e)

  22:     {

  23:         Console.WriteLine("Erreur : " + e.Message);

  24:     }

  25:     finally

  26:     {

  27:         // Fermeture de la connexion

  28:         if (cnx.State == System.Data.ConnectionState.Open)

  29:             cnx.Close();

  30:     }

  31: } 

Et maintenant en ajoutant des paramètres :

   1: // Variables quelconques

   2: String lastname = "Lavocat";

   3: String firstname = "Fabien"; 

   4:  

   5: // Chaîne de connexion à la base de données

   6: String cnxStr = System.Configuration.ConfigurationManager.ConnectionStrings[”cnx”].ConnectionString;

   7: // Requête SQL avec paramètres

   8: String sql = "INSERT INTO Users (user_lastname, user_firstname) VALUES (@lastname, @firstname)"; 

   9:  

  10: using (System.Data.SqlClient.SqlConnection cnx = new System.Data.SqlClient.SqlConnection(cnxStr))

  11: using (System.Data.SqlClient.SqlCommand cmd = new System.Data.SqlClient.SqlCommand(sql, cnx))

  12: {

  13:     try

  14:     {

  15:         // Ajout des paramètres

  16:         cmd.Parameters.AddWithValue("lastname", lastname);

  17:         cmd.Parameters.AddWithValue("firstname", firstname);   // Ouverture de la connexion

  18:         cnx.Open();  // Exécution de la requête sur la base de données

  19:         cmd.ExecuteNonQuery();

  20:         }

  21:     catch (Exception e)

  22:     {

  23:         Console.WriteLine("Erreur : " + e.Message);

  24:     }

  25:     finally

  26:     {

  27:         // Fermeture de la connexion

  28:         if (cnx.State == System.Data.ConnectionState.Open)

  29:             cnx.Close();

  30:     }

  31: }

Vous remarquez la modification de la requête SQL. En effet j’ai rajouté deux paramètres qui sont des “variables” précédées d’un @.

   1: cmd.Parameters.AddWithValue("lastname", lastname);

   2: cmd.Parameters.AddWithValue("firstname", firstname); 

Ces deux lignes permettent d’affecter à ces paramètres des valeurs.
Note : Le caractère "@" n’est pas obligatoire ici.

Prenons une classe quelconque avec une propriété :

public class MyClass
{
   public String MyProperty { get; set; }
}

Nous allons maintenant voir une nouvelle façon de créer une instance de cette classe en définissant une valeur pour la propriété MyProperty.

MyClass variableA = new MyClass() { MyProperty = "Bonjour" };
MyClass variableB = new MyClass();
variableB.MyProperty = "Bonjour";

Vous remarquez le premier appel du constructeur avec l’assignation de la valeur à la propriété MyProperty est entre accolades.
Quelle est la différence entre ces deux méthodes ? Voyons ce que nous propose Reflector :

MyClass <>g__initLocal0 = new MyClass();
<>g__initLocal0.MyProperty = "Bonjour”;
MyClass variableA = <>g__initLocal0;
MyClass variableB = new MyClass();
variableB.MyProperty = "Bonjour";

Avec ce code, nous pouvons comprendre le mécanisme de création de la variable A. La CLR commence par créer une instance de la classe MyClass en temporaire dans la mémoire de l’ordinateur, ensuite elle affecte une valeur à la propriété MyProperty de la variable temporaire puis si aucune erreur n’est déclenchée, la variable variableA reçoit la référence de la variable temporaire.
Dans la seconde méthode, on créé simplement une nouvelle instance de la classe MyClass que l’on affecte à notre variable variableB puis on change la valeur de sa propriété MyProperty.

En C#2.0, comment faisions-nous pour créer des attributs avec leurs propriétés associées ?

private String _myProperty;

public String MyProperty 

{ 

    get { return this._myProperty; } 

    set { this._myProperty = value; } 

}

Et voilà ce que le logiciel Reflector traduit à partir du code IL généré à la compilation :

private string _myProperty;

public string MyProperty 

{ 

    get 

      { 

        return this._myProperty; 

      } 

    set 

      { 

        this._myProperty = value; 

      } 

}

Vous remarquez que ce sont exactement les même lignes.
Nous allons maintenant utiliser la simplification d’écriture de C#3.5 :

public String MyProperty 

{ 

    get; 

    set; 

}

Il n’est désormais plus nécessaire de créer l’attribut privé ainsi que le contenu des méthodes get et set de la propriété.
Voilà ce que Reflector nous génére à partir du code IL :

public string MyProperty 

{ 

    [CompilerGenerated] 

    get 

      {

        return this.<myproperty>k__backingfield;

      }

    [CompilerGenerated]

    set 

      {

        this.<myproperty>k__BackingField = value;

      }

}

L’attribut [CompilerGenerated] qui est rajouté par le compilateur indique que c’est lui-même (le compilateur) qui as créé le contenu de la méthode. <myproperty>k__backingfield permet à la CLR de récupérer ou modifier la valeur auquel fait référence la propriété étant donné que tout à été généré par le compilateur.

Si vous ne connaissez pas Reflector, je vous conseille de jeter un coup d’oeil sur ce logiciel : http://www.aisto.com/roeder/dotnet/

A la différence de la convertion implicite, la convertion explicite est obligatoire lors qu’il y a un risque de perte de données. On utilise alors le mot clef explicit, ainsi que le type de l’objet cible entre parenthèses. Exemple :

Prennons une classe Euro et une classe Dollar afin de faire des conversions :

public class Euro
{
  public Single Value { get; set; }  public static explicit operator Euro(Dollar value)
  {
    return new Euro() { Value = value.Value * 0.6476f };
  }
}

public class Dollar
{
  public Single Value { get; set; }  public static explicit operator Dollar(Euro value)
  {
    return new Dollar() { Value = value.Value * 1.5435f };
  }
}

La méthode permettant de faire la convertion explicite doit être marquée static et on utilise les mots clefs explicit et operator :

public static explicit operator Type d’arrivée(Type de départ value)
{
  Traitement de la convertion…
}

Voilà comment faire la convertion explicite :

Euro euro = new Euro() { Value = 15 };
Dollar dollar = (Dollar)euro; // Convertion explicite
Console.WriteLine(euro.Value.ToString() + “€ = $” + dollar.Value.ToString());
// Affiche : 15€ = $23.1525

Lien MSDN : http://msdn2.microsoft.com/fr-fr/library/xhbhezf4.aspx

On appelle convertion implicite le fait de convertir un objet d’un certain type en un objet d’un autre type sans préciser le cast. Ce type de convertion doit garantir qu’il n’y ait aucune perte de données.

Ce type de convertion est possible lorsque l’on essaye de convertir un objet d’un type A en un type B si la classe A dérive ou implémente la classe ou l’interface B. Exemple :

L’autre possibilité est l’utilisation du mot clef implicit lors de la déclaration d’un opérateur de convertion. Exemple :
Ici, nous avons une classe nommée MyString qui contient une chaîne de caractère.
public class MyString
{
  private String _value;  public MyString(String value)
  {
    this._value = value;
  }

  public static implicit operator MyString(String value)
  {
    return new MyString(value);
  }

  public override String ToString()
  {
    return this._value;
  }
}

La méthode permettant de faire la convertion implicite doit être marquée static et on utilise les mots clefs implicit et operator :

public static implicit operator Type d’arrivée(Type de départ value)
{
  Traitement de la convertion…
}

Voilà comment faire la convertion implicite :

String s = “Bonjour”;
MyString ms = s; // Convertion implicite
Console.WriteLine(ms); // Affiche : Bonjour

Lien MSDN : http://msdn2.microsoft.com/fr-fr/library/z5z9kes2.aspx

LINQ to XML (anciennement XLINQ) est une technologie permettant de manipuler des fichiers XML plus simplement et plus intuitivement qu’en utilisant les techniques de C#2.0 et précédemment.

Commençons par créer le document XML en mémoire par un code C# :

Les classes XDocument, XElement et XAttribute se trouvent dans le namespace : System.Xml.Linq. Utiliser ces classes est quand même plus simple que l’ancienne méthode et plus lisible surtout. Enfin il ne s’agit que de mon point de vue.

Passons maintenant à requête LINQ :

// Récupération de toutes les voitures dont la puissance est supérieure à 500cv
// Vous remarquerez l’utilisation de la méthode d’extention GetPower()
var search = from car in cars.Descendants(“car”) // Tous les éléments “car”
             where car.Element(“Puissance”).Value.GetPower() > 500
             select car.Attribute(“Immatriculation”).Value + ” est une ” +
                    car.Element(“Marque”).Value + ” “ +
                    car.Element(“Modèle”).Value + ” puissance “ +
                    car.Element(“Puissance”).Value + ” prix : “ +
                    car.Element(“Prix”).Value + “€”;

Si vous avez essayé l’exemple de code LINQ to Object, vous ne serez pas dépaysé par l’écriture de la requête. Donc ici je cherche dans tous les éléments “car” dont la puissance est supérieure à 500 cv. Pour cela, j’ai créé une méthode d’extention de la classe String, nommée GetPower. Voilà son implémentation :

public static class ExtendMethods
{
 ///
 /// Méthode d’extention permettant de récupérer la puissance
 /// d’une voiture à partir d’une chaîne de caractère
 ///
 public static Int32 GetPower(this String entry)
 {
  String power = entry.Replace(“cv”, “”);
  Int32 result;
  if (Int32.TryParse(power, out result))
    return result;
  else
    return 0;
 }
}

Cette méthode d’extention, retire “cv” de la chaîne de caractère et fait une convertion en Int32.

Maintenant, on affiche le résultat :

foreach (var item in search)
  Console.WriteLine(item);

Et voilà ce que l’on a dans la console :

1234AB33 est une Aston Martin Vantage V8 Coupé puissance 557cv prix : 110.000,00€
9012EF33 est une Ferrari F430 Scuderia puissance 510cv prix : 207.900,00€
Appuyez sur une touche pour continuer…

Lien MSDN : http://msdn2.microsoft.com/fr-fr/library/bb387098.aspx