Introduction-to-Csharpppppppppppppppp.ppt

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
 The first component oriented
The first component oriented
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

A component oriented language
A component oriented language
 C# is the first “component oriented”
C# is the first “component oriented”
 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

 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

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

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

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, y; }
struct Point { int x, 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.Int32
System.Int32
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 index] {
public string this[int index] {
get {
get {
return items[index];
return items[index];
}
}
set {
set {
items[index] = value;
items[index] = value;
Repaint();
Repaint();
}
}
}
}
}
}
ListBox listBox = new ListBox();
ListBox listBox = new 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, EventArgs e);
public delegate void EventHandler(object sender, 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);
}
}
}
}

Events
Events
Handling
Handling
 Define and register event handler
Define and register event handler
public class MyForm: Form
public class MyForm: Form
{
{
Button okButton;
Button okButton;
public MyForm() {
public MyForm() {
okButton = new Button(...);
okButton = new Button(...);
okButton.Caption = "OK";
okButton.Caption = "OK";
okButton.Click += new EventHandler(OkButtonClick);
okButton.Click += new EventHandler(OkButtonClick);
}
}
void OkButtonClick(object sender, EventArgs e) {
void OkButtonClick(object sender, EventArgs e) {
ShowMessage("You pressed the OK button");
ShowMessage("You pressed the OK button");
}
}
}
}

Attributes
Attributes
 How do you associate information
How do you associate information
with types and members?
with types and members?
 Documentation URL for a class
Documentation URL for a class
 Transaction context for a method
Transaction context for a method
 XML persistence mapping
XML persistence mapping
 Traditional solutions
Traditional solutions
 Add keywords or pragmas to language
Add keywords or pragmas to language
 Use external files, e.g., .IDL, .DEF
Use external files, e.g., .IDL, .DEF
 C# solution: Attributes
C# solution: Attributes

Attributes
Attributes
public class OrderProcessor
public class OrderProcessor
{
{
[WebMethod]
[WebMethod]
public void SubmitOrder(PurchaseOrder order) {...}
public void SubmitOrder(PurchaseOrder order) {...}
}
}
[XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")]
[XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")]
public class PurchaseOrder
public class PurchaseOrder
{
{
[XmlElement("shipTo")] public Address ShipTo;
[XmlElement("shipTo")] public Address ShipTo;
[XmlElement("billTo")] public Address BillTo;
[XmlElement("billTo")] public Address BillTo;
[XmlElement("comment")] public string Comment;
[XmlElement("comment")] public string Comment;
[XmlElement("items")] public Item[] Items;
[XmlElement("items")] public Item[] Items;
[XmlAttribute("date")] public DateTime OrderDate;
[XmlAttribute("date")] public DateTime OrderDate;
}
}
public class Address {...}
public class Address {...}
public class Item {...}
public class Item {...}

Attributes
Attributes
 Attributes can be
Attributes can be
 Attached to types and members
Attached to types and members
 Examined at run-time using reflection
Examined at run-time using reflection
 Completely extensible
Completely extensible
 Simply a class that inherits from
Simply a class that inherits from
System.Attribute
System.Attribute
 Type-safe
Type-safe
 Arguments checked at compile-time
Arguments checked at compile-time
 Extensive use in .NET Framework
Extensive use in .NET Framework
 XML, Web Services, security, serialization,
XML, Web Services, security, serialization,
component model, COM and P/Invoke interop,
component model, COM and P/Invoke interop,
code configuration…
code configuration…

XML Comments
XML Comments
class XmlElement
class XmlElement
{
{
/// <summary>
/// <summary>
/// Returns the attribute with the given name and
/// Returns the attribute with the given name and
/// namespace</summary>
/// namespace</summary>
/// <param name="name">
/// <param name="name">
/// The name of the attribute</param>
/// The name of the attribute</param>
/// <param name="ns">
/// <param name="ns">
/// The namespace of the attribute, or null if
/// The namespace of the attribute, or null if
/// the attribute has no namespace</param>
/// the attribute has no namespace</param>
/// <return>
/// <return>
/// The attribute value, or null if the attribute
/// The attribute value, or null if the attribute
/// does not exist</return>
/// does not exist</return>
/// <seealso cref="GetAttr(string)"/>
/// <seealso cref="GetAttr(string)"/>
///
///
public string GetAttr(string name, string ns) {
public string GetAttr(string name, string ns) {
...
...
}
}
}
}

Statements And
Statements And
Expressions
Expressions
 High C++ fidelity
High C++ fidelity
 If, while, do require bool condition
If, while, do require bool condition
 goto can’t jump into blocks
goto can’t jump into blocks
 Switch statement
Switch statement
 No fall-through, “goto case” or “goto default”
No fall-through, “goto case” or “goto default”
 foreach statement
foreach statement
 Checked and unchecked statements
Checked and unchecked statements
 Expression statements must do work
Expression statements must do work
void Foo() {
void Foo() {
i == 1; // error
i == 1; // error
}
}

foreach Statement
foreach Statement
 Iteration of arrays
Iteration of arrays
 Iteration of user-defined collections
Iteration of user-defined collections
foreach (Customer c in customers.OrderBy("name")) {
foreach (Customer c in customers.OrderBy("name")) {
if (c.Orders.Count != 0) {
if (c.Orders.Count != 0) {
...
...
}
}
}
}
public static void Main(string[] args) {
public static void Main(string[] args) {
foreach (string s in args) Console.WriteLine(s);
foreach (string s in args) Console.WriteLine(s);
}
}

Parameter Arrays
Parameter Arrays
 Can write “printf” style methods
Can write “printf” style methods
 Type-safe, unlike C++
Type-safe, unlike C++
void printf(string fmt, params object[] args) {
void printf(string fmt, params object[] args) {
foreach (object x in args) {
foreach (object x in args) {
...
...
}
}
}
}
printf("%s %i %i", str, int1, int2);
printf("%s %i %i", str, int1, int2);
object[] args = new object[3];
object[] args = new object[3];
args[0] = str;
args[0] = str;
args[1] = int1;
args[1] = int1;
Args[2] = int2;
Args[2] = int2;
printf("%s %i %i", args);
printf("%s %i %i", args);

Operator Overloading
 First class user-defined data types
First class user-defined data types
 Used in base class library
Used in base class library
 Decimal, DateTime, TimeSpan
Decimal, DateTime, TimeSpan
 Used in UI library
Used in UI library
 Unit, Point, Rectangle
Unit, Point, Rectangle
 Used in SQL integration
Used in SQL integration
 SQLString, SQLInt16, SQLInt32,
SQLString, SQLInt16, SQLInt32,
SQLInt64, SQLBool, SQLMoney,
SQLInt64, SQLBool, SQLMoney,
SQLNumeric, SQLFloat…
SQLNumeric, SQLFloat…

public struct DBInt
public struct DBInt
{
{
public static readonly DBInt Null = new DBInt();
public static readonly DBInt Null = new DBInt();
private int value;
private int value;
private bool defined;
private bool defined;
public bool IsNull { get { return !defined; } }
public bool IsNull { get { return !defined; } }
public static DBInt operator +(DBInt x, DBInt y) {...}
public static DBInt operator +(DBInt x, DBInt y) {...}
public static implicit operator DBInt(int x) {...}
public static implicit operator DBInt(int x) {...}
public static explicit operator int(DBInt x) {...}
public static explicit operator int(DBInt x) {...}
}
}
DBInt x = 123;
DBInt x = 123;
DBInt y = DBInt.Null;
DBInt y = DBInt.Null;
DBInt z = x + y;
DBInt z = x + y;

Versioning
Versioning
 Problem in most languages
Problem in most languages
 C++ and Java produce fragile base classes
C++ and Java produce fragile base classes
 Users unable to express versioning intent
Users unable to express versioning intent
 C# allows intent to be expressed
C# allows intent to be expressed
 Methods are not virtual by default
Methods are not virtual by default
 C# keywords “virtual”, “override” and “new”
C# keywords “virtual”, “override” and “new”
provide context
provide context
 C# can't guarantee versioning
C# can't guarantee versioning
 Can enable (e.g., explicit override)
Can enable (e.g., explicit override)
 Can encourage (e.g., smart defaults)
Can encourage (e.g., smart defaults)

Versioning
Versioning
class Derived: Base
class Derived: Base // version 1
// version 1
{
{
public virtual void Foo() {
Console.WriteLine("Derived.Foo");
}
}
}
}
class Derived: Base
class Derived: Base // version 2a
// version 2a
{
{
new public virtual void Foo() {
new public virtual void Foo() {
}
}
}
}
class Derived: Base
class Derived: Base // version 2b
// version 2b
{
{
public override void Foo() {
public override void Foo() {
base.Foo();
base.Foo();
}
}
}
}
class Base
class Base // version 1
// version 1
{
{
}
}
class Base
class Base // version 2
// version 2
{
{
Console.WriteLine("Base.Foo");
Console.WriteLine("Base.Foo");
}
}
}
}

Conditional Compilation
Conditional Compilation
 #define, #undef
#define, #undef
 #if, #elif, #else, #endif
#if, #elif, #else, #endif
 Simple boolean logic
Simple boolean logic
 Conditional methods
Conditional methods
public class Debug
public class Debug
{
{
[Conditional("Debug")]
[Conditional("Debug")]
public static void Assert(bool cond, String s) {
public static void Assert(bool cond, String s) {
if (!cond) {
if (!cond) {
throw new AssertionException(s);
throw new AssertionException(s);
}
}
}
}
}
}

Unsafe Code
Unsafe Code
 Platform interoperability covers most cases
Platform interoperability covers most cases
 Unsafe code
Unsafe code
 Low-level code “within the box”
Low-level code “within the box”
 Enables unsafe casts, pointer arithmetic
Enables unsafe casts, pointer arithmetic
 Declarative pinning
Declarative pinning
 Fixed statement
Fixed statement
 Basically “inline C”
Basically “inline C”
unsafe void Foo() {
unsafe void Foo() {
char* buf = stackalloc char[256];
char* buf = stackalloc char[256];
for (char* p = buf; p < buf + 256; p++) *p = 0;
for (char* p = buf; p < buf + 256; p++) *p = 0;
...
...
}
}

Unsafe Code
Unsafe Code
class FileStream: Stream
class FileStream: Stream
{
{
int handle;
int handle;
public unsafe int Read(byte[] buffer, int index, int count) {
public unsafe int Read(byte[] buffer, int index, int count) {
int n = 0;
int n = 0;
fixed (byte* p = buffer) {
fixed (byte* p = buffer) {
ReadFile(handle, p + index, count, &n, null);
ReadFile(handle, p + index, count, &n, null);
}
}
return n;
return n;
}
}
[dllimport("kernel32", SetLastError=true)]
[dllimport("kernel32", SetLastError=true)]
static extern unsafe bool ReadFile(int hFile,
static extern unsafe bool ReadFile(int hFile,
void* lpBuffer, int nBytesToRead,
void* lpBuffer, int nBytesToRead,
int* nBytesRead, Overlapped* lpOverlapped);
int* nBytesRead, Overlapped* lpOverlapped);
}
}

More Information
More Information
http://msdn.microsoft.com/net
http://msdn.microsoft.com/net
 Download .NET SDK and documentation
Download .NET SDK and documentation
http://msdn.microsoft.com/events/pdc
http://msdn.microsoft.com/events/pdc
 Slides and info from .NET PDC
Slides and info from .NET PDC
news://msnews.microsoft.com
news://msnews.microsoft.com
 microsoft.public.dotnet.csharp.general
microsoft.public.dotnet.csharp.general

Introduction-to-Csharpppppppppppppppp.ppt

More Related Content

Similar to Introduction-to-Csharpppppppppppppppp.ppt (20)

More from kamalsmail1 (9)

Recently uploaded (20)

Introduction-to-Csharpppppppppppppppp.ppt