Csharp In Detail Part2

C# in Detail Jon Jagger Software Trainer, Designer, Consultant www.jaggersoft.com jon @ jaggersoft.com { JSL } Part 2

Blatant Advert an interactive, friendly, expert instructor Jon has worked for Microsoft using C# lots of great exercises to make sure you understand even more slides with detail, explanations, and rationales full slide notes include careful comparisons with C++ and Java C# in Detail is also available as an instructor led course

Agenda string class constructors fields parameters arrays boxing exceptions garbage collection inheritance, interfaces, abstract classes nested types delegates and events namespaces assemblies attributes reflection

string C# Programming Fundamentals Objects Relationships Systems

string Type string is a reference type the only one with a literal syntax immutable; just like in Java s stack heap null @ t static void Main() { string s = null ; string t = "Hiker" ; ... t[0] = 'B' ; } Hiker compile time error

indexer string has a readonly indexer integer index is always bounds checked throws ArgumentOutOfRangeException static void Func( string s) { for ( int i = 0; i != s.Length; i++) { char c = s[i]; Console.Write(c); } }

System.String string is an alias for System.String namespace System { public sealed class String ... { ... // static methods public static int Compare( string , string ); public static bool Equals( string , string ); public static string Format( string , params object []); ... // readonly property public int Length { get; } // readonly indexer public char this [ int index] { get; } // instance methods public int CompareTo( string ); public override bool Equals( object ); public new bool Equals( string ); ... } }

StringBuilder System.Text.StringBuilder namespace System.Text { public sealed class StringBuilder { public StringBuilder(); // read-write properties public int Length { get ; set ; } public int Capacity { get ; set ; } // read-write indexer public char this [ int index] { get ; set ; } // instance methods public StringBuilder Append(...); public StringBuilder Insert(...); public StringBuilder Remove( int , int ); public StringBuilder Replace(...); ... public override string ToString(); } }

string Literals usual syntax embedded escape chars, but no octal unusual syntax @ verbatim string literals "c:\temp" @"c:\temp" @"quote"" char" @" MP: we got a slug JC: does it talk? MP: yup JC: I'll have it" c: emp c:\temp quote"char MP: we got a slug JC: does it talk? MP: yup JC: I'll have it

string Operators equality operators are overloaded they compare the values not the references relational operators are not overloaded binary + is overloaded, forwards to .Concat operator += too IsTrue(s == t); IsTrue(s.Equals(t)); IsFalse(( object )s == ( object )t); s stack heap @ @ t Hiker Hiker IsTrue(s == t); IsTrue(s.Equals(t)); IsTrue(( object )s == ( object )t); s @ @ t Hiker

class C# Programming Fundamentals Objects Relationships Systems

class Declaration a user-defined reference type class Pair { public int X, Y; }; optional semi-colon by convention public names start with an uppercase letter (PascalCasing) class Pair { private int x, y; } ...and private names start with a lowercase letter (camelCasing) class Pair { int x, y; } default access is private

object Creation a class local variable lives on the stack is not definitely assigned can be initialised with null or a c'tor call p stack ? .X .Y heap required static void Main() { Pair p; } static void Main() { Pair p = null ; } static void Main() { Pair p = new Pair(); } p null p @ 0 0

class Constructor usual class rules compiler declares a default c'tor you can declare the default c'tor if you declare a c'tor the compiler doesn't class Pair { } you declare a default c'tor class Pair { public Pair( int x, int y) {...} } compiler declares a default c'tor class Pair { public Pair() { ... } } no one declares a default c'tor

: this(...) a c'tor can call a sibling c'tor syntax is a cross between C++ and Java no general member-init-list syntax though class Point { public Point( int x, int y) : this (x, y, Colour.Red) { } public Point( int x, int y, Colour c) { ... } ... private int x, y; private Colour c; }

instance Fields instance fields... are default initialised by default in all c'tors can be initialised in variable initialiser can be explicitly initialised in a c'tor class Point { public Point( int x, int y) { this .x = x; y = y; } ... private int x; private int y = 42; } no warning! OK OK OK

readonly Fields readonly instance fields... are instance fields that cannot be assigned to compile time errors class Pair { public Pair( int x, int y) { this .x = x; this .y = y; } public void Reset() { x = 0; y = 0; } private readonly int x, y; } this declares Pair as an immutable object

const Fields const fields are implicitly static only simple types, enum s, & string can be const const fields require a variable initializer class Pair { private const int x = 0, y = 0; } class BadFields { ... BadFields(...) { question = 9 * 6; } ... static const int answer = 42; ... const int question; ... const Pair origin = new Pair(); } OK compile time errors this declares Pair with no instance fields

static Fields to declare static fields of other types use static keyword ! static fields are default initialised static fields can use variable initialisers access is via typename only class Pair { ... static Pair origin; ... static Pair topLeft = new Pair(10,20); ... static AnyClass field; ... static string both = "Arthur"; } Pair p = new Pair(); ... F(p.Origin); // compile-time error F(Pair.Origin); // OK

static Constructor a static c'tor initialises the type can initialize static fields but not const fields called by VES when the type is loaded cannot be called, no access modifier allowed class GoodExample { static GoodExample() { origin = new Pair(0,0); } ...static readonly Pair origin; } OK class BadExample { public static GoodExample() { x = 42; } ...const int x; } compile time errors

Copy Parameters a plain parameter is a copy of the argument no frills bitwise copy the argument must be definitely assigned argument can be an "rvalue" static void Method(Pair parameter) { parameter = new Pair(42,42); } static void Main() { Pair arg = new Pair(0,0); Console.WriteLine(arg.X); Method(arg); Console.WriteLine(arg.X); } 0 0

ref Parameters a ref parameter is an alias for the argument no copy takes place argument must be definitely assigned argument must be an "lvalue" ref required on argument and parameter static void Method( ref Pair parameter) { parameter = new Pair(42,42); } static void Main() { Pair arg = null ; //Console.WriteLine(p.X); Method( ref arg); Console.WriteLine(arg.X); } 42 Method( ref type [ ] array ) allowed

out Parameters an out parameter is an alias for the argument no copy takes places argument need not be definitely assigned parameter must be definitely assigned argument must be an "lvalue" out required on argument and parameter static void Method( out Pair parameter) { parameter = new Pair(42,42); } static void Main() { Pair arg; //Console.WriteLine(p.X); Method( out arg); Console.WriteLine(arg.X); } 42 Method( out type [ ] array ) allowed

in Parameters? readonly , const, and in , are all C# keywords they cannot be applied to parameters reference types always grant write access argument parameter optional required Copy ref out @ @ @ @ @@ @@ 0 0 initialize

[ ] Arrays C# Programming Fundamentals Objects Relationships Systems

Array Variables C# supports rectangular arrays rectangular arrays are reference types int [] row = null ; int [,] grid = null ; int [,,] threeD = null ; row stack heap null null grid

Array Instances array instances are created using new rectangular arrays must specify all dimensions array instance elements are default initialised int [] row = new int [4]; int [,] grid = new int [2,3]; row stack heap @ @ grid 0 0 0 0 0 0 0 0 0 0 array of struct s

Array Initialisation arrays can be initialised omitted initialisers are not permitted array size may be omitted standard shortcut notation int [] row = new int [4] {1,2,3,4}; int [,] grid = new int [,] { {1,2,3}, {4,5,6,}, }; int [,] shortcut = { {1,2,3}, {4,5,6} }; row stack heap @ @ grid 1 2 3 4 1 2 3 4 5 6 trailing commas are permitted

System.Array all array types inherit from System.Array namespace System { public class Array { protected Array(); ... // readonly properties public int Length { get; } public int Rank { get; } // instance methods public int GetLength( int ); // static methods public static void Clear(Array, int , int ); ... } } int [,] cosmic = { {1,2,3}, {4,5,6} }; Console.Write(cosmic.Length); Console.Write(cosmic.Rank); Console.Write(cosmic.GetLength(0)); Console.Write(cosmic.GetLength(1)); 6223

Using Arrays all array access is bounds checked throws IndexOutOfRangeException class Example { static void Use( int [,] grid) { int rowLength = grid.GetLength(0); int colLength = grid.GetLength(1); for (int row = 0; row != rowLength; row++) { for (int col = 0; col != colLength; col++) { Console.WriteLine(grid[row,col]); } } } static void Main() { Use( new int [,]{ {1,2,3}, {4,5,6} }); ... } } there is no direct way to make rowLength constant

Ragged Arrays C# also supports ragged arrays arrays of arrays array instance still created using new int [][] ragged = new int [3][ ]; int [][][] tatters = null ; ragged stack heap @ null null null tatters null

Ragged Initialisation each sub array can be intialised as before you can only specify the first dimension int [][] ragged = new int [3][4]; int [][] ragged = new int [3][] { new int [2], null , new int [4]{ 1, 2, 3, 4 } }; ragged stack heap @ @ null @ 0 0 1 2 3 4 { ... } shorthand allowed here but not here compile time error

params type[ ] C# supports variadic functions params keyword can be used on array parameter only on a single dimension array parameter static void GreyHole( params int [] row) { if (row != null ) Console.WriteLine(row.Length); else Console.WriteLine( "null" ); } static void Main() { GreyHole( null ); GreyHole(); GreyHole(1); GreyHole( new int []{1, 2}); GreyHole(1,2,3); } null 0 1 2 3 params is not part of the signature

params object[ ] params with object as the element type creates a truly variadic function thanks to boxing static void BlackHole( params object [] row) { if (row != null ) Console.WriteLine(row.Length); else Console.WriteLine( "null" ); } static void Main() { BlackHole( null ); BlackHole(); BlackHole(1M); BlackHole( new int []{1,2}); BlackHole(1, 2.0, "three" ); } null 0 1 1 3

Array Notes int [ ] illegal[ , ]; class Base {...} class Derived : Base {...} Derived[] ds = new Derived[]{...}; Base[] bs = ds; unsafe { int * array = stackalloc int [42]; ... } only one syntax C# supports array covariance you can create an array on the stack, but only in unsafe code object o = new int [42]; arrays are reference types int [ ][ , ] mixed; you can mix the two kinds of arrays

Boxing C# Programming Fundamentals Objects Relationships Systems

Recap value types variables contain their own data directly local variables always live on the stack reference types variables refer to their data indirectly local variables refer to objects on the heap object value enum class interface [ ]array delegate struct value object object object @ @ @ @

struct vs class struct Pair { int x, y; ... } Pair p = new Pair(1,2); Pair copy = p; p.x stack heap class Pair { int x, y; ... } Pair p = new Pair(1,2); Pair copy = p; 1 2 @ p @ copy 1 2 p.y copy.x copy.y .x 1 2 .y

Objects Everywhere everything implicitly inherits from object arrays, class es, interface s, delegate s struct s, enum s, as well ! System.Int32 « struct » System.ValueType « class » System.Enum « class » Suit « enum » Pair « struct » System.Object « class » int == System.Int32

Problem? a reference can bind to a value does the reference refer into the stack? if so what happes when the scope ends? struct Pair { public int X, Y; ... } class Example { static object Dangle() { Pair p = new Pair(1,2); object o = p; return o; } static void Main() { object o = Dangle(); ... } } p.X stack 1 2 @ o p.Y ?

Boxed Solution when a reference variable binds to a value the runtime copies the value onto the heap the reference refers to the copy on the heap this is called boxing the copy is the same plain bitwise copy used for value parameters/returns struct Pair { public int X, Y; ... } static void Function() { Pair p = new Pair(1,2); object o = p; } p.X stack heap 1 2 p.Y .X 1 2 .Y @ o box

Unboxing unboxing copies the boxed value back again this requires an explicit cast to exact type if the target type is wrong - InvalidCastException struct Pair { public int X, Y; ... } static void Function() { Pair p = new Pair(1,2); object o = p; p.X = p.Y = 0; Pair q = (Pair)o; } p.X stack heap 0 0 p.Y .X 1 2 .Y @ o cast q.X 1 2 q.Y box unbox

System.Object object is an alias for System.Object namespace System { public class Object { public Object(); public virtual bool Equals( object ); public virtual int GetHashCode(); public Type GetType(); public virtual string ToString(); ... } } static void AnySingleArgument( object accepted) { ... } any value variable (implicit boxing) any reference variable (implicit conversion)

No Overhead in fact, value types do not derive from object each value type has a hidden reference type the hidden reference type holds the boxed value object virtual method are not override n in values they are override n in the hidden reference type Pair « struct » Object « class » Pair Reference « class » Int32 Reference « class » Int32 « struct » 42.ToString() is not a virtual call 1 1

Inheritance C# Programming Fundamentals Objects Relationships Systems

Extension like Java... a class can inherit from a single base class all inheritance is implicitly public unlike Java... there is no extends keyword by default methods are not virtual a struct cannot inherit from a struct or class * ViolinPlayer « class » Musician « class » class Musician { public void NotVirtual()... } class ViolinPlayer : Musician { ... }

: base(...) a class can call a sibling constructor a struct can too a class can call its base class constructor a struct can't (since it can't have a base class ) class Musician { public Musician( string name)... public void NotVirtual()... } class ViolinPlayer : Musician { public ViolinPlayer( string name) : base (name) { ... } }

Method Access two restrictions a private method cannot be virtual a struct can't declare a protected member class GoodClass { public virtual void Alpha()... protected virtual void Beta()... private void Gamma()... } class BadClass { private virtual void Delta()... } struct GoodStruct { public void Alpha()... private void Gamma()... } struct BadStruct { protected void Beta()... }

virtual Methods a virtual method... introduces a method implementation cannot be declared in a struct class Musician { ... public virtual void TuneUp() { ... } } class ViolinPlayer : Musician { public virtual void TuneUp() { ... } } this does not override TuneUp from the Musician class

override Methods an override method... specialises an inherited identical virtual method is implicitly virtual itself cannot be declared in a struct * class Musician { ... public virtual void TuneUp() { ... } } class ViolinPlayer : Musician { public override void TuneUp() { ... } } this does same access too

sealed Methods a sealed override method... specialises an inherited identical virtual method which cannot itself be override n cannot be declared in a struct class Musician { ... public virtual void TuneUp() { ... } } class ViolinPlayer : Musician { public sealed override void TuneUp() { ... } } sealed is always used with override

new Methods a new method... hides an identical inherited method can be used in combination with virtual cannot be used in combination with override class Musician { ... public virtual void TuneUp() { ... } } class ViolinPlayer : Musician { public new virtual void TuneUp() { ... } }

Table method modifiers struct class override no* yes sealed no yes new no* yes public yes yes protected no yes private yes yes virtual no yes only needed when overriding or hiding methods from System.ValueType

Interfaces C# Programming Fundamentals Objects Relationships Systems

interface interfaces contain method signatures no access modifier, implicitly public no fields, not even static ones interface names should start with an I interface ITuneable { void TuneUp(); } interface IPluckable { void Pluck(); } IPluckable « interface » ITuneable « interface »

Multiple Interfaces a class can implement many interface s so can an interface so can a struct (boxing) no implements keyword notation is positional base class first, then base interface s class Violin : Instrument , IPluckable , ITuneable { ... } IPluckable « interface » ITuneable « interface » Violin « class » Instrument « class »

I.I.I. "implicit" interface implementation methods must be explicitly declared public by default methods are not virtual a class must implement all inherited interface methods interface ITuneable { void TuneUp(); } interface IPluckable { void Pluck(); } class Violin : IPluckable, ITuneable { public void TuneUp() { ... } public virtual void Pluck() { ... } ... }

E.I.I. explicit interface implementation cannot have access modifier ( private -ish) cannot be virtual interface ITuneable { void TuneUp(); } interface IPluckable { void Pluck(); } class Violin : Instrument , IPluckable, ITuneable { void ITuneable.TuneUp() { ... } void IPluckable.Pluck() { ... } ... } consider inheriting two operations with the same signature you can mix III and EII

interface Property an interface can declare a property readwrite, readonly, writeonly interface IButton { string Caption { get ; set ; } ... } class Button : IButton { public virtual string Caption { get { ... } set { ... } } ... private string caption; }

interface Indexer an interface can declare an indexer readwrite, readonly, writeonly indexers are not static operators interface IDictionary { string this [ string word ] { get ; set ; } ... } class Dictionary : IDictionary { public virtual string this [ string word ] { get { ... } set { ... } } ... }

is use is operator to check for type support returns true or false a cast can throw an InvalidCastException static void GreyHole( object o) { if (o is IPluckable) { IPluckable ip = (IPluckable)o; ip.Pluck() ... } } static void Main() { GreyHole( new Violin()); GreyHole(42); } check once check twice cast

as the as operator is similar performs the conversion if the type is supported returns null if its not static void GreyHole( object o) { IPluckable ip = o as IPluckable; if (ip != null ) { ip.Pluck(); ... } } static void Main() { GreyHole( new Violin()); GreyHole(42); } check once

typeof retrieving the exact type of an object System.Object.GetType() for variables typeof for types known at compile time Type.GetType() for types known at runtime static void Main() { Violin stradi = new Violin(); IPluckable ip = stradi; Type t1 = ip.GetType(); Type t2 = typeof (Violin); Type t3 = Type.GetType( "Violin" ); Console.WriteLine(t1 == t2); Console.WriteLine(t2 == t3); Console.WriteLine(( object )t1 == ( object )t2); Console.WriteLine(( object )t2 == ( object )t3); } True True True True

ref out interface parameters can be ref qualified can be out qualified interface IPluckable { void Pluck(); } static void Replace( ref IPluckable instrument) { instrument = new Guitar(); } static void Create( out IPluckable instrument) { instrument = new Banjo(); }

Table method modifiers struct class override no* yes sealed no yes new no* yes public yes yes protected no yes private yes yes virtual no yes i'face no no yes no no no no

Abstract Classes C# Programming Fundamentals Objects Relationships Systems

abstract Classes an abstract class ... cannot be instantiated can extend an abstract class or a class otherwise the same as a class abstract class Bar { ... private int instanceMethod() { ... } private int instanceField; } abstract class Foo : Bar { ... public static int StaticMethod() { ... } public static int StaticField; }

abstract Methods an abstract method... can only be declared in an abstract class has no body cannot be private abstract class Foo : Bar { public abstract void Method(); ... }

abstract Notes an abstract method... can override a inherited virtual method must be implemented with the same access abstract class Bar { protected virtual void Method() { ... } ... } abstract class Foo : Bar { protected abstract override void Method(); ... }

sealed Classes a sealed class cannot be derived from cannot declare virtual methods cannot declare abstract methods struct s and enum s are implicitly sealed abstract class Foo : Bar { protected abstract Method(); } sealed class Wibble : Foo { protected override void Method() { ... } ... }

Table method modifiers struct class override no* yes sealed no yes new no* yes public yes yes protected no yes private yes yes virtual no yes i'face no no yes no no no no abstract yes yes yes yes yes no yes sealed yes yes yes yes yes yes no abstract no no no yes no

Another Table method modifier combinations override new sealed virtual 1 2 N N abstract • abstract N 3 N • virtual • N 4 override • N new • sealed modifier order is not significant

Exceptions C# Programming Fundamentals Objects Relationships Systems

System.Exception the root of all Exception clasases namespace System { public class Exception ... { public Exception(); public Exception( string ); public Exception( string , Exception); ... public Exception InnerException { get ; } public virtual string Message { get ; } public virtual string StackTrace { get ; } ... public override string ToString(); ... } }

Hierarchy Exception ArithmeticException InvalidCastException DivideByZeroException OutOfMemoryException NullReferenceException OverflowException SystemException ... ExecutionEngineException IndexOutOfRangeException

throw you can throw any object you like as long as it's derived from System.Exception class Matrix { public Matrix( int rowSize, int colSize) { ... } public Row this [ int index ] { get { BoundsCheck(index); ... } set { BoundsCheck(index); ... } } // validation private void BoundsCheck( int index) { if (index < 0 || index >= rows.Length) throw new IndexOutOfRangeException(); } // representation private Row[] rows; } don't forget the new

try catch you can separate out error handling code in a catch { block } after a try { block } goodbye HRESULT try { FileInfo source = new FileInfo(filename); int length = ( int )source.Length; char [] contents = new char [length]; ... } catch (SecurityException caught) { ... } catch (IOException caught) { ... } catch (OutOfMemoryException) { ... } catch { ... throw ; } name is optional general catch block

finally you can ensure code always runs in a finally { block } exception in finally block dominates you cannot jump out of a finally block TextReader reader = null ; try { FileInfo source = new FileInfo(filename); int length = ( int )source.Length; char [] contents = new char [length]; reader = source.OpenText(); reader.Read(contents, 0, length); ... } ... finally { if (reader != null ) { reader.Close(); } } definite assignment rules, OK

Local Resources deterministic finalisation via finally ... is exception safe, but... is repetitive and doesn't scale is complex and fails to abstract TextReader reader = null ; try { FileInfo source = new FileInfo(filename); int length = ( int )source.Length; char [] contents = new char [length]; reader = source.OpenText(); reader.Read(contents, 0, length); ... } ... finally { if (reader != null ) { reader.Close(); } }

using Statements after discussions on the .NET reflector M'Soft provided a solution consisting of... the IDisposable interface in combination with... the using statement using ( type variable = init) embedded - statement { type variable = init ; try { embedded - statement } finally { if ( variable != null ) { ((IDisposable) variable ).Dispose(); } } } precisely equivalent to

IDisposable struct AutoClosing : IDisposable { public AutoClosing(TextReader reader) { if (reader == null ) { throw new ArgumentNullException(); } target = reader; } public void Dispose() { target.Close(); } private readonly TextReader target; } interface IDisposable { void Dispose(); }

Preference? ... TextReader reader = source.OpenText(); using ( new AutoClosing(reader)) { reader.Read(contents, 0, length); ... } TextReader reader = null ; try { ... reader = source.OpenText(); reader.Read(contents, 0, length); ... } finally { if (reader != null ) { reader.Close(); } } Before... ...After

lock C# does not have a synchronize keyword it has lock statements public class Monitor { public static void Enter( object ); public static void Exit( object ); ... } lock ( expression ) e mbedded - statement System.Threading.Monitor.Enter( expression ); try { embedded - statement } finally { System.Threading.Monitor.Exit( expression ) ; } precisely equivalent to ( expression is evaluated once)

Exception Notes throw specifications - NO checked/unchecked distinction - NO compile time exceptions - NO

Garbage Collection C# Programming Fundamentals Objects Relationships Systems

The Miracle of Birth object birth is a two phase process allocate the raw memory using operator new { 1,2,3,4 } is an [ ]array shorthand "literal" is a string shorthand initialise an object in the memory using a constructor you can't use a constructor without new Get that would you, Deidre....

Death object death is a two phase process finalise the object back to raw memory deallocate the raw memory back to the heap C++ – deterministic user calls destructor user calls operator delete C# – non deterministic (like Java) GC calls Finalize GC reclaims heap memory Shall we take our cars?

Finalize garbage collector finalizes objects when they become unreachable by calling Finalize( ) but you cannot override Object.Finalize!! or call it public class Resource { ... public void Dispose() { this .Finalize(); } protected override void Finalize() { ... } } compile time errors

Destructor instead you write a destructor which the compiler translates into Finalize can be declared in a class but not a struct automatically calls its base class Finalize can only be called by garbage collector public class Resource { ... ~Resource() { //... } ... } public class Resource { ... protected override void Finalize() { //... base .Finalize(); } ... }

GC Notes Beta-2 destructors are called when program exits :-) API to toggle this behavior :-) Finalize can make this known again complex resurrection issues, slows GC :-( what happens if Finalize throws ? specification doesn't say :-(

Nested Types C# Programming Fundamentals Objects Relationships Systems

Nested Types a class or struct can declare nested types nested types default to private access non-nested types default to internal access class Outer { interface Space { } abstract class Reaches { } class Limits { } sealed class Hebrides { } struct Mongolia { } } internal access private access

Nested Access a nested type... has access to all members of outer types but not vice versa C# follows Java access model class Outer { public class Inner { private void peek(Outer can) { can.peek( this ); } } private void peek(Inner cannot) { cannot.peek( this ); } } OK Fails Outer.peek(Inner cannot) Inner.peek(Outer can)

Access Modifiers there are five kinds of access nested types can have any access modifier non-nested types can be public or internal internal protected internal private protected Y public Y non-nested Y Y Y Y nested Y protected OR internal

Semantics C# nested types are implicitly static C# does not have Java inner classes C# does not have Java local classes C# does not have Java anonymous classes class Outer { ... class Nested { ... } ... } Outer.Nested « class » Outer « class » Outer$Inner « class » Outer « class » Outer.this 1 C#, C++ Java

Delegates C# Programming Fundamentals Objects Relationships Systems

delegate Type a delegate is the last C# type... declares a named signature including return type like a C++ function pointer/object similar to a Delphi closure delegate void Func( string s); class Eg { public static void ForAll( string [] args, Func call) { foreach ( string arg in args) { call(arg); } } } Func is a type name

static Method a delegate instance... can hold and call a static method delegate void Func( string s); ... class Test { static void Display( string s) { ... } static void Main( string [] args) { Eg.ForAll(args, new Func(Test.Display)); Eg.ForAll(args, new Func(Display)); } } note no ( ) create a delegate instance

Instance Method a delegate instance... can hold and call an instance method delegate void Func( string s); ... class Test { void Stash( string s) { ... } void NotMain( string [] args) { Eg.ForAll(args, new Func( this .Stash)); Eg.ForAll(args, new Func(Stash)); } }

Remember This? delegate void Method(); ... TextReader reader = source.OpenText(); using ( new Finally( new Method(reader.Close))) { reader.Read(contents, 0, length); ... } TextReader reader = null ; try { ... reader = source.OpenText(); reader.Read(contents, 0, length); ... } finally { if (reader != null ) { reader.Close(); } } ...After Before...

Finally public delegate void Method(); public struct Finally : IDisposable { public Finally(Method call) { if (call == null ) { throw new ArgumentNullException(); } this .call = call; } public override void Dispose() { call(); } private readonly Method call; }

Mulitcast delegate a void return type delegate ... can hold multiple callback in its invocation list first in, first called delegate void Pred( string s); ... class Test { void DoThis( string s) { ... } static void ThenThat( string s) { ... } void Method( string arg) { Pred call = null ; call += new Pred( this .DoThis); call += new Pred(Test.ThenThat); ... call(arg); } }

delegate Notes delegates are called directly from invokers thread can be compared for equality can be ref and out parameters are implicitly sealed types combinable delegate void return type implicitly derive from System.Delegate non-combinable delegate non void return type no out parameters implicitly derive from System.MultiCastDelegate

Events C# Programming Fundamentals Objects Relationships Systems

event Delegates a delegate field can be marked as an event only += and -= can be performed on the field used widely in GUI classes namespace System.Windows.Forms { public class Button : ... { ... public event EventHandler Click; ... ... protected void OnClick(EventArgs e) { if (Click != null ) { Click( this , e); } } ... } }

Event Delegates .NET framework has many event delegates by convention first parameter is event sender and second parameter derives from EventArgs namespace System { public delegate void EventHandler ( object sender, EventArgs e ); ... public class EventArgs { ... } }

Event Example easy to imagine this in Java... using an anonymous class using System; using System.Windows.Forms; class MyForm : Form { private void InitializeComponent() { openFile = new Button(); ... openFile.Click += new EventHandler(OpenFile); } protected void OpenFile( object sender, EventArgs e) { ... } private Button openFile; } Note case difference: openFile vs OpenFile

Event Properties event fields can be exposed as properties consider a class with lots of event s lazy creation might be useful += forwards to add -= forwards to remove namespace System.Windows.Forms { public class Button : ... { ... public event EventHandler Click { add { ... } remove { ... } } ... } }

Namespaces C# Programming Fundamentals Objects Relationships Systems

namespace a namespace is a logical naming mechanism no relation to directory names or assemblies a single .cs file can declare several namespaces implicitly public handy shorthand no anonymous namespace namespace Accu { namespace Conference { ... } } namespace Informant { ... } namespace Accu.Conference { ... ... ... ... } namespace Informant { ... }

using Directive only allowed at the start of namespace respect scope, not recursive, no clash if no use never affect other using directives using System; class Bar { ... } namespace Accu.Conference { using System.Collections; ... class Foo : Bar { static void Main(String[] args) { Console.Write(args[0]); } ... private Hashtable store; } }

using Alias a using alias creates alias for... a namespace, or a type namespace CSharp { using Vector = System.Collections.ArrayList; class SourceFile { ... Vector tokens; } }

Namespace Notes using only at start of namespace respects scope never affect subsequent using directives never affect subsequent using aliases namespace top level, non nested classes public or internal , default to internal cannot be protected or private

Assemblies C# Programming Fundamentals Objects Relationships Systems

Modules a physical .NET .DLL contains types and MSIL code unit of dynamic download a PE (portable executable) file written using C#, VB.NET, managed C++, raw MSIL, others... but not a mixture C:\> csc ... /target:module ...

Assembly a logical .NET .DLL containing... manifest containing metadata name, version#, file-list referenced assemblies type-list  containing module security permissions one or more modules containing types one containing assembly entry point zero or more resources bitmaps, icons, etc physically or logically containing C:\> csc ... /target:library ... C:\> csc ... /addmodule:... C:\> csc ... /target:exe /reference:...

Deployment to deploy an assembly... drop it and its linked files into a single directory goodbye registry private assemblies... live in their application's directory are not versioned shared assemblies... live in a shared directory (Global Assembly Cache) are versioned need a shared name (aka strong name) textual name public key digital signature

Versioning assemblies with different versions co-exist allows assembly evolution management never modify an existing assembly instead, create a new assembly with a new version <major>.<minor>.<build>.<revision> incompatible maybe compatible Quick Fix Engineering

Version Policy update policy controlled via .XML text file default major.minor as built specific major.minor as specified QFE latest build.revision? safe exactly as built ... <BindingPolicy> <BindingRedir Name="Wibble" Originator="32ab4ba45e0a69a1" Version="*" VersionNew="6.1.1212.14" UseLatestBuildRevision="no"/> </BindingPolicy>

internal access logical access control public, protected, private physical access control internal access is within assembly an assembly of four classes public internal private

[Attributes] C# Programming Fundamentals Objects Relationships Systems

What Are They? attributes allow code elements to... be tagged with declarative information which is then added to the metadata which can queried using reflection for example... suppose you wanted to record which developers implemented which types ... create a class to represent the developer info tag types with the developer attribute specify developer attribute is only for types decide whether to allow multiple tags

Attribute Class create attribute class must derive from System.Attribute recommedation – use Attribute suffix in name ... public sealed class DeveloperAttribute : System.Attribute { ... public DeveloperAttribute( string name) { ... } ... }

[ tag ] tag code elements with [attribute]'s ConstInt struct is tagged [ DeveloperAttribute ] [DeveloperAttribute("Jon Jagger")] public struct ConstInt { public ConstInt( int value) { this .value = value; } public static implicit operator int (ConstInt from) { return from.value; } private readonly int value; }

Problem how can you specify which kind of code elements the attribute is to be used with? Assembly, Module Interface, Class, Struct, Enum, Delegate Constructor, Method, Property, Field, Event Parameter, ReturnValue All

AttributeUsage use a predefined AttributeUsage attribute! with AttributeTarget enum [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)] public sealed class DeveloperAttribute : System.Attribute { ... public DeveloperAttribute( string name) { ... } ... }

Multiple Tags decide whether to allow multiple tags use named parameter, AllowMultiple = true [AttributeUsage(AttributeTargets.Class | ..., AllowMultiple = true )] public sealed class DeveloperAttribute : System.Attribute { ... public DeveloperAttribute( string name) { ... } ... } [DeveloperAttribute("Jon Jagger")] [DeveloperAttribute("Patrick Jagger")] public struct ConstInt { ... }

Positional positional parameters must be specified in the attribution correspond to constructor arguments ... public sealed class DeveloperAttribute : System.Attribute { public DeveloperAttribute( string name) { ... } ... } [DeveloperAttribute("Jon Jagger")] public struct ConstInt { ... }

Named named parameters optionally specified in the attribution must correspond to fields/properties (non- static , public , read-write) ... public sealed class DeveloperAttribute : System.Attribute { public DeveloperAttribute( string name) ... ... public string TelExt { get {...} set {...} } } [DeveloperAttribute("Patrick Jagger")] [DeveloperAttribute("Jon Jagger", TelExt="4263")] public struct ConstInt { ... }

metadata attributes are added to assembly metadata visible though ILDASM or reflection

Notes attributes are checked at compile time incorrect usage causes compile time error predefined attribute classes include [Conditional] [Obsolete] [CLSCompliant] [Serializable] attribute parameter types limited to bool, byte, char, double, float, int, long, short string, object public enums Type CLS attribute based templates check out www.newtelligence.com

Reflection C# Programming Fundamentals Objects Relationships Systems

Terminology .NET has almost perfect reflection reflection API's even allow dynamic creation Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. There are two apects to such manipulation: Introspection is the ability of a program to observe and therefore reason about its own state. Intercession is the ability of a program to modify its own execution state or alter its own interpretation or meaning. Both apects require a mechanism for encoding execution state as data; providing such an encoding is called reification Richard Gabriel, et al

Attributes retrieving custom attributes public sealed class DeveloperAttribute ... { ... public override string ToString() { ... } ... } public class Example { static void Main() { string typename = "ConstInt"; Type t = Type.GetType(typename); object [] atts = t.GetCustomAttributes( true ); foreach ( object att in atts) { Console.WriteLine(att); } } }

Remember This? TextReader reader = source.OpenText(); using ( new Finally(reader, "Close" )) { reader.Read(contents, 0, length); ... } TextReader reader = null ; try { ... reader = source.OpenText(); reader.Read(contents, 0, length); ... } finally { if (reader != null ) { reader.Close(); } } ...After

Finally using System; using System.Reflection; public struct Finally : IDisposable { public Finally( object target, string methodName) { this .target = target; this .methodName = methodName; } public void Dispose() { Type t = target.GetType(); MethodInfo method = t.GetMethod(methodName); if (method != null ) { t.InvokeMember( methodName, BindingFlags.InvokeMethod, target, new object [0] ); } } private readonly object target; private readonly string methodName; }

Summary arrays: rectangular, ragged, params string: immutable, readonly[], verbatim class: ref/out, static c'tor, boxing exceptions: lock, no throw-specs GC: d'tor, using statement, IDisposable inheritance: positional, virtual/override interfaces: no fields, EII, properties, indexers nested types: Java access, C++ semantics delegates: function pointers, single and multicast events: restricted multicast delegate assemblies: logical DLL, no registry, versioning namespaces: shorthand syntax reflection: metadata, introspection, intercession attributes: add to metadata, reflect

Standards ECMA/TC39/2000-2 Standard 1, C# Standard 2, Common Language Infrastructure Timeline March 2001 – draft submission Sept 2001 – final submission Dec 2001 – Version 1 adopted by GA Jan 2002 – submit to ISO for fast track process

Bibliography Presenting C# Christophe Wille; SAMS A Programmer's Introduction to C# Eric Gunnerson; Apress Programming C# with the public Beta Harvey, Robinson,Templeman, Watson; Wrox C# Essentials Albahari, Drayton, Merrill; O'Reilly Inside C# Tom Archer; MS Press

Csharp In Detail Part2

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Csharp In Detail Part2 (20)

More from Mohamed Krar (18)

Recently uploaded (20)

Csharp In Detail Part2

Editor's Notes