La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

C# 4.0 et les améliorations à la BCL Découvrez le framework.NET 4.0 : les apports au langage Quelques améliorations de la « Base Class Library » Découvrez.

Présentations similaires


Présentation au sujet: "C# 4.0 et les améliorations à la BCL Découvrez le framework.NET 4.0 : les apports au langage Quelques améliorations de la « Base Class Library » Découvrez."— Transcription de la présentation:

1 C# 4.0 et les améliorations à la BCL Découvrez le framework.NET 4.0 : les apports au langage Quelques améliorations de la « Base Class Library » Découvrez le framework.NET 4.0 : les apports au langage Quelques améliorations de la « Base Class Library » Pierre-Emmanuel Dautreppe – 04 Mars 2010 –

2 2 Evolution du langage C# 1.0 (Nov. 2001) C# 2.0 (Oct. 2005) C# 3.5 (3.0: Nov. 2006) (3.5: Nov. 2007) (3.5sp1: Nov.2008) C# 3.5 : LINQ et méthodes lambdas LINQ Programmation déclarative Concis, mais statiquement typé Méthodes Lambdas Programmation fonctionnelle Meta-Programmation Le code devient une donnée Expression Trees C# 3.5 : LINQ et méthodes lambdas LINQ Programmation déclarative Concis, mais statiquement typé Méthodes Lambdas Programmation fonctionnelle Meta-Programmation Le code devient une donnée Expression Trees C# 2.0 : Génériques Apparition des génériques : type safety Correction de manques Types nullables Classes statiques Simplifications Méthodes anonymes Itérateurs (yield) C# 2.0 : Génériques Apparition des génériques : type safety Correction de manques Types nullables Classes statiques Simplifications Méthodes anonymes Itérateurs (yield) C# 1.0 : Toute la base Code Managé Common Type System Programmation Orientée Objets Méthodes, Propriétés, Indexeurs, Evènements Compatibilité avec autres technologies Interopérabilité COM P/Invoke Code Unsafe C# 1.0 : Toute la base Code Managé Common Type System Programmation Orientée Objets Méthodes, Propriétés, Indexeurs, Evènements Compatibilité avec autres technologies Interopérabilité COM P/Invoke Code Unsafe

3 3 Tendances dévolution de.NET Programmation Déclarative Progammation Dynamique Concurrence / Parallélisation Programmation Déclarative Quoi Comment ImpératifDéclaratif from i in list where i > 10 orderby i select i foreach ( int i in list ) if ( i > 10 ) result.Add(i); result.Sort(); Programmation Dynamique Concurrence / Parallélisation Architectures multi-cœur Serveurs multi-processeurs Tirer parti de lamélioration possible des performances en se reposant sur des frameworks en programmant différement Simplifier la prise en compte de la parallélisation Concurrence / Parallélisation Architectures multi-cœur Serveurs multi-processeurs Tirer parti de lamélioration possible des performances en se reposant sur des frameworks en programmant différement Simplifier la prise en compte de la parallélisation

4 4 Agenda C# 1.0 C# 2.0 C# 3.0 C# 1.0 C# 2.0 C# 3.0 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion

5 5 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion

6 6 Co & Contra Variance – Définition Contravariance Un opérateur de conversion de type est contravariant sil ordonne les types du plus générique au plus spécifique Covariance Un opérateur de conversion de type est covariant sil ordonne les types du plus spécifique au plus générique Si tu me fournis une SqlCommand, alors je peux me contenter de la traiter comme une DbCommand Si tu sais comparer deux « object », alors tu sauras aussi comparer deux « EventArgs ». Ainsi, si tu as besoin dun comparateur dEventArgs, alors je peux te donner un comparateur dobjet

7 7 Co & Contra Variance – Les delegates – 1/2 public class Employé { } public class Développeur : Employé { } class Program { static Employé CréeEmployé() { return null; } static Développeur CréeDéveloppeur() { return null; } static void Main(string[] args) { var créeEmployé = new Func (CréeEmployé); Employé employé1 = créeEmployé(); var créeDeveloppeur = new Func (CréeDéveloppeur); Employé employé2 = créeDeveloppeur(); } public class Employé { } public class Développeur : Employé { } class Program { static Employé CréeEmployé() { return null; } static Développeur CréeDéveloppeur() { return null; } } Func Les delegates sont covariants

8 8 Co & Contra Variance – Les delegates – 2/2 void MonHandler(object sender, EventArgs e) { } TextBox txtBox = new TextBox(); txtBox.Click += MonHandler; txtBox.KeyDown += MonHandler; TextBox txtBox = new TextBox(); txtBox.Click += txtBox.KeyDown += Les delegates sont contravariants delegate void EventHandler(object sender, EventArgs e); delegate void KeyEventHandler(object sender, KeyEventArgs e);

9 9 Covariance des tableaux string[] strArray = new[] { "A", "B" }; object[] objArray = strArray; objArray[0] = 12; string s = strArray[0]; Les arrays sont covariants… System.ArrayTypeMismatchException …mais pas type safe …mais pas type safe Possible seulement pour les types références Il sagit ici dune conversion par boxing Interdit Possible seulement pour les types références Il sagit ici dune conversion par boxing Interdit int[] intArray = new[] { 1, 2, 3}; object[] objArray = intArray;

10 10 Co & Contra Variance des types génériques – 1/4 Génériques = Sécurité de typage List strArray = new List { "A", "B" }; List objArray = strArray; List strArray = new List { "A", "B" }; IEnumerable objEnum = strArray; Non « Type Safe » donc non covariant Non « Type Safe » donc non covariant « Type Safe » donc covariant

11 11 Co & Contra Variance des types génériques – 2/4 IComparer stringComparer = new MyStringComparer(); IComparer objectComparer = new MyObjectComparer(); TestContravariance(stringComparer); TestContravariance(objectComparer); public class MyObjectComparer : IComparer {... } public class MyStringComparer : IComparer {... } public void TestContravariance(IComparer comparer) { comparer.Compare("chaine 1", "chaine 2"); } IComparer est contravariant IComparer stringComparer = new MyStringComparer(); stringComparer.Compare("chaine 1", "chaine 2"); IComparer objectComparer = new MyObjectComparer(); objectComparer.Compare("chaine 1", "chaine 2")

12 12 Co & Contra Variance des types génériques – 3/4 public interface IEnumerable : IEnumerable { IEnumerator GetEnumerator(); } Mot-clé « out » T ne doit être utilisé que comme type de retour IEnumerable est covariant IEnumerable est considéré comme IEnumerable si conversion de référence de B vers A IEnumerable est considéré comme IEnumerable si conversion de référence de B vers A AB IEnumerable

13 13 Co & Contra Variance des types génériques – 4/4 Mot-clé « in » T ne doit être utilisé que comme paramètre dinput IComparer est contravariant IComparer est considéré comme IComparer si conversion de référence de B vers A IComparer est considéré comme IComparer si conversion de référence de B vers A public interface IComparer { int Compare(T x, T y); } AB IComparer

14 14 Variance en.NET 4.0 System.Collections.Generic.IEnumerable System.Collections.Generic.IEnumerator System.Linq.IQueryable System.Collections.Generic.IComparer System.Collections.Generic.IEqualityComparer System.IComparable System.Collections.Generic.IEnumerable System.Collections.Generic.IEnumerator System.Linq.IQueryable System.Collections.Generic.IComparer System.Collections.Generic.IEqualityComparer System.IComparable System.Func System.Action System.Predicate System.Comparison System.EventHandler System.Func System.Action System.Predicate System.Comparison System.EventHandler Interfaces Delegates

15 15 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion

16 16 Paramètres Optionnels et Nommés – 1/4 FileStream Open(string path, FileMode mode, FileAccess access, FileShare share) FileStream Open(string path, FileMode mode, FileAccess access) FileStream Open(string path, FileMode mode) Une méthode principale Plusieurs overloads Redirection avec des valeurs par défaut

17 17 Paramètres Optionnels et Nommés – 2/4 Methode(10);//Equivalent à Methode(10, 5, 10); Methode(10,, 15);//INTERDIT Methode(10, 2, 15); Methode(10, 2);//Equivalent à Methode(10, 2, 10); public void Methode(int x, int y = 5, int z = 10) { } 2 paramètres optionnels Les paramètres omis doivent être en dernier

18 18 Paramètres Optionnels et Nommés – 3/4 Methode(10, z: 15); Methode(y: 15, x: 10); Methode(y: 15, x: 10, z: 2); Les paramètres nommées doivent être en dernier Les paramètres nommées doivent être en dernier Les paramètres non optionnels doivent être spécifiés Les paramètres nommés peuvent être dans nimporte quel ordre Les paramètres nommés sont évalués dans lordre décriture

19 19 Paramètres Optionnels et Nommés – 4/4 Identique à VB.NET Paramètres optionnels Doivent être des constantes de compilation Valeur par défaut copiée dans lappel Paramètres nommés La compilation se base sur les noms Ne changez pas votre API A utiliser plutôt en temps que client Même question que pour const ou static readonly

20 20 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion

21 21 Exemples appels « dynamiques » avec C# 3.5 object calculator = GetCalculator(); Type calcType = calculator.GetType(); int result = (int)calcType.InvokeMember("Add", BindingFlags.InvokeMethod, null, calculator, new object[] { 10, 20 }); ScriptScope python = Python.CreateRuntime().UseFile("Calculator.py"); ScriptEngine engine = python.Engine; int resultat = (int)engine.Execute ("GetCalculator().Add(10, 20)", python); ScriptObject calc = GetCalculator(); int resultat = (int)calc.Invoke("Add", 10, 20); ScriptObject calc = GetCalculator(); int resultat = (int)calc.Invoke("Add", 10, 20); Calculator calc = GetCalculator(); int resultat = calc.Add(10, 20); Calculator calc = GetCalculator(); int resultat = calc.Add(10, 20); C# C# IronPython Silverlight Javascript Silverlight Javascript

22 22 POCO Binder JavaScript Binder Python Binder Ruby Binder COM Binder IronPythonIronPythonIronRubyIronRubyC#C# Visual Basic Autres…Autres… Dynamic Language Runtime (DLR) Expression Trees Dynamic Dispatch Call Site Caching

23 23 Types dynamiques – 1/3 dynamic calc = GetCalculator(); int resultat = calc.Add(10, 20); dynamic calc = GetCalculator(); int resultat = calc.Add(10, 20); Calculator calc = GetCalculator(); int resultat = calc.Add(10, 20); Calculator calc = GetCalculator(); int resultat = calc.Add(10, 20); Statiquement typé comme dynamic Statiquement typé comme dynamic Appel dynamique de la méthode Appel dynamique de la méthode Conversion dynamique de la valeur de retour Conversion dynamique de la valeur de retour

24 24 Types dynamiques – 2/3 Quand les opérandes sont dynamic… La sélection des membres est différée à lexécution A lexécution, dynamic est remplacé par le type réel de chaque membre Le type de retour de lopération est également dynamic dynamic x = 1; dynamic y = "Bonjour"; dynamic z = new List { 1, 2, 3 }; dynamic x = 1; dynamic y = "Bonjour"; dynamic z = new List { 1, 2, 3 }; Type statique (à la compilation) Type dynamique(à lexécution) dynamicInt32 dynamicString dynamicList

25 25 Types dynamiques – 3/3 public class Calculator { public double Add(double a, double b) {... } public int Add(int a, int b) {... } } public class Calculator { public double Add(double a, double b) {... } public int Add(int a, int b) {... } } Calculator calc = GetCalculator(); double x = 2.25, y = 3.75; double result = calc.Add(x, y); Calculator calc = GetCalculator(); double x = 2.25, y = 3.75; double result = calc.Add(x, y); Calculator calc = GetCalculator(); dynamic x = 2.25, y = 3.75; dynamic result = calc.Add(x, y); Calculator calc = GetCalculator(); dynamic x = 2.25, y = 3.75; dynamic result = calc.Add(x, y); Calculator calc = GetCalculator(); dynamic x = 2, y = 3; dynamic result = calc.Add(x, y); Calculator calc = GetCalculator(); dynamic x = 2, y = 3; dynamic result = calc.Add(x, y); A la compilation : double Add(double, double) A la compilation : double Add(double, double) A lexécution : double Add(double, double) A lexécution : double Add(double, double) A lexécution : int Add(int, int) A lexécution : int Add(int, int)

26 26 Types dynamiques – Points à retenir La résolution des méthodes est différée à lexécution si nécessaire public void Methode(dynamic d) On ne peut pas appeler des méthodes dextensions A savoir (ou non): Nouveaux types de conversion : assignation, structurelle, … dynamic nexiste pas au niveau du code IL

27 27 Types dynamiques – Exemples décritures – 1/2 Ces écritures sont valides dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... IEnumerable enumerable =... dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... IEnumerable enumerable =... dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... IEnumerable enumerable =... List liste =... dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... IEnumerable enumerable =... List liste =... dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... IEnumerable enumerable =... List liste =... class BaseClass { } class Derived : BaseClass { } dynamic MaMethode(int i, dynamic d) {... } dynamic[] monArray =... IEnumerable enumerable =... List liste =... class BaseClass { } class Derived : BaseClass { }

28 28 Types dynamiques – Exemples décritures – 2/2 Ces écritures ne sont pas valides class C : dynamic { } class C : IEnumerable { } class C : dynamic { } class C : IEnumerable { } class C : dynamic { } class C : IEnumerable { } class C where T : BaseClass { } class C : dynamic { } class C : IEnumerable { } class C where T : BaseClass { } Pour plus dinformation : Blog de Chris Burrows

29 29 Créer un type dynamique – 1/2 public class DynamicObject : IDynamicMetaObjectProvider { public virtual IEnumerable GetDynamicMemberNames(); public virtual DynamicMetaObject GetMetaObject(Expression parameter); public virtual bool TryConvert(ConvertBinder binder, out object result); public virtual bool TryDeleteMember(DeleteMemberBinder binder); public virtual bool TryGetMember(GetMemberBinder binder, out object result); public virtual bool TrySetMember(SetMemberBinder binder, object value); public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result); public virtual bool TryUnaryOperation(UnaryOperationBinder binder, out object result);... } Dans System.Core.dll Namespace System.Dynamic Dans System.Core.dll Namespace System.Dynamic IDynamicObject a été renommé IDynamicObject a été renommé

30 30 Créer un type dynamique – 2/2 public class MonDynamicObject : DynamicObject { Dictionary dic = new Dictionary (); public override bool TryGetMember(GetMemberBinder binder, out object result) { return this.dic.TryGetValue(binder.Name, out result); } public override bool TrySetMember(SetMemberBinder binder, object value) { this.dic[binder.Name] = value; return true; } dynamic monObjet = new MonDynamicObject(); monObjet.Nom = "Dautreppe"; monObjet.Prenom = "Pierre-Emmanuel"; Console.WriteLine(monObjet.Prenom + " " + monObjet.Nom);

31 31 Types dynamiques – Utilisation de la classe Expando static void Main() { dynamic personne = new ExpandoObject(); //1. Définir des propriétés personne.Nom = "Dautreppe"; personne.Prenom = "Pierre-Emmanuel"; //2. Définir des méthodes personne.ToString = new Func ( () => personne.Nom + " " + personne.Prenom ); Console.WriteLine(personne.ToString()); //3. Définir un évènement personne.MonEvent = null; personne.OnMonEvent = new Action ((e) => { if (personne.MonEvent != null) personne.MonEvent(personne, e); }); personne.MonEvent += new EventHandler(MonEventHandler); personne.OnMonEvent(EventArgs.Empty); } private static void MonEventHandler(dynamic obj, EventArgs e) { Console.WriteLine("MonEvent appelé sur '" + obj.ToString()); }

32 32 Types dynamiques – Conclusion – 1/2 Que peut-on appeler ? Toute méthode définie sur linstance Méthode publique Méthode protected Méthode private (de linstance) Méthode dinterface (si implémentation implicite) Que ne peut-on pas appeler ? Toute méthode « nexistant pas » sur linstance Méthode private (dune classe de base) Méthode static (quelque soit sa visibilité) Méthode dinterface (si implémentation explicite) Méthode dextension

33 33 Types dynamiques – Conclusion – 2/2 Quand doit-on les utiliser ? Quand on travaille sans type (par ex. réflexion) Quand on fait de linterop COM Silverlight Javascript … Compenser des manques du Framework « INumeric » Quand ne devrait-on pas les utiliser ? Pour compenser une erreur de design Eg Coder en utilisant une classe de base, mais avoir besoin dune connaissance des types dérivés

34 34 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion

35 35 Interopérabilité COM – 1/3 doc.SaveAs("Test.docx"); Paramètres optionnels et nommés object fileName = "Test.docx"; object missing = System.Reflection.Missing.Value; doc.SaveAs(ref fileName, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing); Les APIs COM déclarent des paramètres optionnels « ref » nest plus obligatoire Les APIs COM déclarent des paramètres optionnels « ref » nest plus obligatoire

36 36 Interopérabilité COM – 2/3 COM et dynamic IExcel.Trendlines trendLines = (IExcel.Trendlines)serie.Trendlines(Type.Missing); IExcel.Range cell = (IExcel.Range)sheet.Cells[row, column]; IExcel.Trendlines trendLines = serie.Trendlines(); IExcel.Range cell = sheet.Cells[row, column]; IExcel.Trendlines trendLines = serie.Trendlines(); IExcel.Range cell = sheet.Cells[row, column]; Les APIs COM renvoient des dynamic Conversion dassignation vers le type désiré Les APIs COM renvoient des dynamic Conversion dassignation vers le type désiré

37 37 Interopérabilité COM – 3/3 « No PIA » : Pas de « Primary Interop Assemblies » namespace OfficeApplication { class Program { static void Main(string[] args) { Application excel = new Application(); Worksheet sheet = excel.Sheets.Add(); ChartObjects charts = sheet.ChartObjects(); ChartObject chart = charts.Add(10, 10, 100, 100); SeriesCollection series = chart.Chart.SeriesCollection(); Series serie = series.Add(...); Trendlines trendLines = serie.Trendlines(); Range cell = sheet.Cells[10, 10]; } Par défaut : True

38 38 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion TUples System.IO Fichiers mappés Code Contracts Parallel Extensions System.Numerics TUples System.IO Fichiers mappés Code Contracts Parallel Extensions System.Numerics

39 39 BCL – Tuples – 1/2 public Tuple TryGetElement(string key) { int valeur; bool result = dic.TryGetValue(key, out valeur); return new Tuple (result, valeur); } public static class Tuple { public static Tuple Create (T1 item1); public static Tuple Create (T1 item1, T2 item2); public static Tuple Create (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest); } Supporté nativement par F# et IronPython Supporté nativement par F# et IronPython System.Tuple : Factory de Tuple System.Tuple : Factory de Tuple De 1 à 8 types génériques Typiquement un autre Tuple return Tuple.Create(result, valeur);

40 40 BCL – Tuples – 2/2 « new Tuple » et « Tuple.Create » sont équivalents var a = new Tuple > (1, 2, 3, 4, 5, 6, 7, new Tuple (8, 9)); var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9)); var a = new Tuple > (1, 2, 3, 4, 5, 6, 7, new Tuple (8, 9)); var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9)); Console.WriteLine(a.Item5); // 5 Console.WriteLine(a.Rest.Item2); // 9 var a = new Tuple > (1, 2, 3, 4, 5, 6, 7, new Tuple (8, 9)); var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9)); Console.WriteLine(a.Item5); // 5 Console.WriteLine(a.Rest.Item2); // 9 Console.WriteLine(b.Item5); // 5 Console.WriteLine(b.Rest.Item1.Item2); // 9 p r e s q u e ! ! Rest = Tuple Rest = Tuple >

41 41 BCL – Améliorations à System.IO var errorlines = from file in "*.log") from line in File.ReadLines(file) where line.StartsWith("Error:") select string.Format("File={0}, Line={1}", file, line); errorlines); var errorlines = from file in "*.log") from line in File.ReadAllLines(file) where line.StartsWith("Error:") select string.Format("File={0}, Line={1}", file, line); errorlines); IEnumerable EnumerateFiles(string path, string searchPattern); void WriteAllLines(string path, string[] contents); string[] ReadAllLines(string path); string[] GetFiles(string path, string searchPattern); void WriteAllLines(string path, IEnumerable contents); IEnumerable ReadLines(string path);

42 42 BCL – Fichiers mappés en mémoire – 1/2 Gros Fichier Process 1 Environment.SystemPageSize Vue N Vue 2 Vue 1 Exploite la mémoire paginée du système Taille de la vue <= Mémoire disponible pour mapping (2Gb sur 32 bits) Taille de la vue <= Mémoire disponible pour mapping (2Gb sur 32 bits) Stream (lecture séquentielle) Accessor (lecture aléatoire) Stream (lecture séquentielle) Accessor (lecture aléatoire) Ressource partagée Process 1 Process 2 Vue N Vue 1 Scénario 1 Scénario 2 Gestion de la mémoire par le système Pagination automatique en mémoire Gestion de la mémoire par le système Pagination automatique en mémoire Mémoire partagée Simplification pour IPC ( Inter-Process Communication ) Mémoire partagée Simplification pour IPC ( Inter-Process Communication )

43 43 BCL – Fichiers mappés en mémoire – 2/2 using (var mmf = MemoryMappedFile.CreateNew("FichierMappé", 1000)) { using (var stream = mmf.CreateViewStream()) new BinaryWriter(stream).Write("Bonjour"); var startInfo = new ProcessStartInfo("AutreProcess.exe"); startInfo.UseShellExecute = false; Process.Start(startInfo).WaitForExit(); } using (var mmf = MemoryMappedFile.OpenExisting("FichierMappé")) { using (var stream = mmf.CreateViewStream()) Console.WriteLine(new BinaryReader(stream).ReadString()); } Process 1 Process 2 Ou mmf.CreateViewAccessor

44 44 CodeContracts – 1/2 Permettre lajout de contrats dans le code Disponible dans 3.5 (installation séparée) 4 parties Une nouvelle API System.Diagnostics.Contracts Le « rewriter » (ccrewrite.exe) Injecte le code de vérification des contrats « aux bons endroits » Le « static checker » (cccheck.exe) Analyse le code pour vérifier si les contrats sont respectés Le générateur dassembly (ccrefgen.exe) Produit une DLL avec les contrats seuls

45 45 CodeContracts – 2/2 public class CompteBancaire { private int numeroCompte, modulo; private double solde; public void EffectueDepot(double montant) { this.solde += montant; } static void Main() { var compte = new CompteBancaire { numeroCompte = , modulo = 27 }; compte.EffectueDepot(1000); } public class CompteBancaire { private int numeroCompte, modulo; private double solde; public void EffectueDepot(double montant) { Contract.Requires(montant > 0); this.solde += montant; } static void Main() { var compte = new CompteBancaire { numeroCompte = , modulo = 27 }; compte.EffectueDepot(1000); } public class CompteBancaire { private int numeroCompte, modulo; private double solde; public void EffectueDepot(double montant) { Contract.Requires(montant > 0); Contract.Ensures(ancien solde < nouveau solde); this.solde += montant; } static void Main() { var compte = new CompteBancaire { numeroCompte = , modulo = 27 }; compte.EffectueDepot(1000); } public class CompteBancaire { private int numeroCompte, modulo; private double solde; public void EffectueDepot(double montant) { Contract.Requires(montant > 0); Contract.Ensures(Contract.OldValue(this.solde) < this.solde); this.solde += montant; } static void Main() { var compte = new CompteBancaire { numeroCompte = , modulo = 27 }; compte.EffectueDepot(1000); } public class CompteBancaire { private int numeroCompte, modulo; private double solde; public void EffectueDepot(double montant) { Contract.Requires(montant > 0); Contract.Ensures(Contract.OldValue(this.solde) < this.solde); this.solde += montant; } [ContractInvariantMethod] private void ObjectInvariant() { Contract.Invariant(this.solde >= 0); Contract.Invariant(this.numeroCompte % 97 == this.modulo); } static void Main() { var compte = new CompteBancaire { numeroCompte = , modulo = 27 }; compte.EffectueDepot(1000); } Contract.Requires Pré-condition Evalué « avant » lappel Contract.Ensures Post-condition Evalué « après » lappel Contract.OldValue Retourne la valeur avant lappel ContractInvariantMethod Invariance de lobjet Appelé après chaque appel public Contract.Requires Pré-condition Evalué « avant » lappel Contract.Ensures Post-condition Evalué « après » lappel Contract.OldValue Retourne la valeur avant lappel ContractInvariantMethod Invariance de lobjet Appelé après chaque appel public

46 46 PFX – Parallel Framework Extensions static void Main() { IEnumerable liste = Enumerable.Range(0, ); var query = from i in liste where EstNombrePremier(i) select i; Console.WriteLine(query.Count()); } static bool EstNombrePremier(int p) { int limite = (int)Math.Sqrt(p); for (int i = 2; i <= limite; i++) if (p % i == 0) return false; return true; } Parallel.Invoke(() => RealiseAction1(), () => RealiseAction2(), () => RealiseAction3()); System.Collection.Concurrent BlockingCollection ConcurrentQueue ConcurrentDictionary Lazy System.Threading SemaphoreSlim ManuelResetEventSlim SpinLock Visual Studio Nouveau Debugger Nouveau Profiler System.Collection.Concurrent BlockingCollection ConcurrentQueue ConcurrentDictionary Lazy System.Threading SemaphoreSlim ManuelResetEventSlim SpinLock Visual Studio Nouveau Debugger Nouveau Profiler

47 47 System.Numerics – 1/2 Une nouvelle DLL : System.Numerics.dll BigInteger Un entier, « arbitrairement grand » Complex Structure pour représenter des nombres complexes

48 48 System.Numerics – 2/2 BigInteger static BigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } static void Main() { Console.WriteLine(Factorielle(5)); } 120 static BigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } static void Main() { Console.WriteLine(Factorielle(5)); Console.WriteLine(Factorielle(10)); } static BigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } static void Main() { Console.WriteLine(Factorielle(5)); Console.WriteLine(Factorielle(10)); Console.WriteLine(Factorielle(55)); } static BigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } static void Main() { Console.WriteLine(Factorielle(5)); Console.WriteLine(Factorielle(10)); Console.WriteLine(Factorielle(55)); Console.WriteLine(Factorielle(542)); } // 11 autres lignes de chiffres Prévu pour.NET 3.5 Retardé pour problème de performance Toutes opérations de int Autres opérations (statiques) Abs DivRem GreatestCommonDivisor Remainder Prévu pour.NET 3.5 Retardé pour problème de performance Toutes opérations de int Autres opérations (statiques) Abs DivRem GreatestCommonDivisor Remainder

49 49 C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion C# 4.0 Co & Contra Variance des génériques Paramètres nommés et optionnels Types dynamiques Interopérabilité COM Améliorations à la Base Class Library Conclusion

50 50 Conclusion – 1/2 & Framework 4.0 Nouveautés au niveau du langage Codage Simplifications décriture Amélioration des performances Design Interopérabilité simplifiée et homogénéisée « Design By Contracts » Framework de concurrence

51 51 Conclusion – 2/2 Nouveautés au niveau de lenvironnement Team Foundation Server se démocratise Nouveaux debuggers Modélisation UML Nouveautés au niveau des frameworks ASP.NET, MVC, AJAX 4.0, Sync Framework, F#… Et Après ? C# 5.0 (?) : « Compiler As A Service » Tout simplement une nouvelle révolution

52 52 Noubliez pas votre formulaire de participation au concours! Prochains évènements 09/03 : Windows Live Meeting – VS NET /03 : MyTIC : Sharepoint /03 au 01/04 : Tech Days /04 : DotNetHub : Méthodes Agiles 28/04 : DotNetHub : NService Bus Merci à tous !


Télécharger ppt "C# 4.0 et les améliorations à la BCL Découvrez le framework.NET 4.0 : les apports au langage Quelques améliorations de la « Base Class Library » Découvrez."

Présentations similaires


Annonces Google