1. What's New In C# 4.0

2. Paulo Morgado

3. The Evolution Of C# Covariance And Contravariance Named And Optional Arguments Dynamic Programming COM Interop Improvements Agenda

4. The Evolution Of C#

5. The Evolution Of C#

6. Trends

7. Dynamic vs. Static

9. Optional Arguments

10. Index Properties (COM)

11. Lambda Statements

12. Auto-Implemented Properties

13. Colection InitializersC# C# VB Co-Evolution

14. The Evolution Of C#

15. The Evolution Of C# http://paulomorgado.net/en/blog/archive/2010/04/12/the-evolution-of-c.aspx Resources

16. Covariance And Contravariance

17. In multilinear algebra and tensor analysis, covariance and contravariance describe how the quantitative description of certain geometrical or physical entities changes when passing from one coordinate system to another. Wikipedia Covariance And Contravarance

18. Type Tis greater than (>) type Sif Sis a subtype of (derives from) T Covariance And Contravarance T≥S typeof(T).IsAssignableFrom(typeof(S))

19. Give 2 types Base and Derived, such that: There is a reference (or identity) conversion between Base and Derived Base ≥ Derived A generic type definition Generic<T> is: Covariant in T If Genérico<Base> ≥ Genérico<Derived> Contravariant in T If Genérico<Base> ≤ Genérico<Derived> Invariant in T If neither of the above apply Covariance And Contravarance

20. Contravariante em T Covariante em T typeof(Base).IsAssignableFrom(typeof(Derived)) typeof(Base).IsAssignableFrom(typeof(Derived)) typeof(G<Derived>).IsAssignableFrom(typeof(G<Base>)) typeof(G<Base>).IsAssignableFrom(typeof(G<Derived>)) Covariance And Contravarance

21. Covariance And Contravarance C# (.NET) arrays are covariant string[] strings = GetStringArray(); Process(strings); … but not safely covariant void Process(object[] objects) { … } void Process(object[] objects) { objects[0] = "Hello"; // Ok objects[1] = newButton(); // Exception! }

22. Covariance And Contravarance Until now, C# (.NET) generics have been invariant List<string> strings = GetStringList(); Process(strings); C# 4.0 supports safe covariance and contravariance void Process(IEnumerable<object> objects) { // IEnumerable<T> is read-only and // therefore safely covariant } void Process(IEnumerable<object> objects) { … }

23. Safe Covariance out= covariant Output positions only publicinterfaceIEnumerable<T> { IEnumerator<T> GetEnumerator(); } publicinterfaceIEnumerable<out T> { IEnumerator<T> GetEnumerator(); } Can be treated as less derived publicinterfaceIEnumerator<T> { T Current { get; } boolMoveNext(); } publicinterfaceIEnumerator<out T> { T Current { get; } boolMoveNext(); } IEnumerable<string> strings = GetStrings(); IEnumerable<object> objects = strings;

24. Safe Contravariance in= contravariantInput positions only Can be treated as more derived publicinterfaceIComparer<T> { int Compare(T x, T y); } publicinterfaceIComparer<in T> { int Compare(T x, T y); } IComparer<object> objComp = GetComparer(); IComparer<string> strComp = objComp;

25. Supported for generic interface and delegate types only. Verified/enforced staticaliy in the definition. Value types are always invariant IEnumerable<int> is not IEnumerable<object> Similar to existing rules for arrays ref and out parameters need invariant types Variance In C# 4.o

26. Variance In .NET 4.0

27. Covariance And Contravariance In Generics http://paulomorgado.net/en/blog/archive/2010/04/13/c-4-0-covariance-and-contravariance-in-generics.aspx Covariance And Contravariance In Generics Made Easy http://paulomorgado.net/en/blog/archive/2010/04/15/c-4-0-covariance-and-contravariance-in-generics-made-easy.aspx Covarince and Contravariance in Generics http://msdn.microsoft.com/library/dd799517(VS.100).aspx Exact rules for variance validity http://blogs.msdn.com/ericlippert/archive/2009/12/03/exact-rules-for-variância-validity.aspx Events get a little overhaul in C# 4, Afterward: Effective Events http://blogs.msdn.com/cburrows/archive/2010/03/30/events-get-a-little-overhaul-in-c-4-afterward-effective-events.aspx Resources

28. Named And Optional Arguments

29. Named And Optional Arguments Greeting("Mr.", "Morgado", 42); Parameters Arguments public void Greeting(string title, string name, intage) They always have names They are never optional

30. Named Arguments int i = 0; Method(i, third: i++, second: ++i); int i = 0; int CS$0$0000 = i++; int CS$0$0001 = ++i; Method(i, CS$0$0001, CS$0$0000); public void Method(intfirst, intsecond, intthird)

31. Optional Arguments int i = 0; Method(i, third: ++i); int i = 0; int CS$0$0000 = ++i; Method(i, 2, CS$0$0000); public void Method(intfirst, intsecond = 5, intthird = 6) public void Method(intfirst, intsecond = 2, intthird = 3) public void Method(intfirst, intsecond) They look like overloads. But they aren’t! public void Method(intfirst)

32. Argument Classes Optional Arguments - Alternative XmlReaderSettings settings = newXmlReaderSettings(); settings.ValidationType = ValidationType.Auto; XmlReader.Create("file.xml", settings); XmlReader.Create( "file.xml", new { ValidationType = ValidationType.Auto }); XmlReader.Create( "file.xml", newXmlReaderSettings { ValidationType = ValidationType.Auto }); Not yet!

33. C# 4.0: Named And Optional Arguments http://paulomorgado.net/en/blog/archive/2010/04/16/c-4-0-named-and-optional-arguments.aspx C# 4.0: Alternative To Optional Arguments http://paulomorgado.net/en/blog/archive/2010/04/18/c-4-0-alternative-to-optional-arguments.aspx Named and Optional Arguments (C# Programming Guide) http://msdn.microsoft.com/library/dd264739(VS.100).aspx Resources

34. Dynamic Programming

35. Dynamic Language Runtime IronPython IronRuby C# VB.NET Others… Dynamic Language Runtime Expression Trees Dynamic Dispatch Call Site Caching PythonBinder RubyBinder COMBinder JavaScriptBinder ObjectBinder

36. Objectos Tipados Dinâmicamente Calculatorcalculator = GetCalculator(); int sum = calc.Add(10, 20); object calculator = GetCalculator(); Type calculatorType = calculator.GetType(); object res = calculatorType.InvokeMember("Add", BindingFlags.InvokeMethod, null, calculator, newobject[] { 10, 20 }); int sum = Convert.ToInt32(res); ScriptObject calculator = GetCalculator(); object res = calculator.Invoke("Add", 10, 20); int sum = Convert.ToInt32(res); Statically typed to be dynamic dynamic calc = GetCalculator(); int sum = calc.Add(10, 20); Dynamic method invocation Dynamic conversion

38. At run-time, actual type(s) substituted for dynamic

40. IDynamicMetaObjectProvider Represents a dynamic object that can have operations determined at run-time. DynamicObject : IDynamicMetaObjectProvider Enables you to define which operations can be performed on dynamic objects and how to perform those operations. ExpandoObject : IDynamicMetaObjectProvider Enables you to add and delete members of its instances at run time and also to set and get values of these members. Building Dynamic Objects

41. Dynamic Programming http://paulomorgado.net/en/blog/archive/2010/04/18/c-4-0-dynamic-programming.aspx C# Proposal: Compile Time Static Checking Of Dynamic Objects http://paulomorgado.net/en/blog/archive/2010/03/19/c-proposal-compile-time-static-checking-of-dynamic-objects.aspx Using Type dynamic (C# Programming Guide) http://msdn.microsoft.com/library/dd264736(VS.100).aspx Dynamic Language Runtime Overview http://msdn.microsoft.com/library/dd233052(v=VS.100).aspx Resources

42. COM Interop Improvements

43. Named and optional arguments Ommiting ref Dynamic Import Automatic mapping object -> dynamic Indexed properties Type Equivalence And Type Embedding (“NO PIA”) COM Interop Improvements

44. Ommiting ref objectfileName = "Test.docx"; object missing = Missing.Value; document.SaveAs(reffileName, 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); document.SaveAs("Test.docx", Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value); document.SaveAs("Test.docx");

45. Dynamic Import ((Excel.Range)(excel.Cells[1, 1])).Value2 = "Hello World!"; excel.Cells[1, 1] = "Hello World!"; Excel.Range range = (Excel.Range)(excel.Cells[1, 1]); Excel.Rangerange = excel.Cells[1, 1];

46. Type Equivalence And Type Embedding (NO PIA)

47. COM Interop Improvements http://paulomorgado.net/en/blog/archive/2010/04/19/c-4-0-com-interop-improvements.aspx Type Equivalence and Embedded InteropTypes http://msdn.microsoft.com/library/dd997297.aspx Resources

48. Demos

50. Conclusion

51. The Evolution Of C# Covariance And Contravariance Named And Optional Arguments Dynamic Programming COM Interop Improvements Conclusion

52. Visual C# Developer Center http://csharp.net/ Visual C# 2010 Samples http://code.msdn.microsoft.com/cs2010samples C# Language Specification 4.0 http://www.microsoft.com/downloads/details.aspx?familyid=DFBF523C-F98C-4804-AFBD-459E846B268E&displaylang=en Resources

53. .NET Reflector http://www.red-gate.com/products/reflector/ LINQPad http://linqpad.net/ Paulo Morgado http://PauloMorgado.NET/ Resources

54. Thank You!