Nouveautés du Langage C# 3

Les évolutions du langage C# 3 permettent une simplification d’écriture, une manipulation simplifiée et plus avancée des données.

Déclaration de variables :

Avant, pour déclarer un objet on devait précéder le nom de la variable par le type de l’objet. Maintenant, on peut utiliser le mot clé « var » (Attention il n’a rien à voir avec le var du VB). Ceci est possible grâce à l’inférence de type pour les variables locales :
var client = new Client(); » au lieu de « Client client = new Client();»

Les initialisations d'objets :

Il suffit d’appeler les propriétés et d'attribuer les données à la volée. Il s'agit plus d'une présentation d'écriture que d'une évolution du langage. Cela permet de diminuer le nombre de lignes pour faire l’affection et d'avoir une meilleure lisibilité du code puisque l’on peut voir les propriétés et leurs valeurs plus facilement.

Capacites capa = new Capacites{Id = 1 ,Boire=true,Dormir=false,Mange=true};

Les Expressions lambdas :

En C# 2 on utilisait un délégué (delegate) ou un prédicat sur la méthode « FindAll » d'une liste, par exemple, pour sortir tous les éléments de la liste qui correspondaient à un critère précis.
Il s'agit d'écrire d'une façon plus simple les méthodes anonymes :

C#2 :
string result = liste.Find(delegate(string tmp) { return tmp == “test”; });

C#3 :
string result = liste.Find(tmp => tmp == “test”);

Une technique pour faire une somme, trouve un maximum un minimum d’un type énumérable :

int tabint = { 0, 2, 5, 8, 12, 18 };

Console.WriteLine("Sum : {0}", tabint.Sum());

Console.WriteLine("Max : {0}", tabint.Max());

Console.WriteLine("Min : {0}", tabint.Min());

Les types anonymes :

On peut créer des objets sans déclarer la classe. On instancie un objet sans connaître son type de départ.
Cependant on connaît ses propriétés lors de la création, ce “AnonymousType” sera ensuite utilisable dans tous le reste de l'application.

var anonyme= new { Id = 1, Nom = "Guillaume", Age = 23 };

Si l’objet créé est une collection d’objets, une syntaxe particulière est prévue :

var liste = new List<Client> {anonyme};

La méthode d'extension:

Elle permet de rajouter des méthodes à des classes existantes. Par exemple, si vous vouliez avoir votre propre librairie de méthodes dites « utiles », vous aviez souvent à passer par de nouvelles classes. Ici, vous pourrez directement ajouter une méthode à votre classe de base, par exemple à la classe « String ». Pour cela, il faut que la méthode déclarée soit « static » et prenne en paramètre la classe à étendre avec en préfixe le mot clé « this ».

public static string UpperClean(this string s) {
return s.ToUpper().Trim();
} 
string s = “ test ”;
Console.WriteLine(s.UpperClean());
$> “TEST”;

Linq:

Il s’agit du nouveau framework de manipulation de données en .Net. Il est composé de plusieurs parties :
• Une pour le XML (LINQ to XML).
• Une pour les objets (LINQ to ENTITIES).
• Une pour le SQL (LINQ to SQL).

En plus de cela, linq intègre désormais aux collections une partie de ses possibilités grâce aux opérateurs standards d’interrogation (Standard Query Operators) :

IEnumerable<int> indices =
products.
Select((product, index) => new { product, index }).
Where(x => x.product.UnitPrice >= 10).
Select(x => x.index);

LINQ to SQL permettra de faire de la persistance objet. L’objet de base à invoquer est une classe du type

DataClasseDataContext

On aura créé et mappé au préalable une table personne en base de données et en code c#.

 [global :: System.Data.Linq.Table(Name="dbo.Personnes")]
public partial class Personnes  {
private int _id; 
public Personnes() {
this._id = default(int);
} 
 [global :: System.Data.Linq.Column(Storage="_id", Name="id", DBType="Int NOT NULL IDENTITY", IsPrimaryKey=true, IsDBGenerated=true, CanBeNull=false)] 
public int id { 
get { 
return this._id; 
}
}
}

On remarque un système d’annotation similaire à Hibernate en Java pour la déclaration des champs et de la base. Pour rapatrier tous les enregistrements on récupère d’abord la table et on interroge la table grâce à une requête LINQ.

Table<Personnes> table_personne = context.GetTable<Personnes>();
var in_db = from e in table_personne
select e;

Si je veux récupérer, par exemple, toutes les personnes dont le nom contient « Netapsys », je peux utiliser cette syntaxe :

var res = from r in table_personne
where r.nom.Contains("Netapsys")
select r;

La simplicité d’utilisation de cette syntaxe revient à faire un like % en base de données, On peut d’ailleurs voir toutes les requêtes en redirigeant les logs du contexte sur la sortie standard. Et pour finir cet article, regardons l’insertion en base de données d’une personne et la sauvegarde des changements.

Personnes personne = new Personnes { nom = "NewPrenom", prenom="NewPrenom"};
context.Personnes.Add(personne);
context.SubmitChanges();

Un commentaire

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.