C# 4

22

C# 4

8/02/2010 Mitsuru FURUTARelations techniques développeursMicrosoft Francehttp://blogs.msdn.com/mitsuhttp://blogs.msdn.com/mitsufu

33

Agenda

IntroductionNouveautés de C# 4

Objects typés dynamiquementParamètres nommés et optionnelsInteroperabilité COM amélioréeCo- et Contra-varianceExpressions

Conclusion

444

Evolution de C#

C# 1.0

C# 2.0

C# 3.0

Managed Code

Generics

Language Integrated Query

C# 4.0Dynamic Programming

555

Tendances

Declarative

ConcurrentDynamic

666

Objets typés dynamiquement

Calculator calc = GetCalculator();int sum = calc.Add(10, 20);

object calc = GetCalculator();Type calcType = calc.GetType();object res = calcType.InvokeMember("Add", BindingFlags.InvokeMethod, null, new object[] { 10, 20 });int sum = Convert.ToInt32(res);

ScriptObject calc = GetCalculator();object res = calc.Invoke("Add", 10, 20);int sum = Convert.ToInt32(res);

dynamic calc = GetCalculator();int sum = calc.Add(10, 20);

Statically typed to be dynamic

Dynamic method invocation

Dynamic conversion

777

Objets typés dynamiquement

dynamic x = 1;dynamic y = "Hello";dynamic z = new List<int> { 1, 2, 3 };

Compile-time typedynamic

Run-time typeSystem.Int32

Quand les opérandes sont dynamic…• L’accès aux membres est déterminé à l’exécution• A l’exécution, le type actuel se substitue au type dynamic• Le résultat statique de l’opération est de type dynamic

888

public static class Math{ public static decimal Abs(decimal value); public static double Abs(double value); public static float Abs(float value); public static int Abs(int value); public static long Abs(long value); public static sbyte Abs(sbyte value); public static short Abs(short value); ...}

double x = 1.75;double y = Math.Abs(x);

dynamic x = 1.75;dynamic y = Math.Abs(x);

Objets typés dynamiquement

Method chosen at compile-time:

double Abs(double x)

Method chosen at run-time:

double Abs(double x)

dynamic x = 2;dynamic y = Math.Abs(x);

Method chosen at run-time:

int Abs(int x)

99

DémoObjets typés dynamiquement

101010

DynamicObjectpublic class DynamicObject : IDynamicMetaObjectProvider{ public virtual IEnumerable<string> GetDynamicMemberNames(); public virtual DynamicMetaObject GetMetaObject(Expression parameter); public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result); public virtual bool TryConvert(ConvertBinder binder, out object result); public virtual bool TryCreateInstance(CreateInstanceBinder binder, object[] args, out object result); public virtual bool TryDeleteIndex(DeleteIndexBinder binder, object[] indexes); public virtual bool TryDeleteMember(DeleteMemberBinder binder); public virtual bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result); public virtual bool TryGetMember(GetMemberBinder binder, out object result); public virtual bool TryInvoke(InvokeBinder binder, object[] args, out object result); public virtual bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result); public virtual bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value); public virtual bool TrySetMember(SetMemberBinder binder, object value); public virtual bool TryUnaryOperation(UnaryOperationBinder binder, out object result);}

1111

DémoDynamicObject

121212

Optional and Named Parameters

public StreamReader OpenTextFile( string path, Encoding encoding, bool detectEncoding, int bufferSize);

public StreamReader OpenTextFile( string path, Encoding encoding, bool detectEncoding);

public StreamReader OpenTextFile( string path, Encoding encoding);

public StreamReader OpenTextFile( string path);

Primary method

Secondary overloads

Call primary with default values

131313

Optional and Named Parameters

public StreamReader OpenTextFile( string path, Encoding encoding, bool detectEncoding, int bufferSize);

public StreamReader OpenTextFile( string path, Encoding encoding = null, bool detectEncoding = true, int bufferSize = 1024);

Optional parameters

OpenTextFile("foo.txt", Encoding.UTF8);OpenTextFile("foo.txt", Encoding.UTF8, bufferSize: 4096);

Named argument

OpenTextFile( bufferSize: 4096, path: "foo.txt", detectEncoding: false);

Named arguments must be last

Non-optional must be specified

Arguments evaluated in order written

Named arguments can appear in any order

141414

Improved COM Interoperability

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);

doc.SaveAs("Test.docx");

1515

• Automatic object dynamic mapping• Optional and named parameters• Indexed properties• Optional “ref” modifier• Interop type embedding (“No PIA”)

Improved COM Interoperability

161616

Co- and Contra-variance

void Process(object[] objects) { … }

string[] strings = GetStringArray();Process(strings);

void Process(object[] objects) { objects[0] = "Hello"; // Ok objects[1] = new Button(); // Exception!}

List<string> strings = GetStringList();Process(strings);

void Process(IEnumerable<object> objects) { … }

.NET arrays are co-variant

…but not safelyco-variant

Until now, C# generics have

been invariant

void Process(IEnumerable<object> objects) { // IEnumerable<T> is read-only and // therefore safely co-variant}

C# 4.0 supports safe co- and

contra-variance

171717

Safe Co- and Contra-variance

public interface IEnumerable<T>{ IEnumerator<T> GetEnumerator();}

public interface IEnumerator<T>{ T Current { get; } bool MoveNext();}

public interface IEnumerable<out T>{ IEnumerator<T> GetEnumerator();}

public interface IEnumerator<out T>{ T Current { get; } bool MoveNext();}

out = Co-variantOutput positions only

IEnumerable<string> strings = GetStrings();IEnumerable<object> objects = strings;

Can be treated asless derived

public interface IComparer<T>{ int Compare(T x, T y);}

public interface IComparer<in T>{ int Compare(T x, T y);}

IComparer<object> objComp = GetComparer();IComparer<string> strComp = objComp;

in = Contra-variantInput positions only

Can be treated asmore derived

1818

• Supporté sur les interfaces et délégués• “La variance est statiquement vérifiée

localement”• Les types valeurs sont toujours invariants– IEnumerable<int> n’est pas IEnumerable<object>– Identique aux règles actuelles des tableaux

• Les paramètres ref et out nécessitent des paramètres invariants

Variance in C# 4.0

191919

La Variance dans le .NET Framework 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>

Interfaces

System.Func<in T, …, out R>System.Action<in T, …>System.Predicate<in T>System.Comparison<in T>System.EventHandler<in T>

Delegates

2020

DémoVariance

2121

DémoExpressions