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 Visual Studio.NET

Common Language Specification ASP.NET: Web Services And Web Forms Windows forms

ADO.NET: Data and XML Base Class Library Common Language Runtime

The .NET Framework

Common Language Runtime
VB C++ C# JScript
Visual Studio.NET

Common Language Specification ASP.NET: Web Services and Web Forms Windows 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 code
VB Compiler C# Compiler Assembly IL Code C++ Compiler Assembly IL Code Unmanaged Component

Managed code

Assembly IL Code

Common Language Runtime

JIT Compiler
Native Code

Operating System Services

The .NET Framework

.NET Framework Services
VB C++ C# JScript
Visual Studio.NET

Common Language Specification ASP.NET: Web Services and Web Forms Windows 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 Framework for building rich clients New objects (e.g., DataSets)

Windows Forms

ADO.NET, Evolution of ADO

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
No external files like header files, IDL, etc. Can be embedded in ASP pages

Enables one-stop programming

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 Deep simplicity throughout system New primitive types: Decimal, SQL Collections, etc., work for all types

C# unifies with no performance cost

Improved extensibility and reusability

Design Goals of C#
Robust and Durable Software

Garbage collection

No memory leaks and stray pointers

Exceptions

Error handling is not an afterthought

No uninitialized variables, unsafe casts Pervasive versioning considerations in all aspects of language design

Type-safety

Versioning

Design Goals of C#
Preserving Your Investment

C++ Heritage

Namespaces, enums, pointers (in unsafe code), unsigned types, etc. No unnecessary sacrifices foreach, using, switch on string decimal type for financial applications ref and out parameters Short learning curve Increased productivity

Real-world useful constructs

Millions of lines of C# code in .NET

Design Goals of C#
Interoperability

.NET Languages

XML/SOAP

VB.NET MC++

C#

COM OLE Automation

P/Invoke and unsafe code

JScript
...

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 Classes, structs, interfaces, enums, and delegates Constants, fields, methods, properties, indexers, events, operators, constructors, destructors No header files, code written in-line No declaration order dependence

Type declarations

Members

Organization

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 Contain references to objects May be null
int i = 123; string s = "Hello world";
i s 123 "Hello world"

Reference types

Language Features
Type System

Value types

Primitives Enums Structs Classes Interfaces Arrays Delegates

int i; enum State { Off, On } struct Point { int x, y; } class Foo: Bar, IFoo {...} interface IFoo: IBar {...} string[] a = new string[10]; delegate void Empty();

Reference types

Language Features
Predefined Types

C# predefined types

Reference Signed Unsigned Character Floating-point Logical

object, string sbyte, short, int, long byte, ushort, uint, ulong char float, double, decimal 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
Public, protected, internal, private

Member access

Language Features
Structs

Like classes, except

Stored in-line, not heap allocated Assignment copies data, not reference No inheritance Complex, point, rectangle, color int, float, double, etc., are all structs No heap allocation, less GC pressure More efficient use of memory

Ideal for light weight objects

Benefits

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);
sp 10 20 cp 10 20 CPoint

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 o j 123

System.Int32 123
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 Not naming patterns, adapters, etc. Not external files

C# has first class support

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 { items[index] = value; Repaint(); } } }

ListBox listBox = new ListBox(); 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 Simply a class that inherits from System.Attribute Arguments checked at compile-time XML, Web Services, security, serialization, component model, COM and P/Invoke interop, code configuration

Completely extensible

Type-safe

Extensive use in .NET framework

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 Link to DISCO or WSDL document

UDDI

Discovery
Web Service Consumer
http://myservice.com HTML or XML with link to WSDL

How do we talk? (WSDL)

http://myservice.com?wsdl XML with service descriptions

Web Service

Lets talk (SOAP)

http://myservice.com/svc1 XML/SOAP BODY

Web Services With .NET

The .NET framework provides a bi-directional mapping
Application Concepts Data

Web
XML

Programs
Objects

Schema
Services Invocation

XSD
WSDL SOAP

Classes
Methods Calls

Web Services With .NET

public class OrderProcessor { [WebMethod] public void SubmitOrder(PurchaseOrder order) {...} <?xml version="1.0" encoding="utf-8"?> } <soap:Envelope> <soap:Body> [XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")] <SubmitOrder> public class PurchaseOrder <Order date=20010703"> { <shipTo>Anders Hejlsberg</shipTo> public [XmlElement("shipTo")] string ShipTo; Gates</billTo> public string ShipTo; <billTo>Bill public [XmlElement("billTo")] string BillTo; public string BillTo; <comment>Overnight delivery</comment> public [XmlElement("comment")] string Comment; public string Comment; <items> PurchaseOrder poItems; = new PurchaseOrder(); public [XmlElement("items")] Item[] public Item[] Items; <productId>17748933</productId> po.ShipTo = Anders Hejlsberg"; public [XmlAttribute("date")] DateTime OrderDate; public DateTime OrderDate; <description>Dom Perignon</description> Bill Gates"; } po.BillTo = </items> 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

( i<100 ) switch( argwhile ) Goto cant jump into { blocks static short x = { 32767; // Max short static short casey0: = in_label: 32767; Foreach statement int i; case 1: i++; Console.WriteLine(Low); } Checked and try if{( i case )goto break; // 2:error case 2; unchecked foreach word in ( myArray.words if( z(string =i>0 case checked((short)(x Console.WriteLine(Med); )2: while i<100 + ) y)); ) statements { } break; Console.WriteLine(Med); { Console.WriteLine({0}, FileClass (OverflowException void default: Foo() break; file; if { ( j>50 e)) word) Expression } catch { default: Console.WriteLine(High); i == 1; goto // error out_label; statements ifConsole.WriteLine(e.ToString()); }( file Console.WriteLine(High); i = + OpenFile() j; } // ) error // error must do work if} }( (file = out_label: OpenFile()) != NULL )

goto in_label; No fall-through, goto case or goto default

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 Unit, point, rectangle SQLString, SQLInt16, SQLInt32, SQLInt64, SQLBool, SQLMoney, SQLNumeric, SQLFloat

Used in the framework

Used in SQL integration

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 Methods are not virtual by default C# keywords virtual, override and new provide context Can enable (e.g., explicit override) Can encourage (e.g., smart defaults)

C# allows intent to be expressed

C# can't guarantee versioning

Language Features
Versioning
class Base // version version2 1 class Base // { } public virtual void Foo() { Console.WriteLine("Base.Foo"); } }

1 class Derived: Base // version 2b 2a { virtual void Foo() {{ { new public public override virtual void 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 Fixed statement

Declarative pinning

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 COM object identification Parameter and return value marshalling HRESULT behavior

System.Runtime.Interopservices

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.