3. Common Type System

4. Programmation Orientée Objets

5. Méthodes, Propriétés, Indexeurs, Evènements

6. Compatibilité avec autres technologies

7. Interopérabilité COM

8. P/Invoke

10. Correction de manques

11. Types nullables

12. Classes statiques

13. Simplifications

14. Méthodes anonymes

16. Programmation déclarative

17. Concis, mais statiquement typé

18. Méthodes Lambdas

19. Programmation fonctionnelle

20. Meta-Programmation

21. Le code devient une donnée

23. Serveurs multi-processeurs

24. Tirer parti de l’amélioration possible des performances

25. en se reposant sur des frameworks

26. en programmant différement Simplifier la prise en compte de la parallélisation

28. Paramètres nommés et optionnels

29. Types dynamiques

30. Interopérabilité COM

31. Améliorations à la Base Class LibraryConclusion

33. Paramètres nommés et optionnels

34. Types dynamiques

35. Interopérabilité COM

36. Améliorations à la Base Class LibraryConclusion

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. Si tu me fournis une SqlCommand, alors je peux me contenter de la traiter comme une DbCommand

40. Contravariance

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. Si tu sais comparer deux « object », alors tu sauras aussi comparer deux « EventArgs ». Ainsi, si tu as besoin d’un comparateur d’EventArgs, alors je peux te donner un comparateur d’objet

43. Co & Contra Variance – Les delegates – 1/2 public class Employé { } public class Développeur : Employé { } class Program { staticEmployé CréeEmployé() { return null; } staticDéveloppeur CréeDéveloppeur() { return null; } staticvoid Main(string[] args) { var créeEmployé = new Func<Employé>(CréeEmployé); Employé employé1 = créeEmployé(); var créeDeveloppeur = new Func<Employé>(CréeDéveloppeur); Employé employé2 = créeDeveloppeur(); } } public class Employé { } public class Développeur : Employé { } class Program { staticEmployé CréeEmployé() { return null; } staticDéveloppeur CréeDéveloppeur() { return null; } } Func<Employé> Func<Développeur> Les delegates sontcovariants

44. Co & Contra Variance – Les delegates – 2/2 delegatevoidEventHandler(objectsender, EventArgse); TextBoxtxtBox = new TextBox(); txtBox.Click += txtBox.KeyDown += delegatevoidKeyEventHandler(objectsender, KeyEventArgse); voidMonHandler(objectsender, EventArgse) { } TextBoxtxtBox = new TextBox(); txtBox.Click += MonHandler; txtBox.KeyDown += MonHandler; Les delegates sontcontravariants

45. Covariance des tableaux Les arrays sontcovariants… string[] strArray = new[] { "A", "B" }; object[] objArray = strArray; …mais pas “type safe” objArray[0] = 12; string s = strArray[0]; System.ArrayTypeMismatchException Possible seulement pour les types références Il s’agiticid’une conversion par “boxing”  Interdit int[] intArray = new[] { 1, 2, 3}; object[] objArray = intArray;

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

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

49. T ne doit être utilisé que comme type de retour

50. IEnumerable<T> est covariantIEnumerable<B>estconsidérécommeIEnumerable<A> si conversion de référence de B vers A A B IEnumerable<A> IEnumerable<B>

52. T ne doit être utilisé que comme paramètre d’input

53. IComparer<T> est contravariantIComparer<A>estconsidérécommeIComparer<B> si conversion de référence de B vers A A B IComparer<A> IComparer<B>

54. Variance en .NET 4.0 Interfaces System.Collections.Generic.IEnumerable<out T> System.Collections.Generic.IEnumerator<out T> System.Linq.IQueryable<out T> System.Collections.Generic.IComparer<in T> System.Collections.Generic.IEqualityComparer<in T> System.IComparable<in T> Delegates System.Func<in T, …, out R> System.Action<in T, …> System.Predicate<in T> System.Comparison<in T> System.EventHandler<in T>

56. Paramètres nommés et optionnels

57. Types dynamiques

58. Interopérabilité COM

59. Améliorations à la Base Class LibraryConclusion

60. Paramètres Optionnels et Nommés – 1/4 Une méthode principale FileStream Open(string path, FileModemode, FileAccessaccess, FileShareshare) FileStream Open(string path, FileModemode, FileAccessaccess) FileStream Open(string path, FileModemode) Plusieurs overloads Redirection avec des valeurs par défaut

61. Paramètres Optionnels et Nommés – 2/4 public voidMethode(intx, inty = 5, intz = 10) { } 2 paramètres optionnels Methode(10, 2, 15); Methode(10, 2); //Equivalent à Methode(10, 2, 10); Methode(10); //Equivalent à Methode(10, 5, 10); Methode(10, , 15); //INTERDIT Les paramètres omis doivent être en dernier

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

64. Paramètres optionnels

65. Doivent être des constantes de compilation

66. Valeur par défaut copiée dans l’appel

67. Paramètres nommés

68. La compilation se base sur les nomsNe changez pas votre API Même question que pour constou staticreadonly A utiliserplutôt en temps que client

70. Paramètres nommés et optionnels

71. Types dynamiques

72. Interopérabilité COM

73. Améliorations à la Base Class LibraryConclusion

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

75. IronPython IronRuby C# Visual Basic Autres… Dynamic Language Runtime (DLR) Expression Trees Dynamic Dispatch Call Site Caching POCOBinder JavaScriptBinder PythonBinder RubyBinder COMBinder <

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

78. A l’exécution,dynamic est remplacé par le type réel de chaque membre

81. A savoir(ou non):

82. Nouveaux types de conversion : assignation, structurelle, …

85. Créer un type dynamique – 2/2 public class MonDynamicObject : DynamicObject { Dictionary<string, object> dic = new Dictionary<string, object>(); public overrideboolTryGetMember(GetMemberBinder binder, out objectresult) { return this.dic.TryGetValue(binder.Name, out result); } public overrideboolTrySetMember(SetMemberBinder binder, objectvalue) { this.dic[binder.Name] = value; return true; } } dynamicmonObjet = new MonDynamicObject(); monObjet.Nom = "Dautreppe"; monObjet.Prenom = "Pierre-Emmanuel"; Console.WriteLine(monObjet.Prenom + " " + monObjet.Nom);

86. Types dynamiques – Utilisation de la classe Expando staticvoidMain() { dynamicpersonne = 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<string>( () => personne.Nom + " " + personne.Prenom ); Console.WriteLine(personne.ToString()); //3. Définir un évènement personne.MonEvent = null; personne.OnMonEvent = new Action<EventArgs>((e) => { if (personne.MonEvent != null) personne.MonEvent(personne, e); }); personne.MonEvent += new EventHandler(MonEventHandler); personne.OnMonEvent(EventArgs.Empty); } privatestaticvoidMonEventHandler(dynamicobj, EventArgs e) { Console.WriteLine("MonEvent appelé sur '" + obj.ToString()); }

87. Types dynamiques – Conclusion – 1/2 Que peut-on appeler ? Toute méthode définie sur l’instance Méthode publique Méthode protected Méthode private (de l’instance) Méthode d’interface (si implémentation implicite) Que ne peut-on pas appeler ? Toute méthode « n’existant pas » sur l’instance Méthode private (d’une classe de base) Méthode static (quelque soit sa visibilité) Méthode d’interface (si implémentation explicite) Méthode d’extension

89. Quand on travaille sans type (par ex. réflexion)

90. Quand on fait de l’interop

91. COM

92. Silverlight Javascript

93. …

94. Compenser des manques du Framework

95. « INumeric »

96. Quand ne devrait-on pas les utiliser ?

97. Pour compenser une erreur de design

99. Paramètres nommés et optionnels

100. Types dynamiques

101. Interopérabilité COM

102. Améliorations à la Base Class LibraryConclusion

107. Paramètres nommés et optionnels

108. Types dynamiques

109. Interopérabilité COM

111. System.IO

112. Fichiers mappés

113. Code Contracts

114. Parallel Extensions

116. BCL – Tuples – 2/2 « new Tuple » et « Tuple.Create » sont équivalents presque !! var a = newTuple<int, int, int, int, int, int, int, Tuple<int, int>> (1, 2, 3, 4, 5, 6, 7, newTuple<int, int>(8, 9)); var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9)); var a = newTuple<int, int, int, int, int, int, int, Tuple<int, int>> (1, 2, 3, 4, 5, 6, 7, newTuple<int, int>(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 = newTuple<int, int, int, int, int, int, int, Tuple<int, int>> (1, 2, 3, 4, 5, 6, 7, newTuple<int, int>(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 Rest = Tuple<int, int> Rest = Tuple<Tuple<int, int>>

117. BCL – Améliorations à System.IO string[]GetFiles(string path, string searchPattern); var errorlines = fromfile in Directory.GetFiles(@"C:ogs", "*.log") fromline in File.ReadAllLines(file) whereline.StartsWith("Error:") select string.Format("File={0}, Line={1}", file, line); File.WriteAllLines(@"C:rrorlines.log", errorlines); string[]ReadAllLines(string path); void WriteAllLines(string path, string[] contents); IEnumerable<string>EnumerateFiles(string path, string searchPattern); var errorlines = fromfile in Directory.EnumerateFiles(@"C:ogs", "*.log") fromline in File.ReadLines(file) whereline.StartsWith("Error:") select string.Format("File={0}, Line={1}", file, line); File.WriteAllLines(@"C:rrorlines.log", errorlines); IEnumerable<string>ReadLines(string path); void WriteAllLines(string path, IEnumerable<string> contents);

120. Simplification pour IPC (Inter-Process Communication) Taille de la vue <= Mémoire disponible pour mapping (2Gb sur 32 bits) Stream (lecture séquentielle) Accessor (lecture aléatoire) Process 1 Process 2

121. BCL – Fichiers mappés en mémoire – 2/2 Process 1 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(); } Ou mmf.CreateViewAccessor Process 2 using(var mmf = MemoryMappedFile.OpenExisting("FichierMappé")) { using(var stream = mmf.CreateViewStream()) Console.WriteLine(new BinaryReader(stream).ReadString()); }

123. Disponible dans 3.5 (installation séparée)

124. 4 parties

125. Une nouvelle API  System.Diagnostics.Contracts

126. Le « rewriter » (ccrewrite.exe)

127. Injecte le code de vérification des contrats « aux bons endroits »

128. Le « staticchecker » (cccheck.exe)

129. Analyse le code pour vérifier si les contrats sont respectés

130. Le générateur d’assembly(ccrefgen.exe)

132. Pré-condition

133. Evalué « avant » l’appel

134. Contract.Ensures

135. Post-condition

136. Evalué « après » l’appel

137. Contract.OldValue

138. Retourne la valeur avant l’appel

139. ContractInvariantMethod

140. Invariance de l’objet

141. Appelé après chaque appel publicpublic class CompteBancaire { privateintnumeroCompte, modulo; private double solde; public voidEffectueDepot(double montant) { this.solde += montant; } staticvoidMain() { var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 }; compte.EffectueDepot(1000); } } public class CompteBancaire { privateintnumeroCompte, modulo; private double solde; public voidEffectueDepot(double montant) { Contract.Requires(montant > 0); this.solde += montant; } staticvoidMain() { var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 }; compte.EffectueDepot(1000); } } public class CompteBancaire { privateintnumeroCompte, modulo; private double solde; public voidEffectueDepot(double montant) { Contract.Requires(montant > 0); Contract.Ensures(ancien solde < nouveau solde); this.solde += montant; } staticvoidMain() { var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 }; compte.EffectueDepot(1000); } } public class CompteBancaire { privateintnumeroCompte, modulo; private double solde; public voidEffectueDepot(double montant) { Contract.Requires(montant > 0); Contract.Ensures(Contract.OldValue(this.solde) < this.solde); this.solde += montant; } staticvoidMain() { var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 }; compte.EffectueDepot(1000); } } public class CompteBancaire { privateintnumeroCompte, modulo; private double solde; public voidEffectueDepot(double montant) { Contract.Requires(montant > 0); Contract.Ensures(Contract.OldValue(this.solde) < this.solde); this.solde += montant; } [ContractInvariantMethod] privatevoidObjectInvariant() { Contract.Invariant(this.solde >= 0); Contract.Invariant(this.numeroCompte % 97 == this.modulo); } staticvoidMain() { var compte = new CompteBancaire { numeroCompte = 0011234567, modulo = 27 }; compte.EffectueDepot(1000); } }

143. BlockingCollection<T>

144. ConcurrentQueue<T>

145. ConcurrentDictionary<K, V>

146. Lazy<T>

147. System.Threading

148. SemaphoreSlim

149. ManuelResetEventSlim

150. SpinLock

151. Visual Studio

152. Nouveau Debugger

153. Nouveau ProfilerParallel.Invoke(() => RealiseAction1(), () => RealiseAction2(), () => RealiseAction3());

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

156. Prévu pour .NET 3.5

157. Retardé pour problème de performance

158. Toutes opérations de int

159. Autres opérations (statiques)

160. Abs

161. DivRem

162. GreatestCommonDivisor

163. RemainderstaticBigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } staticvoidMain() { Console.WriteLine(Factorielle(5)); } staticBigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } staticvoidMain() { Console.WriteLine(Factorielle(5)); Console.WriteLine(Factorielle(10)); } staticBigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } staticvoidMain() { Console.WriteLine(Factorielle(5)); Console.WriteLine(Factorielle(10)); Console.WriteLine(Factorielle(55)); } staticBigInteger Factorielle(BigInteger i) { if (i == 2) return 2; return i * Factorielle(--i); } staticvoidMain() { Console.WriteLine(Factorielle(5)); Console.WriteLine(Factorielle(10)); Console.WriteLine(Factorielle(55)); Console.WriteLine(Factorielle(542)); } 120 120 3628800 120 3628800 12696403353658275925965100847566516959580321051449436762275840000000000000 120 3628800 12696403353658275925965100847566516959580321051449436762275840000000000000 1607535095378011891056328484225529595243838798499054994766025156939288169810835272449306354580237969682411561904659247352233869578500369085015849202525200 // 11 autreslignes de chiffres 27593805066916468242618448796850243328574235699250768859321062302677755711983880776617227228201878615112377392168960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

165. Paramètres nommés et optionnels

166. Types dynamiques

167. Interopérabilité COM

168. Améliorations à la Base Class LibraryConclusion

170. Nouveautés au niveau du langage

171. Codage

172. Simplifications d’écriture

173. Amélioration des performances

174. Design

175. Interopérabilité simplifiée et homogénéisée

176. « Design By Contracts »

178. Team Foundation Server se démocratise

179. Nouveaux debuggers

180. Modélisation UML

181. Nouveautés au niveau des frameworks

182. ASP.NET, MVC, AJAX 4.0, Sync Framework, F#…

183. Et Après ?

184. C# 5.0 (?) : « Compiler As A Service »Tout simplement une nouvelle révolution

185. Merci à tous ! N’oubliez pas votre formulaire de participation au concours! Prochains évènements 09/03 : Windows Live Meeting – VS 2010 - .NET 4.0 23/03 : MyTIC : Sharepoint 2010 30/03 au 01/04 : Tech Days 2010 21/04 : DotNetHub : Méthodes Agiles 28/04 : DotNetHub : NService Bus