neal stublen nstublen@jccc.edu. tonight’s agenda indexers delegates and events operator...

C#: INTRODUCTION

FOR DEVELOPERS

Neal Stublen

nstublen@jccc.edu

Tonight’s Agenda

Indexers Delegates and events Operator overloading Class inheritance Q&A

BUT FIRST...SOME REVIEW

Review

What methods can you use to get data into and out of a form?Form.Tag propertyAdd methods and properties to the form

Review

What issues might make you think twice about using the Form.Tag property?It’s a generic Object type, so there are no

compiler checks on the data type

Review

Using the Debug class to trace program executionStepping through class construction

○ Multiple constructorsStepping through properties

○ get and setStepping through form construction

and initialization○ Construction and initialization

CHAPTER 13

INDEXERS

What’s an indexer?

An array has an indexer…

int[] myArray = new int[5];for (int index = 0; index < 5; ++index){ myArray[index] = 3;}

The [ ] is the indexer.

What’s an indexer?

An indexer accesses one value by using another value

A special property: public <type> this[<index_type> <index_value>]

The index_type is often an integer, but can be another data type

Implemented on collection classes

What’s an indexer?

Indexers can create classes that act like “virtual arrays”They have the array syntax, but they are not

actually allocated as arrays A special class property:

public <type> this[<index_type> <value>]

The index_type is often an integer, but can be another data type

Invalid Indexes

Using an invalid index value throws an ArgumentExceptionArgumentNullExceptionArgumentOutOfRangeException

Files as Byte Arraysclass FileArray{ public byte this[long index] { get { // read byte at index } set { // write byte value at index } }}

Books as Page Arraysclass Book{ public Page this[long index] { get { // return page “index” } set { // insert page at “index” } }}

CHAPTER 13, PART 2

DELEGATES AND EVENTS

What’s a delegate?

A delegate specifes a method signature for an event

Declare a delegate data type:public delegate <return_type> DelegateName([parameters_list]);

Delegate Example// The delegate type declarationpublic delegate void NameChangedEventHandler(object sender, EventArgs e);

class NameObject{ // The event member public event NameChangedEventHandler NameChanged;

public void setName(string inName) { mName = inName; if (NameChanged != null) { NameChanged(this, new EventArgs()); } }}

Connecting to an Eventclass SomeObject{ private NameObject mTheName = new NameObject();

public void Init() { mTheName.NameChanged += new NameChangedEventHandler(EventHandler) }

private void EventHandler(object sender, EventArgs e) { }}

An Event Example

Reuse the SportsTeam class One form updates a team’s record Another form reports the team’s record

CHAPTER 13, PART 3

OPERATOR OVERLOADING

What operations?

Unary operators+, -, !, ++, --, true, falsepublic static <return_type>operator <operator>(<operand_type>)

Binary operators+, -, *, /, %, &, |, ==, !=, >, <, >=, <=public static <return_type>operator <operator>(<operand_type_1>,

<operand_type_2>)

Operator Exampleclass MyCollection{ private List<object> mList;

public static MyCollection operator +(MyCollection col, object newObject)

{ col.mList.Add(newObject); return col; }}

collection += new object();

Overloading ==

Must also overload Equals() Must also overload GetHashCode() Must also overload !=

Must overload relational operators in pairs (<, >), (<=, >=), (==, !=)

Practice Exercise

Exercise 13-1, p. 418

CHAPTER 14

CLASS INHERITANCE

What is inheritance? One class inherits the attributes and

behaviors of another class The base class should be a larger

classification of the derived class (ex. a Control is a larger classification for Button)A Button “is-a” Control; a Button “has-a”

BackColorA Book “is-a” Product; a Book “has-a” Publisher

The derived class extends or overrides behavior

.NET Inheritance

All classes implicitly inherit from System.ObjectGetType()ToString()Equals()ReferenceEquals()GetHashCode()Finalize()MemberwiseClone()

How does inheritance work?

class Fourth class Third class Second class First

methodA

methodB methodB

methodC methodC methodC

methodD methodD

methodE methodE

Fourth fourth = new Fourth();fourth.methodA();fourth.methodB();fourth.methodC();fourth.methodD();fourth.methodE();

First first = new Fourth();first.methodA();first.methodB();first.methodC();first.methodD();first.methodE();

“Polymorphism”The base class can take many different

forms.

Polymorphism

List<First> myList = new List<First>();myList.Add(new First());myList.Add(new Second());myList.Add(new Third());myList.Add(new Fourth());

foreach (First item in myList){ item.methodB(); item.methodC();}

How do we “do” inheritance?

Keywords: virtual, override A base class declares a method as

virtual A derived class declares a method as

override Reference base class from a derived

class using “base.”

Inherited Classesclass First{ public virtual void methodA() { }}

class Second : First{ public override void methodA() { base.methodA(); }}

Public vs. Private

“public” indicates a method or property can be accessed from outside a class

“private” indicates a method or property can be accessed only from within a class

“protected” indicates a method or property can be accessed from within a class or a derived class

Public/Protected/Privateclass MyClass{ public void MyPublicMethod() { } private void MyPrivateMethod() { } protected void MyProtectedMethod() { }}

class YourClass{ public void Sample() { MyClass test; // Access from anywhere test.MyPublicMethod(); }}

Public/Protected/Privateclass MyClass{ public void MyPublicMethod() { } private void MyPrivateMethod() { } protected void MyProtectedMethod() { }}

class MyDerivedClass : MyClass{ public void Sample() { // Access from a derived class MyProtectedMethod(); }}

Public/Protected/Privateclass MyClass{ public void MyPublicMethod() { }

private void MyPrivateMethod() { }

protected void MyProtectedMethod() { // Access from within the class MyPrivateMethod(); }}

What about “internal”?

The internal keyword provides access to methods and properties, but only from within other files in the same .NET assembly

Casting Operations

A derived class type can be implicitly cast to any of its base class types

Base class types must be explicitly cast to a derived class type

Implicit Casting

class Base { }class Derived : Base { }

int DoSomething(Base inObject) { }

Derived derivedObject = new Derived();

// Implicitly cast to Base class typeDoSomething(derivedObject);

Explicit Casting

class Base { }class Derived : Base { }

int DoSomething(Derived inObject) { }

Base someObject = new Derived();

// Explicit cast to Derived class typeDoSomething((Derived)someObject); // May throw an exception

Explicit Casting

class Base { }class Derived : Base { }

int DoSomething(Derived inObject) { }

Base someObject = new Derived();

// Explicit cast to Derived class typeDoSomething(someObject as Derived); // May return null

Considerations for Inheritance

Confirm “is-a” versus “has-a” relationship

Does adding one or more properties to the base class make more sense?

Would an interface be more beneficial? Implicit and explicit casting between

inherited types Using the “as” operator instead of

casting to avoid exceptions

Inheritance Example

Example product heirarchyp. 429

Abstract Classes

Abstract classes cannot be instantiated, and can only serve as a base class

Abstract methods and properties must be overridden in a derived classYou know the method or property exists for

every object of this type, but there is no implementation at this level of abstraction

All Objects have a ToString() implementation, but the implementations are all independent of one another

Sealed Classes

Sealed classes cannot be inherited Sealed methods and properties cannot

be overridden

Start thinking about how objects you need to model may inherit from one another.

Are there any obvious heirarchies, common attributes, or shared behavior?

Suggestions

Try to work through Exercises 14-1 and 14-2 in the book (p. 457)

Inheritance Walkthrough