Hoang Anh Viet

Hà Nội University of Technology

Chapter 1. Introduction to
C# Programming
Microsoft
Objectives
“This chapter gives a quick glimpse of what a simple C#
application looks like, and it describes some basic
differences between the C# programming environment
and the native C++ environment.”
Microsoft
Roadmap
1.1.Differences between C# and C++
1.2. Example of a C# program
1.3. Overview of Features Added in C# 2.0
1.4. Overview of What’s new in C# 3.0
Microsoft
Language

C#:

Is a completely an Object-Oriented Language

Every program is class

Every work is done through objects

C++:


Remains some features of procedural language

Example: free functions
Microsoft
Compiling

C#:

C# source code compiles into managed code, an intermediate language(IL)

At runtime, the Common Language Runtime (CLR) compiles the code by using
Just In Time(JIT) compiling

The JIT compiler compiles a function or method only the first time and it
produces machine code native to the platform on which it’s running

Pros:

The working set of the application is reduced( the memory footprint
of intermediate code is smaller

The CLR can optimize the program’s execution on the fly at run
time

C++:

C++ code compiles into native code( the machine code that’s native to the
processor)
Microsoft
Garbage Collection


C#:

One of the key facilities in the CLR is the garbage collector

GC automatically handles memory allocation and deallocation

C++:

Not support

Programmers have to handle memory explicitly
Microsoft
Programming
Generally, C# language is similar to C++ because it
is developed from C++ and Java. However, it’s added
many new features allowing programmers to program
easier and friendlier.
Example:
•
Statement: foreach
•
Properties: set and get method
Microsoft
Roadmap
1.1.Differences between C# and C++
1.2. Example of a C# program
1.3. Overview of Features Added in C# 2.0
1.4. Overview of What’s new in C# 3.0
Microsoft

1.2 Example of a C# Program

1. // Welcome.cs

2. // A first console program in C#.

3. using System;

4. class Welcome

5. {

6. static void Main( string[] args )

7. {

8. Console.WriteLine( "Welcome to C#
Programming!" );

9. }

10. }
9
Each
application
must have
exactly one
Call a method
like C++
Microsoft

Roadmap
1.1.Differences between C# and C++
1.2. Example of a C# program
1.3. Overview of Features Added in C# 2.0
1.4. Overview of What’s new in C# 3.0
Microsoft
1.3. Overview of Features Added in C#
2.0

Generics

Iterators

Partial types

Anonymous method
Microsoft
Generics

Generics?

Similar Templates in C++

Type checking, no boxing, no downcasts

Increased sharing (typed collections)

How are C# generics implemented?

Instantiated at run-time, not compile-time


Checked at declaration, not instantiation

Work for both reference and value types

Exact run-time type information
Microsoft
Generics (2)

Collection classes

Collection interfaces

Collection base classes

Utility classes

Reflection
List<T>
Dictionary<K,V>
SortedDictionary<K,V>
Stack<T>
Queue<T>
IList<T>
IDictionary<K,V>
ICollection<T>
IEnumerable<T>
IEnumerator<T>
IComparable<T>
IComparer<T>

Collection<T>
KeyedCollection<T>
ReadOnlyCollection<T>
Nullable<T>
EventHandler<T>
Comparer<T>
Microsoft
Iterators

C# provides interfaces IEnumerable<T> that abstract the
ability to enumerate a collection

C# 2.0 introduces iterators, easing task of implementing
IEnumerable e.g.

We can use the foreach construct:

New keyword yield
static IEnumerable<int> UpAndDown(int bottom, int top) {
for (int i = bottom; i < top; i++) { yield return i; }
for (int j = top; j >= bottom; j ) { yield return j; }
}
foreach (int x in SomeList) { Console.WriteLine(x); }
Microsoft
Partial Types

New keyword partial

Separate the definition of a class, a struct, an interface
over two or more source files

//first file (MyClass_1.cs)
public partial class MyClass
{
private int nCount;
. . . . .
}
//second file (MyClass_2.cs)
public partial class MyClass
{
private bool isPresent
. . . . .
}
Microsoft
Anonymous methods

Delegates are clumsy: programmer has to name the
function and “closure-convert” by hand

So C# 2.0 introduced anonymous methods

No name

Compiler does closure-conversion, creating a class
and object that captures the environment e.g.
bool b = xs.Exists(delegate(int x) { return x>y; });
Local y is free in body of
anonymous method
Microsoft
Other New Features


Static classes

Property accessibility control

External aliases

Namespace alias qualifiers

Inline warning control

Fixed size buffers
Microsoft
Roadmap
1.1.Differences between C# and C++
1.2. Example of a C# program
1.3. Overview of Features Added in C# 2.0
1.4. Overview of What’s new in C# 3.0
Microsoft
1.4. Overview of What’s new in C# 3.0

Implicitly Typed Local Variables

Object and Collection Initializers

Extension Methods

Partial Methods

Anonymous Types


Query Keywords

Lambda Expressions
Microsoft
Implicitly Typed Local Variables

Use the new var keyword to implicitly declare a variable

Useful in cases where you do not know the exact type of
data and you need the compiler to determine for you

Examples
var i = 5;
var s = "Hello";
Are equivalent to:
int i = 5;
string s = "Hello";
20
Microsoft
Object and Collection Initializers

Enables you to combine declaration and initialization one
object in one step
Ex: class A
public class A { public int x ; public string y; }
Then could declare and initialize an A object:
var myA = new A{ x = 0, y= “some text”} ;

Collection Initializer is similar
List<string> animals = new List<string>();

animals.Add("monkey"); fg
animals.Add("donkey");
animals.Add("cow");
Can replace by:
var animals = new List<string>
{"monkey", "donkey", "cow”} ;
Microsoft
Extension Methods

Enable you to extend various types with additional static
methods

Can be declared only in static classes and are identified
by the keyword "this“

This allows you to take advantage of the extensible
nature of various built-in or defined types and add newer
methods to them
22
Microsoft
Anonymous Types

Create an instance of a class without having to write
code for the class beforehand

Example:
var A = new {x=9,y=“hello”}

 A has two properties: x=9 and y=“hello”
23

Microsoft
Lambda Expressions

A lambda expression is an anonymous function that can
contain expressions and statements, and can be used to
create delegates or expression tree types.

Implicitly or explicitly typed parameters
24
Microsoft
Lambda Expressions(2)

Examples:
x => x + 1 // Implicitly typed, expression body
x => { return x + 1; } // Implicitly typed, statement body
(int x) => x + 1 // Explicitly typed, expression body
(int x) => { return x + 1; } // Explicitly typed, statement body
(x, y) => x * y // Multiple parameters
() => Console.WriteLine() // No parameters
25