Successfully reported this slideshow.
C# 4.0 et les améliorations à la BCL<br />Pierre-Emmanuel Dautreppe – 04 Mars 2010<br />pierre@dotnethub.be – www.pedautre...
 Quelques améliorations de la « Base Class Library »</li></li></ul><li>Evolution du langage<br />C# 1.0 : Toute la base<br...
 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</li></ul>C# 2.0 : Génériques<br /><ul><li> Apparition des génériques : type safety
Correction de manques
 Types nullables
 Classes statiques
 Simplifications
 Méthodes anonymes
Itérateurs(yield)</li></ul>C# 3.5 : LINQ et méthodes lambdas<br /><ul><li> LINQ
 Programmation déclarative
 Concis, mais statiquement typé
 Méthodes Lambdas
 Programmation fonctionnelle
 Meta-Programmation
 Le code devient une donnée
 Expression Trees</li></li></ul><li>Tendances d’évolution de .NET<br />Programmation Déclarative<br />Quoi<br />Comment<br...
 Serveurs multi-processeurs
 Tirer parti de l’amélioration possible des performances
 en se reposant sur des frameworks
 en programmant différement</li></ul> Simplifier la prise en compte de la parallélisation<br />
Agenda<br />C# 4.0<br /><ul><li>Co & Contra Variance des génériques
 Paramètres nommés et optionnels
 Types dynamiques
 Interopérabilité COM
 Améliorations à la Base Class Library</li></ul>Conclusion<br />
C# 4.0<br /><ul><li>Co & Contra Variance des génériques
Paramètres nommés et optionnels
 Types dynamiques
 Interopérabilité COM
 Améliorations à la Base Class Library</li></ul>Conclusion<br />
Co & Contra Variance – Définition<br /><ul><li>Covariance
Un opérateur de conversion de type est covariant s’il 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
Contravariance
Un opérateur de conversion de type est contravariant s’il ordonne les types du plus générique au plus spécifique
Si tu sais comparer deux « object », alors tu sauras aussi comparer deux « EventArgs ».</li></ul>	Ainsi, si tu as besoin d...
Co & Contra Variance – Les delegates – 1/2<br />public class Employé { }<br />public class Développeur : Employé { }<br />...
Co & Contra Variance – Les delegates – 2/2<br />delegatevoidEventHandler(objectsender, EventArgse);<br />TextBoxtxtBox = n...
Covariance des tableaux<br />Les arrays sontcovariants…<br />string[] strArray = new[] { "A", "B" };<br />object[] objArra...
Co & Contra Variance des types génériques – 1/4<br />Génériques = Sécurité de typage<br />List<string> strArray = newList<...
Co & Contra Variance des types génériques – 2/4<br />public voidTestContravariance(IComparer<string> comparer)<br />{<br /...
Co & Contra Variance des types génériques – 3/4<br />public interface IEnumerable<out T> : IEnumerable<br />{<br />IEnumer...
T ne doit être utilisé que comme type de retour
IEnumerable<T> est covariant</li></ul>IEnumerable<B>estconsidérécommeIEnumerable<A><br />si conversion de référence de B v...
Co & Contra Variance des types génériques – 4/4<br />public interface IComparer<in T><br />{<br />intCompare(T x, T y);<br...
T ne doit être utilisé que comme paramètre d’input
Prochain SlideShare
Chargement dans…5
×

Découvrez C# 4.0 et les améliorations apportées à la BCL

1 781 vues

Publié le

Publié dans : Technologie, Business
  • Soyez le premier à commenter

Découvrez C# 4.0 et les améliorations apportées à la BCL

  1. 1. C# 4.0 et les améliorations à la BCL<br />Pierre-Emmanuel Dautreppe – 04 Mars 2010<br />pierre@dotnethub.be – www.pedautreppe.com – @pedautreppe<br />Découvrez le framework .NET 4.0 : <br /><ul><li> les apports au langage
  2. 2. Quelques améliorations de la « Base Class Library »</li></li></ul><li>Evolution du langage<br />C# 1.0 : Toute la base<br /><ul><li> Code Managé
  3. 3. Common Type System
  4. 4. Programmation Orientée Objets
  5. 5. Méthodes, Propriétés, Indexeurs, Evènements
  6. 6. Compatibilité avec autres technologies
  7. 7. Interopérabilité COM
  8. 8. P/Invoke
  9. 9. Code Unsafe</li></ul>C# 2.0 : Génériques<br /><ul><li> Apparition des génériques : type safety
  10. 10. Correction de manques
  11. 11. Types nullables
  12. 12. Classes statiques
  13. 13. Simplifications
  14. 14. Méthodes anonymes
  15. 15. Itérateurs(yield)</li></ul>C# 3.5 : LINQ et méthodes lambdas<br /><ul><li> LINQ
  16. 16. Programmation déclarative
  17. 17. Concis, mais statiquement typé
  18. 18. Méthodes Lambdas
  19. 19. Programmation fonctionnelle
  20. 20. Meta-Programmation
  21. 21. Le code devient une donnée
  22. 22. Expression Trees</li></li></ul><li>Tendances d’évolution de .NET<br />Programmation Déclarative<br />Quoi<br />Comment<br />Impératif<br />Déclaratif<br />fromi in list<br />wherei > 10<br />orderbyi<br />select i<br />foreach ( inti inlist )<br /> if ( i > 10 )<br />result.Add(i);<br />result.Sort();<br />Programmation Dynamique<br />Concurrence / Parallélisation<br /><ul><li> Architectures multi-cœur
  23. 23. Serveurs multi-processeurs
  24. 24. Tirer parti de l’amélioration possible des performances
  25. 25. en se reposant sur des frameworks
  26. 26. en programmant différement</li></ul> Simplifier la prise en compte de la parallélisation<br />
  27. 27. Agenda<br />C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  28. 28. Paramètres nommés et optionnels
  29. 29. Types dynamiques
  30. 30. Interopérabilité COM
  31. 31. Améliorations à la Base Class Library</li></ul>Conclusion<br />
  32. 32. C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  33. 33. Paramètres nommés et optionnels
  34. 34. Types dynamiques
  35. 35. Interopérabilité COM
  36. 36. Améliorations à la Base Class Library</li></ul>Conclusion<br />
  37. 37. Co & Contra Variance – Définition<br /><ul><li>Covariance
  38. 38. Un opérateur de conversion de type est covariant s’il ordonne les types du plus spécifique au plus générique
  39. 39. Si tu me fournis une SqlCommand, alors je peux me contenter de la traiter comme une DbCommand
  40. 40. Contravariance
  41. 41. Un opérateur de conversion de type est contravariant s’il ordonne les types du plus générique au plus spécifique
  42. 42. Si tu sais comparer deux « object », alors tu sauras aussi comparer deux « EventArgs ».</li></ul> Ainsi, si tu as besoin d’un comparateur d’EventArgs, alors je peux te donner un comparateur d’objet<br />
  43. 43. Co & Contra Variance – Les delegates – 1/2<br />public class Employé { }<br />public class Développeur : Employé { }<br />class Program<br />{<br />staticEmployé CréeEmployé() { return null; }<br />staticDéveloppeur CréeDéveloppeur() { return null; }<br />staticvoid Main(string[] args)<br /> {<br />var créeEmployé = new Func<Employé>(CréeEmployé);<br />Employé employé1 = créeEmployé();<br />var créeDeveloppeur = new Func<Employé>(CréeDéveloppeur);<br />Employé employé2 = créeDeveloppeur();<br /> }<br />}<br />public class Employé { }<br />public class Développeur : Employé { }<br />class Program<br />{<br />staticEmployé CréeEmployé() { return null; }<br />staticDéveloppeur CréeDéveloppeur() { return null; }<br />}<br />Func<Employé><br />Func<Développeur><br />Les delegates sontcovariants<br />
  44. 44. Co & Contra Variance – Les delegates – 2/2<br />delegatevoidEventHandler(objectsender, EventArgse);<br />TextBoxtxtBox = new TextBox();<br />txtBox.Click +=<br />txtBox.KeyDown += <br />delegatevoidKeyEventHandler(objectsender, KeyEventArgse);<br />voidMonHandler(objectsender, EventArgse) { }<br />TextBoxtxtBox = new TextBox();<br />txtBox.Click += MonHandler;<br />txtBox.KeyDown += MonHandler;<br />Les delegates sontcontravariants<br />
  45. 45. Covariance des tableaux<br />Les arrays sontcovariants…<br />string[] strArray = new[] { "A", "B" };<br />object[] objArray = strArray;<br />…mais pas <br />“type safe”<br />objArray[0] = 12;<br />string s = strArray[0];<br />System.ArrayTypeMismatchException<br />Possible seulement pour les types références<br />Il s’agiticid’une conversion par “boxing”  Interdit<br />int[] intArray = new[] { 1, 2, 3};<br />object[] objArray = intArray;<br />
  46. 46. Co & Contra Variance des types génériques – 1/4<br />Génériques = Sécurité de typage<br />List<string> strArray = newList<string> { "A", "B" };<br />List<object> objArray = strArray;<br />Non « Type Safe » <br />donc non covariant<br />List<string> strArray = newList<string> { "A", "B" };<br />IEnumerable<object> objEnum = strArray;<br />« Type Safe » donc covariant<br />
  47. 47. Co & Contra Variance des types génériques – 2/4<br />public voidTestContravariance(IComparer<string> comparer)<br />{<br />comparer.Compare("chaine 1", "chaine 2");<br />}<br />public class MyObjectComparer : IComparer<object> { ... }<br />public class MyStringComparer: IComparer<string> { ... }<br />IComparer<string> stringComparer = new MyStringComparer();<br />stringComparer.Compare("chaine 1", "chaine 2");<br />IComparer<object> objectComparer = new MyObjectComparer();<br />objectComparer.Compare("chaine 1", "chaine 2")<br />IComparer<T> est contravariant<br />IComparer<string> stringComparer = new MyStringComparer();<br />IComparer<object> objectComparer = new MyObjectComparer();<br />TestContravariance(stringComparer);<br />TestContravariance(objectComparer);<br />
  48. 48. Co & Contra Variance des types génériques – 3/4<br />public interface IEnumerable<out T> : IEnumerable<br />{<br />IEnumerator<T> GetEnumerator();<br />}<br /><ul><li>Mot-clé « out »
  49. 49. T ne doit être utilisé que comme type de retour
  50. 50. IEnumerable<T> est covariant</li></ul>IEnumerable<B>estconsidérécommeIEnumerable<A><br />si conversion de référence de B vers A<br />A<br />B<br />IEnumerable<A><br />IEnumerable<B><br />
  51. 51. Co & Contra Variance des types génériques – 4/4<br />public interface IComparer<in T><br />{<br />intCompare(T x, T y);<br />}<br /><ul><li>Mot-clé « in »
  52. 52. T ne doit être utilisé que comme paramètre d’input
  53. 53. IComparer<T> est contravariant</li></ul>IComparer<A>estconsidérécommeIComparer<B><br />si conversion de référence de B vers A<br />A<br />B<br />IComparer<A><br />IComparer<B><br />
  54. 54. Variance en .NET 4.0<br />Interfaces<br />System.Collections.Generic.IEnumerable<out T><br />System.Collections.Generic.IEnumerator<out T><br />System.Linq.IQueryable<out T><br />System.Collections.Generic.IComparer<in T><br />System.Collections.Generic.IEqualityComparer<in T><br />System.IComparable<in T><br />Delegates<br />System.Func<in T, …, out R><br />System.Action<in T, …><br />System.Predicate<in T><br />System.Comparison<in T><br />System.EventHandler<in T><br />
  55. 55. C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  56. 56. Paramètres nommés et optionnels
  57. 57. Types dynamiques
  58. 58. Interopérabilité COM
  59. 59. Améliorations à la Base Class Library</li></ul>Conclusion<br />
  60. 60. Paramètres Optionnels et Nommés – 1/4<br />Une méthode principale<br />FileStream Open(string path, <br />FileModemode, <br />FileAccessaccess, <br />FileShareshare)<br />FileStream Open(string path, <br />FileModemode, <br />FileAccessaccess)<br />FileStream Open(string path, <br />FileModemode)<br />Plusieurs overloads<br />Redirection avec des valeurs par défaut<br />
  61. 61. Paramètres Optionnels et Nommés – 2/4<br />public voidMethode(intx, inty = 5, intz = 10) { }<br />2 paramètres optionnels<br />Methode(10, 2, 15);<br />Methode(10, 2); //Equivalent à Methode(10, 2, 10);<br />Methode(10); //Equivalent à Methode(10, 5, 10);<br />Methode(10, , 15); //INTERDIT<br />Les paramètres omis doivent être en dernier<br />
  62. 62. Paramètres Optionnels et Nommés – 3/4<br />Les paramètres nommées <br />doivent être en dernier<br />Methode(10, z: 15);<br />Les paramètres non optionnelsdoivent être spécifiés<br />Methode(y: 15, x: 10);<br />Methode(y: 15, x: 10, z: 2);<br />Les paramètres nommés peuvent être dans n’importe quel ordre<br />Les paramètres nommés sont évalués dans l’ordre d’écriture<br />
  63. 63. Paramètres Optionnels et Nommés – 4/4<br /><ul><li>Identique à VB.NET
  64. 64. Paramètres optionnels
  65. 65. Doivent être des constantes de compilation
  66. 66. Valeur par défaut copiée dans l’appel
  67. 67. Paramètres nommés
  68. 68. La compilation se base sur les noms</li></ul>Ne changez pas votre API<br />Même question que pour constou staticreadonly<br />A utiliserplutôt en temps que client<br />
  69. 69. C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  70. 70. Paramètres nommés et optionnels
  71. 71. Types dynamiques
  72. 72. Interopérabilité COM
  73. 73. Améliorations à la Base Class Library</li></ul>Conclusion<br />
  74. 74. Exemples appels « dynamiques » avec C# 3.5<br />Calculator calc = GetCalculator();<br />intresultat = calc.Add(10, 20);<br />objectcalculator = GetCalculator();<br />TypecalcType = calculator.GetType();<br />intresult = (int)calcType.InvokeMember("Add", <br />BindingFlags.InvokeMethod, null, <br />calculator, new object[] { 10, 20 });<br />C#  C#<br />ScriptObject calc = GetCalculator();<br />intresultat<br /> = (int)calc.Invoke("Add", 10, 20);<br />Silverlight<br /> Javascript<br />ScriptScope python <br /> = Python.CreateRuntime().UseFile("Calculator.py");<br />ScriptEngineengine = python.Engine;<br />intresultat = (int)engine.Execute<br /> ("GetCalculator().Add(10, 20)", python);<br />C#  IronPython<br />
  75. 75. IronPython<br />IronRuby<br />C#<br />Visual Basic<br />Autres…<br />Dynamic Language Runtime (DLR)<br />Expression Trees<br />Dynamic Dispatch<br />Call Site Caching<br />POCOBinder<br />JavaScriptBinder<br />PythonBinder<br />RubyBinder<br />COMBinder<br /><<br />
  76. 76. Types dynamiques – 1/3<br />Calculator calc = GetCalculator();<br />intresultat = calc.Add(10, 20);<br />Statiquement typé <br />comme “dynamic”<br />dynamic calc = GetCalculator();<br />intresultat = calc.Add(10, 20);<br />Appel dynamique<br />de la méthode<br />Conversion dynamique<br />de la valeur de retour<br />
  77. 77. Types dynamiques – 2/3<br />Type statique (à la compilation)<br />Type dynamique(à l’exécution)<br />dynamic x = 1;<br />dynamic y = "Bonjour";<br />dynamic z = newList<int> { 1, 2, 3 };<br />dynamic<br />Int32<br />dynamic<br />String<br />dynamic<br />List<int><br />Quand les opérandes sont dynamic…<br /><ul><li>La sélection des membres est différée à l’exécution
  78. 78. A l’exécution,dynamic est remplacé par le type réel de chaque membre
  79. 79. Le type de retour de l’opération est également dynamic</li></li></ul><li>Types dynamiques – 3/3<br />public class Calculator<br />{<br /> public double Add(double a, double b) { ... }<br /> public intAdd(int a, int b) { ... }<br />}<br />Calculatorcalc = GetCalculator();<br />double x = 2.25, y = 3.75;<br />double result = calc.Add(x, y);<br />A la compilation : <br />double Add(double, double)<br />Calculatorcalc = GetCalculator();<br />dynamic x = 2.25, y = 3.75;<br />dynamic result = calc.Add(x, y);<br />A l’exécution : <br />double Add(double, double)<br />Calculatorcalc = GetCalculator();<br />dynamic x = 2, y = 3;<br />dynamic result = calc.Add(x, y);<br />A l’exécution : <br />intAdd(int, int)<br />
  80. 80. Types dynamiques – Points à retenir<br /><ul><li>La résolution des méthodes est différée à l’exécution si nécessaire</li></ul>public voidMethode(dynamic d)<br /><ul><li>On ne peut pas appeler des méthodes d’extensions
  81. 81. A savoir(ou non):
  82. 82. Nouveaux types de conversion : assignation, structurelle, …
  83. 83. dynamic n’existe pas au niveau du code IL</li></li></ul><li>Types dynamiques – Exemples d’écritures – 1/2<br /><ul><li>Ces écritures sont valides</li></ul>dynamicMaMethode(int i, dynamic d) { ... }<br />dynamicMaMethode(int i, dynamic d) { ... }<br />dynamic[] monArray = ...<br />dynamicMaMethode(int i, dynamic d) { ... }<br />dynamic[] monArray = ...<br />IEnumerable<dynamic> enumerable = ...<br />dynamicMaMethode(int i, dynamic d) { ... }<br />dynamic[] monArray = ...<br />IEnumerable<dynamic> enumerable = ...<br />List<dynamic> liste = ...<br />dynamicMaMethode(int i, dynamic d) { ... }<br />dynamic[] monArray = ...<br />IEnumerable<dynamic> enumerable = ...<br />List<dynamic> liste = ...<br />class BaseClass<T> { }<br />class Derived : BaseClass<dynamic> { }<br />
  84. 84. Types dynamiques – Exemples d’écritures – 2/2<br /><ul><li>Ces écritures ne sont pas valides</li></ul>classC : dynamic { }<br />classC : dynamic { }<br />classC : IEnumerable<dynamic> { }<br />classC : dynamic { }<br />classC : IEnumerable<dynamic> { }<br />classC<T> whereT : BaseClass<dynamic> { }<br /><ul><li>Pour plus d’information : Blog de Chris Burrows http://blogs.msdn.com/cburrows/default.aspx</li></li></ul><li>Créer un type dynamique – 1/2<br />Dans System.Core.dll<br />NamespaceSystem.Dynamic<br />IDynamicObject<br />a été renommé<br />public class DynamicObject: IDynamicMetaObjectProvider<br />{<br />public virtual IEnumerable<string> GetDynamicMemberNames();<br />public virtual DynamicMetaObjectGetMetaObject(Expression parameter);<br />public virtual boolTryConvert(ConvertBinder binder, out object result);<br />public virtual boolTryDeleteMember(DeleteMemberBinder binder);<br />public virtual boolTryGetMember(GetMemberBinder binder, <br />out object result);<br />public virtual boolTrySetMember(SetMemberBinder binder, object value);<br />public virtual boolTryBinaryOperation(BinaryOperationBinder binder, <br />object arg, out object result);<br />public virtual boolTryUnaryOperation(UnaryOperationBinder binder, <br />out object result);<br /> ...<br />}<br />
  85. 85. Créer un type dynamique – 2/2<br />public class MonDynamicObject : DynamicObject<br />{<br />Dictionary<string, object> dic = new Dictionary<string, object>();<br /> public overrideboolTryGetMember(GetMemberBinder binder, out objectresult)<br /> {<br />return this.dic.TryGetValue(binder.Name, out result);<br /> }<br />public overrideboolTrySetMember(SetMemberBinder binder, objectvalue)<br /> {<br />this.dic[binder.Name] = value;<br />return true;<br /> }<br />}<br />dynamicmonObjet = new MonDynamicObject();<br />monObjet.Nom = "Dautreppe";<br />monObjet.Prenom = "Pierre-Emmanuel";<br />Console.WriteLine(monObjet.Prenom + " " + monObjet.Nom);<br />
  86. 86. Types dynamiques – Utilisation de la classe Expando<br />staticvoidMain() <br />{<br />dynamicpersonne = new ExpandoObject();<br /> //1. Définir des propriétés<br />personne.Nom = "Dautreppe";<br />personne.Prenom = "Pierre-Emmanuel";<br /> //2. Définir des méthodes<br />personne.ToString = new Func<string>( () => personne.Nom + " " + personne.Prenom );<br />Console.WriteLine(personne.ToString());<br /> //3. Définir un évènement<br />personne.MonEvent = null;<br />personne.OnMonEvent = new Action<EventArgs>((e) => {<br />if (personne.MonEvent != null)<br />personne.MonEvent(personne, e);<br /> });<br />personne.MonEvent += new EventHandler(MonEventHandler);<br />personne.OnMonEvent(EventArgs.Empty);<br />}<br />privatestaticvoidMonEventHandler(dynamicobj, EventArgs e) <br />{<br />Console.WriteLine("MonEvent appelé sur '" + obj.ToString());<br />}<br />
  87. 87. Types dynamiques – Conclusion – 1/2<br />Que peut-on appeler ?<br />Toute méthode définie sur l’instance<br />Méthode publique<br />Méthode protected<br />Méthode private (de l’instance)<br />Méthode d’interface (si implémentation implicite)<br />Que ne peut-on pas appeler ?<br />Toute méthode « n’existant pas » sur l’instance<br />Méthode private (d’une classe de base)<br />Méthode static (quelque soit sa visibilité)<br />Méthode d’interface (si implémentation explicite)<br />Méthode d’extension<br />
  88. 88. Types dynamiques – Conclusion – 2/2<br /><ul><li>Quand doit-on les utiliser ?
  89. 89. Quand on travaille sans type (par ex. réflexion)
  90. 90. Quand on fait de l’interop
  91. 91. COM
  92. 92. Silverlight Javascript
  93. 93.
  94. 94. Compenser des manques du Framework
  95. 95. « INumeric »
  96. 96. Quand ne devrait-on pas les utiliser ?
  97. 97. Pour compenser une erreur de design
  98. 98. Eg Coder en utilisant une classe de base, mais avoir besoin d’une connaissance des types dérivés</li></li></ul><li>C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  99. 99. Paramètres nommés et optionnels
  100. 100. Types dynamiques
  101. 101. Interopérabilité COM
  102. 102. Améliorations à la Base Class Library</li></ul>Conclusion<br />
  103. 103. Interopérabilité COM – 1/3<br /><ul><li>Paramètres optionnels et nommés</li></ul>objectfileName = "Test.docx";<br />object missing = System.Reflection.Missing.Value;<br />doc.SaveAs(reffileName,<br />ref missing, ref missing, ref missing,<br />ref missing, ref missing, ref missing,<br />ref missing, ref missing, ref missing,<br />ref missing, ref missing, ref missing,<br />ref missing, ref missing, ref missing);<br />doc.SaveAs("Test.docx");<br /><ul><li> Les APIs COM déclarent des paramètres optionnels
  104. 104. « ref » n’est plus obligatoire</li></li></ul><li>Interopérabilité COM – 2/3<br /><ul><li>COM et dynamic</li></ul>IExcel.TrendlinestrendLines<br /> = (IExcel.Trendlines)serie.Trendlines(Type.Missing);<br />IExcel.Rangecell = (IExcel.Range)sheet.Cells[row, column];<br />IExcel.TrendlinestrendLines = serie.Trendlines();<br />IExcel.Rangecell = sheet.Cells[row, column];<br /><ul><li> Les APIs COM renvoient des dynamic
  105. 105. Conversion d’assignation vers le type désiré</li></li></ul><li>Interopérabilité COM – 3/3<br /><ul><li>« No PIA » : Pas de « PrimaryInteropAssemblies »</li></ul>namespaceOfficeApplication<br />{<br />class Program<br /> {<br />staticvoidMain(string[] args)<br /> {<br />Application excel = new Application();<br />Worksheetsheet = excel.Sheets.Add();<br />ChartObjectscharts = sheet.ChartObjects();<br />ChartObjectchart = charts.Add(10, 10, 100, 100);<br />SeriesCollectionseries = chart.Chart.SeriesCollection();<br />Seriesserie = series.Add(...);<br />TrendlinestrendLines = serie.Trendlines();<br />Range cell = sheet.Cells[10, 10];<br /> }<br /> }<br />}<br />Par défaut : True<br />
  106. 106. C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  107. 107. Paramètres nommés et optionnels
  108. 108. Types dynamiques
  109. 109. Interopérabilité COM
  110. 110. Améliorations à la Base Class Library</li></ul>Conclusion<br /><ul><li>TUples
  111. 111. System.IO
  112. 112. Fichiers mappés
  113. 113. Code Contracts
  114. 114. Parallel Extensions
  115. 115. System.Numerics</li></li></ul><li>BCL – Tuples – 1/2<br />Supporté nativement <br />par F# et IronPython<br />public Tuple<bool, int> TryGetElement(string key)<br />{ <br />intvaleur;<br />boolresult = dic.TryGetValue(key, out valeur);<br /> return new Tuple<bool, int>(result, valeur);<br />}<br />return Tuple.Create(result, valeur);<br />System.Tuple :<br />Factory de Tuple<...><br />public static class Tuple<br />{<br />public staticTuple<T1> Create<T1>(T1 item1);<br />public staticTuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2);<br /> ... ...<br /> public staticTuple<T1, T2, T3, T4, T5, T6, T7, TRest> <br />Create<T1, T2, T3, T4, T5, T6, T7, Trest><br /> (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, <br /> T6 item6, T7 item7, TRestrest);<br />}<br />De 1 à 8 types génériques<br />Typiquement un autre Tuple<...><br />
  116. 116. BCL – Tuples – 2/2<br />« new Tuple » et « Tuple.Create » sont équivalents<br />presque !!<br />var a = newTuple<int, int, int, int, int, int, int, Tuple<int, int>><br /> (1, 2, 3, 4, 5, 6, 7, newTuple<int, int>(8, 9));<br />var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));<br />var a = newTuple<int, int, int, int, int, int, int, Tuple<int, int>><br /> (1, 2, 3, 4, 5, 6, 7, newTuple<int, int>(8, 9));<br />var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));<br />Console.WriteLine(a.Item5); // 5<br />Console.WriteLine(a.Rest.Item2); // 9<br />var a = newTuple<int, int, int, int, int, int, int, Tuple<int, int>><br /> (1, 2, 3, 4, 5, 6, 7, newTuple<int, int>(8, 9));<br />var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));<br />Console.WriteLine(a.Item5); // 5<br />Console.WriteLine(a.Rest.Item2); // 9<br />Console.WriteLine(b.Item5); // 5<br />Console.WriteLine(b.Rest.Item1.Item2); // 9<br />Rest = Tuple<int, int><br />Rest = Tuple<Tuple<int, int>><br />
  117. 117. BCL – Améliorations à System.IO<br />string[]GetFiles(string path, string searchPattern);<br />var errorlines =<br />fromfile in Directory.GetFiles(@"C:logs", "*.log")<br />fromline in File.ReadAllLines(file)<br />whereline.StartsWith("Error:")<br />select string.Format("File={0}, Line={1}", file, line);<br />File.WriteAllLines(@"C:errorlines.log", errorlines);<br />string[]ReadAllLines(string path);<br />void WriteAllLines(string path, string[] contents);<br />IEnumerable<string>EnumerateFiles(string path, <br /> string searchPattern);<br />var errorlines =<br />fromfile in Directory.EnumerateFiles(@"C:logs", "*.log")<br />fromline in File.ReadLines(file)<br />whereline.StartsWith("Error:")<br />select string.Format("File={0}, Line={1}", file, line);<br />File.WriteAllLines(@"C:errorlines.log", errorlines);<br />IEnumerable<string>ReadLines(string path);<br />void WriteAllLines(string path, <br />IEnumerable<string> contents);<br />
  118. 118. BCL – Fichiers mappés en mémoire – 1/2<br />Environment.SystemPageSize<br />Scénario 1<br /><ul><li> Gestion de la mémoire par le système
  119. 119. Pagination automatique en mémoire</li></ul>Exploite la mémoire paginée du système<br />Ressource partagée<br />Gros Fichier<br />Process 1<br />Vue 1<br />Vue N<br />Vue N<br />Vue 1<br />Vue 1<br />Vue 2<br />Scénario 2<br />Vue N<br /><ul><li> Mémoire partagée
  120. 120. Simplification pour IPC </li></ul>(Inter-Process Communication)<br />Taille de la vue <= Mémoire disponible pour mapping (2Gb sur 32 bits)<br />Stream (lecture séquentielle)<br />Accessor (lecture aléatoire)<br />Process 1<br />Process 2<br />
  121. 121. BCL – Fichiers mappés en mémoire – 2/2<br />Process 1<br />using(var mmf = MemoryMappedFile.CreateNew("FichierMappé", 1000))<br />{<br />using(var stream = mmf.CreateViewStream())<br /> new BinaryWriter(stream).Write("Bonjour");<br />var startInfo = new ProcessStartInfo("AutreProcess.exe");<br />startInfo.UseShellExecute = false;<br />Process.Start(startInfo).WaitForExit();<br />}<br />Ou mmf.CreateViewAccessor<br />Process 2<br />using(var mmf = MemoryMappedFile.OpenExisting("FichierMappé"))<br />{<br />using(var stream = mmf.CreateViewStream())<br />Console.WriteLine(new BinaryReader(stream).ReadString());<br />}<br />
  122. 122. CodeContracts – 1/2<br /><ul><li>Permettre l’ajout de contrats dans le code
  123. 123. Disponible dans 3.5 (installation séparée)
  124. 124. 4 parties
  125. 125. Une nouvelle API  System.Diagnostics.Contracts
  126. 126. Le « rewriter » (ccrewrite.exe)
  127. 127. Injecte le code de vérification des contrats « aux bons endroits »
  128. 128. Le « staticchecker » (cccheck.exe)
  129. 129. Analyse le code pour vérifier si les contrats sont respectés
  130. 130. Le générateur d’assembly(ccrefgen.exe)
  131. 131. Produit une DLL avec les contrats seuls</li></li></ul><li>CodeContracts – 2/2<br /><ul><li>Contract.Requires
  132. 132. Pré-condition
  133. 133. Evalué « avant » l’appel
  134. 134. Contract.Ensures
  135. 135. Post-condition
  136. 136. Evalué « après » l’appel
  137. 137. Contract.OldValue
  138. 138. Retourne la valeur avant l’appel
  139. 139. ContractInvariantMethod
  140. 140. Invariance de l’objet
  141. 141. Appelé après chaque appel public</li></ul>public class CompteBancaire<br />{<br />privateintnumeroCompte, modulo;<br />private double solde;<br />public voidEffectueDepot(double montant) <br /> {<br />this.solde += montant;<br /> }<br />staticvoidMain() <br /> {<br />var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 };<br />compte.EffectueDepot(1000);<br /> }<br />}<br />public class CompteBancaire<br />{<br />privateintnumeroCompte, modulo;<br />private double solde;<br />public voidEffectueDepot(double montant) <br /> {<br />Contract.Requires(montant > 0);<br />this.solde += montant;<br /> }<br />staticvoidMain() <br /> {<br />var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 };<br />compte.EffectueDepot(1000);<br /> }<br />}<br />public class CompteBancaire<br />{<br />privateintnumeroCompte, modulo;<br />private double solde;<br />public voidEffectueDepot(double montant) <br /> {<br />Contract.Requires(montant > 0);<br />Contract.Ensures(ancien solde < nouveau solde);<br />this.solde += montant;<br /> }<br />staticvoidMain() <br /> {<br />var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 };<br />compte.EffectueDepot(1000);<br /> }<br />}<br />public class CompteBancaire<br />{<br />privateintnumeroCompte, modulo;<br />private double solde;<br />public voidEffectueDepot(double montant) <br /> {<br />Contract.Requires(montant > 0);<br />Contract.Ensures(Contract.OldValue(this.solde) < this.solde);<br />this.solde += montant;<br /> }<br />staticvoidMain() <br /> {<br />var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 };<br />compte.EffectueDepot(1000);<br /> }<br />}<br />public class CompteBancaire<br />{<br />privateintnumeroCompte, modulo;<br />private double solde;<br />public voidEffectueDepot(double montant) <br /> {<br />Contract.Requires(montant > 0);<br />Contract.Ensures(Contract.OldValue(this.solde) < this.solde);<br />this.solde += montant;<br /> }<br /> [ContractInvariantMethod]<br />privatevoidObjectInvariant() <br /> {<br />Contract.Invariant(this.solde >= 0);<br />Contract.Invariant(this.numeroCompte % 97 == this.modulo);<br /> }<br />staticvoidMain() <br /> {<br />var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 };<br />compte.EffectueDepot(1000);<br /> }<br />}<br />
  142. 142. PFX – Parallel Framework Extensions<br />staticvoidMain()<br />{<br />IEnumerable<int> liste = Enumerable.Range(0, 10000000);<br />var query = fromi in liste<br />whereEstNombrePremier(i)<br />select i;<br />Console.WriteLine(query.Count());<br />}<br />staticboolEstNombrePremier(intp)<br />{<br />intlimite = (int)Math.Sqrt(p);<br />for (inti = 2; i <= limite; i++)<br />if (p % i == 0)<br />return false;<br />return true;<br />}<br />.AsParallel()<br /><ul><li>System.Collection.Concurrent
  143. 143. BlockingCollection<T>
  144. 144. ConcurrentQueue<T>
  145. 145. ConcurrentDictionary<K, V>
  146. 146. Lazy<T>
  147. 147. System.Threading
  148. 148. SemaphoreSlim
  149. 149. ManuelResetEventSlim
  150. 150. SpinLock
  151. 151. Visual Studio
  152. 152. Nouveau Debugger
  153. 153. Nouveau Profiler</li></ul>Parallel.Invoke(() => RealiseAction1(), <br /> () => RealiseAction2(), <br /> () => RealiseAction3());<br />
  154. 154. System.Numerics – 1/2<br />Une nouvelle DLL : System.Numerics.dll<br />BigInteger<br />Un entier, « arbitrairement grand »<br />Complex<br />Structure pour représenter des nombres complexes<br />
  155. 155. System.Numerics – 2/2<br /><ul><li>BigInteger
  156. 156. Prévu pour .NET 3.5
  157. 157. Retardé pour problème de performance
  158. 158. Toutes opérations de int
  159. 159. Autres opérations (statiques)
  160. 160. Abs
  161. 161. DivRem
  162. 162. GreatestCommonDivisor
  163. 163. Remainder</li></ul>staticBigInteger Factorielle(BigInteger i)<br />{<br />if (i == 2)<br /> return 2;<br />return i * Factorielle(--i);<br />}<br />staticvoidMain()<br />{<br />Console.WriteLine(Factorielle(5));<br />}<br />staticBigInteger Factorielle(BigInteger i)<br />{<br />if (i == 2)<br /> return 2;<br />return i * Factorielle(--i);<br />}<br />staticvoidMain()<br />{<br />Console.WriteLine(Factorielle(5));<br />Console.WriteLine(Factorielle(10));<br />}<br />staticBigInteger Factorielle(BigInteger i)<br />{<br />if (i == 2)<br /> return 2;<br />return i * Factorielle(--i);<br />}<br />staticvoidMain()<br />{<br />Console.WriteLine(Factorielle(5));<br />Console.WriteLine(Factorielle(10));<br />Console.WriteLine(Factorielle(55));<br />}<br />staticBigInteger Factorielle(BigInteger i)<br />{<br />if (i == 2)<br /> return 2;<br />return i * Factorielle(--i);<br />}<br />staticvoidMain()<br />{<br />Console.WriteLine(Factorielle(5));<br />Console.WriteLine(Factorielle(10));<br />Console.WriteLine(Factorielle(55));<br />Console.WriteLine(Factorielle(542));<br />}<br />120<br />120<br />3628800<br />120<br />3628800<br />12696403353658275925965100847566516959580321051449436762275840000000000000<br />120<br />3628800<br />12696403353658275925965100847566516959580321051449436762275840000000000000<br />1607535095378011891056328484225529595243838798499054994766025156939288169810835272449306354580237969682411561904659247352233869578500369085015849202525200<br />// 11 autreslignes de chiffres<br />27593805066916468242618448796850243328574235699250768859321062302677755711983880776617227228201878615112377392168960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000<br />
  164. 164. C# 4.0<br /><ul><li>Co & Contra Variance des génériques
  165. 165. Paramètres nommés et optionnels
  166. 166. Types dynamiques
  167. 167. Interopérabilité COM
  168. 168. Améliorations à la Base Class Library</li></ul>Conclusion<br />
  169. 169. Conclusion – 1/2<br /><ul><li> & Framework 4.0
  170. 170. Nouveautés au niveau du langage
  171. 171. Codage
  172. 172. Simplifications d’écriture
  173. 173. Amélioration des performances
  174. 174. Design
  175. 175. Interopérabilité simplifiée et homogénéisée
  176. 176. « Design By Contracts »
  177. 177. Framework de concurrence</li></li></ul><li>Conclusion – 2/2<br /><ul><li>Nouveautés au niveau de l’environnement
  178. 178. Team Foundation Server se démocratise
  179. 179. Nouveaux debuggers
  180. 180. Modélisation UML
  181. 181. Nouveautés au niveau des frameworks
  182. 182. ASP.NET, MVC, AJAX 4.0, Sync Framework, F#…
  183. 183. Et Après ?
  184. 184. C# 5.0 (?) : « Compiler As A Service »</li></ul>Tout simplement une nouvelle révolution<br />
  185. 185. Merci à tous !<br />N’oubliez pas votre formulaire de <br /> participation au concours!<br />Prochains évènements<br />09/03 : Windows Live Meeting – VS 2010 - .NET 4.0<br />23/03 : MyTIC : Sharepoint 2010<br />30/03 au 01/04 : Tech Days 2010<br />21/04 : DotNetHub : Méthodes Agiles<br />28/04 : DotNetHub : NService Bus<br />

×