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 708 vues

Publié le

Publié dans : Technologie, Business
0 commentaire
1 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
1 708
Sur SlideShare
0
Issues des intégrations
0
Intégrations
20
Actions
Partages
0
Téléchargements
45
Commentaires
0
J’aime
1
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive
  • Doivent être des constantes de compilation : On ne peut donc pas définir comme valeur par défaut un appel de méthode, …Notez que si on veut assigner une méthode à un delegate, on doit « référencer » tous ses paramètres
  • La DLR a été créée pour IronPythonPuis a été sortie dans une DLL séparée de façon à pouvoir l’utiliser dans d’autres langages dynamiquesEt enfin intégré à .NET 4.0Si on traite avec des dynamiques, le compilateur émet un « dynamic call site » à la place d’un appel direct de méthode.« DynamicDispatch » = appel de la méthode à l’exécution en utilisant le binder adéquat
  • Conversions existantes : implicit, explicit, user-defined, boxing, reference, …Conversion d’assignation : quand on assigne un dynamic vers un type « réel »Conversion structurelle : For a given T, let red(T) (&quot;T reduced&quot;) be the type T except with all the occurrences of dynamic replaced by object. So red(Dictionary&lt;dynamic, object&gt;) == Dictionary&lt;object,object&gt;. We added the following conversions.If there is an implicit reference conversion from red(S) to red(T), then there is also an implicit reference conversion from S to T, except in the case where S is dynamic and T is object. If there is an implicit reference conversion from S to T and from T to U, and one of them is a conversion added by rule 1, then there is an implicit conversion from S to U. If there is an explicit reference conversion from red(S) to red(T), then there is also an explicit reference conversion from S to T.
  • Attention, ne peut pas être utilisé avec IronPython pour le moment : Breaking Changes dans la DLR dans la version de .NET 4.0 Beta 1 Génère un AttributeError
  • Utilise toujours le minimum de mémoire quelque soit le nombre de fichiers / lignes / répertoires
  • StaticChecker : Team System uniquementAttention : l’API est disponible dans le .NET Framework 4.0, mais on doit installer CodeContracts malgré tout si on veut avoir l’onglet « Contract » dans les propriétés du projet, et les activer
  • SpinLock : lock mais qui ne va pas mettre le thread en « idle » s’il ne peut l’acquérir. Au contraire va boucler jusqu’à l’obtenir. Meilleures performances si le temps d’attente est court (mise en « idle » est couteux)
  • TFS : baisse des contraintes, installable sur un poste client
  • 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 />

    ×