Whats New In C# 4 0

What's New In C# 4.0

Paulo Morgado

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

The Evolution Of C#

Trends

Dynamic vs. Static

VB
Named Arguments
Optional Arguments
Index Properties (COM)
Lambda Statements
Auto-Implemented Properties
Colection Initializers
C#
C#
VB
Co-Evolution

The Evolution Of C#

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

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

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

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

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

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!
}

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) { … }

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;

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;

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

Variance In .NET 4.0

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

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

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)

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)

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!

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

Dynamic Programming

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

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

Dynamically Typed Objects
Compile-time typedynamic
Run-time typeSystem.Int32
dynamic x = 1;
dynamic y = "Hello";
dynamic z = newList<int> { 1, 2, 3 };
When operand(s) are dynamic:
Member selection deferred to run-time
At run-time, actual type(s) substituted for dynamic
Static result type of operation is dynamic

Dynamically Typed Objects
public static class Math
{
publicstaticdecimal Abs(decimal value);
publicstaticdouble Abs(double value);
publicstaticfloat Abs(float value);
publicstaticint Abs(int value);
publicstaticlong Abs(long value);
publicstaticsbyte Abs(sbyte value);
publicstaticshort Abs(short value);
...
}
Method chosen at compile-time:double Abs(double x)
double x = 1.75;
double y = Math.Abs(x);
Method chosen at
run-time:double Abs(double x)
dynamic x = 1.75;
dynamic y = Math.Abs(x);
Method chosen at
run-time:int Abs(int x)
dynamic x = 2;
dynamic y = Math.Abs(x);

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

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)
Dynamic Language Runtime Overview
http://msdn.microsoft.com/library/dd233052(v=VS.100).aspx
Resources

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

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

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

Type Equivalence And Type Embedding (NO PIA)

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

Conclusion

The Evolution Of C#
Dynamic Programming
Conclusion

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

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

Thank You!

Whats New In C# 4 0

by Paulo Morgado on Apr 26, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

1 Embed 21

Statistics

Whats New In C# 4 0 — Presentation Transcript