C# in depth

1Copyright © 2012 Retalix |
|
Arnon Axelrod
C# IN DEPTH

About me

About you
Already familiar
with:?
 Reflection
 Generics
 Lambdas
 Linq
 dynamic
 async/await

Anders Hejlsberg

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 c
5 false 0x0000 … 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

The .Net Framework

The .NET Framework
Base Class Library
Common Language Specification
Common Language Runtime
ADO.NET: Data and XML
VB C++ C#
VisualStudio.NET
ASP.NET: Web Services
And Web Forms
JScript …
Windows
forms

.Net
C# Compiler
CLR
JIT Compiler
MS
IL

CLR
The JIT Compiler
void Main()
{
Foo();
Bar();
}
IL of Foo
void Foo()
{
...
Bar();
....
}
void Bar()
{
...
}
IL of Bar
Methods
table
Foo
Bar
…
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# evolution
C# 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
IL
Emitter

using System;
// comment
public class Program
{
public static void Main()
{
Console.WriteLine("Hello, World");
}
}
Lexical Analyzer
KeywordIdentifierPunctuator
Comment
(ignore)Keyword KeywordIdentifier
Punctuator
Keyword Keyword KeywordIdentifierPunctuatorPunctuator
Punctuator
IdentifierPunctuatorIdentifierPunctuatorString literalPunctuatorPunctuator
Punctuator
Punctuator

using System;
{
{
}
}
Parser
Compilation-
unit
Using-
namespace-
directive
Class-
declaration

using System;
{
{
}
}
Parser
Class-
declaration
Class-
modifier
Identifier
Class-body

using System;
{
{
}
}
Parser
Class-body
Class-
member-
declarations

using System;
{
{
}
}
Parser
Class-
member-
declarations
Method-
declaration

using System;
{
{
}
}
Parser
Method-
declaration
Method-
header
Method-
body

using System;
{
{
}
}
Parser
Method-
body
Statements-
list
Statement

using System;
{
{
}
}
Parser
statement
Expression
Invocation-
expression

using System;
{
{
}
}
Parser
Invocation-
expression
Primary-
expression
Argument-
list

using System;
{
{
}
}
Parser
Primary-
expression
Member-
access
Primary-
expression
Identifier

using System;
{
{
}
}
Parser
Primary-
expression
Simple-
name
identifier

C# 1.0

Static memory
Reflection
Methods Table
(MyClass)
Metadata
ToString()
Equals()
MyVirtualMethod()
…
MyClass
Metadata
Name
Derived types…
Fields
Methods
…
Instance 1 of
MyClass
Methods table
Instance
variables…
Instance 2 of
MyClass
Methods table
Instance
variables…
Instance 3 of
MyClass
Methods table
Instance
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

Generics
Automatic 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, Predicate
Delegates 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 methods
Back 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
this

Demo – “this”

Extension methods - Motivation
class 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 methods
ThisIs().Some().Expression().MyExtensionMethod(3)
Is equivalent to:
ClassName.MyExtensionMethod(ThisIs().Some().Expression(), 3)
This is not an
expression – only a
naming scope

Extension methods
Points 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<TResult> Select<TSource, TResult>(this IEnumerable<TSource>
source, Func<TSource, TResult> selector);

Query Expressions
• Language integrated query syntax
from 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 customers
where 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 StudentsTable
where student.FirstName.Length == 4
orderby student.Grade descending
select new {student.LastName, student.Grade};

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> Intersect<TSource>(this IEnumerable<TSource> first,
 IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource>
source, Func<TSource, TResult> selector);

Demo – Entity Framework

C# 4

Optional and Named
Arguments

Optional & Named Parameters
public StreamReader OpenTextFile(
string path,
Encoding encoding,
bool detectEncoding,
int bufferSize);
string path,
Encoding encoding,
bool detectEncoding);
string path,
Encoding encoding);
string path);
Primary method
Secondary
overloads
Call primary with
default values

string path,
Encoding encoding,
bool detectEncoding,
int bufferSize);
string path,
Encoding encoding = null,
bool detectEncoding = true,
int bufferSize = 1024);
Optional & Named Parameters
Optional 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

Python
Binder
Ruby
Binder
COM
Binder
JavaScript
Binder
Object
Binder
.NET Dynamic Programming
Dynamic Language Runtime (DLR)
Expression Trees Dynamic Dispatch Call Site Caching
IronPython IronRuby C# VB.NET Others…

Dynamically Typed Objects
object 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
invocation
Dynamic
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 conversion
int 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

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

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;

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 safely
co-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

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-variant
Output positions only
IEnumerable<string> strings = GetStrings();
IEnumerable<object> objects = strings;
Can be treated as
less derived

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-variant
Input positions only
Can be treated as
more derived

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

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

Covariance and Contra-variance
Notes:
• Works only for Generic delegates and interfaces (not
classes!)
List<Person> list = new List<Employee>();
• Works only for Reference types (no Value types!)
IEnumerable<Object> objects = new List<int>();

Demo - Vairance

C# 5

ASYNC & AWAIT

Terminology
• Multi-core
• Multi-threading
• Parallelism (e.g. Parallel.ForEach)
• Concurrency
– Can be single threaded!
CPU Bound
I/O Bound
async & await

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

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

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

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

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

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

async & await
public 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;
}

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

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

Demo – async & await

C# vNext

Project “Roslyn” –
Compiler as a Service

Class
Field
public Foo
private
string
X
The Roslyn project
CompilerCompilerSource
code
Source
code
Source
File
Source
code
Source
code
.NET
Assembly
Meta-programming Read-Eval-Print Loop
Language
Object Model
DSL Embedding

Roslyn APIs
Language
Service
Compiler
APIs
Compiler
Pipeline
Syntax
Tree API
Symbol
API
Binding and
Flow Analysis
APIs
Emit
API
Formatter
Colorizer
Outlining
NavigateTo
ObjectBrowser
CompletionList
FindAll
References
Rename
QuickInfo
SignatureHelp
ExtractMethod
GoToDefinition
Editand
Continue
Parser
Metadata
Import
Binder
IL
Emitter
Symbols

C# in depth

In this document

More Related Content

What's hot

Similar to C# in depth

More from Arnon Axelrod

Recently uploaded

C# in depth