C# in depth

Arnon Axelrod

C# IN DEPTH

About me

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

Anders Hejlsberg

• 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

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

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

ASP.NET: Web ServicesAnd Web Forms

JScript …

Windowsforms

C# Compiler

Native code

JIT Compiler

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

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

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

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

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

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

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;

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

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

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

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

Demo - Vairance

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 future = DownloadDataAsync(...); future.ContinueWith(data => ProcessData(data));

DownloadDataAsync ProcessData

ProcessDataDownloadData

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

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

DownloadDataAsync ProcessData

ProcessDataDownloadData

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 & 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;}

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

public Foo

private

stringX

The Roslyn project

CompilerCompilerSource code

Source code

SourceFile

Source code

.NET Assembly

Meta-programming Read-Eval-Print Loop

LanguageObject Model DSL Embedding

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

Go To Definition

Edit and Continue

Parser Metadata Import

Binder IL Emitter

Symbols

C# in depth

Software

FTM: In-depth tax reporting

An In-depth Survey Analysis Applying Data Mining … · 1 ) An In-depth Survey Analysis Applying Data Mining Techniques School of Computing, Soongsil University 학과의 교육목표

HASIL PENELITIAN in depth in depth interview yang ...thesis.binus.ac.id/doc/Bab4/2011-2-01621-MC Bab4001.pdf · terpengaruh setelah membaca dan memanfaatkan buletin, dan tiga

Lake Erie Trends in Temperature, Secchi Depth, and Dissolved Oxygen Rates…

SDI in-depth K C 140715 Finalfile.truefriend.com/Storage/research/research05/SDI in...Company report focus 리포트 작성 목적 • 합병법인에 대한 투자의견과 목표주가

Depth Conversion and Depth Contour Maps

In-depth mining of clinical data: the construction of

유럽형 APR1400 I&C 심층방호 및 다양성 (D3) 설계 · 2018-01-01 · II. D3 개요 – Defense-in-Depth & Diversity 심층 방어 (Defense-in-Depth) – 계속 심층 방어

Very low depth whole genome sequencing in complex trait ... · 30 bioinformatics tools. Using genotyping chip, whole-exome sequencing (WES, 75x depth) and 31 high-depth (22x) WGS

2010 in-depth-v11

In-depth Interview

StPaint User's Manual - オンデマンド出版・3Dペー …sManual.pdfIs the difference in the picture of the left and right known? In the Depth mode, each depth is expressed by

In-Depth Display (Overweight)imgstock.naver.com/upload/research/industry/... · 2015-02-09 · In-Depth Display Figure 15 OLED 모델명 제조사 Display(PPI) AP DRAM(GB) NAND(GB)

기업심층분석보고서 『In-Depth Business Analysis ...nicednb.co.kr/file/sub02_02_03_5.pdf · 기업심층분석보고서 『In-Depth Business Analysis Report』 주의사항

1.Introduction 2.Description of model 3.Experimental design 4.Ocean ciruculation on an aquaplanet represented in the model depth latitude depth latitude

Techdays Hyper V In Depth V2

A FONS IN DEPTH

INSTRUMEN EVALUASI DIRI - kemenag.go.id file3. Tim memeriksa kelengkapan pengisian dan menentukan pertanyaan-pertanyaan yang diperlukan untuk in-depth interview 4. Tim melakukan in-depth

Defense in Depth Web Inkognito 12/2013

CONTROL DEPTH