![Page 1: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/1.jpg)
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 »
Pierre-Emmanuel Dautreppe – 04 Mars 2010
[email protected] – www.pedautreppe.com – @pedautreppe
![Page 2: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/2.jpg)
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# 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
![Page 3: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/3.jpg)
3
Tendances d’évolution de .NET
Programmation Déclarative
Progammation Dynamique
Concurrence / Parallélisation
Programmation Déclarative
CommentImpératif Déclaratif
from i in listwhere i > 10orderby iselect i
foreach ( int i in list ) if ( i > 10 ) result.Add(i);result.Sort();
Programmation Dynamique
Ecriture Dynamique
Typage Implicite
Ecriture
Statique
Concurrence / Parallélisation
Architectures multi-cœur Serveurs multi-processeurs Tirer parti de l’amélioration possible des
performances en se reposant sur des frameworks en programmant différement
Simplifier la prise en compte de la parallélisation
![Page 4: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/4.jpg)
4
Agenda
C# 1.0
C# 2.0
C# 3.0
C# 1.0
C# 2.0
C# 3.0
C# 4.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
![Page 5: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/5.jpg)
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
![Page 6: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/6.jpg)
6
Co & Contra Variance – Définition
Contravariance Un opérateur de conversion de type est contravariant s’il
ordonne les types du plus générique au plus spécifique
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
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
![Page 7: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/7.jpg)
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<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{ static Employé CréeEmployé() { return null; } static Développeur CréeDéveloppeur() { return null; }}
Func<Développeur>
Func<Employé>
Les delegates sont covariants
![Page 8: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/8.jpg)
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);
![Page 9: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/9.jpg)
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”
Possible seulement pour les types références
Il s’agit ici d’une conversion par “boxing” Interdit
int[] intArray = new[] { 1, 2, 3};object[] objArray = intArray;
![Page 10: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/10.jpg)
10
Co & Contra Variance des types génériques – 1/4
Génériques = Sécurité de typage
List<string> strArray = new List<string> { "A", "B" };List<object> objArray = strArray;
List<string> strArray = new List<string> { "A", "B" };IEnumerable<object> objEnum = strArray;
Non « Type Safe » donc non covariant
« Type Safe » donc covariant
![Page 11: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/11.jpg)
11
Co & Contra Variance des types génériques – 2/4
IComparer<string> stringComparer = new MyStringComparer();IComparer<object> objectComparer = new MyObjectComparer();TestContravariance(stringComparer);TestContravariance(objectComparer);
public class MyObjectComparer : IComparer<object> { ... }public class MyStringComparer : IComparer<string> { ... }
public void TestContravariance(IComparer<string> comparer){ comparer.Compare("chaine 1", "chaine 2");}
IComparer<T> est contravariant
IComparer<string> stringComparer = new MyStringComparer();stringComparer.Compare("chaine 1", "chaine 2");
IComparer<object> objectComparer = new MyObjectComparer();objectComparer.Compare("chaine 1", "chaine 2")
![Page 12: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/12.jpg)
12
Co & Contra Variance des types génériques – 3/4
public interface IEnumerable<out T> : IEnumerable{ IEnumerator<T> GetEnumerator();}
Mot-clé « out » T ne doit être utilisé que comme type de retour IEnumerable<T> est covariant
IEnumerable<B> est considéré comme IEnumerable<A> si conversion de référence de B vers A
A B
IEnumerable<A> IEnumerable<B>
![Page 13: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/13.jpg)
13
Co & Contra Variance des types génériques – 4/4
Mot-clé « in » T ne doit être utilisé que comme paramètre d’input IComparer<T> est contravariant
IComparer<A> est considéré comme IComparer<B> si conversion de référence de B vers A
public interface IComparer<in T>{ int Compare(T x, T y);}
A B
IComparer<A> IComparer<B>
![Page 14: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/14.jpg)
14
Variance en .NET 4.0
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>
System.Func<in T, …, out R>System.Action<in T, …>System.Predicate<in T>System.Comparison<in T>System.EventHandler<in T>
Interfaces
Delegates
![Page 15: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/15.jpg)
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
![Page 16: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/16.jpg)
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
![Page 17: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/17.jpg)
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
![Page 18: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/18.jpg)
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 non optionnels doivent être
spécifiés
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
![Page 19: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/19.jpg)
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 l’appel
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
![Page 20: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/20.jpg)
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
![Page 21: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/21.jpg)
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);
Calculator calc = GetCalculator();int resultat = calc.Add(10, 20);
C# C#
C# IronPython
Silverlight Javascript
![Page 22: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/22.jpg)
22
POCOBinder
JavaScript
BinderPythonBinder
RubyBinder
COMBinder
IronPython IronRuby C#Visual Basic
Autres…
Dynamic Language Runtime (DLR)
Expression Trees Dynamic Dispatch Call Site Caching
<
![Page 23: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/23.jpg)
23
Types dynamiques – 1/3
dynamic calc = GetCalculator();int resultat = calc.Add(10, 20);
Calculator calc = GetCalculator();int resultat = calc.Add(10, 20);
Statiquement typé
comme “dynamic”
Appel dynamique de la méthode
Conversion dynamique
de la valeur de retour
![Page 24: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/24.jpg)
24
Types dynamiques – 2/3
Quand les opérandes sont dynamic… La sélection des membres est différée à l’exécution A l’exécution, dynamic est remplacé par le type réel de
chaque membre Le type de retour de l’opération est également dynamic
dynamic x = 1;dynamic y = "Bonjour";dynamic z = new List<int> { 1, 2, 3 };
Type statique (à la compilation) Type dynamique(à l’exécution)
dynamic Int32dynamic Stringdynamic List<int>
![Page 25: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/25.jpg)
25
Types dynamiques – 3/3
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();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);
A la compilation : double Add(double, double)
A l’exécution : double Add(double, double)
A l’exécution : int Add(int, int)
![Page 26: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/26.jpg)
26
Types dynamiques – Points à retenir
La résolution des méthodes est différée à l’exécution si nécessaire
public void Methode(dynamic d)
On ne peut pas appeler des méthodes d’extensions
A savoir (ou non): Nouveaux types de conversion : assignation,
structurelle, …
dynamic n’existe pas au niveau du code IL
![Page 27: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/27.jpg)
27
Types dynamiques – Exemples d’écritures – 1/2
Ces écritures sont valides
dynamic MaMethode(int i, dynamic d) { ... }dynamic MaMethode(int i, dynamic d) { ... }
dynamic[] monArray = ...
dynamic MaMethode(int i, dynamic d) { ... }
dynamic[] monArray = ...
IEnumerable<dynamic> enumerable = ...
dynamic MaMethode(int i, dynamic d) { ... }
dynamic[] monArray = ...
IEnumerable<dynamic> enumerable = ...
List<dynamic> liste = ...
dynamic MaMethode(int i, dynamic d) { ... }
dynamic[] monArray = ...
IEnumerable<dynamic> enumerable = ...
List<dynamic> liste = ...
class BaseClass<T> { }class Derived : BaseClass<dynamic> { }
![Page 28: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/28.jpg)
28
Types dynamiques – Exemples d’écritures – 2/2
Ces écritures ne sont pas valides
class C : dynamic { }class C : dynamic { }
class C : IEnumerable<dynamic> { }
class C : dynamic { }
class C : IEnumerable<dynamic> { }
class C<T> where T : BaseClass<dynamic> { }
Pour plus d’information : Blog de Chris Burrows http://blogs.msdn.com/cburrows/default.aspx
![Page 29: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/29.jpg)
29
Créer un type dynamique – 1/2
public class DynamicObject : IDynamicMetaObjectProvider{ public virtual IEnumerable<string> 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.dllNamespace
System.Dynamic
IDynamicObject a été renommé
![Page 30: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/30.jpg)
30
Créer un type dynamique – 2/2
public class MonDynamicObject : DynamicObject{ Dictionary<string, object> dic = new Dictionary<string, object>();
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);
![Page 31: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/31.jpg)
31
Types dynamiques – Utilisation de la classe Expandostatic 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<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);}
private static void MonEventHandler(dynamic obj, EventArgs e) { Console.WriteLine("MonEvent appelé sur '" + obj.ToString());}
![Page 32: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/32.jpg)
32
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
![Page 33: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/33.jpg)
33
Types dynamiques – Conclusion – 2/2
Quand doit-on les utiliser ? Quand on travaille sans type (par ex. réflexion) Quand on fait de l’interop
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 d’une connaissance des types dérivés
![Page 34: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/34.jpg)
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
![Page 35: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/35.jpg)
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, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing);
Les APIs COM déclarent des paramètres optionnels « ref » n’est plus obligatoire
![Page 36: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/36.jpg)
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];
Les APIs COM renvoient des dynamic Conversion d’assignation vers le type désiré
![Page 37: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/37.jpg)
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
![Page 38: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/38.jpg)
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 TUples
System.IO
Fichiers mappés
Code Contracts
Parallel Extensions
System.Numerics
![Page 39: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/39.jpg)
39
BCL – Tuples – 1/2
public Tuple<bool, int> TryGetElement(string key){ int valeur; bool result = dic.TryGetValue(key, out valeur); return new Tuple<bool, int>(result, valeur);}
public static class Tuple{ public static Tuple<T1> Create<T1>(T1 item1); public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2);
... ...
public static Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> Create<T1, T2, T3, T4, T5, T6, T7, Trest>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest);
}
Supporté nativement par F# et
IronPython
System.Tuple :Factory de Tuple<...>
De 1 à 8 types génériques
Typiquement un autre Tuple<...>
return Tuple.Create(result, valeur);
![Page 40: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/40.jpg)
40
BCL – Tuples – 2/2
« new Tuple » et « Tuple.Create » sont équivalents
var a = new Tuple<int, int, int, int, int, int, int, Tuple<int, int>> (1, 2, 3, 4, 5, 6, 7, new Tuple<int, int>(8, 9));var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));
var a = new Tuple<int, int, int, int, int, int, int, Tuple<int, int>> (1, 2, 3, 4, 5, 6, 7, new Tuple<int, int>(8, 9));var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));
Console.WriteLine(a.Item5); // 5Console.WriteLine(a.Rest.Item2); // 9
var a = new Tuple<int, int, int, int, int, int, int, Tuple<int, int>> (1, 2, 3, 4, 5, 6, 7, new Tuple<int, int>(8, 9));var b = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9));
Console.WriteLine(a.Item5); // 5Console.WriteLine(a.Rest.Item2); // 9
Console.WriteLine(b.Item5); // 5Console.WriteLine(b.Rest.Item1.Item2); // 9
presque !!
Rest = Tuple<int, int>
Rest = Tuple<Tuple<int, int>>
![Page 41: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/41.jpg)
41
BCL – Améliorations à System.IO
var errorlines =from file in Directory.EnumerateFiles(@"C:\logs", "*.log")from line in File.ReadLines(file)where line.StartsWith("Error:")select string.Format("File={0}, Line={1}", file, line);
File.WriteAllLines(@"C:\errorlines.log", errorlines);
var errorlines =from file in Directory.GetFiles(@"C:\logs", "*.log")from line in File.ReadAllLines(file)where line.StartsWith("Error:")select string.Format("File={0}, Line={1}", file, line);
File.WriteAllLines(@"C:\errorlines.log", errorlines);
IEnumerable<string> 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<string> contents);
IEnumerable<string> ReadLines(string path);
![Page 42: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/42.jpg)
42
BCL – Fichiers mappés en mémoire – 1/2
Gros FichierProcess 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)
Stream (lecture séquentielle)Accessor (lecture aléatoire)
Ressource partagée
Process 1 Process 2
Vue N Vue N Vue 1Vue 1
Scénario 1
Scénario 2
Gestion de la mémoire par le système
Pagination automatique en mémoire
Mémoire partagée Simplification pour IPC (Inter-Process Communication)
![Page 43: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/43.jpg)
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
![Page 44: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/44.jpg)
44
CodeContracts – 1/2
Permettre l’ajout 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 d’assembly (ccrefgen.exe) Produit une DLL avec les contrats seuls
![Page 45: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/45.jpg)
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 = 0011234567, 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 = 0011234567, 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 = 0011234567, 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 = 0011234567, 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 = 0011234567, modulo = 27 }; compte.EffectueDepot(1000); }}
• Contract.Requires• Pré-condition• Evalué « avant » l’appel
• Contract.Ensures• Post-condition• Evalué « après » l’appel
• Contract.OldValue• Retourne la valeur avant
l’appel
• ContractInvariantMethod• Invariance de l’objet• Appelé après chaque
appel public
![Page 46: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/46.jpg)
46
PFX – Parallel Framework Extensions
static void Main(){ IEnumerable<int> liste = Enumerable.Range(0, 10000000); 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<T>• ConcurrentQueue<T>• ConcurrentDictionary<K, V>
• Lazy<T>
• System.Threading• SemaphoreSlim• ManuelResetEventSlim• SpinLock
• Visual Studio• Nouveau Debugger• Nouveau Profiler
.AsParallel()
![Page 47: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/47.jpg)
47
System.Numerics – 1/2
Une nouvelle DLL : System.Numerics.dll BigInteger
Un entier, « arbitrairement grand » Complex
Structure pour représenter des nombres complexes
![Page 48: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/48.jpg)
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));}
1203628800
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));}
120362880012696403353658275925965100847566516959580321051449436762275840000000000000
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));} 120
3628800126964033536582759259651008475665169595803210514494367622758400000000000001607535095378011891056328484225529595243838798499054994766025156939288169810835272449306354580237969682411561904659247352233869578500369085015849202525200// 11 autres lignes de chiffres27593805066916468242618448796850243328574235699250768859321062302677755711983880776617227228201878615112377392168960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
• 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
![Page 49: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/49.jpg)
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
![Page 50: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/50.jpg)
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
![Page 51: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/51.jpg)
51
Conclusion – 2/2
Nouveautés au niveau de l’environnement 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
![Page 52: Découvrez C# 4.0 et les améliorations apportées à la BCL](https://reader033.vdocuments.pub/reader033/viewer/2022061114/545d4529af7959c8098b4afa/html5/thumbnails/52.jpg)
52
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
Merci à tous !