LectureNotes-02-DSA

Chapter 2

QUICK TOUR OF C#

2.1 Introduction
This chapter is not intended to be an extensive C# course. We are presenting
here the fundamentals needed to understand the rest of the code presented
in the book. Obviously this book is primarily about Data Structures and
Algorithms, but in several places we will explore some aspects of using Iron-
Python with other .NET languages, the foremost being C#. If you don’t
know C#, this chapter will give you a brief over- view of the core parts of
the language. It should be enough to let you read the code examples in the
book, although you’ll probably want more detail if you’re trying to write C#
code.

2.2 Namespaces
Namespaces are similar to other languages packages and modules. The classes
in an assembly live in namespaces, which can be nested to provide a hierar-
chical structure. This structure is used to group together related classes to
make them easier to find. Namespaces are specified in C# like so:

namespace DataS tructur es . Professor {
class Haitham {
...
}
}

Here we declare a namespace called DataStructures.Professor, which con-
tains the Haitham class. Another major feature of namespaces is that they
enable us to avoid name collisions: the fully qualified name of the class

31

32 CHAPTER 2. QUICK TOUR OF C#

is DataStructures.Professor.Haitham, and we could happily use other
Haitham classes in our project as long as they are in di↵erent namespaces.

2.3 Classes
Class declarations in C# are structured like this:

public class Haitham : Professor , IBlogger , IMozillaReMo {
public string name ;
public Haitham ( string name ) {
this . name = name ; // more fields and methods here
}

The access modifier public before the class keyword indicates that the class is
accessible outside the current namespace. The names after the colon specify
what this class inherits from. Haitham is a subclass of the Professor class, as
well as the IBlogger and IMozillaReMo interfaces. C# doesn’t allow multiple
inheritance of classes, but implementing multiple interfaces is fine. If no par-
ent class is specified in a class definition (or it inherits only from interfaces),
the class inherits from System.Object. The body of the class can contain
definitions of various kinds of members:
• Constructors
• Fields (like the name attribute in the previous snippet)
• Methods
• Properties
• Events
• Operators
Each of these members has access modifiers as well:
• private—Can be used only inside this class
• protected—Accessible from this class and any subclasses
• internal—Accessible from any class in the current assembly
• public—Available from any code
Classes can also contain other types (including classes, interfaces, structs, or
dele- gates) as members. As well as access modifiers, other modifiers can be
applied to classes when they are defined:

2.4. ATTRIBUTES 33

• abstract—This declares that the class can be used only as a base class
and can’t be instantiated. It might contain declarations of abstract
methods (without any implementation) that subclasses must define
when they are declared. (Abstract classes can still contain concrete
implementations of some methods.)

• static—This indicates that this class can’t be instantiated or used as a
type (so it can’t be subclassed). Static classes are essentially containers
for their members.

• sealed—This prevents this class from being subclassed, for security or
performance reasons. When the compiler sees a method call on a sealed
class, it can generate a direct call to the method, rather than a virtual
call.

• partial—Partial classes are classes that are defined in more than one
file. This can be useful if some code in a class is machine generated; the
generated code can be kept in a separate file and regenerated without
clobbering the custom code.

2.4 Attributes
Attributes are declarative information that can be attached to di↵erent ele-
ments of a program and examined at runtime using reflection. They can be
applied to types, methods, and parameters, as well as other items. The .NET
framework defines a number of attributes, such as SerializableAttribute,
STAThreadAttribute, and FlagsAttribute, which control various aspects of
how the code runs. You can also create new attributes (to be interpreted
by your own code) by inheriting from System.Attribute. The following code
applies the SecretOverrideAttribute to the ProfessorHaitham.Teach method:

class P r o f e s s o r H a i t h a m {
//...
[ Secr etOverri de ( ” . . . ” ) ] public void Teach ( Subjects d a t a s t r u c t u r e s 2 0 1 2 ) -
{
//...
}
}


2.5 Interfaces
An interface is a type that defines methods and properties with no behavior.
Its purpose is to make a protocol explicit without imposing any other restric-
tions on the implementation. For example, the previous ProfessorHaitham
class implements the IMozillaReMo interface:

interface IMozillaReMo {
IBrowser F a v o u r i te B r o w s e r { get ; s e t ; }
void Browse ( ) ;
}

This means that ProfessorHaitham must provide a definition of the FavouriteBrowser
property and the Browse method. Classes that implement multiple interfaces
must provide definitions for all of the interfaces’ members. Interfaces can
subclass other interfaces (and even inherit from multiple interfaces), which
means that they include all of the members of their bases as well as the
members they declare. Ordinarily, a class that inherits from an interface can
implement its members simply by defining them with the correct name, pa-
rameters, and return type. In some cases, you might not want the interface
members to be part of your class’s interface (for example, if you have two
di↵erent interfaces that clash). You can implement those members explicitly,
so that they are available only when used through a reference to the interface:

public class E x p l i c i t l y D r i v e a b l e : IMozillaReMo {
// member prefixed with interface name
public void IMozillaReMo . Browse ( ) {
// imple mentati on here . . .
// other members
}
}

Then code trying to use the Browse method on an ExplicitlyDriveable in-
stance must cast it to IMozillaReMo first.

2.6 Enums
Enumerations are collections of named constants, which look like this:

enum CoursesITeach {
DataStructuresAndAlgorithms ,
SystemAnalysisAndDesign ,
ResearchMethodologies ,
DataBase
}

2.7. STRUCT 35

The enum values can be referred to in code using CoursesITeach.DataStruct
uresAndAlgorithms. By default, enumerations inherit from int, but they can
be declared (using the inheritance syntax) as any of the integral .NET types:
sbyte, byte, short, ushort, int, uint, long, or ulong. Enums can be combined
as flags with the bitwise-or operator (—) if you annotate them with the Flags
attribute, in which case you should also specify the value of each member (by
default, they’re assigned sequentially from 0). For example, if you wanted
the CoursesITeach values to be combinable, you could define it as follows:

[ Flags ]
enum CoursesITeach {
DataStructuresAndAlgorithms = 1 ,
SystemAnalysisAndDesign = 2 ,
ResearchMethodologies = 4 ,
DataBase = 8
}

2.7 Struct

Structs are data structures that are defined similarly to classes. The di↵er-
ence is that a struct is a value type rather than a reference type like a class.
When a variable is of a class type, it contains a reference to an instance of
the class (or null). A struct variable directly contains the members of the
struct rather than being a reference to an object elsewhere in memory. This
is generally useful for performance or memory optimization: a large array of
structs can be much quicker to create than the same size array of objects.
In some situations using structs can be slower, though, particularly when as-
signing or passing them as parameters (because all their member data needs
to be copied). Struct definitions look like this:

struct Faculty {
public float name ;
public Faculty ( String name ) {
//...
}
}

Structs can’t inherit from any type (other than object, which they inherit
from implicitly), and no types can inherit from them.


2.8 Methods
Methods in C# are members of classes and structs that are defined by giving
the access level, the return type, the name of the method, and the parameters
it accepts, as well as the block of code that is executed when it is called:

class Haitham {
//...
public void GoToLecture ( string LectureName ) {
Point location = this . targ etDataba se . Find ( targetName ) ;
this . FlyToLocation ( location ) ;
}
}

The void return type indicates that this method returns nothing.

2.8.1 Virtual and override Methods
The virtual modifier applied to a method indicates that it can be overridden
in a subclass. The subclass’s version of the method must have the same
visibility, name, parameter types, and return type as the base class method
and be defined using the keyword override.

class GiantRobot {
//...
public virtual void TravelTo ( Point destination ) {
this . TurnTowards ( destination ) ;
w h i l e ( this . Location != destination ) {
this . Trudge ( ) ;
}
}
}

class FlyingRobot : GiantRobot {
//...
public override void TravelTo ( Point destination ) {
i f ( this . WingState == WingState . Operational ) {
this . FlyTo ( destination ) ;
// whee !
} else {
base . TravelTo ( destination ) ; // oh well . . .
}
}
}

In a method, this refers to the current instance, although this doesn’t need to
be a parameter of each method. To call a superclass method or property (for
example, from the body of an override method), you refer to base. Semantics
are simpler because any C# class has only one superclass.

2.9. METHOD OVERLOADING 37

2.8.2 Other method modifiers
A number of other modifiers can be included after the access modifier when
defining a method. The more commonly seen modifiers are these:

• static—This method must be called directly on the class rather than
on an instance (and so can’t refer to this).

• sealed—This override method can’t be overridden again in a subclass.
This is often done for performance or security reasons.

• abstract—This method must be implemented in subclasses. Abstract
methods can’t contain any code.

2.8.3 Parameter passing
By default, method parameters are passed by object value (with the extra
wrinkle that structs are copied). In C# you can change this behavior using
the ref and out parameter modifiers. If a parameter has the ref modifier, it is
passed by reference instead. Assignments to that parameter in the method
will be reflected in the variable passed in by the caller. For example, an
int variable passed as a ref parameter can be assigned in the method, and
the variable’s value will be updated in the calling scope. Out parameters
are similar, with the di↵erence that they don’t need to be assigned a value
before calling the method, and they must be assigned in the method. The
di↵erence between them is that out parameters are viewed as extra return
values of the method, while ref parameters are values that are both input
and potentially output of the method.

2.9 Method overloading
There can be multiple di↵erent methods in a class with the same name, as
long as the combination of name and parameter types is unique within the
class. Methods that have the same name but di↵erent parameters are said to
be overloaded. When you call an overloaded method, the compiler uses the
compile-time types of the parameters passed in to determine which version
of the method is called. This is an important distinction between overload
dispatch, where the selection of which overload to call is purely based on the
declared types of the parameters, and method dispatch, where the method
called is determined by the type of the instance at runtime, regardless of the
declared type of the variable.


2.10 Loops
C# has four looping constructs: while, do, for, and foreach.

2.10.1 while loop
The condition of the loop in C# must evaluate to a bool.

int a = 1 0 ;
while ( a > 0) {
a ;
}

The loop control keywords break and continue work (for all C# loops). The
condition of the loop must be included in parentheses.

2.10.2 do loop
The do loop is like a while loop, where the condition is checked at the end
of the loop body; that is, the loop body always executes at least once.

int a = 0 ;
do {
a ; } while ( a > 0) ;

After the execution of this loop, a will have the value -1.

2.10.3 for loop
The C# for loop has three parts in addition to the loop body:

• An initialization clause, which sets up variables before the loop begins

• A condition that is tested before each execution of the loop body

• An iteration clause, which is executed after each execution of the loop
body

Here’s an example:

int total = 0 ;
for ( int i = 0 ; i < 1 0 ; i++) {
total += i ;
}

2.11. IF 39

After execution, total will have the value 45 (the sum of 0 to 9), because it
stops when i equals 1. Each of the three control clauses is optional, and each
clause can consist of multiple statements separated by commas.

2.10.4 foreach loop
The foreach loop can iterate over any collection that implements the IEnu-
merable interface, including arrays.

string [ ] names = new string [ ] { ” A l i c e ” , ”Bob” , ” M a l l o r y ” } ;
f o r e a c h ( string person in names } {
Console . WriteLine ( person ) ;
}

2.11 if
The condition must be in parentheses and yield a Boolean. If statements can
be chained, so there’s no need for the elif.

if ( ! robot . AtDestination ( ) ) {
robot . Walk ( ) ;
} e l s e i f ( robot . CanSee ( target ) ) {
robot . Destroy ( target ) ;
} else {
robot . ChillOut ( ) ;
}

2.12 switch
Some situations that would require an if-elif-else construct or a dictionary
lookup can be done more cleanly in C# using a switch statement.

M a t e r i a l S e l e c t i o n file ;
s w i t c h ( target . Type ) {
case TargetType . D a t a S t r u c t u r e s A n d A l g o r i t h m s :
book = ” Data S t r u c t u r e s and A l g o r i t h m s u s i n g C# and Python ” ;
break ;
case TargetType . DataBase :
book = ” Database Management Systems , Thomas C o n o l l e y ” ;
break ;
case TargetType . I ma ge Pr o ce ss in g :
case TargetType . OpenCV :
book = ”Open CV R e f e r e n c e Book” ;
break ;
case default :


book = null ;
break ;

The case labels must be constants, and each case has to end with a flow-
control statement like break, throw, or return; execution isn’t allowed to fall
through from one case to another. If you want fall-through behavior, you
can use the goto case statement to explicitly jump to the case that should be
executed. Two case labels together (like the ImageProcessing and OpenCV
case shown previously) are treated as if they share the same body. If the
switch expression doesn’t match any of the case labels and there’s a default
case, it is executed.

2.13 try/catch/finally and throw

try {
robot . ReturnToBase ( TransportMode . FootThrusters ) ;
} catch ( F o o t T h r u s t e r F a i l u r e ) {
robot . ReturnToBase ( TransportMode . BoringWalking ) ;
} catch ( E m e r g e n c y O v e r r i d e E x c e p t i o n e ) {
robot . SelectTarget ( e . NewTarget ) ;
} catch { robot . A s s u m e D e f e n s i v e P o s i t i o n ( ) ;
throw ; // re throw the original exception
} finally {
robot . NotifyBase ( ) ;
}

2.14 null
null, a value that is the singleton instance of NoneType. null is a reference
that doesn’t refer to any object. This has two consequences: first, null can
be assigned to a variable of any reference type, and second, value types like
int, DateTime, or custom structs can’t be null, because they don’t contain
references. The second fact can be inconvenient in some situations, so each
value type in C# has a nullable version, represented with the type name
followed by a question mark. For example, a nullable integer variable would
be declared with int?. Nullable types can then be used as normal (although
there are performance di↵erences under the hood) and be assigned null in
the same way as reference types.

2.15. LAB EXCERCISES 41

2.15 Lab Excercises
Problem:
If we list all the natural numbers below 10 that are multiples of 3 or 5, we
get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the
multiples of 3 or 5 below 1000.
Hint: Answer: 233168
Thanks to http://projecteuler.net/problem=1 Problem Write the Programs
needed to solve the following problems:
P
• Program to compute n = 1ii
Pn
• Program to compute i = 1i using Horner’s rule.

• Program to compute
Pn
• Program to compute i = xi
0
Pn
• Program to compute i = xi using Horner’s rule.
0
Pn
• Program to compute i = xi using the closed-form expression.
0
Pj
• Program to compute i=0 ai for 0  j < n

• Program to compute n!

LectureNotes-02-DSA

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to LectureNotes-02-DSA (20)

More from Haitham El-Ghareeb (20)

LectureNotes-02-DSA