C# 3.0 and 4.0

C# 3.0 & 4.0 Buu Nguyen

Buu Nguyen •  Microso6 MVP ASP.NET/IIS 2010, 2011 •  Vice President of Technology, KMS Technology •  IT Lecturer, RMIT University Vietnam •  www.buunguyen.net/blog •  @buunguyen

Agenda •  .NET and CLR •  EvoluQon of C# •  C# 3.0 and LINQ •  C# 4.0 and Dynamic Programming

.NET AND CLR

.NET Framework C# C++ VB.NET IronRuby ... Visual Studio .NET Common Type System & Common Intermediate Language Common Language Speciﬁca2on Base Class Libraries Common Language Run2me

CTS and CLS •  The Common Type System (CTS) speciﬁes type rules for .NET code. CIL code complies with CTS. •  The Common Language SpeciﬁcaQon (CLS), a subset of CTS, assures language interoperability.

CIL •  Stack-‐based language •  CIL manipulaQon enables –  Dynamic code generaQon, e.g. Fasterﬂect –  Code instrumentaQon, e.g. test coverage tools –  Decompilers, obfuscators…

InteresQng Type Concepts •  Value types vs. reference types •  Stack-‐allocated vs. heap-‐allocated •  Pass-‐by-‐value vs. pass-‐by-‐reference •  Delegate vs. event types

More Types Post 1.x •  ParQal Types (C# 2.0) •  Nullable Types (C# 2.0) •  Generic Types (C# 2.0) •  Dynamic Types (C# 4.0)

EVOLUTION OF C#

C# Language EvoluQon C# 5.0 C# 4.0 Async CaaS Dynamic binding (*) C# 3.0 Named arguments OpQonal parameters LINQ (*) Generic variance Auto-‐ properQes C# 2.0 CollecQon iniQalizer Field-‐like events Robust locking Object iniQalizer Generics (*) Beeer COM interop Anonymous types Nullable types Extension methods Anonymous methods C# 1.0 Yield return ParQal methods Lambda expressions ParQal type Expression trees StaQc class Namespace alias

DirecQon •  Concurrent programming –  FuncQonal-‐style programming in C# 3.0 –  PLINQ in .NET 4.0 •  Dynamic programming –  Dynamic binding in C# 4.0 and CaaS in C# 5.0

C# 3.0

Features •  Implicitly-‐typed Local Variables •  Implicitly-‐typed Arrays •  Auto-‐implemented ProperQes •  Object IniQalizers •  CollecQon IniQalizers •  ParQal Methods •  Anonymous Types •  Extension Methods •  Lambda Expressions •  Expression Trees

Implicitly-‐typed Local Variables •  Beneﬁts –  DRY (Don’t Repeat Yourself) •  SpeciﬁcaQons –  Only apply to local variables –  Must be iniQalized with an non-‐null expression

Implicitly-‐typed Arrays •  More DRY

Auto-‐implemented ProperQes •  AIP allows us to declare properQes with no implementaQon and no backing ﬁelds: compiler will generate code for them automaQcally

Object IniQalizers •  Combine construcQon and property assignments

CollecQon IniQalizers •  Like object iniQalizer, but this Qme applies to collecQons and maps

ParQal Methods •  Method contracts –  Work inside parQal classes –  Must be private & return void –  Can be sta,c or non-‐sta,c –  Cannot have out parameter (support ref nonetheless) –  Must not be virtual, abstract, override, sealed, or new •  Can omit the implementaQon –  All calls will be omieed by the compiler

Anonymous Types •  This feature allows us to quickly create objects inside a method without declaring their corresponding class

Extension Methods •  This feature enable us to add methods to exisQng types. This is useful when –  We don’t have access to source code of a type –  The type is sealed and can’t be inherited

Lambda Expressions •  Shorter form of anonymous methods

Expression Trees •  Code as data –  Enable LINQ-‐2-‐SQL, DLR… –  Can be compiled to delegate –  “Statement trees” are supported in .NET 4.0

Show me some LINQ! var people = from p in GetSalesPeople() where p.HireDate > hireDate select p;foreach (SalesPerson person in people)‫‏‬{ Console.WriteLine(person.FirstName);}

LINQ in a Nutshell Integrate query expressions into languages Uniﬁed approach to query data Declara2ve style of coding Extensible via provider mechanism

How is LINQ Implemented? •  LINQ Query Expressions are translated to normal invocaQons to Standard Query Operators var contacts = from c in customers where c.State == "WA" select new { c.Name, c.Phone }; var contacts = customers .Where(c => c.State == "WA") .Select(c => new { c.Name, c.Phone });

LINQ & C# 3.0 var contacts = from c in customers Query Expression where c.State == "WA" select new { c.Name, c.Phone }; Implicitly-typed Local Variable Lambda Expression var contacts = customers .Where(c => c.State == "WA") .Select(c => new { c.Name, c.Phone });Extension Object Method Initializer Anonymous Type

Where Do SQOs Come From? §  Extensions methods for IEnumerable<T> deﬁned in System.Linq.Enumerable §  Building a LINQ-‐enabled data source is as simple as having your class implemenQng IEnumerable<T>

LINQ Clauses from let where join select orderby group

Structure of LINQ Queries First Line • from clause Middle Lines • from, where, orderby, join, let clauses Last Line • select or group-by clause

LINQ Architecture Visual Basic C# Others… .NET Language-Integrated Query LINQ to ADO.NET LINQ LINQ LINQ LINQ LINQ to XMLto Object to SQL to DataSet to Entities <book> <Qtle/> <author/> <year/> <price/> </book> Objects RelaQonal DB XML

IEnumerable<T> from itemName in srcExpr Object where predExpr Object orderby (keyExpr (ascending | descending)) Object Objects in Memory select selExpr ... where where orderby where orderby select

IQueryable<T> Nothing In from itemName in srcExpr where predExpr orderby (keyExpr (ascending | descending)) Memory select selExpr ... “FROM [srcExpr] WHERE ...” where FROM [srcExpr] WHERE predExpr where ORDER BY [keyExpr]” orderby SELECT [selExpr] where FROM [srcExpr] WHERE predExpr ORDER BY [keyExpr]” orderby select

Deferred vs. Non-‐deferred Operators Deferred Non-‐deferred •  Rule of thumb: LINQ query syntax •  Rule of thumb: scalar/single-‐value or IEnumerable<T> return return or conversion •  AsEnumerable, Cast, •  Aggregate, All, Any, Concat, DefaultIfEmpty, Average, Contains, Count, Distinct, Empty, Except, ElementAt, GroupBy, GroupJoin, ElementAtOrDefault, Last, Intersect, Join, OfType, LastOrDefault, LongCount, OrderBy, Max, Min, Single, OrderByDescending, Range, SingleOrDefault, Sum, Repeat, Reverse, Select, ToArray, ToDictionary, SelectMany, Skip, ToList, ToLookup SkipWhile, Take, TakeWhile, ThenBy, ThenByDescending, Union, Where 36

C# 4.0

Features Covered •  OpQonal Parameters •  Named Arguments •  Beeer COM Interop •  Generic Variance •  Robust Locking •  Field-‐like Events

OPTIONAL PARAMETERS

How to implement MailMessage()?

Overloading

OpQonal Parameters

OpQonal Values •  Numeric and string literals •  null •  Compile-‐Qme constants •  Enum members •  default(T) •  Parameterless constructor for structs

RestricQons •  OpQonal parameters must come a6er required parameters –  Except for parameter array (empty array is used when not speciﬁed) •  OpQonal parameters can’t be ref or out

In Depth: DeﬁniQon Site

In Depth: Call Site

Consequence •  OpQonal values are part of the published API, if they are changed, client code must be recompiled. Worse, the compiler won’t warn you if you don’t change.

NAMED ARGUMENTS

How to Avoid the Comments?

Object IniQalizer

Named Arguments

…Named Arguments

RestricQons •  PosiQonal arguments must come before named arguments

Under the Hood •  The compiler just reorders, that’s all

Consequence •  Parameter names are part of the published API, if they are changed, client code must be changed.

BETTER COM INTEROPERABILITY

How Do You Like This?

#1: Omit ref

#2: OpQonal Parameters

GENERIC VARIANCE

Is This Okay?

No, because…

Generic Covariance •  Generic covariance reserves assignment compaQbility on generic types –  If T1 is a subtype of T2, GT<T1> behaves like subtype of GT<T2> on assignment •  Safe only when GT doesn’t “take in” any T

Example

On Delegate

Is This Okay?

No, because…

Generic Contravariance •  Generic covariance reverses assignment compaQbility on generic types –  If T1 is a subtype of T2, GT<T1> behaves like supertype of GT<T2> on assignment •  Safe only when GT doesn’t return any T

Example

On Delegate

Under the Hood

ROBUST LOCKING

Problem If the thread is aborted a>er the lock is acquired but before we enter the try block, we won’t have released the lock.

SoluQon

FIELD-‐LIKE EVENTS

The Problem Lock on ‘this’ is bad. Lock on ‘type’ is bad.

The SoluQon A simple lock would work, but this is beeer because it’s lock-‐free.

DYNAMIC BINDING

WHAT IS DYNAMIC BINDING

StaQc vs. Dynamic Binding Sta2c Binding Dynamic Biding •  Compiler ﬁgures out which •  All bindings happen during members to call (binding run Qme process) –  Defer subtype polymorphic resoluQon Qll run Qme

StaQc Binding

Beneﬁts of StaQc Binding •  Type and name errors are detected at compile Qme, e.g. –  Invoke non-‐existent members –  Pass in arguments with wrong type –  Perform illegal cast

Dynamic Binding

HOW IS IT IMPLEMENTED?

Run Time Binding •  Instead of aeempQng binding and generaQng CIL, the compiler packages the call and sends it to the Dynamic Language RunQme •  At run Qme, the DLR performs binding and execuQon

Under the Hood becomes

The Dynamic Language RunQme

Process in a nutshell C# dynamic Dynamic builds Objects User-‐deﬁned or from other languages compiled uses IDynamicMetaObjectProvider Call Sites cached Delegate Expression emits Tree DLR C# Binder builds

Dynamic Type in CIL

WHEN DO WE NEED IT?

Key Scenarios 1.  Access a member with only knowledge of its name, arguments, and target object 2.  Interop with dynamic languages, e.g. IronRuby, IronPython 3.  Have the target object decide how to respond to a call at run Qme

Access Members

ReﬂecQon

Dynamic Type

Single vs. MulQple Dispatch Single Dispatch Mul2ple Dispatch •  Method is selected based •  Method is selected based on the runQme type of the on both the runQme type of target object the target object and those of the method’s arguments

Dispatch Example

Invoke Ruby Code

Work with Ruby Class

Work with method_missing

The Magic Interface IDynamicMetaObjectProvider ExpandoObject DynamicObject

ExpandoObject

DynamicObject’s OperaQons Name Descrip2on TryGetMember Member geeer, e.g. obj.Name TrySetMember Member seeer, e.g. obj.age = 10 TryDeleteMember Member removal (no equivalent in C#) TryInvokeMember Method invocaQon, e.g. obj.Invoke() TryConvert CasQng, e.g. (int)obj TryCreateInstance Object creaQon (no equivalent in C#) TryInvoke Self invocaQon, e.g. obj(10) TryBinaryOperaQon Binary operaQon, e.g. obj + 10 TryUnaryOperaQon Unary operaQon, e.g. !obj TryGetIndex Indexer geeer, e.g. obj[“key”] TrySetIndex Indexer seeer, e.g. obj[“key”] = value TryDeleteIndex Indexer removal (no equivalent in C#)

Log Seeers & InvocaQons

StaQcInvoker

Close to the metal

…Close to the metal

RESTRICTIONS

RestricQon #1 •  Doesn’t work with extension methods

RestricQon #2 •  Can’t resolve staQc members or constructors on a dynamic type

RestricQon #3 •  Method groups, anonymous methods and lambda expressions to be casted to exact type

RestricQon #4

http://www.buunguyen.net	5994
http://feeds.feedburner.com	26
http://sotayblog.com	16
url_unknown	16
http://buunguyen.net	13
http://www.slideshare.net	3
http://ngoductuan1987.wordpress.com	2
http://webcache.googleusercontent.com	1

C# 3.0 and 4.0

by Buu Nguyen on Jun 16, 2011

Accessibility

Categories

Tags

Upload Details

Usage Rights

8 Embeds 6,071

Statistics

C# 3.0 and 4.0 — Presentation Transcript