C#

for C++ Programmers

Krzysztof Mossakowski
Faculty of Mathematics and Information Science
Warsaw University of Technology, Poland
http://www.mini.pw.edu.pl/~mossakow
C# vs C++ - Differences
„ Compile target
„ Memory management
„ Pointers
„ Operator overloads
„ Target environments
„ Preprocessor directives
„ Enumerators
„ Destructors
„ Classes versus structs
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
C# vs C++ - Similarities
„ Syntax
„ Execution flow
„ Exceptions
„ Inharitance model
„ Constructors

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

C# vs C++ - New Features
„ Delegates
„ Events
„ Properties
„ Interfaces
„ Attributes
„ Threading
„ Reflection

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

C# vs C++ - Unsupported
„ Multiple inheritance
„ Templates
… supported as Generics in version 2.0

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

General
„ No header files, no #include directive
„ No requirement for items to be defined before
they are referenced in any individual file
„ No linking after compilation to an assembly
„ Program entry point:
static int Main(string[] args)
(metod of a class)

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Language Syntax
„ Does not require semicolon after a class
definition
„ Permits expressions to be used as statements
even if they have no effect (e.g. i+1)
„ Case-sensitive
… (Visual Basic .NET is case-insensitive – potential
problems with interoperatibility)
„ No forward declarations
… the order of definitions is not significant
„ No separation of definition and declaration
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Program Flow
„ All condition expressions must evaluate to a
bool type
int
int xx == 10;
10;
if
if (( xx !=
!= 00 )) //
// OK
OK
if
if (( xx ==
== 00 )) //
// OK
OK
if
if (( xx )) //
// compilation
compilation error
error
if
if (( xx == 00 )) //
// compilation error
compilation error

„ switch
… string can be used as test variable
… no falling throught to the next case clause
… goto case ___

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Foreach Statement
„ Foreach loop iterates through all items in an
array or collection
… collection
is a class which implements the interface
IEnumerable or declares GetEnumerator method
„ Read-only access to iterated elements
foreach
foreach (double
(double someElement
someElement in in MyArray)
MyArray)
{{
Console.WriteLine(someElement);
Console.WriteLine(someElement);
someElement
someElement *=*= 2;
2; //
// Error!
Error! read-only
read-only access
access
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Enumerations
enum
enum Color
Color :: short
short {{ Red,
Red, Green
Green == 5,
5, Blue
Blue }}
// ending semicolon is optional
// ending semicolon is optional
//
// Red=0,
Red=0, Green=5,
Green=5, Blue=6
Blue=6
//
// (default type
(default type isis int,
int, here
here short
short isis used)
used)

Color
Color myColor
myColor == Color.Red;
Color.Red;
Console.WriteLine("{0}",
Console.WriteLine("{0}", myColor);
myColor);
//
// Displays
Displays Red
Red

Color
Color secondColor
secondColor == (Color)Enum.Parse(
(Color)Enum.Parse(
typeof(Color),
typeof(Color), "GREEN",
"GREEN", true
true );
);
// true – ignore case
// true – ignore case

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Basic Data Types
„ Integer: „ Characters and string:
… sbyte, byte – 8-bit … char – 16-bit Unicode
… short, ushort – 16-bit … string – set of Unicode
… int, uint – 32-bit characters
… long, ulong – 64-bit

„ Floating point: „ object

… float – 32-bit
… double – 64-bit
… decimal – 28
significant digits
„ No unsigned,
signed keywords
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Basic Data Types as Classes
„ string ≡ System.String
int ≡ System.Int32 etc.
„ Very useful methods and fields, e.g.:
… char: IsLetter, ToUpper
… string: Length, Format, Substring
… numeric types: MinValue, MaxValue, Parse
… floating point types: Epsilon,
PositiveInfinity, NegativeInfinity

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Casting
„ Implicit and explicit
float
float f1
f1 == 40.0F;
40.0F;
long
long l1 == (long)f1;
l1 (long)f1; //
// explicit:
explicit: possible
possible rounding
rounding
short
short s1 = (short) l1; // explicit: possible overflow
s1 = (short) l1; // explicit: possible overflow
int
int i1
i1 == s1;
s1; //
// implicit:
implicit: no
no problems
problems
uint
uint i2
i2 == (uint)i1;
(uint)i1; //
// explicit:
explicit: possible
possible sign
sign error
error
uint
uint i2
i2 == uint(i1);
uint(i1); //
// wrong
wrong syntax
syntax

„ Checked casting (default: not checked)

… OverflowException at runtime
checked
checked {{
int
int i1
i1 == -3;
-3;
uint
uint i2
i2 == (uint)i1;
(uint)i1;
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Initialization of Variables
„ Member fields of classes and structs are
initialized by 0, false or null
„ Variables local in methods are not initialized
… compilation error: Use of unassigned local variable

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Value and Reference Types
Value Types Reference Types
The variable contains the value The variable contains a reference
directly to the data (data is stored in
separate memory area)
Allocated on stack Allocated on heap using the new
keyword
Assigned as copies Assigned as references

Default behavior is pass by value Passed by reference

== and != compare values == and != compare the

references, not the values
simple types, structs, enums classes

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Boxing and Unboxing
„ Boxing
… to treat a value type as it were a reference type
int
int pp == 123;
123;
object
object box;
box;
box
box == p;
p;

„ Unboxing
pp == (int)box
(int)box
„ Ways to Reduce Boxing and Unboxing
Operations of Value Types
… Encapsulate value types in a class
… Manipulate value types through interfaces
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Strings
„ Escaping special characters
(\’ \” \\ \0 \a \b \f \n \r \t \v)
… \0is not a string terminator
… @ prevents any character from being escaped
@”C:\Program Files\”
„ Unicode
… \u#### - can be used in variable names

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

System.String Class
„ Many methods and properties, e.g.:
… [], Length, Copy, Insert, Concat, Trim,
Pad, ToUpper, ToLower, Join, Split
… Compare - dictionary ordering, case-insensitive
option, locale-specific options
… Equals, ==,!= - value comparison

„ string is immutable
… StringBuilder class - allows to modify a string
without creating a new object
int
int MyInt
MyInt == int.Parse("123,456",
int.Parse("123,456",
System.Globalization.NumberStyles.AllowThousands);
System.Globalization.NumberStyles.AllowThousands);
string
string MyString
MyString == 100.ToString("C");
100.ToString("C"); //
// "$100.00"
"$100.00"
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Regular Expressions
„ Regular expressions – powerful text processing
„ Pattern-matching notation allows to:
… findspecific character patterns
… extract, edit, replace, or delete text substrings
… add the extracted strings to a collection to generate a
report
„ Designed to be compatible with Perl 5
„ System.Text.RegularExpressions.RegEx

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Arrays
double
double []
[] array;
array;
array
array == new
new double[3];
double[3];
double
double []
[] array
array == new
new double[3];
double[3];
double
double []
[] array
array == new
new double[3]
double[3] {{ 1.0,
1.0, 2.0,
2.0, 3.0
3.0 };
};
double
double []
[] array
array == {{ 1.0,
1.0, 2.0,
2.0, 3.0
3.0 };
};

class
class Example3
Example3 {{
static
static void
void Main(string[
Main(string[ ]] args)
args) {{
foreach
foreach (string
(string arg
arg in
in args)
args) {{
System.Console.WriteLine(arg);
System.Console.WriteLine(arg);
}}
}}
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

System.Array
„ All arrays are instances of the base class
System.Array
… many useful properties and methods
„ Rank, Length, Sort, Clear, Clone, GetLength,
IndexOf
… theoverhead is greater than that for C++ arrays
… IndexOutOfRangeException
… copyingan array variable copies the reference only
… implement ICloneable, IList, ICollection,
IEnumerable

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Multidimensional Arrays
„ Rectangular
int
int [,]
[,] myArray2d;
myArray2d;
myArray2d
myArray2d == new
new int[2,3]
int[2,3] {{ {1,
{1, 0},
0}, {3,
{3, 6},
6}, {9,
{9, 12}
12} };
};
int
int [,,]
[,,] myArray3d
myArray3d == new
new int[2,3,2];
int[2,3,2];
//
// default
default constructor
constructor isis called
called onon each
each element
element

int
int xx == myArray3d[1,2,0]
myArray3d[1,2,0] ++ myArray2d[0,1];
myArray2d[0,1];
„ Jagged
int
int [][]
[][] myJaggedArray
myJaggedArray == new
new int[3][];
int[3][];
for (int i=0; i<3; i++)
for (int i=0; i<3; i++)
myJaggedArray[i]
myJaggedArray[i] == new
new int[2*i
int[2*i ++ 2];
2];

int
int xx == myJaggedArray[1][3];
myJaggedArray[1][3];
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Sorting an Array
„ Sort Method Using Element’s
IComparable.CompareTo
Array.Sort(
Array.Sort( anArray
anArray );
);

„ IComparable.CompareTo Design Pattern

public
public int
int CompareTo(Object
CompareTo(Object anObject)
anObject) {{
if
if ( anObject == null) return
( anObject == null) return 1;
1;
if
if ( !(anObject is <classname>) )) {{
( !(anObject is <classname>)
throw
throw new
new ArgumentException();
ArgumentException(); }}
//
// Do comparison and
Do comparison and return
return aa
//
// negative
negative integer if
integer if instance
instance << anObject
anObject
//
// 00 if if instance
instance ==
== anObject
anObject
//
// positive
positive integer
integer ifif instance
instance >> anObject
anObject
}}
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
System.Collections
„ Examples:
… ArrayList
„ implements IList by using a dynamically-sized array
… DictionaryBase
„ provides abstract base class for strongly-typed collection of
associated keys and values
… Hashtable
„ collection of keys and values using key’s hash code
… SortedList
„ Represents the collection of keys and values, sorted by keys
and accessible by key and index
… BitArray, Queue, Stack
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
The new operator
MyClass
MyClass Mine;
Mine; //
// Just
Just declares
declares aa reference.
reference.
//
// Similar
Similar to
to declaring
declaring
//
// an
an uninitialized
uninitialized pointer
pointer in
in C++.
C++.
Mine = new MyClass(); // Creates an instance of MyClass.
Mine = new MyClass(); // Creates an instance of MyClass.
//
// Calls
Calls no-parameter
no-parameter constructor.
constructor.
//
// In the process,
In the process, allocates
allocates
//
// memory
memory on
on the
the heap.
heap.
Mine
Mine == null;
null; //
// Releasing
Releasing the
the object.
object.

MyStruct
MyStruct Struct;
Struct; //
// Creates
Creates aa MyStruct
MyStruct instance
instance
//
// but does not call
but does not call any
any constructor.
constructor.
//
// Fields
Fields in
in MyStruct
MyStruct will
will be
be
//
// uninitialized.
uninitialized.
Struct
Struct == new
new MyStruct();
MyStruct(); //// Calls
Calls constructor,
constructor,
//
// so
so initializing
initializing fields.
fields.
//
// But
But doesn’t
doesn’t allocate
allocate any
any memory
memory
//
// because Struct already exists
because Struct already exists
//
// on
on stack.
stack.
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Operator =
„ Simple data types: copies the value
„ Structs: does a shallow copy of the struct
„ Classes: copies the reference
… to shallow copy the instance:
„ MemberwiseCopy() – protected method of Object class
„ ICloneable interface with Clone() method

„ Shallow copy: members which are objects are

not duplicated (their references are duplicated)

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Syntax of Class Definition
„ Each member is explicitly declared with an
access modifier
„ Member variables can be initialized in the class
definition (also static variables)
… the only items that can be placed in the constructor
initializer is another constructor
„ No ending semicolon

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Classes
„ Inheritance is always public
„ A class can only be derived from one base class
… but it can implement any number of interfaces
„ No inline methods
„ Additional access modifiers:
… internal – access is limited to the current assembly
… protected internal ≡ protected OR internal

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Constructors
„ The constructor at the top of the hierarchy
(System.Object) is executed first, followed in
order by constructors down the tree
„ Static constructors
… executed once only
… allow static fields to be initialized
… no access modifier, no parameters

„ Default constructors
… the compiler will generate this default constructor
only when there are no constructors

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Constructor Initialization List
class
class MyClass
MyClass :: MyBaseClass
MyBaseClass {{
MyClass(int
MyClass(int X) X)
:: base(X)
base(X) //
// executes
executes the
the MyBaseClass
MyBaseClass
//
// 1-parameter constructor
1-parameter constructor
{{ /*
/* ...
... */
*/ }}
MyClass()
MyClass()
:: this
this (10)
(10) //
// executes
executes the
the 1-parameter
1-parameter
//
// MyClass
MyClass constructor
constructor
//
// passing
passing in
in the
the value
value of
of 10
10
{{ /* ... */
/* ... */ } }

„ Only one other constructor can be placed in the

list

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Destructors
„ Finalize method
… in C# syntax is the same as in C++
„ The order and timing of destruction is undefined
… not necessarily the reverse of construction
„ Destructors are guaranteed to be called
… cannot rely on timing and thread ID
„ Avoid destructors if possible
… performance costs
… complexity
… delay of memory resource release
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
IDisposable Interface
„ To reclaim a resource:
… inherit from IDisposable Interface and implement
Dispose method that releases resources
… call GC.SuppressFinalize method
… calling Dispose more than once must be benign
… do not try to use a reclaimed resource
„ Dispose is automatically called at the end of
the using block
using
using (Resource
(Resource r1
r1 == new
new Resource())
Resource()) {{
r1.Method();
r1.Method();
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Inheritance
„ No multiple implementation inheritance
… but there is a possibility to implement many interfaces
„ A reference to a class can refer to instances of
that class or to instances of any derived class
„ All classes are inherited from object
(System.Object)
… the way of using a reference to anything (e.g. in
collection classes)

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Virtual Methods
class
class MyBaseClass
MyBaseClass {{
public
public virtual
virtual void
void VirtualMethod()
VirtualMethod() {{ ...
... }}
public void NormalMethod() { ...
public void NormalMethod() { ... } }
}}

class
class MyClass
MyClass {{
public
public override
override void
void VirtualMethod()
VirtualMethod() {{ ...
... }}
public
public new
new void
void NormalMethod()
NormalMethod() {{ ...
... }}
// hides MyBaseClass.NormalMethod
// hides MyBaseClass.NormalMethod
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Abstract Classes and Methods
„ abstract keyword
„ Abstract class
… cannot be instantiated
… cannot be sealed
… can contain implementation
… can declare non-public members
… can extend a class and interfaces

„ Abstract method
… cannot contain a method body
… is virtual

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Sealed Classes
„ It is not possible to derive from a sealed class
„ Sealed classes can be used for optimizing
operations at run time
„ Many .NET Framework classes are sealed:
String, StringBuilder, and so on
„ sealed keyword

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

 Operators is as
„ The is operator
… returns true if a conversion can be made
„ The as operator
… converts between reference types, like cast
… on error returns null, does not raise an exception
Bird
Bird bb == (Bird)a;
(Bird)a; //
// Unsafe
Unsafe –– possible
possible
// InvalidCastException
// InvalidCastException
if
if (a
(a isis Bird)
Bird)
bb == (Bird)
(Bird) a;a; //
// Safe
Safe
bb == aa as
as Bird;
Bird; //
// Convert,
Convert, no
no exception
exception
if
if (b
(b ==== null)
null)
//
// not
not aa bird
bird
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Structs
„ All structs are value types
„ No inheritance
… itis not possible to inherit from a struct, nor can a
struct inherit from another struct or class
… no virtual and abstract methods

„ The default (no-parameter) constructor of a

struct is always supplied by the compiler and
cannot be replaced

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

const and readonly
„ const: value is set at complite time
… const variables are static (access:
ClassName.Variable), but static keyword
cannot be used in declaration
„ readonly: value is set at runtime, in a
constructor
… instance constant
„ Cannot be applied to methods or parameters

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Methods
„ Always members of classes
… no global functions
„ Definition and declaration in one place
„ No const methods
„ Can be overloaded (the same name, different
parameters)
… no default values for parameters

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Method parameters
„ Default: passed by value
… structs are duplicated, classes passed by reference
„ Reference parameters: ref keyword
… must be initialized before passing to a method
… no const modifier

„ Output parameters: out keyword

public
public void
void MultiplyByTwo(ref
MultiplyByTwo(ref double
double d,
d, out
out double
double square)
square) {{
dd *=
*= 2;
2;
square
square == dd ** d;
d;
}}
//...
//...
double
double value,
value, square;
square;
value
value = 4.0;
= 4.0;
MultiplyByTwo(ref
MultiplyByTwo(ref value,
value, out
out square);
square);
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Variable-Length Parameters
„ Use params keyword
„ Declare as an array at the end of the parameter
list
„ Always pass by value
static
static long
long AddList(params
AddList(params long[long[ ]] v)
v) {{
long total,
long total, i; i;
for
for (i
(i == 0,
0, total
total == 0;
0; ii << v.Length;
v.Length; i++)
i++)
total += v[i];
total += v[i];
return
return total;
total;
}}
static
static void
void Main(
Main( )) {{
long
long xx == AddList(63,21,84);
AddList(63,21,84);
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Properties
class
class MyClass
MyClass {{
private
private int
int length;
length;
public
public int Length
int Length {{
get
get {{ return
return length;
length; }}
set
set { length = value;
{ length = value; }}
}}
}}
//...
//...
MyClass
MyClass MyObject
MyObject == new
new MyClass;
MyClass;
MyObject.Length = 10;
MyObject.Length = 10;
int
int Length
Length == MyObject.Length;
MyObject.Length;

„ It is possible to omit the get or set accesor

… the way of implementing write-only or read-only
access
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Operator Overloading
„ Overloadable operators:
+-*/%
++ -- (prefix version only)
== != < > <= >=
&|~^!
true false
public
public static
static Time
Time operator+(Time
operator+(Time t1,t1, Time
Time t2)
t2)
{{
int
int newHours
newHours == t1.hours
t1.hours ++ t2.hours;
t2.hours;
int
int newMinutes = t1.minutes
newMinutes = t1.minutes ++ t2.minutes;
t2.minutes;
return
return new
new Time(newHours,
Time(newHours, newMinutes);
newMinutes);
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Operators Restrictions
„ = cannot be overloaded
„ && and || cannot be overloaded directly
… are evaluated using &, |, true, false
„ *=, /=, +=, -=, %= cannot be overloaded
… are evaluated using *, /, +, -, % operators
„ &=, |=, ^=, >>=, <<= cannot be overloaded
„ Relational operators must be paired (< and >, <= and
>=, == and !=)
„ Override the Equals method if overloading == !=
„ Override the GetHashCode method if overriding
Equals method

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Indexers
„ Provide array-like access to an object

class
class String
String {{
public
public char
char this[int
this[int index]
index] {{
get
get {{
if
if (index
(index << 00 ||
|| index
index >=
>= Length)
Length)
throw
throw new
new IndexOutOfRangeException(
IndexOutOfRangeException( );
);
...
...
}}
}}
...
...
}}

string
string ss == "Hello
"Hello world!";
world!";
char
char ch
ch == s[3];
s[3];

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Conversion Operators
public
public static
static explicit
explicit operator
operator Time
Time (float
(float hours)
hours)
{{ ... }
... }
public
public static
static explicit
explicit operator
operator float
float (Time
(Time t1)
t1)
{{ ...
... }}
public
public static
static implicit
implicit operator
operator string
string (Time
(Time t1)
t1)
{{ ... }
... }

Time
Time t;
t;
string
string ss == t;
t;
float
float ff == (float)t;
(float)t;

„ If a class defines a string conversion operator, it

should override ToString
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Exceptions
„ finally block
… executed as soon as control leaves a catch or try
block, and typically contains clean-up code for
resources allocated in the try block
… optional
„ catch blocks – optional
„ The exception must be a class derived from
System.Exception

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Excepions Handling
„ Throwing
… avoid exceptions for normal or expected cases
… never create and throw objects of class Exception
… include a description string in an Exception object
… throw objects of the most specific class possible
„ Catching
… arrange catch blocks from specific to general
… do not let exceptions drop off Main

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Unsafe Code
„ Possibilities:
… declaring and operating on pointers
… conversions between pointers and integral types
… taking the address of variables
… fixing data on the heap (fixed keyword)
… declaring arrays on the stack (stackalloc keyword)
„ unsafe keyword used for:
… classor struct
… member field
… block statement
„ /unsafe flag of compilation is required
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Interfaces
„ Set of definitions for methods and properties
„ Restrictions for methods:
… no access modifiers
… no implementation in the interface
… cannot be declared as virtual or abstract

„ Implementing interfaces
…a class can implement zero or more interfaces
… a class must implement all inherited interface
methods
… the implementing method can be virtual or non-virtual

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Explicit Implementation
interface
interface IDimensions
IDimensions {{
float
float Length();
Length();
float
float Width();
Width();
}}
class
class Box
Box :: IDimensions
IDimensions {{
float
float IDimensions.Length() {}
IDimensions.Length() {}
float
float Width()
Width() {}
{}
}}

Box
Box myBox
myBox == new
new Box();
Box();
IDimensions
IDimensions myDimensions == (IDimensions)myBox;
myDimensions (IDimensions)myBox;
float
float aa == myBox.Length();
myBox.Length(); //
// error
error
float
float b = (myBox as IDimensions).Width(); // OK
b = (myBox as IDimensions).Width(); // OK
float
float cc == myBox.Width();
myBox.Width(); //
// OK
OK
float
float dd == myDimensions.Length();
myDimensions.Length(); //
// OK
OK
float
float ee == myDimensions.Width();
myDimensions.Width(); //
// OK
OK
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Delegates
„ Idea: the method pointer is wrapped in a
specialized class, along with a reference to the
object against which the method is to be called
(for an instance method, or the null reference
for a static method)
„ A delegate is a class that is derived from the
class System.Delegate
„ Delegate contains a reference to a method
„ All methods invoked by the same delegate must
have the same parameters and return value
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Using Delegates
delegate
delegate void
void MyOp(int
MyOp(int X);
X);
class MyClass
class MyClass {{
void
void MyMethod(int
MyMethod(int X)
X) {{ ...
... }}
}}

MyClass
MyClass Mine
Mine == new
new MyClass();
MyClass();
MyOp
MyOp DoIt = new MyOp(Mine.MyMethod);
DoIt = new MyOp(Mine.MyMethod);

//
// Invoking
Invoking the
the method
method via
via the
the delegate
delegate
DoIt();
DoIt();

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Events
//
// System
System namespace:
namespace:
public
public delegate
delegate void
void EventHandler(
EventHandler(
object
object sender,
sender, EventArgs
EventArgs ee );
);
// System.Windows.Forms.Control class:
// System.Windows.Forms.Control class:
public
public event
event EventHandler
EventHandler Click;
Click;

public
public class
class MyForm
MyForm :: Form
Form {{
private
private Button
Button button;
button; //
// derived
derived from
from Control
Control
public MyForm() : base()
public MyForm() : base() { {
button.Click
button.Click +=
+= new
new EventHandler(Button_Clicked);
EventHandler(Button_Clicked);
}}

private
private void
void Button_Clicked(
Button_Clicked(
object
object sender,
sender, EventArgs
EventArgs e)
e) {{
MessageBox.Show( "Button was clicked"
MessageBox.Show( "Button was clicked" ););
}}
}}
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Delegates, Events, Interfaces
„ Use a delegate if:
„ you basically want a C-style function pointer
„ you want single callback invocation
„ the callback should be registered in the call or at
construction time, not through an add method call
„ Use events if:
„ client signs up for the callback function through an add
method call
„ more than one object will care
„ you want end users to be able to easily add a listener to the
notification in the visual designer
„ Use an interface if:
„ the callback function entails complex behavior,
such as multiple methods
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Attributes
„ Derived from System.Attribute
„ Declarative tags that convey information to the
runtime
„ Stored with the metadata of the element
„ Predefined attributes in .NET:
… general attributes
… COM interoperability attributes
… transaction handling attributes
… visual designer component building attributes

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Conditional Attribute
„ Serves as a debugging tool
… causes conditional compilation of method calls,
depending on the value of a programmer-defined
symbol
… does not cause conditional compilation of the method
itself
using
using System.Diagnostics;
System.Diagnostics;
class
class MyClass
MyClass {{
[Conditional
[Conditional ("DEBUGGING")]
("DEBUGGING")]
public
public static
static void
void MyMethod(
MyMethod( )) {{ ...
... }}
}}

… compilation parameter /d:DEBUGGING

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
 DllImport Attribute
using
using System.Runtime.InteropServices;
System.Runtime.InteropServices;

public
public class
class Win32
Win32 {{
[DllImport("user32.dll",
[DllImport("user32.dll", CharSet=CharSet.Auto)]
CharSet=CharSet.Auto)]
public
public static
static extern
extern int
int MessageBox(int
MessageBox(int hWnd,
hWnd,
String
String text, String caption,
text, String caption, uint
uint type);
type);
}}

public
public class
class HelloWorld
HelloWorld {{
public
public static void
static void Main()
Main() {{
Win32.MessageBox(0,
Win32.MessageBox(0, "Hello
"Hello World",
World",
"Platform
"Platform Invoke
Invoke Sample",
Sample", 0);
0);
}}
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

 Custom Attributes
using
using System;
System;
[AttributeUsage(
[AttributeUsage( AttributeTargets.Class
AttributeTargets.Class ||
AttributeTargets.Struct,
AttributeTargets.Struct,
AllowMultiple
AllowMultiple == true
true )]
)]
public
public class AuthorAttribute : Attribute {{
class AuthorAttribute : Attribute
public
public Author(string
Author(string name)
name) {{
this.name = name;
this.name = name;
version
version == 1.0;
1.0;
}}
public
public double
double version;
version;
string name;
string name;
}}

[Author("H.
[Author("H. Ackerman",
Ackerman", version=1.1)]
version=1.1)]
class
class SomeClass {{ ...
SomeClass ...
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Documentation Comments
„ Special comment syntax that contains Extensible
Markup Language (XML)
„ Documentation comments must immediately
precede a user-defined type (class, interface,
delegate) or member (field, property, method,
event)
„ Documentation generator produces file, which
can be used as an input for documentation
viewer
… NDoc – http://ndoc.sourceforge.net

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Recommended Tags
„ <c> - text in a code-like font „ <paramref> - identifies that
„ <code> - one or more lines of a word is a parameter name
source code or program output „ <permission> - the security
„ <example> - an example accessibility of a member
„ <exception> - the „ <remarks> - a type
exceptions a method can „ <returns> - the return value
throw of a method
„ <include> - includes XML „ <see> - a link
from an external file „ <seealso> - See Also entry
„ <list> - list or table „ <summary> - a memberof a
„ <para> - permits structure to type
be added to text „ <value> - a property
„ <param> - parameter for a
method or constructor
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Naming Conventions
„ Suggestions:
… use camelCase for:
„ local variables
„ parameters of methods
… use _camelCase or camelCase for :
„ private contants
„ private fields
„ private static fields
… use PascalCase in other cases
… do not use Hungarian notation

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

C# 2.0
„ Generics
„ Anonymous methods
„ Iterators
„ Partial types
„ Static classes
„ Nullable types
„ global keyword
„ Access modifiers for get and set accesors
„ Covariance and contravariance
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
 Generics
using
using System.Collections.Generic;
System.Collections.Generic;
public
public class class Stack<T>
Stack<T> {{
T[] items;
T[] items;
int
int count;
count;
public
public void void Push(T
Push(T item) item) {...}
{...}
public T Pop()
public T Pop() {...} {...}
}}
//
// ...
...
static
static void void PushMultiple<T>(Stack<T>
PushMultiple<T>(Stack<T> stack, stack,
params
params T[] T[] values)
values) {{
foreach
foreach (T (T value
value in in values)
values)
stack.Push(value);
stack.Push(value);
}}
//
// ...
...
Stack<int>
Stack<int> stack stack == new new Stack<int>();
Stack<int>();
stack.Push(3);
stack.Push(3);
int
int xx == stack.Pop();
stack.Pop();
PushMultiple<int>(stack, 1,
1, 2,2, 3,
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
PushMultiple<int>(stack, 3, 4);
4);
 Anonymous Methods
//
// 1.x
1.x
public
public MyForm()
MyForm() {{
addButton.Click
addButton.Click += += newnew EventHandler(AddClick);
EventHandler(AddClick);
}}
void
void AddClick(object
AddClick(object sender, sender, EventArgs
EventArgs e) e) {{
MessageBox.Show(textBox.Text);
MessageBox.Show(textBox.Text);
}}
//
// 2.0 2.0
public
public MyForm()MyForm() {{
addButton.Click
addButton.Click += += delegate
delegate {{
MessageBox.Show(textBox.Text);
MessageBox.Show(textBox.Text);
}}
}}
//
// whenwhen parameter
parameter names names are are needed
needed
addButton.Click
addButton.Click += delegate += delegate
(object
(object sender, sender, EventArgs
EventArgs e)
e) {{
MessageBox.Show(((Button)sender).Text);
MessageBox.Show(((Button)sender).Text);
}}
Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
 Iterators
using
using System.Collections.Generic;
System.Collections.Generic;
public
public class class Stack<T>:
Stack<T>: IEnumerable<T>
IEnumerable<T> {{
T[] items;
T[] items;
int
int count;
count;
public
public IEnumerator<T>
IEnumerator<T> GetEnumerator()GetEnumerator() {{
for
for (int i = count –– 1;
(int i = count 1; ii >=
>= 0;
0; --i)
--i)
yield return
yield return items[i]; items[i];
}}
public
public IEnumerable<T>
IEnumerable<T> TopToBottom TopToBottom {{
get
get { return this; }}
{ return this;
}}
public
public IEnumerable<T>
IEnumerable<T> BottomToTop BottomToTop {{
get
get { {
for
for (int (int ii == 0; 0; ii << count;
count; i++)
i++)
yield return
yield return items[i]; items[i];
}}
}}
}}Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)
Partial Types
„ partial keyword used before class
„ Possibility to write definition of classes, structs
and interfaces in many source files

„ Good programming practice:

… maintain all source code for a type in a single file
„ May be used to seperate machine-generated
and user-written parts of types

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Static Classes
„ static keyword used before class
„ Static classes
… contain only static members
… cannot be instantiated
… are sealed
… cannot contain instance constructor (only static
constructor)

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

 Nullable Types
„ Possibility to assign value types a null value
… especially useful for database solutions

System.Nullable<T>
System.Nullable<T> variable
variable
//
// or
or
T?
T? variable
variable

System.Nullable<int>
System.Nullable<int> myNullableInt;
myNullableInt;
int?
int? myOtherNullableInt;
myOtherNullableInt;

if
if (myNullableInt.HasValue)
(myNullableInt.HasValue)
//
// or
or
if
if (myNullableInt
(myNullableInt !=
!= null)
null)

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

 global Keyword
using
using System;
System;
namespace
namespace GlobalNameSpace
GlobalNameSpace {{
class
class Program {{
Program
public
public class
class System
System {{
}}

static
static void
void Main(string[]
Main(string[] args)
args) {{
bool Console = true;
bool Console = true;
int
int xx == 5;
5;

Console.WriteLine(x);
Console.WriteLine(x); //
// compilation
compilation error
error
System.Console.WriteLine(x);
System.Console.WriteLine(x); //
// compilation
compilation error
error
global::System.Console.WriteLine(x);
global::System.Console.WriteLine(x); //
// OK
OK
global::System.Console.WriteLine(Console);
global::System.Console.WriteLine(Console); //// OK
OK
}}
}}
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Access Modifiers in Properties
„ Accessibility level of the get and set accessors
within a property can be restricted
„ Access cannot be broadened
public
public string
string Something
Something
{{
get
get {{ return
return something;
something; }}
protected
protected set {{ something
set something == value;
value; }}
}}

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)

Covariance & Contravariance
„ Covariance
… delegate method with a return type that is derived
(directly or indirectly) from the delegate's defined
return type
„ Contravariance
… delegate method signature in which one or more of
the parameters is derived from the type defined by
the delegate

Krzysztof Mossakowski (http://www.mini.pw.edu.pl/~mossakow)