c# in depth

1 Copyright © 2012 Retalix ||

Arnon Axelrod

C# IN DEPTH

2 Copyright © 2012 Retalix |

About me


About youAlready familiar with:? Reflection Generics Lambdas Linq dynamic async/await


Anders Hejlsberg

C♯


Today

• Background• C# 1• C# 2

• C# 3• C# 4• C# 5

(+Roslyn)


Assuming you already know: If/switch/for/foreach/while

Local variables, class variables, static variables, parameters public, private, protected, internal

Classes, interfaces, inheritance Virtual, overload, static methods


Basic terms


Class vs. Object

Class Objects


References / Pointers

class Class2(){ int i2 = 3; byte b2 = 4; char c = 'a'}

class Class1(){ int i = 5; bool b = false; public Class2 c2;}

i b c2 i2 b2 c5 false 0x000

0… 3 4 ‘a’

0x1234

0x4567

x = new Class1()y = new Class2();x.c2 = y;

0x4567

Reference Object


Stack vs. Heap

Stack• Local variables

– Can reference objects on the heap

• Parameter values• Return address• LIFO

Heap• Objects

– Containing fields• Arrays• Allocated on demand

(new)• Freed automatically

(GC)


Static variables• Live for the entire lifespan of the process• Fixed size• Can reference objects on the heap


Value types vs. Reference types

Value types• What?

– byte, char, int, etc.– Enums– Structs

• Where?– Stack– Static– Fields (inside objects)

• Assignment (a=b)– Copy

Reference types• What?

– Class objects• string

– Arrays• Where?

– Heap• Assignment (a=b)

– aliasing


Value types & Reference types - common Can contain fields

Value types References to other Reference Types

Can contain methods Can implement interfaces Can have constructors Can have nested type declarations


Naming scopes• Namespaces• Private, public, internal, protected• Nested types

Relevant only

at compile

time!


The .Net Framework


The .NET Framework

Base Class Library

Common Language Specification

Common Language Runtime

ADO.NET: Data and XML

VB C++ C#Visual Studio.N

ET

ASP.NET: Web ServicesAnd Web Forms

JScript …

Windowsforms


.Net

C# Compiler

CLR

Native code

JIT Compiler

MSIL


CLRThe JIT Compilervoid Main(){ Foo(); Bar();}

IL of Foo

void Foo(){ ... Bar(); ....}

void Bar(){ ...}

IL of Bar

Methods tableFooBar…

JIT Compiler

JIT Compile(Foo)

JIT Compile(Bar)

Machine code for Foo

Machine code for Bar


Garbage Collector Allocation in O(1) Automatic De-allocation

Graph traversal Automatic De-

fragmentation On a background thread

Next free position


CLR 4.5

CLR 4.0

CLR 2.0

CLR 1.0/1.1

.Net/C# evolutionC# 1.0

• Managed Code

C# 2.0

• Generics

C# 3.0

• Linq

C# 4.0

• Dynamic

C# 5.0

• Async/Await

Future

• Compiler as a service

.Net FX 1.0/1.1

.Net FX 2.0

.Net FX 3.0

.Net FX 3.5

.Net FX 4.0

.Net FX 4.5


The Compiler


The Compiler pipeline

Lexical Analyzer

Lexical Analyzer

Lexical Analyzer

Parser

Parser

Parser

Semantics analyzer / Binder

ILEmitter


using System;

// commentpublic class Program{ public static void Main() { Console.WriteLine("Hello, World"); }}

Lexical AnalyzerKeywordIdentifie

rPunctuato

rComment (ignore)Keyword KeywordIdentifie

rPunctuator Keyword Keyword KeywordIdentifie

rPunctuato

rPunctuato

rPunctuator Identifie

rPunctuato

rIdentifie

rPunctuato

r String literalPunctuator

PunctuatorPunctuato

rPunctuator


using System;

public class Program{ public static void Main() { Console.WriteLine("Hello, World"); }}

ParserCompilation-unit

Using-namespace-directive

Class-declaration


using System;


ParserClass-declaration

Class-modifier

IdentifierClass-body


using System;


ParserClass-body

Class-member-declarations


using System;


ParserClass-member-declarations

Method-declaration


using System;


ParserMethod-declaration

Method-header

Method-body


using System;


ParserMethod-body

Statements-list

Statement


using System;


Parserstatement

Expression

Invocation-expression


using System;


ParserInvocation-expression

Primary-expression

Argument-list


using System;


ParserPrimary-expression

Member-access

Primary-expression

Identifier


using System;


ParserPrimary-expression

Simple-name

identifier


C# 1.0


Static memory

Reflection

Methods Table (MyClass)MetadataToString()Equals()MyVirtualMethod()…

MyClass MetadataNameDerived types…FieldsMethods…

Instance 1 of MyClass

Methods tableInstance variables…






Demo - Reflection


Demo - Attributes


Demo – Finalize and IDisposable


Demo - IEnumerable


Demo – Delegates & Events


Demo - params


Demo – Explicit & Implicit interface implementations


C# 2.0


Generics• The problem in .Net 1.0/1.1:

ArrayList list = new ArrayList();list.Add(1);list.Add(2);list.Add("3"); // do you really want to allow that?!

int sum = 0;foreach (object element in list){ sum += (int) element; // is it safe?!}


Generics• Solution in .Net 1.0/1.1:

• MyIntList, MyStringList, MyStudentList, …• Still Boxing and Unboxing…

MyIntList list = new MyIntList();list.Add(1);list.Add(2);list.Add(3); // list.Add(“4”); - compilation error!

int sum = 0;foreach (int element in list){ sum += element;}


Generics• Type safety• Reusable• Optimized

– Jitted once for all reference types– Jitted once for each value type (no boxing and unboxing!)

• Applicable for class, struct, interface, Delegate, method

• Can have constraints (more on that later)• Handled by the compiler and the CLR together


GenericsAutomatic type inference• Example:

int i = 3;

MyMethod<int>(i);

Is equivallent to:MyMethod(i);

• Type arguments for a class can be inferred by the arguments passed to the constructor


Generics• typeof(T) provides the real type using reflection• default(T) provides the default value of a value

type or null for a reference type


Demo - Generics


Generics - constraints• struct / class• Primary type and multiple interfaces• new()


Demo: Generics with constraints


Nullable<T>• int i = null; // syntax error

• int? is a syntactic sugar for System.Nullable<int>

• struct – no boxing/unboxing


Demo – Nullable<T>


Action, Func, PredicateDelegates also support Generics• delegate void Action()

delegate void Action<T>(T arg1);…delegate void Action<T1, T2, T3, …, T8>(T1 arg1, T2 arg2, …, T8 arg8);

• delegate TResult Func<TResult>();delegate TResult Func<T, TResult>(T arg);…delegate TResult Action<T1, T2, …, T8, TResult>(T1 arg1, T2 arg2, …, T8 arg8);

• delegate bool Predicate<T>(T obj);


Demo – Anonymous methods


Demo – Iterator blocks


Demo – Partial types


C# 3


Demo – type inference (var)


Demo – initializer and auto-properties


Demo – Anonymous types


Demo – Lambda expressions


Extension methodsBack to basics…• In the beginning there was ‘C’…• Then there was “C with classes” (C++ to C

compiler)• Then we forgot we can live without classes

What is “this”?


Demo – “this”


Extension methods - Motivationclass MyClass{ //...} class SomeLibraryThatICannotTouch{ MyClass CreateMyClass() { return new MyClass(); }} class MyDerivedClass : MyClass

{ public void AddedFunctionality() { … }}

var myObject = SomeLibraryThatICannotTouch.CreateMyClass();myObject.AddedFunctionality();

Compilation error!


Extension methods

public static MyExtensionClass{ public static void MyExtensionMethod(MyClass

myObject, int i) { // Do something… }}

var myObject = SomeLibraryThatICannotTouch.CreateMyClass();

MyExtensionClass.MyExtensionMethod(myObject, 3);


Extension methods

public static MyExtensionClass{ public static void MyExtensionMethod(this

MyClass myObject, int i) { // Do something… }}

var myObject = SomeLibraryThatICannotTouch.CreateMyClass();

myObject.MyExtensionMethod(3);


Extension methodsThisIs().Some().Expression().MyExtensionMethod(3)

Is equivalent to:

ClassName.MyExtensionMethod(ThisIs().Some().Expression(), 3)

This is not an expression – only a naming scope


Extension methodsPoints to remember: Extension methods are really static methods behind

the scenes Can only access public members Both the class and the method must be declared as

static Only the first argument can be prefixed with the ‘this’

keyword To access the extension method you have to import

the namespace (using namespace)


Demo – Extension methods


Linq – Language Integrated Queries


System.Linq.Enumerable IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source,

Func<TSource, bool> predicate);

bool Contains<TSource>(this IEnumerable<TSource> source, TSource value);

int Count<TSource>(this IEnumerable<TSource> source);

TSource First<TSource>(this IEnumerable<TSource> source);TSource Last<TSource>(this IEnumerable<TSource> source);

decimal Sum(this IEnumerable<decimal> source);

IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);

IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);

IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);


Query Expressions• Language integrated query syntaxfrom itemName in srcExpr( from itemName in source| where condition| join itemName in srcExpr on keyExpr equals keyExpr| let itemName = selExpr| orderby (keyExpr (ascending | descending)?)* )*( select expr | group expr by key )[ into itemName query ]?


from c in customerswhere c.State == "WA"select new { c.Name, c.Phone };

customers.Where(c => c.State == "WA").Select(c => new { c.Name, c.Phone });

Query Expressions• Queries translate to method invocations

– Where, Select, SelectMany, OrderBy, GroupBy


Demo – Linq to Object


Expression Trees


Expression Trees - motivation• Linq to SQL / Entity Framework

from student in StudentsTablewhere student.FirstName.Length == 4orderby student.Grade descendingselect new {student.LastName, student.Grade};

Do we need to retrieve

the entire table?!


Expression Trees((16 + 5 x 4) / 9) + 17 x 3


Demo – System.Linq.Expressions (BatchFileCreator)


Demo – Expression<Tdelegate>.Compile()

(DynamicMethodCreatorDemo)


IQueryable<T>interface IQueryable<T> : IEnumerable<T>, IQueryable, IEnumerable{} public interface IQueryable : IEnumerable

{ Type ElementType { get; } Expression Expression { get; } IQueryProvider Provider { get; }} public interface IQueryProvider

{ IQueryable CreateQuery(Expression expression); IQueryable<TElement> CreateQuery<TElement>(Expression expression); object Execute(Expression expression); TResult Execute<TResult>(Expression expression);}


System.Linq.Queryable IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source,

Expression<Func<TSource, bool>> predicate);

bool Contains<TSource>(this IQueryable<TSource> source, TSource item);

int Count<TSource>(this IQueryable<TSource> source);

TSource First<TSource>(this IQueryable<TSource> source);TSource Last<TSource>(this IQueryable<TSource> source);

decimal Sum(this IQueryable<decimal> source);

IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);

IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);

IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);


Demo – Entity Framework


C# 4


Optional and Named Arguments


Optional & Named Parameterspublic 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


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 & Named ParametersOptional 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


Overload resolution• If two signatures are equally good, one that does

not omit optional parameters is preferred.

– A signature is applicable if all its parameters are either optional or have exactly one corresponding argument (by name or position) in the call which is convertible to the parameter type.

1. M( string s, int i = 1 );2. M( object o );3. M( int i , string s = “Hello” );4. M( int i );

M( 5 ); // 4, 3, & 2 are applicable, // but 4 is the best match.


Demo – Optional and named arguments


Dynamic


PythonBinder

RubyBinder

COMBinder

JavaScriptBinder

ObjectBinder

.NET Dynamic Programming

Dynamic Language Runtime (DLR)Expression Trees Dynamic

Dispatch Call Site Caching

IronPython IronRuby C# VB.NET Others…


Dynamically Typed Objectsobject 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);

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

Statically typed to be dynamic

Dynamic method invocationDynamic

conversion

Syntax Error!


The Dynamic Type• With dynamic you can “do things” that are resolved

only at runtime.• Any object can be implicitly converted to dynamic.

( object dynamic )• Any dynamic Type can be assignment conversion to

any other type. ( dynamic object )

dynamic x = 1; // implicit conversionint num = x; // assignment conversion


Dynamic with Plain Objects• The operation will be dispatched using reflection

on its type and a C# “runtime binder” which implements C#’s lookup and overload resolution semantics at runtime.

dynamic d1 = new Foo(); // assume that the actual type Foo of d1 dynamic d2 = new Bar(); // is not a COM type and does not string s; // implement IDynamicObject

d1.M(s, d2, 3, null); // dispatched using reflection


Overload Resolution with Dynamic Arguments

• If the receiver of a method call is of a static type, overload resolution can still happen at runtime. This can happen if one or more of the arguments have the type dynamic.

public static class Math{ public static decimal Abs(decimal value); public static double Abs(double value); public static float Abs(float value); ...}

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

Method chosen at run-time:

double Abs(double x)


Generics => Dynamic

public T Square<T>( T x ){

return x*x;}public T SumOfSquares<T>( T x , T y ){ return Square(x) + Square(y);}

public dynamic Square( dynamic x ){

return x*x;}public dynamic SumOfSquares( dynamic x , dynamic

y ){ return Square(x) + Square(y);}


Dynamic Limitations• Dynamic lookup will not be able to find extension

methods.

• Anonymous functions cannot appear as arguments to a dynamic method call. dynamic collection = ...;var result = collection.Select(e => e + 5);

Note:1. If the Select method is an extension method, dynamic lookup

will not find it.

2. Even if it is an instance method, the above does not compile, because a lambda expression cannot be passed as an argument to a dynamic operation.


Demo - Dynamic


Co- & Contra- Variance

100

Copyright © 2012 Retalix |

Covariance vs. Contra variance • Covariance (Out):

Is the ability to use a more derived type than that specified.

• Contra variance (in):Is the ability to use a less derived type

delegate Animal MyDel();MyDel del = TestMethod; // Co - Variance (Out): Return Dog as Animal, Ok. public Dog TestMethod(){ ... }

delegate void MyDel( Dog dog );MyDel del = TestMethod; del( new Dog() ); // Contra-Variance (In): Arg Dog as Animal, Ok.public void TestMethod( Animal animal){ ... }

101


Covariance & Generic• What you think?

• Allowing an int to be inserted into a list of strings and subsequently extracted as a string. This would be a breach of type safety.

IList<string> strings = new List<string>();IList<object> objects = strings;

IList<string> strings = new List<string>();IList<object> objects = strings;

// IEnumerable<T> is read-only and therefore safely// co-variant (out).

IEnumerable<object> objects = strings;

102


Covariance

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

Before .Net 4.0, 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

103


Safe Covariance (Out)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

104


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

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

Safe Contra Variance (In)

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

in = Contra-variantInput positions only

Can be treated asmore derived

105


Variance in C# 4.0• Supported for interface and delegate types

– E.g. this doesn’t work:

List<Person> list = new List<Employee>();

• Value types are always invariant– IEnumerable<int> is not IEnumerable<object>– Similar to existing rules for arrays

• Ref and Out parameters need invariant type

106


Variance in .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

107


Covariance and Contra-varianceNotes:• Works only for Generic delegates and interfaces

(not classes!)– E.g. this doesn’t work:

List<Person> list = new List<Employee>();

• Works only for Reference types (no Value types!)– E.g. this doesn’t work:

IEnumerable<Object> objects = new List<int>();

108


Demo - Vairance

109


C# 5

110


ASYNC & AWAIT

111


Terminology• Multi-core• Multi-threading• Parallelism (e.g. Parallel.ForEach)• Concurrency

– Can be single threaded!

CPU Bound

I/O Bound

async & await

112


Problem• Many applications need to perform concurrent

tasks and leave the UI responsive• Writing Concurrent code is cumbersome• The trend is to move most Business Logic to the

server side (WCF, REST, HTTP…)

113


Synchronous vs. asynchronous• var data = DownloadData(...);• ProcessData(data);

var future = DownloadDataAsync(...); future.ContinueWith(data => ProcessData(data));

DownloadDataAsync ProcessData

STOP

ProcessDataDownloadData

114


Synchronous vs. asynchronous• var data = DownloadData(...);• ProcessData(data);

var future = DownloadDataAsync(...); future.ContinueWith(data => ProcessData(data));

DownloadDataAsync ProcessData

STOP

ProcessDataDownloadData

STOP

115


Problem Solution 1 – Blocking Problem: UI is “dead” throughout the process Solution 2 – Background thread Problem – need to sync to the UI thread for

updating the UI. Thread safety is a big concern Solution 3 – Use callbacks/events Problem – makes the code fragmented and hard

to follow

116


The Task/Task<Tresult> classes• Abstraction for a unit of work• Task.Factory.StartNew / Task.Run• Task.Wait• TResult Task.Result• Task.ContinueWith(…)

117


The Await keyword• Syntax:await <expression of type Task>

var result = await <expression of type Task<TResult>>

• result is of type TResult (and not Task<TResult>!)var task = <expression of type Task<TResult>>

var result = await task;

• Yields control to the main thread until the task is completed

118


The Async keyword• Return type must be one of: void, Task or Task<TResult>

• Allows the use of the async keyword inside the method

• return TResult (not Task<TResult>!)• The compiler breaks the method in a manner

similar to the Iterator block transformation, while each call to MoveNext() updates the current Awaiter to the method that will act as the continuation

119


async & awaitpublic async Task<XElement> GetXmlAsync(string url) { var client = new HttpClient(); var response = await client.GetAsync(url); var text = response.Content.ReadAsString(); return XElement.Parse(text);}

public Task<XElement> GetXmlAsync(string url) { var tcs = new TaskCompletionSource<XElement>(); var client = new HttpClient(); client.GetAsync(url).ContinueWith(task => { var response = task.Result; var text = response.Content.ReadAsString(); tcs.SetResult(XElement.Parse(text)); }); return tcs.Task;}

120


GetAwaiter• await can be used with any type that has a GetAwaiter() method (or even extension method) – not just Task<T>

• The minimum required is:– INotifyCompletion:

• OnCompleted(Action handler)

– bool IsCompleted { get; }T GetResult()

121


TaskCompletionSource<TResult>• Represents the “producer” of the task’s result• API:

– SetResult(TResult result)

– SetException(Exception ex)

– SetCanceled()

– Task<TResult> Task { get; }

• Normally you don’t use it directly (Task.Factory.Start is the usual way)

• Helpful if you’re implementing GetAwaiter()

122


Demo – async & await

123


C# vNext

124


Project “Roslyn” – Compiler as a Service

125


Class

Field

public Foo

private

stringX

The Roslyn project

CompilerCompilerSource code

Source code

SourceFile

Source code

Source code

.NET Assembly

Meta-programming Read-Eval-Print Loop

LanguageObject Model DSL Embedding

126


Roslyn APIs

Language Service

Compiler APIs

Compiler Pipeline

Syntax Tree API

Symbol API

Binding and Flow Analysis

APIsEmit API

Formatter

ColorizerOutlining

Navigate To

Object Browser

Completion List

Find All References

Rename

Quick Info

Signature Help

Extract M

ethod

Go To Definition

Edit and Continue

Parser Metadata Import

Binder IL Emitter

Symbols

c# in depth

Software