C#

A Component-oriented Language for the

Microsoft® .NET Framework
Objectives
 Introduction to the C# Language
 Syntax
 Concepts
 Technologies
 Overview of C# Tools and the .NET Framework
Contents
 Section 1: C# Overview
 Section 2: Elements of C#
 Section 3: C# Tools
 Section 4: Putting It All Together
 Summary
Section 1: C# Overview
 Component-oriented Systems
 Component Concepts of .NET
 Why C#?
Component-oriented
Systems
 COM
 Most successful component model in history
 Only viable commercial component platform
 Enables cross-organization integration and reuse
 However:
 COM shows its age
 DCOM does not function well over the Internet
 More component-based systems, more "DLL Hell"
 Even with maturing tools, still too difficult to implement
 COM is not truly language agnostic
 Makes some assumptions of binary layout
 Supports "least common denominator" type system only
Component Concepts
of .NET
 Take the best of COM+
 Interfaces as abstract contracts
 Components implement and expose interfaces
 Dynamic exploration of capabilities and contracts
 Attribute-driven behavior (transactions, pooling, ...)
 Add
 True object-orientation and inheritance
 Native events model
 Cross-language type system and runtime
 Extensibility at every level
Why C# ?
 First component-oriented language
 Builds on COM+ experience
 Native support for
 Namespaces
 Versioning
 Attribute-driven development

 Power of C with ease of Microsoft Visual Basic®

 Minimal learning curve for everybody
 Much cleaner than C++
 More structured than Visual Basic
 More powerful than Java
Section 2: Elements of C#
 Shape and Structure
 Understanding the C# Type System
 Understanding the C# Language
Shape and Structure
 No header files
 C# employs "definition at declaration" model
 Much like Visual Basic, Pascal, Modula, Java
 Similar to C++ "inline" implementation
 Without implication on code generation
 All code and declaration in one place
 Keeps code consistent and maintainable
 Much better to understand for team collaboration
 Declaration accessible through metadata
 Conditional compilation but no macros
Type System
 Builds on common type system of .NET Framework
 Native access to .NET type system
 C# was born out of .NET
 Core concepts:
 Everything is an object
 Everything implicitly inherits from [Link]
 Clear distinction between value and reference types
 By-Value: Simple Types, Enums, Structs
 By-Reference: Interfaces, Classes, Arrays
Simple Types
 Integer Types
 byte, sbyte (8bit), short, ushort (16bit)
 int, uint (32bit), long, ulong (64bit)
 IEEE Floating Point Types
 float (precision of 7 digits)
 double (precision of 15–16 digits)
 Exact Numeric Type
 decimal (28 significant digits)
 Character Types
 char (single character)
 string (rich functionality, by-reference type)
 Boolean Type
 bool (distinct type, not interchangeable with int)
Enums
 Named elements used instead of numbering options
 Strongly typed
 Better to use "[Link]" than "3"
 More readable, better maintenance
 Still as lightweight as a plain int
 Example: enum Color
{
Red,
Green,
Blue,
Yellow
};
Arrays
 Zero based, type bound
 Built on .NET [Link] class
 Declared with type and shape, but no bounds
 int[] SingleDim;
 int[,] TwoDim;
 int [][] Jagged;
 Created using new with bounds or initializers
 SingleDim = new int[20];
 TwoDim = new int[,]{{1,2,3},{4,5,6}};
 Jagged = new int[1][];
Jagged[0] = new int[]{1,2,3};
Interfaces
 Declarations of semantics contracts between parties
 Enables component orientation
 Define structure and semantics for specific purposes
 Abstract definitions of methods and properties
 Support (multiple) inheritance
 Example: interface IPersonAge
{
int YearOfBirth {get; set;}
int GetAgeToday();
}
 Classes
 Implementation of code and data public class Person :
IPersonAge
{
 Represents semantic unit private int YOB;

 Implement public Person()

interfaces {
}
 Inherit from single base class public int YearOfBirth
{
 Classes contain: get { return YOB; };
set { YOB = value; };
}
 Fields: member variables
public int GetAgeToday()
 Properties: values accessed through {
get/set method pairs return Today()-
YearOfBirth
 Methods: functionality for object or };
}
class
 Specials: events, indexers,
delegates
Structs
 Groups of data and code
 Similar to classes, however:
 No inheritance allowed
 Always passed by value
 Classes vs. Structs
 Struct  Lightweight data container, value type
 Class  Rich object with references, reference type

 C++ Developers!
 Struct is not a class with everything being public
 Example: struct Point
{
double X;
double Y;
void MoveBy(double dX, double dY)
{ X+=dX; Y+=dY; }
}
Properties
 Mix between fields and methods
 Use properties for:
 Implementation of read-only members
(by omitting set)
 Validation on assignment
 Calculated or composed values
 Exposing values on interfaces
 Example: string Name
{
get { return name; }
set { name = value; }
}
Indexers
 Consistent way to build containers
 Build on properties idea
 Allow indexed access to contained objects
 Index qualifier may be of any type
 Example: object this[string index]
{
get { return [Link](index); }
set { [Link](index,value); }

}
Delegates and Events
 Delegates
 Similar to function pointers found in C and C++
 Strongly typed, no type-cast confusion
 delegate void Clicked(Element e, Point p);
 Events
 Language-intrinsic event model (at last!)
 Declare and call in the event-source class
 Consume by adding handler in sink
 [Link] += MyClickHandler;
 All management done by C#
 event Clicked OnClicked;
...
OnClicked(this,PointerLocation);
Attributes
 Similar to attributes known from IDL
 Declarative access to functionality
 Extensible through custom attributes
 Allow code augmentation with:
 Hints for the runtime environment
[Transaction([Link])]
class MyBusinessComponent { ... }
 Declarative semantics

[PersonFirstName] String Vorname;

[PersonFirstName] String PrimarioNome;
Creating Custom
Attributes
 Implement class with Attribute suffix
 Automatically extend Language (!)
 Explore through .NET reflection
 Typeof(<object-expr>).GetCustomAttributes();
 Example:

class PersonFirstNameAttribute : Attribute

{
public PersonFirstName()
{
}
}
Statements
 Very C: Flow Control and Loops
 if (<bool expr>) { ... } else { ... };
 switch(<var>) { case <const>: ...; };
 while (<bool expr>) { ... };
 for (<init>;<bool test>;<modify>) { ... };
 do { ... } while (<bool expr>);

 Very not C:
 lock(<object>){ ... };
 Language inherent critical section synchronization
 checked {...}; unchecked { ...};
 Integer overflow protection
Collections Built-in:
foreach
 Straightforward support for iterating over collections
 Can be used for arrays and other collections
 Can also be used with any custom class
 Implements IEnumerable with GetEnumerator()
 Returning object implementing IEnumerator
 Example: Point[] Points = GetPoints();
foreach( Point p in Points )
{
[Link](p.x,p.y);
}
Operators
 Very C:
 Logical/conditional: && || ^
 Arithmetic: * / + - % << >>
 Relational: == != < > >= <=
 Not exactly C:
 For bool: & and | are logical with full evaluation
 For integer: & and | perform binary AND/OR
 Very un-C:
 is Tests run-time type
 as Converts a value to a specified type
 typeof Retrieves run-time type
Operator Overloading
 Most operators can be overloaded
 Arithmetic, relational, conditional, and logical
 No overloading for
 Assignment operators
 Special operators (sizeof, new, is, typeof)
 Example: Total operator +(int Amount, Total t)
{
[Link] += Amount;
}
Access Protection
 Adopts C++ model
 public  Everyone may call or access
 protected  Only members may access
 private  Only members of exactly this class
 Expands C++ model
 sealed  Can't use as base class
 internal  Public access only within assembly
 protected internal  Protected in assembly
“Pointers, I need
pointers!”
 C# supports
 Intrinsic string type
 Rich garbage-collection model
 By-reference parameters using ref
void increment(ref int value, int by)
 Outbound parameters using out
bool add(int a, int b, out int c)
 Eliminates vast majority of C++ uses of pointers
 Pointers are available for code marked unsafe
unsafe void crypt(byte[] arr)
{
byte * b = arr;
...
}
Boxing and Unboxing
 By-value types can be "boxed" and "unboxed"
 "Boxing" allows by-value types to travel by-ref
 Based on objectness of all types.
 Think: Throw value in box and reference the box

double Value;
42 42
// Boxing
object BoxedValue = Value;
// Unboxing
42 Value = (double)BoxedValue;

Boxed: Unboxed:
Reference Copy
Garbage Collection 1/2

 C/C++ applications often leak memory

 Manual memory management
 No clear rules for ownership of objects
 COM fixes this partly through ref-counts
 AddRef/Release calls must be balanced
 SmartPointers don't catch all problems
 Server applications must be leak free
 Must run for months and years
 Solution: automatic memory management
 Garbage Collection 2/2

 Developer creates new objects and data arrays

 Everything created/allocated using new keyword
 The .NET runtime tracks all memory usage automatically
 GC automatically removes all unused objects
 More efficient memory management
 Ease of use and "zero memory leaks"
 Catch! Nondeterministic destruction of objects
 Destructors called at some random future time
 Code should not depend on destructors to free resources
 Use Dispose() design pattern
Exception Handling
 Very similar to C++ and SEH
 Read like this:
 try running this code ...
 ... if error occurs, catch what I can deal with ...
 ...finally allow me to do some manual cleanup work
 Example: try
{
//... run code
}
catch(SomeException e)
{
//... handle
}
finally
{
//...end gracefully
}
Core Differences from C+
+
 C# looks a lot like C/C++
 Fixes a lot of common bug sources:
 Stricter type-checking, very unforgiving with type-casts
 No "fall-through" in switch
 Boolean expressions are strongly typed
 Better access protection, no cheating through headers
 "Mostly no pointers"  "Mostly no GPF"
 Forget hunting memory leaks
Class Version
Management
 Real Life:
 Two people at two places write two pieces of software
 A's class builds on B's class
 B implements a method CalcResult
 Next version, A also adds CalcResult
 Q: Does B want CalcResult to be an override of A's ?
 A: Unlikely.

 Solution: Must state intent when using inheritance

 Must specify override to override a method
 Can specify new virtual to never inherit from base
Namespaces
 Every definition must be contained in a namespace
 Avoids name collisions
 Enforces order
 Makes API's easier to comprehend
 Can and should be nested
 Group classes and types by semantics
 Declared with keyword namespace
 Referenced with using
Goodies: XML Comments
 Consistent, intrinsic way to create doc from code
 Triple-slash "///" comments are exported
 Extract full documentation during compile with /doc
 Comes with predefined schema
 Example: ///<summary>
/// This function serves to calculate the
/// overall value of the item including all
/// taxes
/// </summary>
public decimal GetTotalValue()
{
}
Section 3: The Tools
 .NET Framework SDK—all you need to build apps
 C# compiler
 Visual debugger
 Nmake
 Visual [Link]—the productivity rocket
 Development environment optimized for C#
 Code wizards and templates
 Smart help
.NET Framework SDK
 C# compiler (plus Visual Basic, C++, and JScript)
 All language features
 Runs from the command line
 Visual Debugger—GuiDebug
 Built on Visual [Link] technology
 Full access to runtime metadata
 Tools
 Nmake, security, configuration, IL Disassembler, ...
 Free for everyone
Visual [Link]
 Built on the .NET Framework SDK
 Reinvention of the concept of Visual Studio®, now with:
 Multiple-language projects
 One integrated development environment for all
languages and tasks
 Integrated tools: Visual Modeler, Database Management
 Perfect help integration: Dynamic Help, IntelliSense®
 Highest productivity for all:
 Rapid application development
 Large-scale projects
Section 4: Putting It All
Together
 Samples
 The Classic Start: "Hello World!" in C#
 Exploring C# Features in Duwamish Books
Hello World
namespace Sample
{
using System;

public class HelloWorld

{
public HelloWorld()
{
}

public static int Main(string[] args)

{
[Link]("Hello World!");
return 0;
}
}
}
Hello World Anatomy
 Contained in its own namespace
 References other namespaces with "using"
 Declares a publicly accessible application class
 Entry point is "static int Main( ... )"
 Writes "Hello World!" to the system console
 Uses static method WriteLine on [Link]
C# Unleashed: Duwamish
Books
 [Link] sample application
 "Best practice" multiple-tier design
 Included with Visual [Link]
 Great start to learn about C# and [Link]
Summary
 C# builds on the .NET Framework component model
 New language with familiar structure
 Easy to adopt for developers of C, C++, Java, and
Visual Basic applications
 Fully object oriented
 Optimized for the .NET Framework
Questions?
Duwamish Books
A Sample Application for Microsoft .NET
Installing the Sample 1/2

 Install the "Enterprise Samples" with Visual [Link]

 Location of the C# Version
 Visual [Link] folder
 Directory .\EnterpriseSamples\DuwamishOnline CS
 Location of the Visual Basic Version
 Directory .\EnterpriseSamples\DuwamishOnline VB
 Installation Tasks
 Check the prerequisites
 Microsoft Windows® 2000 Server; Microsoft SQL Server™ 2000
with English Query optional and supported
 Read the [Link]
 Run installer [Link] (double-click it)
Installing the Sample 2/2

 The installation wizard will guide you

 Defaults should be OK for almost everybody
 Setup will install database, Web site, and code
 After installation is complete:
 File/Open Solution with the [Link] file
 Can build the sample with Build/Build Solution
Duwamish Architecture
Overview
User / Browser
[Link]

IIS

Web
SystemFramework

[Link]
BusinessFacade

BusinessRules

DataAccess

[Link]
T Database
Common Components
 [Link]
 Contains systems configuration options
 Contains common data definitions (classes)
 Subnamespace [Link]
 "Internal" data representation for Book, Category,
Customer, OrderData
 [Link]
 Diagnostics utilities
 Pre and post condition checking classes
 Dynamic configuration
 In short:
 Everything that's pure tech and not business code
[Link]
 Contains all database-related code
 Uses [Link] architecture
 Using SQL Server managed provider
 Shows DataSet, DataSetCommand usage
 Optimized for performance by using stored procs
[Link]
s
 Implements all business rules
 Validation of business objects (for example,
Customer EMail)
 Updating business objects
 Calculations (Shipping Cost, Taxes)
 All data access performed through DataAccess
[Link]
de
 Implements logical business subsystems
 CustomerSystem: Profile management
 OrderSystem: Order management
 ProductSystem: Catalog management
 Reads data through DataAccess
 Data validated and updated using BusinessRules
 BusinessFacade encapsulates all business-related
functionality
[Link]
 Implements the user interface for Web access
 Uses [Link] architecture
 Employs Web Forms model
 Uses code behind forms
 Manages state
 Uses custom Web controls
 All functionality accessed through BusinessFacade
Shop at Duwamish
[Link]
 Demo: Duwamish in Action
Exploring
DuwamishOnline C#
 Exploring C# Features in Duwamish Online
Extending
DuwamishOnline C#
 Extending Duwamish Online Using C#
To C# from Visual Basic
A very brief introduction to the C language
family syntax for Visual Basic developers
C
 Core principles: Be brief. Be expressive.
 Relatively few and short keywords
 Uses symbol ASCII characters instead of words
 Core element: "{" The Block "}"
 Code groups for structural or flow-control elements

Blocks in Visual Basic Blocks in C

Sub Xyz() void Xyz() {
'Code /*Code*/
End Sub }

If MyVal=0 Then if (MyVal==0) {

'Code /*Code*/
End If }
 Statements
 All statements ("do that!") are inside blocks
 Every statement is terminated with a semicolon ";"
 White space, line breaks, tabs are not significant
 May have many statements on one line
 Statements may be split across lines

Statements: Just as legal: This too: #define/**/X

char*d="X0[!4cM,!"
" 4cK`*!4cJc(!4cHg&!4c$j"
"8f'!&~]9e)!'|:d+!)rAc-!*m*"
" :d/!4c(b4e0!1r2e2!/t0e4!-y-c6!"

a = add( 2, 3 ); a=
" +|,c6!)f$b(h*c6!(d'b(i)d5!(b*a'`&c"
")c5!'b+`&b'c)c4!&b-_$c'd*c3!&a.h'd+"
"d1!%a/g'e+e0!%b-g(d.d/!&c*h'd1d-!(d%g)"
"d4d+!*l,d7d)!,h-d;c'!.b0c>d%!A`Dc$![7)35E"
"!'1cA,,!2kE`*!-s@d(!(k(f//g&!)f.e5'f(!+a+)"
"f%2g*!?f5f,!=f-*e/!<d6e1!9e0'f3!6f)-g5!4d*b"
"+e6!0f%k)d7!+~^'c7!)z/d-+!'n%a0(d5!%c1a+/d4"
"!2)c9e2!9b;e1!8b>e/! 7cAd-!5fAe+!7fBe(!"
"8hBd&!:iAd$![7S,Q0!1 bF 7!1b?'_6!1c,8b4"

q = a – 1; add
"!2b*a,*d3!2n4f2!${4 f. '!%y4e5!&f%"
"d-^-d7!4c+b)d9!4c-a 'd :!/i('`&d"
";!+l'a+d<!)l*b(d=!' m- a &d>!&d'"
"`0_&c?!$dAc@!$cBc@!$ b < ^&d$`"
":!$d9_&l++^$!%f3a' n1 _ $ !&"
"f/c(o/_%!(f+c)q*c %! * f &d+"
"f$s&!-n,d)n(!0i- c- k) ! 3d"
"/b0h*!H`7a,![7* i] 5 4 71"
"[=ohr&o*t*q*`*d *v *r ; 02"

out( q ); (2,3
"7*~=h./}tcrsth &t : r 9b"
"].,b-725-.t--// #r [ < t8-"
"752793? <.~;b ].t--+r / # 53"
"7-r[/9~X .v90 <6/<.v;-52/={ k goh"
"./}q; u vto hr `.i*$engt$ $ ,b"
";$/ =t ;v; 6 =`it.`;7=` : ,b-"
"725 = / o`. .d ;b]`--[/+ 55/ }o"
"`.d : - ?5 / }o`.' v/i]q - "
"-[; 5 2 =` it . o;53- . "

q--; );q=a
"v96 <7 / =o : d =o"
"--/i ]q-- [; h. / = "
"i]q--[ ;v 9h ./ < - "
"52={cj u c&` i t . o ; "
"?4=o:d= o-- / i ]q - "
"-[;54={ cj uc& i]q - -"
"[;76=i]q[;6 =vsr u.i / ={"
"=),BihY_gha ,)\0 " , o [
3217];int i, r,w,f , b ,x ,

return; –1;out
p;n(){return r <X X X X X
768?d[X(143+ X r++ + *d ) %
768]:r>2659 ? 59: ( x = d
[(r++-768)% X 947 + 768] ) ?
x^(p?6:0):(p = 34 X X X )
;}s(){for(x= n (); ( x^ ( p
?6:0))==32;x= n () ) ;return x ; }
void/**/main X () { r = p
=0;w=sprintf (X X X X X X o

(q);q—-
,"char*d="); for ( f=1;f < * d
+143;)if(33-( b=d [ f++ X ] )
){if(b<93){if X(! p ) o
[w++]=34;for X(i = 35 +
(p?0:1);i<b; i++ ) o
[w++]=s();o[ w++ ]
=p?s():34;} else X
{for(i=92; i<b; i
++)o[w++]= 32;} }

;return;
else o [w++ ]
=10;o [
w]=0 ;
puts(o);}

"This too" Credits: Don Yang, Winner "Best Layout" International Obfuscated C Contest [Link]
Declaration Principles
 Core declaration principle: "What then who"
 What: data type or declaration keyword
 Types: int, string, decimal, float
 Keywords: enum, struct, class
 Who: user-defined identifier
 Must begin with a letter, may contain numbers, "_"
 Attention: All identifiers are case sensitive

Variable declarations: Structure declaration:

int MyValue;
string MyName; struct Point {
int x; int y;
Function declaration: }
int MyFunc(string Arg);
Operators
 Arithmetic
 binary operators  "oprd1 operator oprd2"
 add (+), subtract (-), divide (/), multiply (*)
 Modulo (%)  a=b%c; instead of a=b mod c
 unary operators  "oprd1 operator"
 increment (++), decrement (--)  i++ instead of i=i+1
 Logical
 and (&&), or (||), not(!)
 Bitwise
 and (&), or(|), xor (^), not (~)
 Relational
 equal (==), not equal (!=), less (<)
 greater (>), less equal (<=), greater equal (>=)
Expressions
 Boolean expressions
 Evaluate to true or false
 (2 == 1) is false, (2 > 1) is true
 Arithmetic expressions like Visual Basic
 1 + 2 * (6 / 2)
 Assignment
 a = 1;  also at declaration time: int a = 0;
 a += 4;  equivalent to a = a + 4;
 a *= 2;  equivalent to a = a * 2;
 works with all binary operators.
Flow Control
 Conditional execution of code blocks:
 if (<expression>) <block> [else <block>];

 Selective execution of code blocks:

 switch(<variable>) {
case <value>:
<statements>; break;
}

switch (i)
{
if (i == 0 ) case 0:
{ [Link]("This");
[Link]("This"); break;
} case 1:
else [Link]("That");
{ break;
[Link]("That"); default:
}; [Link]("Else");
break;
}
Loops
 Counted loops
 for(<pre>;<while>;<increment>) <block>
 <pre>: Setting precondition "i=0"
 <while>: Testing continuation condition "i<10"
 <increment>: Calculating counter state "i++"
 While loops
 while (<expression>) <block>
 do <block> while (<expression>);

for (i=0; i< 10; i++ ) while ( ![Link] )

{ {
[Link](i); [Link]([Link]());
} }
Other Noteworthy
Things ...
 The data type "void" means "no type"
  method void func(int a) returns nothing
 Like a "Sub" in Visual Basic
  method int func(void) has no arguments
C has pointers. In C# you do not need them
  Don't worry about them
 Reference and value types are clearly defined
 ref keyword for values by reference
 Very few keywords and intrinsic functionality
 "C" languages rely heavily on run-time libraries
 Example: [Link](a,b) instead of a^b
Legal Notices
Unpublished work. 2001 Microsoft Corporation. All rights
reserved.
Microsoft, IntelliSense, JScript, Visual Basic, Visual Studio, and
Windows are either registered trademarks or trademarks of
Microsoft Corporation in the United States and/or other
countries.
The names of actual companies and products mentioned herein
may be the trademarks of their respective owners.