Introduction to Csharp

Introduction to C#
Introduction to C#
Anders Hejlsberg
Anders Hejlsberg
Distinguished Engineer
Distinguished Engineer
Developer Division
Developer Division
Microsoft Corporation
Microsoft Corporation
C# – The Big Ideas
C# – The Big Ideas

The first component oriented
The first component oriented
language in the C/C++ family
language in the C/C++ family

Everything really is an object
Everything really is an object

Next generation robust and
Next generation robust and
durable software
durable software

Preservation of investment
Preservation of investment
C# – The Big Ideas
C# – The Big Ideas
A component oriented language

A component oriented language

C# is the first “component oriented”
C# is the first “component oriented”
language in the C/C++ family
language in the C/C++ family

Component concepts are first class:
Component concepts are first class:

Properties, methods, events
Properties, methods, events

Design-time and run-time attributes
Design-time and run-time attributes

Integrated documentation using XML
Integrated documentation using XML

Enables one-stop programming
Enables one-stop programming

No header files, IDL, etc.
No header files, IDL, etc.

Can be embedded in web pages
Can be embedded in web pages
C# – The Big Ideas
C# – The Big Ideas
Everything really is an object

Everything really is an object

Traditional views
Traditional views

C++, Java: Primitive types are “magic” and do
C++, Java: Primitive types are “magic” and do
not interoperate with objects
not interoperate with objects

Smalltalk, Lisp: Primitive types are objects, but
Smalltalk, Lisp: Primitive types are objects, but
at great performance cost
at great performance cost

C# unifies with no performance cost
C# unifies with no performance cost

Deep simplicity throughout system
Deep simplicity throughout system

Improved extensibility and reusability
Improved extensibility and reusability

New primitive types: Decimal, SQL…
New primitive types: Decimal, SQL…

Collections, etc., work for
Collections, etc., work for
all

all
types
types
C# – The Big Ideas
C# – The Big Ideas
Robust and durable software
Robust and durable software

Garbage collection
Garbage collection

No memory leaks and stray pointers
No memory leaks and stray pointers

Exceptions
Exceptions

Error handling is not an afterthought
Error handling is not an afterthought

Type-safety
Type-safety

No uninitialized variables, unsafe casts
No uninitialized variables, unsafe casts

Versioning
Versioning

Pervasive versioning considerations in

Pervasive versioning considerations in
all aspects of language design
all aspects of language design
C# – The Big Ideas
C# – The Big Ideas
Preservation of Investment
Preservation of Investment

C++ heritage
C++ heritage

Namespaces, enums, unsigned types, pointers
Namespaces, enums, unsigned types, pointers
(in unsafe code), etc.
(in unsafe code), etc.

No unnecessary sacrifices
No unnecessary sacrifices

Interoperability
Interoperability

What software is increasingly about
What software is increasingly about

MS C# implementation talks to XML, SOAP,
MS C# implementation talks to XML, SOAP,
COM, DLLs, and any .NET language
COM, DLLs, and any .NET language


Millions of lines of C# code in .NET
Millions of lines of C# code in .NET

Short learning curve
Short learning curve

Increased productivity
Increased productivity
Hello World
Hello World
using System;
using System;
class Hello
class Hello
{
{


static void Main() {
static void Main() {


Console.WriteLine("Hello world");
Console.WriteLine("Hello world");


}
}
}
}

C# Program Structure
C# Program Structure

Namespaces
Namespaces

Contain types and other namespaces
Contain types and other namespaces

Type declarations
Type declarations

Classes, structs, interfaces, enums,
Classes, structs, interfaces, enums,
and delegates
and delegates

Members
Members

Constants, fields, methods, properties, indexers,
Constants, fields, methods, properties, indexers,
events, operators, constructors, destructors
events, operators, constructors, destructors

Organization
Organization

No header files, code written “in-line”
No header files, code written “in-line”


No declaration order dependence
No declaration order dependence
C# Program Structure
C# Program Structure
using System;
using System;
namespace System.Collections
namespace System.Collections
{
{


public class Stack
public class Stack


{
{


Entry top;
Entry top;


public void Push(object data) {
public void Push(object data) {


top = new Entry(top, data);

top = new Entry(top, data);


}
}


public object Pop() {
public object Pop() {


if (top == null) throw new InvalidOperationException();
if (top == null) throw new InvalidOperationException();


object result = top.data;
object result = top.data;


top = top.next;
top = top.next;


return result;
return result;


}
}

}
}
}
}
Type System
Type System

Value types
Value types

Directly contain data
Directly contain data

Cannot be null
Cannot be null

Reference types
Reference types

Contain references to objects
Contain references to objects

May be null
May be null
int i = 123;
int i = 123;
string s = "Hello world";
string s = "Hello world";
123

123
i
i
s
s
"Hello world"
"Hello world"
Type System
Type System

Value types
Value types

Primitives
Primitives


int i;
int i;

Enums
Enums
enum State { Off, On }
enum State { Off, On }

Structs
Structs
struct Point { int x,
struct Point { int x,
y; }

y; }

Reference types
Reference types

Classes
Classes
class Foo: Bar, IFoo
class Foo: Bar, IFoo
{ }
{ }

Interfaces
Interfaces


interface IFoo: IBar
interface IFoo: IBar
{ }
{ }

Arrays
Arrays
string[] a = new string[10];
string[] a = new string[10];

Delegates
Delegates
delegate void Empty();
delegate void Empty();

Predefined Types
Predefined Types

C# predefined types
C# predefined types

Reference
Reference
object, string
object, string

Signed
Signed
sbyte, short, int, long
sbyte, short, int, long

Unsigned
Unsigned
byte, ushort, uint, ulong
byte, ushort, uint, ulong

Character
Character
char
char

Floating-point
Floating-point
float, double, decimal
float, double, decimal


Logical
Logical
bool
bool

Predefined types are simply aliases
Predefined types are simply aliases
for system-provided types
for system-provided types

For example, int == System.Int32
For example, int == System.Int32
Classes
Classes

Single inheritance
Single inheritance

Multiple interface implementation
Multiple interface implementation

Class members
Class members

Constants, fields, methods, properties,
Constants, fields, methods, properties,
indexers, events, operators,
indexers, events, operators,
constructors, destructors

constructors, destructors

Static and instance members
Static and instance members

Nested types
Nested types

Member access
Member access

public, protected, internal, private
public, protected, internal, private
Structs
Structs

Like classes, except
Like classes, except

Stored in-line, not heap allocated
Stored in-line, not heap allocated

Assignment copies data, not reference
Assignment copies data, not reference

No inheritance
No inheritance

Ideal for light weight objects
Ideal for light weight objects


Complex, point, rectangle, color
Complex, point, rectangle, color

int, float, double, etc., are all structs
int, float, double, etc., are all structs

Benefits
Benefits

No heap allocation, less GC pressure
No heap allocation, less GC pressure

More efficient use of memory
More efficient use of memory
Classes And Structs
Classes And Structs


class CPoint { int x, y; }
class CPoint { int x, y; }
struct SPoint { int x, y; }
struct SPoint { int x, y; }
CPoint cp = new CPoint(10, 20);
CPoint cp = new CPoint(10, 20);
SPoint sp = new SPoint(10, 20);
SPoint sp = new SPoint(10, 20);
10
10
20

20
sp
sp
cp
cp
10
10
20
20
CPoint
CPoint
Interfaces
Interfaces

Multiple inheritance
Multiple inheritance

Can contain methods, properties,
Can contain methods, properties,
indexers, and events
indexers, and events

Private interface implementations
Private interface implementations
interface IDataBound
interface IDataBound
{
{

void Bind(IDataBinder binder);
void Bind(IDataBinder binder);
}
}
class EditBox: Control, IDataBound
class EditBox: Control, IDataBound
{
{


void IDataBound.Bind(IDataBinder binder)
void IDataBound.Bind(IDataBinder binder)
{ }
{ }
}
}
Enums
Enums

Strongly typed
Strongly typed

No implicit conversions to/from int
No implicit conversions to/from int

Operators: +, -, ++, , &, |, ^, ~
Operators: +, -, ++, , &, |, ^, ~

Can specify underlying type
Can specify underlying type


Byte, short, int, long
Byte, short, int, long
enum Color: byte
enum Color: byte
{
{


Red = 1,
Red = 1,


Green = 2,
Green = 2,


Blue = 4,
Blue = 4,


Black = 0,
Black = 0,


White = Red | Green | Blue,
White = Red | Green | Blue,
}
}
Delegates

Delegates

Object oriented function pointers
Object oriented function pointers

Multiple receivers
Multiple receivers

Each delegate has an invocation list
Each delegate has an invocation list

Thread-safe + and - operations
Thread-safe + and - operations

Foundation for events
Foundation for events
delegate void MouseEvent(int x, int y);
delegate void MouseEvent(int x, int y);
delegate double Func(double x);
delegate double Func(double x);
Func func = new Func(Math.Sin);
Func func = new Func(Math.Sin);
double x = func(1.0);
double x = func(1.0);
Unified Type System
Unified Type System

Everything is an object
Everything is an object


All types ultimately inherit from object
All types ultimately inherit from object

Any piece of data can be stored,
Any piece of data can be stored,
transported, and manipulated with no
transported, and manipulated with no
extra work
extra work
Stream
Stream
MemoryStream
MemoryStream
FileStream
FileStream
Hashtable
Hashtable
double
double
int
int
object
object
Unified Type System
Unified Type System

Boxing
Boxing

Allocates box, copies value into it

Allocates box, copies value into it

Unboxing
Unboxing

Checks type of box, copies value out
Checks type of box, copies value out
int i = 123;
int i = 123;
object o = i;
object o = i;
int j = (int)o;
int j = (int)o;
123
123
i
o
123
123
System.Int3
System.Int3
2
2
123
123
j
Unified Type System
Unified Type System

Benefits

Benefits

Eliminates “wrapper classes”
Eliminates “wrapper classes”

Collection classes work with all types
Collection classes work with all types

Replaces OLE Automation's Variant
Replaces OLE Automation's Variant

Lots of examples in .NET Framework
Lots of examples in .NET Framework
string s = string.Format(
string s = string.Format(


"Your total was {0} on {1}", total, date);
"Your total was {0} on {1}", total, date);
Hashtable t = new Hashtable();
Hashtable t = new Hashtable();
t.Add(0, "zero");
t.Add(0, "zero");
t.Add(1, "one");
t.Add(1, "one");
t.Add(2, "two");
t.Add(2, "two");
Component Development
Component Development


What defines a component?
What defines a component?

Properties, methods, events
Properties, methods, events

Integrated help and documentation
Integrated help and documentation

Design-time information
Design-time information

C# has first class support
C# has first class support

Not naming patterns, adapters, etc.
Not naming patterns, adapters, etc.

Not external files
Not external files

Components are easy to build
Components are easy to build
and consume
and consume
Properties
Properties

Properties are “smart fields”
Properties are “smart fields”


Natural syntax, accessors, inlining
Natural syntax, accessors, inlining
public class Button: Control
public class Button: Control
{
{


private string caption;
private string caption;


public string Caption {
public string Caption {


get {
get {


return caption;
return caption;


}
}


set {

set {


caption = value;
caption = value;


Repaint();
Repaint();


}
}


}
}
}
}
Button b = new Button();
Button b = new Button();
b.Caption = "OK";
b.Caption = "OK";
String s = b.Caption;
String s = b.Caption;
Indexers
Indexers

Indexers are “smart arrays”
Indexers are “smart arrays”


Can be overloaded
Can be overloaded
public class ListBox: Control
public class ListBox: Control
{
{


private string[] items;
private string[] items;


public string this[int
public string this[int
index] {
index] {


get {
get {


return items[index];
return items[index];


}
}

set {
set {
items[index] = value;
items[index] = value;


Repaint();
Repaint();


}
}


}
}
}
}
ListBox listBox = new
ListBox listBox = new
ListBox();
ListBox();
listBox[0] = "hello";
listBox[0] = "hello";
Console.WriteLine(listBox[0]
Console.WriteLine(listBox[0]
);
);
Events

Events
Sourcing
Sourcing

Define the event signature
Define the event signature

Define the event and firing logic
Define the event and firing logic
public delegate void EventHandler(object sender,
public delegate void EventHandler(object sender,
EventArgs e);
EventArgs e);
public class Button
public class Button
{
{
public event EventHandler Click;
public event EventHandler Click;


protected void OnClick(EventArgs e) {
protected void OnClick(EventArgs e) {
if (Click != null) Click(this, e);
if (Click != null) Click(this, e);
}
}
}
}