Dynamic Binding in C# 4.0: Mads Torgersen C# Language PM Microsoft Corporation

FT31
Dynamic Binding in C# 4.0
Mads Torgersen
C# Language PM
Microsoft Corporation
Dynamic in C#
> The Dynamic Language Runtime (DLR)
> dynamic in C#
> Designing dynamic

The DLR on the CLR
> Common Language Runtime – CLR:

> Common platform for static languages
> Facilitates great interop
The DLR on the CLR

> Dynamic Language Runtime – DLR:

> Common platform for dynamic languages
The DLR on the CLR

> Dynamic Language Runtime – DLR:

> Common platform for dynamic languages
Dynamic Objects
> Implement their own binding
> The DLR caches and optimizes
> Built by dynamic languages – or you!

Why Dynamic in C#?
> Build on DLR opportunity
> Use code from dynamic languages
> Use other dynamic object models
> Better COM interop

The Dynamic Type in C#
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 });
ScriptObject calc = GetCalculator();
int sum = Convert.ToInt32(res);
object res = calc.Invoke("Add", 10, 20);
Statically typed dynamic calc = GetCalculator();

to be dynamic int sum = calc.Add(10, 20);
Dynamic Dynamic method

conversion invocation
C# Dynamic
demo
Designing Dynamic
> C# is not a dynamic language!
> Dynamic is a dangerous foreign element
> Should be syntactically explicit

Static Example
string[] strings = GetStrings();
string last = strings[strings.Length – 1];

Explicit Dynamic Operations
object strings = GetDynamicObject();

string last = strings[strings~.Length – 1];

string last = strings~[strings~.Length – 1];

string last = strings~[strings~.Length ~– 1];

string last = (string)strings~[strings~.Length ~– 1];

string last = ~(string)strings~[strings~.Length ~– 1];

> Reads horribly!
> Dynamic binding travels in packs!

> Reads horribly!
> Dynamic binding travels in packs!

Dynamic Contexts

string last;
dynamic { last = strings[strings.Length – 1]; }
Dynamic Contexts

string last;
> Different dialect of C# inside

> Opt out with static contexts?
> Lose sight of big contexts
Dynamic Contexts

string last;
> Different dialect of C# inside

> Opt out with static contexts?
> Lose sight of big contexts

Contagious Dynamic Expressions
string last = strings[dynamic(strings).Length – 1];

> Rules of propagation – what is dynamic?
> Factoring out subexpressions is hard

> Rules of propagation – what is dynamic?
> Factoring out subexpressions is hard

Dynamic Type
dynamic strings = GetDynamicObject();

Dynamic Type
> “Dynamicness” follows the object
> There is no syntactic difference!

Dynamic Type
> “Dynamicness” follows the object
> There is no syntactic difference!

Why is this OK?
> Embrace dynamic!
> Still explicit – just not in syntax!
> Replaces lengthy error-prone code

Type or Type Modifier?
> Generality:
dynamic Foo foo = GetDynamicFoo();
> Static binding of Foo’s members
> Dynamic binding of the rest
> Simplicity:
dynamic foo = GetDynamicFoo();
> Dynamic binding of all members

> Even those on Object
Type or Type Modifier?
> Generality:
dynamic Foo foo = GetDynamicFoo();
> Static binding of Foo’s members
> Dynamic binding of the rest 
> Simplicity:
dynamic foo = GetDynamicFoo();
> Dynamic binding of all members

> Even those on Object

Dynamic Binding When?
> When the receiver is dynamic:

dynamic result = Math.Abs((double)d);
> Forces you to choose a type
> When any subexpression is dynamic:

dynamic result = Math.Abs(d);
> Softer landing
Dynamic Binding When?
> When the receiver is dynamic:

dynamic result = Math.Abs((double)d);
> Forces you to choose a type 
> When any subexpression is dynamic:
dynamic result = Math.Abs(d);
> Softer landing

Dynamic Operations
> Dynamic result:

> Method call Math.Abs(d)
> Invocation d(“Hello”)
> Member access d.Length
> Operator application 4 + d
> Indexing d[“Hello”]
> Static result:
> Conversions (double)d
> Object creation new Foo(d)
How Dynamic?
M(GetFoo(), d);
Bind with Bind with

compile-time type runtime type
How Dynamic?
M(GetFoo(), d);
Bind with Bind with

compile-time type runtime type
> “Just enough” dynamicness
> Principle of least surprise:

> Argument’s contribution to binding is invariant
The Meaning of dynamic
dynamic means
“use my runtime type for binding”
Twice Daily Against Skepticism
> Which would you rather see – or write?
Type calcType = calc.GetType();

object res = calcType.InvokeMember("Add",
BindingFlags.InvokeMethod, null,
new object[] { 10, 20 });
or
int sum = calc.Add(10, 20);
Related Sessions
Future Directions for C# and Visual Basic
November 17, 11:00 - 12:00 – Hall F Luca Bolognese
Dynamic Binding in C# 4
November 17, 12:30 - 13:15 – Hall F Mads Torgersen
Using Dynamic Languages to Build Scriptable Applications
November 17, 12:30 - 13:15 – 403AB Dino Viehland
Code Like the Wind with Microsoft Visual Basic 2010
November 18, 13:00 - 13:45 – Petree Hall D Lucian Wischik
F# for Parallel and Asynchronous Programming
November 19, 11:30 - 12:30 – 515A Luke Hoban
Microsoft Visual C# IDE Tips and Tricks
November 19, 12:45 - 13:30 – Petree Hall D DJ Park
Microsoft Visual Basic IDE Tips and Tricks
November 19, 12:45 - 13:30 – Petree Hall C Dustin Campbell
YOUR
FEEDBACK IS
IMPORTANT TO
US! Please fill out session
evaluation forms online
at
MicrosoftPDC.com
Learn More On Channel 9
> Expand your PDC experience through
Channel 9
> Explore videos, hands-on labs, sample code

and demos through the new Channel 9
training courses
channel9.msdn.com/learn
Built by Developers for Developers….
© 2009 Microsoft Corporation. All rights reserved. Microsoft, Windows, Windows Vista and other product names are or may be registered trademarks and/or trademarks in the U.S. and/or other countries.
The information herein is for informational purposes only and represents the current view of Microsoft Corporation as of the date of this presentation. Because Microsoft must respond to changing market
conditions, it should not be interpreted to be a commitment on the part of Microsoft, and Microsoft cannot guarantee the accuracy of any information provided after the date of this presentation. MICROSOFT
MAKES NO WARRANTIES, EXPRESS, IMPLIED OR STATUTORY, AS TO THE INFORMATION IN THIS PRESENTATION.

Dynamic Binding in C# 4.0: Mads Torgersen C# Language PM Microsoft Corporation

Uploaded by

Copyright:

Available Formats

Dynamic Binding in C# 4.0: Mads Torgersen C# Language PM Microsoft Corporation

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Dynamic Binding in C# 4.0: Mads Torgersen C# Language PM Microsoft Corporation

Uploaded by

Copyright:

Available Formats

FT31

Dynamic Binding in C# 4.0

> The Dynamic Language Runtime (DLR)

> Designing dynamic

> Common Language Runtime – CLR:

> Common Language Runtime – CLR:

> Dynamic Language Runtime – DLR:

> Common Language Runtime – CLR:

> Dynamic Language Runtime – DLR:

> Implement their own binding

> The DLR caches and optimizes

> Built by dynamic languages – or you!

> Build on DLR opportunity

> Use code from dynamic languages

> Use other dynamic object models

> Better COM interop

object calc = GetCalculator();

Statically typed dynamic calc = GetCalculator();

Dynamic Dynamic method

> C# is not a dynamic language!

> Dynamic is a dangerous foreign element

> Should be syntactically explicit

string[] strings = GetStrings();

string last = strings[strings.Length – 1];

object strings = GetDynamicObject();

string last = strings[strings.Length – 1];

object strings = GetDynamicObject();

string last = strings[strings~.Length – 1];

object strings = GetDynamicObject();

string last = strings~[strings~.Length – 1];

object strings = GetDynamicObject();

string last = strings~[strings~.Length ~– 1];

object strings = GetDynamicObject();

string last = (string)strings~[strings~.Length ~– 1];

object strings = GetDynamicObject();

string last = ~(string)strings~[strings~.Length ~– 1];

object strings = GetDynamicObject();

string last = ~(string)strings~[strings~.Length ~– 1];

> Reads horribly!

> Dynamic binding travels in packs!

object strings = GetDynamicObject();

string last = ~(string)strings~[strings~.Length ~– 1];

> Reads horribly!

> Dynamic binding travels in packs!

object strings = GetDynamicObject();

object strings = GetDynamicObject();

> Different dialect of C# inside

object strings = GetDynamicObject();

> Different dialect of C# inside

object strings = GetDynamicObject();

string last = strings[dynamic(strings).Length – 1];

object strings = GetDynamicObject();

string last = strings[dynamic(strings).Length – 1];

> Rules of propagation – what is dynamic?

> Factoring out subexpressions is hard

object strings = GetDynamicObject();

string last = strings[dynamic(strings).Length – 1];

> Rules of propagation – what is dynamic?

> Factoring out subexpressions is hard