Introduction to C#

Raimonds Rudmanis
Senior Consultant
Microsoft Baltic
Session Prerequisites
 This session assumes that you
understand the fundamentals of
 Object oriented programming
 This is a Level 200 Session
What Will Be Covered Today
 Brief introduction to the
.NET framework
 C# language overview
Agenda
 Hello World
 The .NET Framework
 Design Goals of C#
 Language Features
Hello World
DEMO 1: Hello World

using System;

class Hello
{
static void Main() {
Console.WriteLine("Hello world");
}
}
Agenda
 Hello World
 The .NET Framework
 Design Goals of C#
 Language Features
The .NET Framework
Overview
VB C++ C# JScript …

Common Language Specification

Visual Studio.NET
ASP.NET: Web Services Windows
And Web Forms forms

ADO.NET: Data and XML

Base Class Library

Common Language Runtime

The .NET Framework
Common Language Runtime
VB C++ C# JScript …

Common Language Specification

Visual Studio.NET
ASP.NET: Web Services Windows
and Web Forms Forms

ADO.NET: Data and XML

Base Class Library

Common Language Runtime

The .NET Framework
Common Language Runtime
 New Runtime Environment – Common
Language Runtime
 Language Interoperability
 Common Classes for all Languages
 Common Types for all Languages
 Runtime Controls Compilation to Machine
Code
 Assemblies
 Application Domains
The .NET Framework
Common Language Runtime

 Simplified development
 XCOPY deployment
 Scalability
 Rich Web clients and safe Web hosting
 Potentially multi-platform
 Multiple languages (cross inheritance)
 Increases productivity
 Robust and secure execution environment
.NET Framework and CLR
CLR Execution Model
Source VB C# C++
code
Unmanaged
Compiler Compiler Compiler
Component

Managed Assembly Assembly Assembly

code IL Code IL Code IL Code

Common Language Runtime

JIT Compiler

Native Code

Operating System Services

The .NET Framework
.NET Framework Services
VB C++ C# JScript …

Common Language Specification

Visual Studio.NET
ASP.NET: Web Services Windows
and Web Forms Forms

ADO.NET: Data and XML

Base Class Library

Common Language Runtime

The .NET Framework
.NET Framework Services

 ASP.NET
 Separation of code and presentation
 Compiled
 Web Forms
 Web Services
 Windows® Forms
 Framework for building rich clients
 ADO.NET, Evolution of ADO
 New objects (e.g., DataSets)
 XML support throughout
Agenda
 Hello World
 The .NET Framework
 Design Goals of C#
 Language Features
Design Goals of C#
The Big Ideas

 The first “Component Oriented”

language in the C/C++ family
 Everything really is an object
 Next generation robust and
durable software
 Preserving your investment
Design Goals of C#
A Component Oriented Language

 C# is the first “Component Oriented”

language in the C/C++ family
 Component concepts are first class
 Properties, methods, events
 Design-time and run-time attributes
 Integrated documentation using XML
 Enables one-stop programming
 No external files like header files, IDL, etc.
 Can be embedded in ASP pages
Design Goals of C#
Everything Really Is an Object

 Traditional views
 C++, Java™: Primitive types are “magic”
and do not interoperate with objects
 Smalltalk, Lisp: Primitive types are
objects, but at great performance cost
 C# unifies with no performance cost
 Deep simplicity throughout system
 Improved extensibility and reusability
 New primitive types: Decimal, SQL…
 Collections, etc., work for all types
Design Goals of C#
Robust and Durable Software

 Garbage collection
 No memory leaks and stray pointers
 Exceptions
 Error handling is not an afterthought
 Type-safety
 No uninitialized variables, unsafe casts
 Versioning
 Pervasive versioning considerations in all
aspects of language design
Design Goals of C#
Preserving Your Investment
 C++ Heritage
 Namespaces, enums, pointers (in unsafe
code), unsigned types, etc.
 No unnecessary sacrifices
 Real-world useful constructs
 foreach, using, switch on string
 decimal type for financial applications
 ref and out parameters
 Millions of lines of C# code in .NET
 Short learning curve
 Increased productivity
Design Goals of C#
Interoperability

.NET Languages XML/SOAP

VB.NET
COM
MC++ C# OLE Automation

JScript P/Invoke and unsafe code

... Dynamic Link Libraries

Agenda
 Hello World
 The .NET Framework
 Design Goals of C#
 Language Features
Language Features
Program Structure
 Namespaces
 Contain types and other namespaces
 Type declarations
 Classes, structs, interfaces, enums,
and delegates
 Members
 Constants, fields, methods, properties, indexers,
events, operators, constructors, destructors
 Organization
 No header files, code written “in-line”
 No declaration order dependence
 Language Features
Program Structure
using System;
namespace System.Collections
{
public class Stack
{
Entry top;
public void Push(object data) {
top = new Entry(top, data);
}
public object Pop() {
if (top == null) throw new InvalidOperationException();
object result = top.data;
top = top.next;
return result;
}
}
}
Language Features
Type System

 Value types
 Directly contain data
 Cannot be null
 Reference types
 Contain references to objects
 May be null
int i = 123;
string s = "Hello world";
i 123

s "Hello world"
Language Features
Type System

 Value types
 Primitives int i;
 Enums enum State { Off, On }
 Structs struct Point { int x, y; }
 Reference types
 Classes class Foo: Bar, IFoo {...}
 Interfaces interface IFoo: IBar {...}
 Arrays string[] a = new string[10];
 Delegates delegate void Empty();
Language Features
Predefined Types

 C# predefined types
 Reference object, string
 Signed sbyte, short, int, long
 Unsigned byte, ushort, uint, ulong
 Character char
 Floating-point float, double, decimal
 Logical bool
 Predefined types are simply aliases for
system-provided types
 For example, int = System.Int32
Language Features
Classes

 Single inheritance
 Multiple interface implementation
 Class members
 Constants, fields, methods,
properties, indexers, events,
operators, constructors, destructors
 Static and instance members
 Nested types
 Member access
 Public, protected, internal, private
Language Features
Structs

 Like classes, except

 Stored in-line, not heap allocated
 Assignment copies data, not reference
 No inheritance
 Ideal for light weight objects
 Complex, point, rectangle, color
 int, float, double, etc., are all structs
 Benefits
 No heap allocation, less GC pressure
 More efficient use of memory
Language Features
Classes and Structs
struct SPoint { int x, y; ... }
class CPoint { int x, y; ... }

SPoint sp = new SPoint(10, 20);

CPoint cp = new CPoint(10, 20);

10
sp
20

cp CPoint
10
20
Language Features
Interfaces
 Multiple inheritance
 Can contain methods, properties,
indexers and events
 Private interface implementations
interface IDataBound
{
void Bind(IDataBinder binder);
}

class EditBox: Control, IDataBound

{
void IDataBound.Bind(IDataBinder binder) {...}
}
Language Features
Enums
 Strongly typed
 No implicit conversions to/from int
 Operators: +, -, ++, --, &, |, ^, ~
 Can specify underlying type
 Byte, short, int, long

enum Color: byte

{
Red = 1,
Green = 2,
Blue = 4,
Black = 0,
White = Red | Green | Blue,
}
Language Features
Delegates
 Object oriented function pointers
 Multiple receivers
 Each delegate has an invocation list
 Thread-safe + and - operations
 Foundation for framework events

delegate void MouseEvent(int x, int y);

delegate double Func(double x);

Func func = new Func(Math.Sin);

double x = func(1.0);
Language Features
Unified Type System

 Everything is an object
 All types ultimately inherit from object
 Any piece of data can be stored,
transported, and manipulated with no
extra work
object

Stream Hashtable int double

MemoryStream FileStream
Language Features
Unified Type System

 Boxing
 Allocates box, copies value into it
 Unboxing
 Checks type of box, copies value out
int i = 123;
object o = i;
int j = (int)o;
i 123

o System.Int32
123
j 123
Language Features
Unified Type System

 Benefits
 Eliminates “wrapper classes”
 Collection classes work with all types
 Replaces OLE Automation's Variant
 Lots of examples in .NET framework
string s = string.Format(
"Your total was {0} on {1}", total, date);

ArrayList al = new ArrayList();

al.Add( new Customer() );

al.Add( 1 );
al.Add( "test" );
Language Features
Component Development

 What defines a component?

 Properties, methods, events
 Integrated help and documentation
 Design-time information
 C# has first class support
 Not naming patterns, adapters, etc.
 Not external files
 Components are easy to build and
to consume
Language Features
Properties

 Properties Are “Smart Fields”

 Natural syntax, accessors, inlining

public class Button: Control

{
private string caption;

public string Caption {

get {
return caption;
}
set {
caption = value;
Repaint(); Button b = new Button();
} b.Caption = "OK";
} String s = b.Caption;
}
Language Features
Indexers

 Indexers are “smart arrays”

 Can be overloaded
public class ListBox: Control
{
private string[] items;

public string this[int

index] {
get {
return items[index];
}
set { ListBox listBox = new
items[index] = value; ListBox();
Repaint(); listBox[0] = "hello";
} Console.WriteLine(listBox[0]);
}
}
Language Features
Creating and Firing an Event

 Define the Event signature

public delegate void EventHandler(object sender,
EventArgs e);

 Define the Event and firing logic

public class Button
{
public event EventHandler Click;

protected void OnClick(EventArgs e) {

if (Click != null) Click(this, e);
}
}
Language Features
Handling an Event

 Define and register Event Handler

public class MyForm: Form
{
Button okButton;

public MyForm() {
okButton = new Button(...);
okButton.Caption = "OK";
okButton.Click += new EventHandler(OkButtonClick);
}

void OkButtonClick(object sender, EventArgs e) {

ShowMessage("You pressed the OK button");
}
}
Language Features
DEMO 2: Creating an Event Handler
 Define an Event Handler for a button in a
Windows Forms application
Language Features
Attributes

 Associate information with types

and members
 Documentation URL for a class
 Transaction context for a method
 XML persistence mapping
 Traditional solutions
 Add keywords or pragmas to language
 Use external files, e.g., .IDL, .DEF
 C# solution: Attributes
Language Features
Attributes
public class OrderProcessor
{
[WebMethod]
public void SubmitOrder(PurchaseOrder order) {...}
}

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

public class Address {...}

public class Item {...}

Language Features
Attributes
 Attributes can be
 Attached to types and members
 Examined at run-time using reflection
 Completely extensible
 Simply a class that inherits from System.Attribute
 Type-safe
 Arguments checked at compile-time
 Extensive use in .NET framework
 XML, Web Services, security, serialization,
component model, COM and P/Invoke interop,
code configuration…
What Is A Web Service?
 HTML = user-to-machine
 XML/SOAP = machine-to-machine
 Leveraging the Web
 Same infrastructure
 Same programming model
 Anyone can play

 Truly scalable distributed applications

 Stateless and loosely coupled
 Both Internet and intranet
How Does It Work?
Find a Service
http://www.uddi.org
UDDI
Link to DISCO or WSDL document

Discovery
http://myservice.com
Web
Service HTML or XML with link to WSDL
Consumer
How do we talk? (WSDL)
http://myservice.com?wsdl
Web
XML with service descriptions Service

Let’s talk (SOAP)

http://myservice.com/svc1
XML/SOAP BODY
Web Services With .NET
The .NET framework provides
a bi-directional mapping
Application
Concepts Web Programs

Data XML Objects

Schema XSD Classes

Services WSDL Methods

Invocation SOAP Calls

Web Services With .NET
public class OrderProcessor
{
[WebMethod]
public void SubmitOrder(PurchaseOrder
<?xml version="1.0" encoding="utf-8"?>order) {...}
} <soap:Envelope>
<soap:Body>
[XmlRoot("Order",
<SubmitOrder>Namespace="urn:acme.b2b-schema.v1")]
public class PurchaseOrder
<Order date=“20010703">
{ <shipTo>Anders Hejlsberg</shipTo>
public
[XmlElement("shipTo")]
string ShipTo; Gates</billTo>
<billTo>Bill public string ShipTo;
public
[XmlElement("billTo")]
string BillTo;
<comment>Overnightpublic string BillTo;
delivery</comment>
public
[XmlElement("comment")]
string
<items>Comment; public string Comment;
PurchaseOrder
public poItems;
= new PurchaseOrder();
[XmlElement("items")]
Item[] public Item[] Items;
<productId>17748933</productId>
po.ShipTo
public = “Anders
DateTime Hejlsberg";
[XmlAttribute("date")]
OrderDate;
<description>Dompublic DateTime OrderDate;
Perignon</description>
} po.BillTo =</items>
“Bill Gates";
po.OrderDate = DateTime.Today;
</Order>
… </SubmitOrder>
OrderProcessor.SubmitOrder(po);
</soap:Body>
</soap:Envelope>
Language Features
DEMO 3: Attributes
 Create a Web service by using the
[WebMethod] attribute
Language Features
XML Comments
class XmlElement
{
/// <summary>
/// Returns the attribute with the given name and
/// namespace</summary>
/// <param name="name">
/// The name of the attribute</param>
/// <param name="ns">
/// The namespace of the attribute, or null if
/// the attribute has no namespace</param>
/// <return>
/// The attribute value, or null if the attribute
/// does not exist</return>
/// <seealso cref="GetAttr(string)"/>
///
public string GetAttr(string name, string ns) {
...
}
}
Language Features
DEMO 4: XML Comments
 Show how the compiler can auto generate
documentation from the source code using
XML comments
 Language Features
Statements and Expressions
 High C++ fidelity
 if, while, do require bool condition
 Switch statement
goto in_label;
 No fall-through, “goto case” or “goto default”
switch( argwhile) ( i<100 )
 Goto can’t jumpstatic
into {blocks
short x = {32767; // Max short
static short
casey0: = in_label:
32767;
 Foreach statement int i;case 1: i++;
 Checked and try Console.WriteLine(“Low”);
}
unchecked foreachif({(string
i
case
)goto
break;
//
2:error
case 2;
word in (myArray.words
ifz(=case
i>0
checked((short)(x i<100+ )y)); )
Console.WriteLine(“Med”);
)2: while
statements { } break;
Console.WriteLine(“Med”);
{
 Expression } catchConsole.WriteLine(“{0}”,
FileClass
void
default:
Foo()
break; { ( j>50e)) word)
(OverflowException
file;
if
statements { default:
Console.WriteLine(“High”);
i == 1; goto
// error
out_label;
ifConsole.WriteLine(e.ToString());
}( fileConsole.WriteLine(“High”);
i =+ OpenFile()
j;
} // )error
// error
must do work if}}( (file = out_label:
OpenFile()) != NULL )
Language Features
For Each Statement

 Iteration of arrays
public static void Main(string[] args) {
foreach (string s in args) Console.WriteLine(s);
}

 Iteration of user-defined collections

foreach (Customer c in customers.OrderBy("name")) {
if (c.Orders.Count != 0) {
...
}
}
Language Features
Parameter Arrays

 Can write “printf” style methods

 Type-safe, unlike C++
void printf(string fmt, params object[] args) {
foreach (object x in args) {
...
}
}

printf("%s %i %i", str, int1, int2);

object[] args = new object[3];

args[0] = str;
args[1] = int1;
Args[2] = int2;
printf("%s %i %i", args);
Language Features
Operator Overloading

 First class user-defined data types

 Used in base class library
 Decimal, DateTime, TimeSpan
 Used in the framework
 Unit, point, rectangle
 Used in SQL integration
 SQLString, SQLInt16, SQLInt32,
SQLInt64, SQLBool, SQLMoney,
SQLNumeric, SQLFloat…
Language Features
Operator Overloading
public struct DBInt
{
public static readonly DBInt Null = new DBInt();

private int value;

private bool defined;

public bool IsNull { get { return !defined; } }

public static DBInt operator +(DBInt x, DBInt y)

{...}

public static implicit operator DBInt(int x) {...}

public static explicit operator int(DBInt x) {...}
}
DBInt x = 123;
DBInt y = DBInt.Null;
DBInt z = x + y;
Language Features
Versioning

 Overlooked in most languages

 C++ and Java produce fragile base classes
 Users unable to express versioning intent
 C# allows intent to be expressed
 Methods are not virtual by default
 C# keywords “virtual”, “override” and
“new” provide context
 C# can't guarantee versioning
 Can enable (e.g., explicit override)
 Can encourage (e.g., smart defaults)
Language Features
Versioning
class Base
class Base // version
// version2 1
{
} public virtual void Foo() {
Console.WriteLine("Base.Foo");
}
}

class Derived: Base // version 1

2a
2b
{
virtual
new public
public override void
virtual
void Foo()
void
Foo() {{ {
Foo()
Console.WriteLine("Derived.Foo");
base.Foo();
} Console.WriteLine("Derived.Foo");
} }
}
Language Features
Conditional Compilation

 #define, #undef
 #if, #elif, #else, #endif
 Simple boolean logic
 Conditional methods
public class Debug
{
[Conditional("Debug")]
public static void Assert(bool cond, String s) {
if (!cond) {
throw new AssertionException(s);
}
}
}
Language Features
Unsafe Code
 COM integration, P/invoke cover most cases
 Unsafe code
 Low-level code without leaving the box
 Enables unsafe casts, pointer arithmetic
 Declarative pinning
 Fixed statement
 Basically “inline C”
unsafe void Foo() {
char* buf = stackalloc char[256];
for (char* p = buf; p < buf + 256; p++) *p = 0;
...
}
Language Features
Unsafe Code
class FileStream: Stream
{
int handle;

public unsafe int Read(byte[] buffer, int index, int

count) {
int n = 0;
fixed (byte* p = buffer) {
ReadFile(handle, p + index, count, &n, null);
}
return n;
}

[dllimport("kernel32", SetLastError=true)]
static extern unsafe bool ReadFile(int hFile,
void* lpBuffer, int nBytesToRead,
int* nBytesRead, Overlapped* lpOverlapped);
}
Language Features
COM Support

 .Net framework provides great

COM support
 TLBIMP imports existing COM classes
 TLBEXP exports .NET types
 Most users will have a
seamless experience
Language Features
COM Support

 Sometimes you need more control

 Methods with complicated structures
as arguments
 Large TLB – only using a few classes
 System.Runtime.Interopservices
 COM object identification
 Parameter and return value marshalling
 HRESULT behavior
Language Features
DEMO 5: COM and C#
Call a COM component from C#
Language Features
DEMO 6: Visual Studio .NET
Windows programming with C#
C# And CLI Standardization
 Work begun in September 2000
 Submitted to ECMA (www.ecma.ch)
 Active involvement by Intel, HP, IBM,
Fujitsu, Plum Hall, …
 Since December 2001
 “C#Language Specification”
 “Common Language Infrastructure (CLI)”
C# Books
C# Customers
More Resources
 http://msdn.microsoft.com/
 C# language specification
 C# newsgroups
 microsoft.public.dotnet.languages.csharp
Questions?
© 2001 Microsoft Corporation. All rights reserved.