4. OBJECT ORIENTED PROGRAMMING WITH SCOPE AND FEATURES

OBJECT ORIENTED PROGRAMMING WITH SCOPE AND FEATURES

1. Object Oriented Concepts – C#Object Oriented Concepts – C#
QQ

2. AgendaAgenda
Review Object-Oriented ConceptsReview Object-Oriented Concepts
InterfacesInterfaces
Classes and StructsClasses and Structs
DelegatesDelegates
EventsEvents

3. Review Review
Key Object-Oriented ConceptsKey Object-Oriented Concepts
InheritanceInheritance
The “is a” relationshipThe “is a” relationship
Types are arranged in a hierarchyTypes are arranged in a hierarchy
Called base/derived or superclass/subclassCalled base/derived or superclass/subclass
Accord Corvette
Car Truck Plane Boat
Vehicle
Accelerate()
Decelerate()
TakeOff()
Land()
OpenTrunk()
VIN

4. Review Review
Key Object-Oriented ConceptsKey Object-Oriented Concepts
PolymorphismPolymorphism
The ability to perform an operation on an object without knowing The ability to perform an operation on an object without knowing
the precise type of the objectthe precise type of the object
Lets “old” code call “new” codeLets “old” code call “new” code
void Poly(object o) {
Console.WriteLine(o.ToString());
}
Poly(42);
Poly(“abcd”);
Poly(12.345678901234m);
Poly(new Point(23,45));
Poly(new PurchaseOrder(“PO11235811”));

5. AgendaAgenda
Review Object-Oriented ConceptsReview Object-Oriented Concepts
InterfacesInterfaces
Classes and StructsClasses and Structs
DelegatesDelegates
EventsEvents

6. InterfacesInterfaces
An interface defines a contractAn interface defines a contract
An interface is a typeAn interface is a type
Can declare variables of that typeCan declare variables of that type
However, you cannot directly instantiate an interfaceHowever, you cannot directly instantiate an interface
Includes methods, properties, indexers, eventsIncludes methods, properties, indexers, events
Any class or struct implementing an interface must support all parts of Any class or struct implementing an interface must support all parts of
the contractthe contract
Interfaces provide no implementationInterfaces provide no implementation
When a class or struct implements an interface it must provide the When a class or struct implements an interface it must provide the
implementations for all members of the interfaceimplementations for all members of the interface
Interfaces provide polymorphismInterfaces provide polymorphism
Many classes and structs may implement a particular interfaceMany classes and structs may implement a particular interface

7. public interface IDisposable {
void Dispose();
}
public class TextBox : IDisposable {
public void Dispose() { ... }
}
public class Car : IDisposable {
public void Dispose() { ... }
}
InterfacesInterfaces
ExampleExample
void PolyDispose(IDisposable id) {
id.Dispose();
} TextBox tb = new TextBox();
PolyDispose(tb);
Car c = new Car();
PolyDispose(c);

8. InterfacesInterfaces
CastingCasting
A class that implements an interface can be cast A class that implements an interface can be cast
(converted) to any of those interfaces(converted) to any of those interfaces
public interface IDisposable {
}
public interface IEnumerable {
}
public class ListBox : IDisposable, IEnumerable {
}
ListBox lb = new ListBox();
IDisposable id = (IDisposable)lb;
IEnumerable ie = (IEnumerable)lb;

9. interface ITextBox {
void SetText(string s);
}
interface IListBox {
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {
}
InterfacesInterfaces
Multiple InheritanceMultiple Inheritance
Interfaces can inherit from multiple interfaces Interfaces can inherit from multiple interfaces
Classes and structs can inherit from Classes and structs can inherit from
multiple interfacesmultiple interfaces

10. AgendaAgenda
Review Object-Oriented ConceptsReview Object-Oriented Concepts
InterfacesInterfaces
Classes and StructsClasses and Structs
DelegatesDelegates
EventsEvents

11. Classes and StructsClasses and Structs
SimilaritiesSimilarities
Both are user-defined typesBoth are user-defined types
Both can containBoth can contain
Data Data
Fields, constants, events, arraysFields, constants, events, arrays
Functions Functions
Methods, properties, indexers, operatorsMethods, properties, indexers, operators
Constructors, finalizersConstructors, finalizers
Type definitionsType definitions
Classes, structs, enums, interfaces, delegatesClasses, structs, enums, interfaces, delegates
Both can implement multiple interfacesBoth can implement multiple interfaces
Both are instantiated with Both are instantiated with newnew operator operator

12. ClassClass StructStruct
Reference typeReference type Value typeValue type
Can inherit from any Can inherit from any
non-sealed reference classnon-sealed reference class
No inheritanceNo inheritance
(inherits only from (inherits only from System.ValueTypeSystem.ValueType))
Can have a finalizerCan have a finalizer No finalizerNo finalizer
Can have user-defined Can have user-defined
parameterless constructorparameterless constructor
No user-defined parameterless constructorNo user-defined parameterless constructor
Classes and StructsClasses and Structs
DifferencesDifferences

13. C++ StructC++ Struct C# StructC# Struct
Same as C++ class, but all members Same as C++ class, but all members
are are publicpublic
User-defined value typeUser-defined value type
Can be allocated on the heap, Can be allocated on the heap,
on the stack or as a member on the stack or as a member
(can be used as value or reference), just (can be used as value or reference), just
like C++ classlike C++ class
Always allocated on the stack or Always allocated on the stack or
as a memberas a member
Members are always Members are always publicpublic
Members can be Members can be publicpublic, , internalinternal
or or privateprivate
ClassesClasses and Structsand Structs
C# Structs vs. C++ StructsC# Structs vs. C++ Structs
Very different from C++ structVery different from C++ struct

14. public class Car : Vehicle {
public enum Make { GM, Honda, BMW }
Make make;
string vid;
Point location;
Car(Make m, string vid; Point loc) {
this.make = m;
this.vid = vid;
this.location = loc;
}
public void Drive() {
Console.WriteLine(“vroom”); }
}
Car c =
new Car(Car.Make.BMW,
“JF3559QT98”,
new Point(3,7));
c.Drive();
Classes and StructsClasses and Structs
ClassClass

15. public struct Point {
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int X { get { return x; }
set { x = value; } }
public int Y { get { return y; }
set { y = value; } }
}
Point p = new Point(2,5);
p.X += 100;
int px = p.X; // px = 102
Classes and StructsClasses and Structs
StructStruct

16. ClassesClasses and Structsand Structs
Static vs. Instance MembersStatic vs. Instance Members
By default, members are per instanceBy default, members are per instance
Each instance gets its own fieldsEach instance gets its own fields
Methods apply to a specific instanceMethods apply to a specific instance
Static members are per typeStatic members are per type
Static methods can’t access instance dataStatic methods can’t access instance data
No No thisthis variable in static methods variable in static methods
Don’t abuse static membersDon’t abuse static members
They are essentially object-oriented They are essentially object-oriented
global data and global functionsglobal data and global functions

17. Classes and StructsClasses and Structs
Access ModifiersAccess Modifiers
Access modifiers specify who can use a type Access modifiers specify who can use a type
or a memberor a member
Access modifiers control encapsulationAccess modifiers control encapsulation
Top-level types (those directly in a namespace) can be Top-level types (those directly in a namespace) can be
publicpublic or or internal internal
Class members can be Class members can be publicpublic, , privateprivate, , protectedprotected, ,
internalinternal, or, or
protected internalprotected internal
Struct members can be Struct members can be publicpublic, , privateprivate or or internalinternal

18. If the access If the access
modifier ismodifier is
Then a member defined in type T and Then a member defined in type T and
assembly A is accessibleassembly A is accessible
publicpublic to everyoneto everyone
privateprivate within T only (the default)within T only (the default)
protectedprotected to T or types derived from Tto T or types derived from T
internalinternal to types within Ato types within A
protected internalprotected internal
to T or types derived from Tto T or types derived from T
or to types within Aor to types within A
Classes and StructsClasses and Structs
Access ModifiersAccess Modifiers

19. Classes and StructsClasses and Structs
Abstract ClassesAbstract Classes
An abstract class is one that cannot be instantiatedAn abstract class is one that cannot be instantiated
Intended to be used as a base classIntended to be used as a base class
May contain abstract and non-abstract function membersMay contain abstract and non-abstract function members
Similar to an interfaceSimilar to an interface
Cannot be sealedCannot be sealed

20. Classes and StructsClasses and Structs
Sealed ClassesSealed Classes
A sealed class is one that cannot be used as a base classA sealed class is one that cannot be used as a base class
Sealed classes can’t be abstractSealed classes can’t be abstract
All structs are implicitly sealedAll structs are implicitly sealed
System.String is sealedSystem.String is sealed
Why seal a class?Why seal a class?
To prevent unintended derivationTo prevent unintended derivation
Code optimizationCode optimization
Virtual function calls can be resolved at compile-timeVirtual function calls can be resolved at compile-time

21. class Person
{
string name;
public Person(string name)
{
this.name = name;
}
public void Introduce(Person p)
{
if (p != this)
Console.WriteLine(“Hi, I’m “ + name);
}
}
Classes and StructsClasses and Structs
thisthis
The The thisthis keyword is a predefined variable available in keyword is a predefined variable available in
non-static function members non-static function members
Used to access data and function members unambiguouslyUsed to access data and function members unambiguously

22. class Shape
{
int x, y;
public override string ToString()
{
return "x=" + x + ",y=" + y;
}
}
class Circle : Shape
{
int r;
public override string ToString()
{
return base.ToString() + ",r=" + r;
}
}
Classes and StructsClasses and Structs
basebase
The The basebase keyword is used to access class members that keyword is used to access class members that
are hidden by similarly named members of the current are hidden by similarly named members of the current
classclass

23. public class MyClass
{
public const string version = “1.0.0”;
public const string s1 = “abc” + “def”;
public const int i3 = 1 + 2;
public const double PI_I3 = i3 * Math.PI;
public const double s = Math.Sin(Math.PI); //ERROR
...
}
Classes and StructsClasses and Structs
ConstantsConstants
A constant is a data member that is evaluated at A constant is a data member that is evaluated at
compile-time and is implicitly static (per type)compile-time and is implicitly static (per type)
e.g. e.g. Math.PIMath.PI

24. Classes and StructsClasses and Structs
FieldsFields
A field is a member variableA field is a member variable
Holds data for a class or structHolds data for a class or struct
Can hold:Can hold:
a reference type (e.g. class instance), a reference type (e.g. class instance),
a value type (e.g. a struct instance), or a value type (e.g. a struct instance), or
an array of class or struct instances an array of class or struct instances
(an array is actually a reference)(an array is actually a reference)

25. Classes and StructsClasses and Structs
Readonly FieldsReadonly Fields
Similar to a const, but is initialized at Similar to a const, but is initialized at
run-time in its declaration or in a constructorrun-time in its declaration or in a constructor
Once initialized, it cannot be modifiedOnce initialized, it cannot be modified
Differs from a constant Differs from a constant
Initialized at run-time (vs. compile-time)Initialized at run-time (vs. compile-time)
Don’t have to re-compile clientsDon’t have to re-compile clients
Can be static or per-instanceCan be static or per-instance
public class MyClass {
public static readonly double d1 = Math.Sin(Math.PI);
public readonly string s1;
public MyClass(string s) { s1 = s; } }

26. 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;
Classes and StructsClasses and Structs
PropertiesProperties
A property is a virtual fieldA property is a virtual field
Looks like a field, but is implemented with codeLooks like a field, but is implemented with code

27. public class Personpublic class Person
{{
private int age;private int age;
public int Age {public int Age {
get { return age; }get { return age; }
set { age = set { age = valuevalue;;
Console.WriteLine(age); Console.WriteLine(age);
}}
}}
}}
Person p = new Person();Person p = new Person();
p.Age = 27;p.Age = 27;
p.Age++;p.Age++;
PropertiesProperties
Access to private fields normally requires accessors and Access to private fields normally requires accessors and
mutatorsmutators
Properties allow access to private fields as if they were Properties allow access to private fields as if they were
publicpublic
Person p = new Person();Person p = new Person();
p.setAge(27);p.setAge(27);
p.setAge(p.getAge() + 1);p.setAge(p.getAge() + 1);
instead of:instead of:
PropertyProperty
C#C#
OtherOther

28. Classes and StructsClasses and Structs
PropertiesProperties
Properties can be:Properties can be:
Read-only (implement only Read-only (implement only getget))
Not the same as a Not the same as a readonlyreadonly field field
Write-only (implement only Write-only (implement only setset) )
Read/write (implement both Read/write (implement both getget and and setset))

29. IndexersIndexers
Index an object as if it were an arrayIndex an object as if it were an array
public class numberspublic class numbers
{{
private int[3] nums;private int[3] nums;
public int this[int index] public int this[int index]
{{
get { return nums[index]; }get { return nums[index]; }
set { nums[index] = value; }set { nums[index] = value; }
}}
}}
Numbers Num = new NumbersNumbers Num = new Numbers ()();;
Num[0] = 5;Num[0] = 5;
int Val = Num[0];int Val = Num[0];
Numbers Num = new NumbersNumbers Num = new Numbers ()();;
Num.Set_Nums(0,5);Num.Set_Nums(0,5);
int Val = Num.Get_Nums(0);int Val = Num.Get_Nums(0);
instead of:instead of:
IndexerIndexer
C#C#
OtherOther

30. 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]);
Classes and StructsClasses and Structs
IndexersIndexers
An indexer lets an instance behave as a virtual arrayAn indexer lets an instance behave as a virtual array
Can be overloaded Can be overloaded (e.g. index by (e.g. index by intint and by and by stringstring))
Can be Can be
read-only, read-only,
write-only, write-only,
or read/writeor read/write

31. Classes and StructsClasses and Structs
MethodsMethods
All code executes in a methodAll code executes in a method
Constructors, finalizers and operators are special types of Constructors, finalizers and operators are special types of
methodsmethods
Properties and indexers are implemented with get/set methodsProperties and indexers are implemented with get/set methods
Methods have argument listsMethods have argument lists
Methods contain statementsMethods contain statements
Methods can return a valueMethods can return a value
Only if return type is not voidOnly if return type is not void

32. Classes and StructsClasses and Structs
Method Argument PassingMethod Argument Passing
By default, data is passed by valueBy default, data is passed by value
A copy of the data is created and passed to the methodA copy of the data is created and passed to the method
For value types that are passed by value, variables For value types that are passed by value, variables
cannot be modified by a method callcannot be modified by a method call
For reference types that are passed by value, the instance For reference types that are passed by value, the instance
can be modified by a method call, but the variable itself can be modified by a method call, but the variable itself
cannot be modified by a method callcannot be modified by a method call

33. void RefFunction(ref int p) {
p++;
} int x = 10;
RefFunction(ref x);
// x is now 11
Classes and StructsClasses and Structs
Method Argument PassingMethod Argument Passing
The ref modifier causes arguments to be passed by referenceThe ref modifier causes arguments to be passed by reference
Allows a method call to modify a variableAllows a method call to modify a variable
Applies to both value and reference typesApplies to both value and reference types
Have to use ref modifier in method definition Have to use ref modifier in method definition andand
in the code that calls itin the code that calls it
Variable has to have a value before callVariable has to have a value before call

34. void OutFunction(out int p) {
p = 22;
} int x;
OutFunction(out x);
// x is now 22
Classes and StructsClasses and Structs
Method Argument PassingMethod Argument Passing
The The outout modifier causes arguments to be passed out by modifier causes arguments to be passed out by
referencereference
Allows a method call to initialize a variableAllows a method call to initialize a variable
Have to use Have to use outout modifier in method definition and the modifier in method definition and the
code that calls itcode that calls it
Argument has to have a value before returningArgument has to have a value before returning

35. void Print(int i);
void Print(string s);
void Print(char c);
void Print(float f);
int Print(float f); // Error: duplicate signature
Classes and StructsClasses and Structs
Overloaded MethodsOverloaded Methods
A type may overload methods, i.e. provide multiple methods with A type may overload methods, i.e. provide multiple methods with
the same namethe same name
Each must have a unique signatureEach must have a unique signature
Signature is based upon arguments only, the return value is ignoredSignature is based upon arguments only, the return value is ignored

36. int Sum(params int[] intArr) {
int sum = 0;
foreach (int i in intArr)
sum += i;
return sum;
}
int sum = Sum(13,87,34);
Classes and StructsClasses and Structs
Parameter ArraysParameter Arrays
Methods can have a variable number of arguments, Methods can have a variable number of arguments,
called a parameter arraycalled a parameter array
paramsparams keyword declares parameter array keyword declares parameter array
Must be the last argumentMust be the last argument

37. class Foo {
public void DoSomething(int i) {
...
}
}
Foo f = new Foo();
f.DoSomething();
Classes and StructsClasses and Structs
Virtual MethodsVirtual Methods
Methods may be virtual or non-virtual (default)Methods may be virtual or non-virtual (default)
Non-virtual methods are not polymorphicNon-virtual methods are not polymorphic
They cannot be overriddenThey cannot be overridden
Non-virtual methods cannot be abstractNon-virtual methods cannot be abstract

38. Classes and StructsClasses and Structs
Virtual MethodsVirtual Methods
Defined in a base classDefined in a base class
Can be overridden in derived classesCan be overridden in derived classes
Derived classes provide their own specialized implementationDerived classes provide their own specialized implementation
May contain a default implementationMay contain a default implementation
Use abstract method if no default implementationUse abstract method if no default implementation
Needed for inheritance-based polymorphismNeeded for inheritance-based polymorphism
Properties, indexers and events can also Properties, indexers and events can also
be virtualbe virtual

39. class Shape {
public virtual void Draw() { ... }
}
class Box : Shape {
public override void Draw() { ... }
}
class Sphere : Shape {
public override void Draw() { ... }
}
void HandleShape(Shape s) {
s.Draw();
...
}
HandleShape(new Box());
HandleShape(new Sphere());
HandleShape(new Shape());
Classes and StructsClasses and Structs
Virtual MethodsVirtual Methods

40. Classes and StructsClasses and Structs
Abstract MethodsAbstract Methods
An abstract method is virtual and has no implementationAn abstract method is virtual and has no implementation
Must belong to an abstract classMust belong to an abstract class
Intended to be implemented in a derived classIntended to be implemented in a derived class

41. abstract class Shape {
public abstract void Draw();
}
class Box : Shape {
public override void Draw() { ... }
}
class Sphere : Shape {
public override void Draw() { ... }
}
void HandleShape(Shape s) {
s.Draw();
...
}
HandleShape(new Box());
HandleShape(new Sphere());
HandleShape(new Shape()); // Error!
Classes and StructsClasses and Structs
Abstract MethodsAbstract Methods

42. Classes and StructsClasses and Structs
Overloaded vs. Overridden MethodsOverloaded vs. Overridden Methods
Unlike method overriding, method overloading depends upon the type of the Unlike method overriding, method overloading depends upon the type of the
variable, NOT on the type of the objectvariable, NOT on the type of the object
Method overloading is resolved at compile-timeMethod overloading is resolved at compile-time
However, at run-time, if the overloaded method is virtual, then the method that However, at run-time, if the overloaded method is virtual, then the method that
is called is determined by the type of the objectis called is determined by the type of the object
Method overriding is resolved at run-timeMethod overriding is resolved at run-time

43. Classes and StructsClasses and Structs
Method VersioningMethod Versioning
Must explicitly use Must explicitly use overrideoverride or or newnew keywords to keywords to
specify versioning intentspecify versioning intent
Avoids accidental overridingAvoids accidental overriding
Methods are non-virtual by defaultMethods are non-virtual by default
C++ and Java produce fragile base classes – C++ and Java produce fragile base classes – cannotcannot
specify versioning intentspecify versioning intent

44. Method Versioning in C#Method Versioning in C#
class Derived : Base // v1.0class Derived : Base // v1.0
{{
public virtual void Foo() public virtual void Foo()
{{
Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo");
}}
}}
class Base // v1.0class Base // v1.0
{{
}}
class Base class Base // v2.0 // v2.0
{{
public virtual void Foo() public virtual void Foo()
{{
Database.Log("Base.Foo"); Database.Log("Base.Foo");
}}
}}
class Base class Base // v2.0 // v2.0
{{
public virtual public virtual intint Foo() Foo()
{{
Database.Log("Base.Foo"); return 0; Database.Log("Base.Foo"); return 0;
}}
}}
class Derived : Base // v2.0class Derived : Base // v2.0
{{
public public newnew virtual void Foo() virtual void Foo()
{{
Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo");
}}
}}
class Derived : Base // v2.0class Derived : Base // v2.0
{{
public public overrideoverride void Foo() void Foo()
{{
super.Foo();super.Foo();
Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo");
}}
}}

45. Classes and StructsClasses and Structs
ConstructorsConstructors
Instance constructors are special methods that are called when a class or struct is instantiatedInstance constructors are special methods that are called when a class or struct is instantiated
Performs custom initializationPerforms custom initialization
Can be overloadedCan be overloaded
If a class doesn’t define any constructors, an implicit parameterless constructor is createdIf a class doesn’t define any constructors, an implicit parameterless constructor is created
Cannot create a parameterless constructor Cannot create a parameterless constructor
for a structfor a struct
All fields initialized to zero/nullAll fields initialized to zero/null

46. Classes and StructsClasses and Structs
ConstructorsConstructors
Order of construction:Order of construction:
1.1.Instance variables are initializedInstance variables are initialized
2.2.Base constructor is calledBase constructor is called
3.3.Body of constructor is calledBody of constructor is called
All during construction the object is considered to be the constructed typeAll during construction the object is considered to be the constructed type
Avoid calling virtual methods in constructorsAvoid calling virtual methods in constructors
The object may not be property initializedThe object may not be property initialized
This is like Java, but unlike C++This is like Java, but unlike C++

47. class B {
private int h;
public B() { }
public B(int h) { this.h = h; }
}
class D : B {
private int i;
public D() : this(24) { }
public D(int i) { this.i = i; }
public D(int h, int i) : base(h) { this.i = i; }
}
Classes and StructsClasses and Structs
Constructor InitializersConstructor Initializers
One constructor can call another with a constructor One constructor can call another with a constructor
initializerinitializer
Can call Can call this(...)this(...) or or base(...)base(...)
Default constructor initializer is Default constructor initializer is base()base()

48. Classes and StructsClasses and Structs
Static ConstructorsStatic Constructors
A static constructor lets you create initialization code that is called once for the classA static constructor lets you create initialization code that is called once for the class
Guaranteed to be executed before the first instance of a class or struct is created and before any Guaranteed to be executed before the first instance of a class or struct is created and before any
static member of the class or struct static member of the class or struct
is accessedis accessed
No other guarantees on execution orderNo other guarantees on execution order
Only one static constructor per typeOnly one static constructor per type
Must be parameterlessMust be parameterless

49. class Foo {
~Foo() {
Console.WriteLine(“Destroyed {0}”, this);
}
}
Classes and StructsClasses and Structs
FinalizersFinalizers
A finalizer is a method that is called before an instance is garbage collectedA finalizer is a method that is called before an instance is garbage collected
Different from a C++ destructorDifferent from a C++ destructor
Used to clean up any resources held by the instance, do bookkeeping, etc. Used to clean up any resources held by the instance, do bookkeeping, etc.
Only classes, not structs, can have finalizersOnly classes, not structs, can have finalizers

50. Classes and StructsClasses and Structs
FinalizersFinalizers
Unlike C++, C# finalizers are non-deterministicUnlike C++, C# finalizers are non-deterministic
They are not guaranteed to be called at a specific time (i.e. they aren’t called when They are not guaranteed to be called at a specific time (i.e. they aren’t called when
an instance goes out of scope)an instance goes out of scope)
They are guaranteed to be called before shutdown (...kind of)They are guaranteed to be called before shutdown (...kind of)
Use the Use the usingusing statement and the statement and the IDisposableIDisposable interface to achieve interface to achieve
deterministic finalizationdeterministic finalization

51. class Car {
string vid;
public static bool operator ==(Car x, Car y) {
return x.vid == y.vid;
}
}
Classes and StructsClasses and Structs
Operator OverloadingOperator Overloading
User-defined operatorsUser-defined operators
Must be a static methodMust be a static method

52. Classes and StructsClasses and Structs
Operator OverloadingOperator Overloading
++ -- !! ~~
truetrue falsefalse ++++ ----
Overloadable unary operatorsOverloadable unary operators
Overloadable binary operatorsOverloadable binary operators
++ -- ** // !! ~~
%% && || ^^ ==== !=!=
<<<< >>>> << >> <=<= >=>=

53. Classes and StructsClasses and Structs
Operator OverloadingOperator Overloading
No overloading for member access, method invocation, No overloading for member access, method invocation,
assignment operators, nor these operators: assignment operators, nor these operators: sizeofsizeof, ,
newnew, , isis, , asas, , typeoftypeof, , checkedchecked, , uncheckedunchecked, , &&&&, , ||||, ,
and and ?:?:
The The &&&& and and |||| operators are automatically evaluated operators are automatically evaluated
from from && and and ||
Overloading a binary operator (e.g. Overloading a binary operator (e.g. **) implicitly overloads ) implicitly overloads
the corresponding assignment operator (e.g. the corresponding assignment operator (e.g. *=*=))

54. Classes and StructsClasses and Structs
Operator OverloadingOperator Overloading
struct Vector {
int x, y;
public Vector(x, y) { this.x = x; this.y = y; }
public static Vector operator +(Vector a, Vector b) {
return Vector(a.x + b.x, a.y + b.y);
}
...
}
ExampleExample

55. class Note {
int value;
// Convert to hertz – no loss of precision
public static implicit operator double(Note x) {
return ...;
}
// Convert to nearest note
public static explicit operator Note(double x) {
return ...;
}
}
Note n = (Note)442.578;
double d = n;
Classes and StructsClasses and Structs
Conversion OperatorsConversion Operators
User-defined explicit and implicit conversionsUser-defined explicit and implicit conversions

56. Classes and StructsClasses and Structs
isis Operator Operator
The The isis operator is used to dynamically test if the run- operator is used to dynamically test if the run-
time type of an object is compatible with a given typetime type of an object is compatible with a given type
static void DoSomething(object o) {
if (o is Car)
((Car)o).Drive();
}
Don’t abuse the Don’t abuse the isis operator: it is preferable to design an operator: it is preferable to design an
appropriate type hierarchy with polymorphic methodsappropriate type hierarchy with polymorphic methods

57. Classes and StructsClasses and Structs
asas Operator Operator
The The asas operator tries to convert a variable to a specified operator tries to convert a variable to a specified
type; if no such conversion is possible the result is type; if no such conversion is possible the result is nullnull
static void DoSomething(object o) {
Car c = o as Car;
if (c != null) c.Drive();
}
More efficient than using More efficient than using isis operator: test and convert in operator: test and convert in
one operationone operation
Same design warning as with the Same design warning as with the isis operator operator

58. Classes and StructsClasses and Structs
typeoftypeof Operator Operator
The The typeoftypeof operator returns the operator returns the System.TypeSystem.Type object object
for a specified typefor a specified type
Can then use reflection to dynamically obtain information Can then use reflection to dynamically obtain information
about the typeabout the type
Use Use GetType()GetType() to get the type of an instance to get the type of an instance
Console.WriteLine(typeof(int).FullName);
Console.WriteLine(typeof(System.Int32).Name);
Console.WriteLine(typeof(float).Module);
Console.WriteLine(typeof(double).IsPublic);
Console.WriteLine(typeof(Car).MemberType);

59. AgendaAgenda
Review Object-Oriented ConceptsReview Object-Oriented Concepts
InterfacesInterfaces
Classes and StructsClasses and Structs
DelegatesDelegates
EventsEvents

60. DelegatesDelegates
Object oriented function pointersObject oriented function pointers
A reference type encapsulating a method signature and return valueA reference type encapsulating a method signature and return value
Can point to multiple functionsCan point to multiple functions
Thread-safe + and - operationsThread-safe + and - operations
Foundation for eventsFoundation for events
delegate double Func(double x);delegate double Func(double x);
Func func = new Func(Math.Sin);Func func = new Func(Math.Sin);
double x = func(1.0);double x = func(1.0);
public class math {public class math {
double Sin(double x)double Sin(double x)
{{
//return (sin x) //return (sin x)
}}
}}
delegate void Greeting();delegate void Greeting();
Greeting greeting; Greeting greeting;
greeting += new Greeting(A.SayHello);greeting += new Greeting(A.SayHello);
greeting += new Greeting(A.Bow);greeting += new Greeting(A.Bow);
public class a public class a
{{
void SayHello() { //Say Hello }void SayHello() { //Say Hello }
void Bow() { // bow }void Bow() { // bow }
}}
DelegateDelegate Multicast DelegateMulticast Delegate

61. AgendaAgenda
Review Object-Oriented ConceptsReview Object-Oriented Concepts
InterfacesInterfaces
Classes and StructsClasses and Structs
DelegatesDelegates
EventsEvents

62. Events Events
Specialized multicast delegateSpecialized multicast delegate
Represent a signal that something has occurred in a Represent a signal that something has occurred in a
programprogram
Two main issuesTwo main issues
Generating eventsGenerating events
Consuming eventsConsuming events

63. EventsEvents
OverviewOverview
C# has native support for eventsC# has native support for events
Based upon delegatesBased upon delegates
An event is essentially a field holding a delegateAn event is essentially a field holding a delegate
However, public users of the class can only register However, public users of the class can only register
delegatesdelegates
They can only call They can only call +=+= and and -=-=
They They cannotcannot invoke the event’s delegate invoke the event’s delegate
Only the object containing the event can invoke the delegateOnly the object containing the event can invoke the delegate
Multicast delegates allow multiple objects to register with Multicast delegates allow multiple objects to register with
the same eventthe same event

64. EventsEvents
Create a Type defining the information to be passed to Create a Type defining the information to be passed to
receivers of the event.receivers of the event.
public class MailManagerpublic class MailManager
{{
public class MailMsgEventArgs : EventArgs { public class MailMsgEventArgs : EventArgs {
public readonly string from, to, body;public readonly string from, to, body;
public MailMsgEventArgs(string From, string To, string public MailMsgEventArgs(string From, string To, string
Body) {Body) {
this.from = From;this.from = From;
this.to = To;this.to = To;
this.body = Body;this.body = Body;
}}
}}
}}

65. Events Events
SourcingSourcing
Define the event signatureDefine the event signature
Define the event and firing logicDefine the event and firing logic
public delegate void MailMsgEventHandler(object sender, public delegate void MailMsgEventHandler(object sender,
MailMsgEventArgs e);MailMsgEventArgs e);
public class MailManagerpublic class MailManager
{{
public event MailMsgEventHandler MessageReceived; public event MailMsgEventHandler MessageReceived;
protected void OnMessageReceived(MailMsgEventArgs e) {protected void OnMessageReceived(MailMsgEventArgs e) {
if (MessageReceived != null) if (MessageReceived != null)
MessageReceived(this, e);MessageReceived(this, e);
} }
}}

66. EventsEvents
Create a Method that is responsible for raising the event.Create a Method that is responsible for raising the event.
public void SimulateArrivingMsg (string from, string to, public void SimulateArrivingMsg (string from, string to,
string body) {string body) {
MailMsgEventArgs e = new MailMsgEventArgs(from, to, body); MailMsgEventArgs e = new MailMsgEventArgs(from, to, body);
OnMailMessageReceived(e);OnMailMessageReceived(e);
}}

67. Events Events
HandlingHandling
Define and register event handlerDefine and register event handler
public class MyForm: Formpublic class MyForm: Form
{{
MailManager FaxApplication;MailManager FaxApplication;
public MyForm() {public MyForm() {
FaxApplication = new MailManager();FaxApplication = new MailManager();
FaxApplication.MessageReceived += new FaxApplication.MessageReceived += new
MailMsgEventHandler(FaxMsg);MailMsgEventHandler(FaxMsg);
}}
void FaxMsg(object sender, MailMsgEventArgs e) {void FaxMsg(object sender, MailMsgEventArgs e) {
MessageBox.Show("You recd a msg from “ + e.from);MessageBox.Show("You recd a msg from “ + e.from);
}}
}}

68. AttributesAttributes
How do you associate information with types and How do you associate information with types and
members?members?
Documentation URL for a classDocumentation URL for a class
Transaction context for a methodTransaction context for a method
XML persistence mappingXML persistence mapping
Traditional solutionsTraditional solutions
Add keywords or pragmas to languageAdd keywords or pragmas to language
Use external files, e.g., IDL, DEFUse external files, e.g., IDL, DEF
C# solution: AttributesC# solution: Attributes

69. AttributesAttributes
Appear in square bracketsAppear in square brackets
Attached to code elementsAttached to code elements
[HelpUrl(“http://SomeUrl/Docs/SomeClass”)][HelpUrl(“http://SomeUrl/Docs/SomeClass”)]
class SomeClassclass SomeClass
{{
[WebMethod][WebMethod]
void GetCustomers() { … }void GetCustomers() { … }
string Test([SomeAttr] string param1) {…}string Test([SomeAttr] string param1) {…}
}}

70. Attribute Fundamentals Attribute Fundamentals
Can be Intrinsic or CustomCan be Intrinsic or Custom
Attributes are generic classes!Attributes are generic classes!
Easy to attach to types and membersEasy to attach to types and members
Attributes can be queried at runtimeAttributes can be queried at runtime
class HelpUrl : System.Attribute { class HelpUrl : System.Attribute {
public HelpUrl(string url) { … }public HelpUrl(string url) { … }
… …
}}
[HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)][HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)]
class SomeClass { … }class SomeClass { … }
Type type = Type.GetType(“SomeClass”);Type type = Type.GetType(“SomeClass”);
Attribute[] attributes = Attribute[] attributes =
type.GetCustomAttributes();type.GetCustomAttributes();

71. Creating AttributesCreating Attributes
Attributes are simply classesAttributes are simply classes
Derived from System.AttributeDerived from System.Attribute
Class functionality = attribute functionalityClass functionality = attribute functionality
public class HelpURLAttribute: System.Attributepublic class HelpURLAttribute: System.Attribute
{{
public HelpURLAttribute(string url) { … }public HelpURLAttribute(string url) { … }
public string URL { get { … } }public string URL { get { … } }
public string Tag { get { … } set { … } }public string Tag { get { … } set { … } }
}}

72. Using AttributesUsing Attributes
Just attach it to a classJust attach it to a class
Use named parametersUse named parameters
Use multiple attributesUse multiple attributes
[HelpURL(“[HelpURL(“http://someurl/”)]”)]
Class MyClass { … }Class MyClass { … }
[HelpURL(“[HelpURL(“http://someurl/”, Tag=“ctor”)]”, Tag=“ctor”)]
Class MyClass { … }Class MyClass { … }
[HelpURL(“[HelpURL(“http://someurl/”),”),
HelpURL(“http://someurl/”, Tag=“ctor”)]HelpURL(“http://someurl/”, Tag=“ctor”)]
Class MyClass { … }Class MyClass { … }

73. Querying AttributesQuerying Attributes
Use reflection to query attributesUse reflection to query attributes
Type type = typeof(MyClass);Type type = typeof(MyClass);
foreach(object attr in type.GetCustomAttributes())foreach(object attr in type.GetCustomAttributes())
{{
if(attr is HelpURLAttribute)if(attr is HelpURLAttribute)
{{
HelpURLAttribute ha = (HelpURLAttribute) attr;HelpURLAttribute ha = (HelpURLAttribute) attr;
myBrowser.Navigate(ha.URL);myBrowser.Navigate(ha.URL);
}}
}}