Complete set: Intro to C - Bill Buchanan

Name:
Course: Introduction to .NET
Title: Introduction
Instructor: Bill Buchanan
.NET

1 Introduction
1.1 Introduction
The first module provides a basic introduction to the .NET. It covers:
• Introduction to Object‐orientation.
• .NET Framework.
• Visual Studio Environment.
• Benefits of C# over VB.
• .NET Components.
• .NET Languages.
.NET uses a newly developed language named C#, which has evolved through C++,
and has adopted many of the object‐oriented ideas from Java.
1.2 Introduction to Object orientation
duction to .NET
Intro
We live in a world full of objects; so object‐oriented programming is a natural technique
in developing programs. For example, we have an object called a cup, and
each cup has a number of properties, such as its colour, its shape, its size, and so on.
It is efficient for us to identify it as a cup, as we know that cups should be able to
hold liquid, and we will place our cup beside all the other cups that we have. If we
were a cup designer then we could list all the possible properties of a cup, and for
each design, we could set the properties of the cup. Of course, some of the properties
might not actually be used, but for a general‐purpose design, we would specify
every property that a cup might have. For example, in a simple case we could have
the following properties:
Properties Cup 1 Cup 2 Cup3
Shape (Standard/Square/Mug) Standard Square Mug
Colour (Red/Blue/Green) Blue Red Green
Size (Small/Medium/Large) Small Large Small
Transparency (0 to 100%) 100% 50% 25%
Handle type (Small/Large) Small Small Large
Agilent .NET Course: Introduction 2

Thus, we have three choices of shape (square, standard or mug), three choices of
colour (red, blue or green), three choices in size (small, medium or large) and two
choices of handle type (small or large). In addition, we can also choose a level of
transparency of the cup from 0 to 100% (in integer steps). In object‐oriented program,
the collection of properties is known as a class. Thus, we could have a class
for our cup which encapsulates all the design parameters for our cup. The instance
of our class, such as Cup 1, Cup 2 and Cup 3, are known as objects. We can create
many objects from our class. Along with this, there are certain things that we want
to do with the cup, such as picking it up, painting it, or even dropping it. In objectorientation,
these are known as methods, and are the functions that can be allowed
to operate on our objects.
Program 1.1 shows an object‐oriented example of the cup, where a class named
Cup is created, of which an instance is named cup. A full description on this program
will be discussed in a later module. It uses variables, such as Shape, Colour, and Size
to define the property of an object.
Program 1.1: Program1_1_ClassSimpleCup
using System;
namespace ConsoleApplication2
{
public class Cup
{
public string Shape;
public string Colour;
public string Size;
public int Transparency;
public string Handle;
duction to .NET
Intro
public void DisplayCup()
{
System.Console.WriteLine("Cup is {0}, {1}", Colour, Handle);
}
}
class Class1
{
static void Main(string[] args)
{
Cup cup = new Cup();
cup.Colour = "Red"; cup.Handle = "Small";
cup.DisplayCup();
cup.Colour = "Green"; cup.Handle = "Small";
cup.DisplayCup();
System.Console.ReadLine();
}
}
}
Sample Run 1.1
Cup is Red, Small
Cup is Green, Small
Agilent .NET Course: Introduction 3

In the following example, we create a class named Circuit, of which we create a
new instance of it named cir. The class then has two methods, named Serial and
Parallel.
Program 1.2: Program1_2_ClassSimpleResistor
using System;
namespace ConsoleApplication2
{
public class Circuit
{
public string name;
}
public double Parallel(double r1, double r2)
{
return((r1*r2)/(r1+r2));
}
public double Series(double r1, double r2)
{
return(r1+r2);
}
class Class1
{
static void Main(string[] args)
{
double v1=100,v2=100;
double res;
Circuit cir = new Circuit();
cir.name="Circuit 1";
res=cir.Parallel(v1,v2);
System.Console.WriteLine("[{0}] Parallel resistance is {1} ohms",
cir.name,res);
cir.name="Circuit 2";
res=cir.Series(v1,v2);
System.Console.WriteLine("[{0}] Series resistance is {1} ohms ",
cir.name,res);
duction to .NET
Intro
}
}
}
System.Console.ReadLine();
Sample Run 1.2
[Circuit 1] Parallel resistance is 50 ohms
[Circuit 2] Series resistance is 200 ohms
In this case, we have used a single object (cir). Of course, we could have created
two objects, with:
Circuit cir1 = new Circuit();
Circuit cir2 = new Circuit();
cir1.name="Circuit 1"; res1=cir1.Parallel(v1,v2);
cir2.name="Circuit 2"; res2=cir.Series(v1,v2);
Agilent .NET Course: Introduction 4

Finally, for this section, Program 1.3 shows an example of a complex number class,
where a complex number object is created (r), which is made up of two components
(r.real and r.imag). The class defines two methods: mag() and angle(), which calculate
the magnitude and the angle of the complex number, using:
z = x + jy
z
z
=
x
2
= tan
+ y
−1
⎛
⎜
⎝
2
y
x
⎞
⎟
⎠
Program 1.3: Program1_3_ClassComplexNumberExample
using System;
namespace ConsoleApplication2
{
public class Complex
{
public double real;
public double imag;
public double mag()
{
return (Math.Sqrt(real*real+imag*imag));
}
public double angle()
{
return (Math.Atan(imag/real)*180/Math.PI);
}
}
class Class1
{
static void Main(string[] args)
{
string str;
double mag,angle;
Complex r = new Complex();
duction to .NET
Intro
}
}
System.Console.Write("Enter real value >>");
str=System.Console.ReadLine();
r.real = Convert.ToInt32(str);
System.Console.Write("Enter imag value >>");
str=System.Console.ReadLine();
r.imag = Convert.ToInt32(str);
mag=r.mag();
angle=r.angle();
System.Console.WriteLine("Mag is {0} and angle is {1}",mag,angle);
System.Console.ReadLine();
}
Sample Run 1.2
Enter real value >> 3
Enter imag value >> 4
Mag is 5 and angle is 53.130102354156
Agilent .NET Course: Introduction 5

1.3 .NET Framework
The PC has slowly evolved with ever‐increasing operating system components. Unfortunately,
these additions make version control difficult. Microsoft has thus tried
to overcome this by creating a common framework in which programs run. This
framework should be easier to control and to update, where bug fixes can be updated
with news downloads. Generally, Microsoft have further developed objectorientation,
and integrated many of the new techniques that Java created, such as
operating system/hardware independence. They have also, for the first time, binded
the .NET Framework to the Windows environment, which should improve security
and allow enhanced integration with system components, such as using Microsoft
Word as an editor, or Microsoft Excel to create and process spreadsheets.
Figure 1.1 shows the typical steps taken in developing a program. Initially the
source code is converted into object code (OBJ) using a compiler. This converts the
code into a form which is matched to the hardware of the system, but cannot be run
as it does not contain the basic elements of a program, such as routines which interface
to the input/output. These elements are integrated with the linker, which takes
all the created object code files, and searches in the static libraries for any code that
is required to produce the executable program. The program can then access system
routing through API (Application Programming Interface) calls, such as in creating
Windows, or interfacing to networking functions. These API calls are typically contained
in run‐time libraries (DLL’s), which contain the code which implements the
require function.
Introduction to .NET
Source
Code
(C/C++/
Delphi/
VB)
Compilation
OBJ file
Static Static
Libraries
Linker Linker
gdi32.dll
EXE EXE
Program Program
API
(Application
Programming
Interface)
ole32.dll
Figure 1.1: Traditional stages of program development
Agilent .NET Course: Introduction 6

1.3.1 Win32 API
The Win32 API library contains many routines:
• Creating windows.
• Windows support functions.
• Message processing.
• Menus.
• Resources.
• Dialog boxes.
• User input functions.
• Memory management.
• GDI (graphical device interface).
• Bitmaps, icons and metafiles.
• Printing and text output.
• Painting and drawing.
• File I/O.
• Clipboard. Support for public and
private clipboards.
• Registry. Support for functions
which access the Registry.
• Initialization files. Support for
functions which access INI files.
• System information.
• String manipulation.
• Timers.
• Processes and threads.
• Error and exception processing.
• Help files.
• File compression/decompression.
• DLLs.
• Network support (NetBios and
Windows sockets 1.1 APIs).
• Multimedia support (sound
APIs).
• OLE and DDE (dynamic data exchange).
• TrueType fonts.
An example of a C++ call to these APIs is:
duction to .NET
Intro
Program 1.4: ClassComplexNumberExample
#include
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
{
char msg[128];
wsprintf(msg, "My name is Fred");
MessageBox(GetFocus(), msg, "My first Window", MB_OK | MB_ICONINFORMATION);
return(0);
}
Where the MessageBox() routine is a standard API call to show a basic message box,
such as:
Agilent .NET Course: Introduction 7

1.3.2 .NET Enhancements
Software development for the PC has developed through the use of languages such
as C++, Delphi and Visual Basic. These languages are all focused on producing Windows‐based
programs using the x86 architecture. The computing industry, though,
has moved over the last few years, with the advent of the Internet and Java. With
Java, Sun Microsystems have tried to produce programs which could be run on any
type of hardware. This has the advantage that the program can be produced for a
range of hardware, including Apple‐based computers and hand‐held devices. There
has also been a move toward using software routines which are not necessarily
based on the host computer, and in integrating WWW services with programs. This
integration is illustrated in Figure 1.2.
In general the current weaknesses of software development which have been
overcome with .NET are:
duction to .NET
Intro
• Lack of support for different hardware. .NET overcomes this in a similar way
to Java in that it produces an intermediate code known as MSIL (Microsoft Intermediate
Language) which when run with the CLR (Common Language
Runtime) produces an executable program which matches the hardware.
• Difficult to integrate different programming languages. This is a problem with
most software development environments, especially in representing the variables
in the same way. .NET overcomes this by producing a standardized
system for data representation, known as CTS (Common Type Representation).
The compiler also uses CLS (Common Language Specification) to produce code
which can be integrated with other programming languages. Along with this the
.NET framework uses a FCL (Framework Class Library) which is a common set
of classes which can be used with the different languages.
• Lack of security integration. .NET binds itself with the operating system so that
it integrates better with the security controls of the system.
• Poor version control of system components. .NET improves this by supporting
the installation of different versions of the .NET framework. Users can choose
which of the version they install, and previous versions will be stored on the
host.
• Weak integration with the WWW/Internet. .NET integrates WWW development
with code development by integrating ASP with VB/C#.
In order to support these advancements, Microsoft has developed Visual Basic further
and integrated it with ASP, to produce VB.NET. C++ has also been advanced to
C# which incorporates many of the advanced features of Java. Figure 1.3 outlines
some of the key features of the .NET framework.
Agilent .NET Course: Introduction 8

VB VB
ASP ASP
ASP ASP
VBA VBA
VB VB .NET .NET
C# C#
Executable Executable
Program Program
Visual Studio
C C
C++ C++
ASP
WWW
Services
COM+
(Distributed
Components)
.NET Platform
API
(Application
Programming
Interface)
Figure 1.2: .NET Integration
VB VB .NET .NET
C# C#
Introduction to .NET
CTS
CTS
(Common
(Common
Type
Type
System)
System)
FCL FCL
(Framework
Class Class Library)
Web
Web
component
component
Compiler
MSIL (Microsoft
Intermediate Language)
CLS
CLS
(Common
(Common
Language
Language
Specification)
Specification)
CLR CLR (Common Language Runtime)
Allows Allows the the programs to to run run – similar similar to to the the Java Java Virtual Virtual Machine (JVM) (JVM)
Figure 1.3: .NET Framework
Agilent .NET Course: Introduction 9

1.3.3 .NET Environment
DLL’s are typically installed in the system folders of the host. It is thus difficult to
keep track of new updates which enhance features or to fix bugs, as system files
where often overwritten by new ones. One method that was used to support these
updates was Direct X, which allowed software components to be registered onto a
system (Figure 1.4). Thus, when a program required a service, such as network support,
it would call the required DLL.
The problem of version control has now been reduced using the .NET framework.
With this the key framework files are installed to a single folder. An example
of this is shown in Figure 1.5. It can be seen that the single folder makes it easier to
update with new versions. A key DLL is the Mscorlib.dll which contains many of
the key elements of the .NET framework, such as for file I/O, system interfacing and
security.
Figure 1.4: DLL registration
1.4 Visual Studio .NET Environment
duction to .NET
Intro
The Visual Studio .NET Environment provides an integration of the Visual Studio
environment with new features, especially in automated code generation, and intelligent
sensing of user requirements. It uses projects (VBP) or solutions (SLN) to
create folders which contains the required elements of the program. In creating a
new project (with FileNewProject), the user is then asked for the required application
(Figure 1.6). This include a C# or a VB project. Once selected the user then
selects a template for the project, such as:
• Console application. This uses a command line window for the output, and is
useful in applications which require text‐based information.
• Windows application. This uses type of application uses Windows for its interface,
such as with text boxes and menus.
Agilent .NET Course: Introduction 10

Volume in drive C has no label.
Volume Serial Number is 1A83-0D9D
Directory of C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322
21/02/2003 08:24 7,680 Accessibility.dll
21/02/2003 06:00 98,304 alink.dll
20/02/2003 20:19 24,576 aspnet_filter.dll
20/02/2003 20:19 253,952 aspnet_isapi.dll
20/02/2003 20:19 40,960 aspnet_rc.dll
20/02/2003 20:09 77,824 CORPerfMonExt.dll
21/02/2003 11:21 626,688 cscomp.dll
21/02/2003 08:24 12,288 cscompmgd.dll
21/02/2003 08:24 33,792 CustomMarshalers.dll
29/07/2002 12:11 219,136 c_g18030.dll
21/02/2003 11:21 524,288 diasymreader.dll
19/03/2003 02:52 245,760 envdte.dll
20/02/2003 20:16 798,720 EventLogMessages.dll
20/02/2003 20:06 282,624 fusion.dll
21/02/2003 08:24 7,168 IEExecRemote.dll
21/02/2003 08:24 32,768 IEHost.dll
21/02/2003 08:24 4,608 IIEHost.dll
21/02/2003 08:25 1,564,672 mscorcfg.dll
20/02/2003 20:09 77,824 mscordbc.dll
20/02/2003 20:09 233,472 mscordbi.dll
20/02/2003 20:09 86,016 mscorie.dll
20/02/2003 20:06 311,296 mscorjit.dll
20/02/2003 20:09 98,304 mscorld.dll
21/02/2003 08:26 2,088,960 mscorlib.dll
20/02/2003 19:43 131,072 mscormmc.dll
20/02/2003 20:06 65,536 mscorpe.dll
20/02/2003 20:09 143,360 mscorrc.dll
20/02/2003 20:09 81,920 mscorsec.dll
20/02/2003 20:09 77,824 mscorsn.dll
20/02/2003 20:07 2,494,464 mscorsvr.dll
20/02/2003 20:09 9,216 mscortim.dll
20/02/2003 20:08 2,482,176 mscorwks.dll
21/02/2003 05:42 348,160 msvcr71.dll
18/03/2003 20:03 544,768 msvcr71d.dll
20/02/2003 20:18 20,480 mtxoci8.dll
19/03/2003 02:50 196,608 office.dll
20/02/2003 20:09 90,112 PerfCounter.dll
21/02/2003 08:26 32,768 RegCode.dll
Program
Contains most of the code
that is called by the program
Mscorlib.dll
Arrays,
Arrays,
File
File
I/O,
I/O,
System,
System,
Security
Security
Figure 1.5: .NET framework installation folder
Name of the folder
Which contains the
Project files
the project is stored.
Folder where
the project is stored.
duction to .NET
Intro
Figure 1.6: Creating a project
Figure 1.7 shows an example of the Visual Studio C# .NET environment. The project
elements are stored in the Solution explorer window. The actual code is displayed in
the Code and Text Editor window. For C# programs, the file name has a .cs extension.
A useful feature of the environment is the editor’s statement completion which
aids the developer by completing the required statement, as well as given help on
its syntax.
Agilent .NET Course: Introduction 11

1.4.1 Solution files
The solution file contains of the required elements of a project. The information is
contained in an sln file. In Figure 1.9, the solution file is named Module01_01.sln,
will the contents of the file is displayed in Figure 1.9. It can be seen that it defines
the environment of the development system, and defines a project file, which is defined
with a csproj file extension. In this case, the project file is named
Module01_01.csproj. The project file contains the references to all the required files
that the solution uses. In this case, as shown in Figure 1.10, the files used are
App.ico, AssemblyInfo.cs and Class1.cs. The C# code is contained in cs files, which
are known as class files.
Class file (.cs)
Solution explorer
Code and
Text Editor
Editor's statement
completion
Figure 1.7: Visual Studio C# .NET environment
duction to .NET
Intro
Figure 1.8: Example listing
Agilent .NET Course: Introduction 12

Module01_01.sln
Module01_01.sln
Microsoft Visual Studio Solution File, Format Version 8.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}")
Microsoft Visual Studio Solution File, Format Version
= "Module01_01",
8.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}")
"Module01_01.csproj", "{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}"
= "Module01_01",
ProjectSection(ProjectDependencies)
"Module01_01.csproj", "{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}"
= postProject
EndProjectSection
ProjectSection(ProjectDependencies) = postProject
EndProject
EndProjectSection
Global
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
GlobalSection(SolutionConfiguration)
Debug = Debug
= preSolution
Release
Debug =
=
Debug
Release
EndGlobalSection
Release = Release
GlobalSection(ProjectConfiguration)
EndGlobalSection
= postSolution
GlobalSection(ProjectConfiguration)
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Debug.ActiveCfg
= postSolution
=
Debug|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Debug.ActiveCfg =
Debug|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Debug.Build.0 =
Debug|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Debug.Build.0 =
Debug|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Release.ActiveCfg =
Release|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Release.ActiveCfg =
Release|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Release.Build.0 =
Release|.NET
{1EA384DD-927E-4B94-ABB8-BA08DFAE5AB3}.Release.Build.0 =
EndGlobalSection
Release|.NET
GlobalSection(ExtensibilityGlobals)
EndGlobalSection
= postSolution
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
GlobalSection(ExtensibilityAddIns)
EndGlobalSection
= postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobal
EndGlobalSection
EndGlobal
Figure 1.9: Example sln file
duction to .NET
Intro
Module01_01.csprof
Module01_01.csprof
/>
SubType = "Code"
BuildAction = "Compile" />
Figure 1.10: Project file
Agilent .NET Course: Introduction 13

Class1.cs
Class1.cs
using System;
using System;
namespace Module01_01
namespace Module01_01
{
{
///
///
/// Summary description for Class1.
/// Summary description for Class1.
///
///
class Class1
class Class1
{
{
///
///
/// The main entry point for the application.
/// The main entry point for the application.
///
///
static void Main(string[] args)
static void Main(string[] args)
{
{
//
//
// TODO: Add code to start application here
// TODO: Add code to start application here
System.Console.WriteLine("Agilent
System.Console.WriteLine("Agilent
Course");
Course");
System.Console.ReadLine();
System.Console.ReadLine();
}
}
}
}
}
}
Figure 1.11: CS file
Along with this, most projects contain an AssemblyInfo class file, an example of
which is shown in Figure 1.12. .NET uses assembly to represent a single unit. An
assembly, to be covered in a future unit, is a collection of files that appear as a single
unit, such as a single DLL or an EXE. Along with class files, most projects contain an
icon file, which is associated with the executable program. An example of an icon is
shown in Figure 1.13.
Introduction to .NET
AssemblyInfo.cs
AssemblyInfo.cs
using System.Reflection;
using
using
System.Runtime.CompilerServices;
System.Reflection;
using System.Runtime.CompilerServices;
//
//
//
General Information about an assembly is controlled through the following
//
//
set
General
of attributes.
Information
Change
about
these
an assembly
attribute
is
values
controlled
to modify
through
the
the
information
following
//
//
associated
set of attributes.
with an assembly.
Change these attribute values to modify the information
//
// associated with an assembly.
[assembly:
//
AssemblyTitle("")]
[assembly:
[assembly:
AssemblyDescription("")]
AssemblyTitle("")]
[assembly:
[assembly:
AssemblyConfiguration("")]
AssemblyDescription("")]
[assembly:
[assembly:
AssemblyCompany("")]
AssemblyConfiguration("")]
[assembly:
[assembly:
AssemblyProduct("")]
AssemblyCompany("")]
[assembly:
[assembly:
AssemblyCopyright("")]
AssemblyProduct("")]
[assembly:
[assembly:
AssemblyTrademark("")]
AssemblyCopyright("")]
[assembly:
[assembly:
AssemblyCulture("")]
AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
//
//
//
Version information for an assembly consists of the following four values:
//
// Version information for an assembly consists of the following four values:
//
//
Major Version
//
//
Minor
Major
Version
Version
//
//
Build
Minor
Number
Version
//
//
Revision
Build Number
//
// Revision
//
//
You can specify all the values or you can default the Revision and Build
// You
Numbers
can specify all the values or you can default the Revision and Build
// by using
Numbers
the '*' as shown below:
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyDelaySign(false)]
[assembly:
[assembly:
AssemblyKeyFile("")]
AssemblyDelaySign(false)]
[assembly:
[assembly:
AssemblyKeyName("")]}
AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]}
Figure 1.12: AssemblyInfo class file
Agilent .NET Course: Introduction 14

1.4.2 Using the environment
Figure 1.13: Icon file
The C# code is displayed in the Editor windows, as illustrated in Figure 1.14. The
classes within the file are displayed within the Types pull down menu item. It can
be seen, that, in this case, that the classes are named:
• ConsoleApplication2.ArrayExample02().
• ConsoleApplication2.test().
These are defined with the namespace of ConsoleApplication2 (namespaces will be
covered in a following section). Once within the class the members of the class are
shown in the right‐hand pull down menu. The main graphics used to display the
members are:
‐ Method within a class. If it has a padlock, it is a private method.
‐ Variable within a class. If it has a padlock, it is a private variable.
‐ Property of a class. Figure 1.15 shows an example of this.
duction to .NET
Intro
Figure 1.14: Types
Types
Agilent .NET Course: Introduction 15

Methods Variable
1.4.3 Viewing objects
Figure 1.15: Class members
Along with viewing the classes, it is possible to view the complete hierarchy of the
objects in the solution. This includes the hierarchy above the classes that have been
developed. Figure 1.16 shows an example of the object browser, and Figure 1.17
shows the browsing of the objects within the core library (mscorlib). In this case it
shows the objects within Systems.Collections.
duction to .NET
Intro
Figure 1.16: Object browsing
Agilent .NET Course: Introduction 16

Figure 1.17: Object browsing for other classes
1.5 .NET Languages
The two main languages of .NET are VB.NET and C#. Example of their syntax are
shown in Program 1.5 and 1.6. The gulf between VB and C++ was, at one time, a
massive one, as C++ contained more error checking and had a strong syntax. With
the advent of VB.NET, the gulf between VB and the new version of C++ (C#) has reduced.
Both are fully object‐oriented, and the weaknesses of VB have now been
overcome. The true strength of C# is its simple and precise syntax which many professional
developers prefer to VB.
duction to .NET
Intro
Program 1.5: Program1_5_ExampleOfVBCodePrimeNumberGeneration
‘ VB.NET Code
Dim j As Integer
Dim prime As Boolean
Dim i As Integer
For i = 1 To 100
prime = True
For j = 2 To (i / 2)
If ((i Mod j) = 0) Then
prime = False
End If
Next j
If (prime = True) Then
TextBox1.Text = TextBox1.Text & "," & Str(i)
End If
Next i
Sample Run 1.5
1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79,
83, 89, 97
Agilent .NET Course: Introduction 17

Program 1.6: Program1_6_ExampleOfC#CodePrimeNumberGeneration
// C# Code
int i, j;
bool prime;
for (i=0;i

1.6 Basic elements of a C# program
C# follows its parents in having a minimal number of keywords. These are:
abstract event new struct
as explicit null switch
base extern object this
bool false operator throw
break finally out true
byte fixed override try
case float params typeof
catch for private uint
char foreach protected ulong
checked goto public unchecked
class if readonly unsafe
const implicit ref ushort
continue in return using
decimal int sbyte virtual
default interface sealed volatile
delegate internal short void
do is sizeof while
double lock stackalloc
else long static
enum namespace string
C#, as the other C languages is case sensitive, thus the keywords must use the lowercase
format. The main elements of a C# program are given next.
duction to .NET
Intro
using System;
namespace ConsoleApplication2
{
public class Complex
{
public double real;
public double imag;
}
public int val { set {} get {} };
public double mag()
{
return (Math.Sqrt(real*real+imag*imag));
}
public double angle()
{
return (Math.Atan(imag/real)*180/Math.PI);
}
using. Imports types defined
in other namespaces.
namespace. Defines a unique
name for the objects. In this case
the objects would have the name
of:
ConsoleApplications2.Complex()
ConsoleApplicaitons2.Class1()
Agilent .NET Course: Introduction 19

class Class1
{
static void Main(string[] args)
{
Complex r = new Complex();
string str;
double mag,angle;
System.Console.Write("Enter real value >> ");
str=System.Console.ReadLine();
r.real = Convert.ToInt32(str);
System.Console.Write("Enter imag value >> ");
str=System.Console.ReadLine();
r.imag = Convert.ToInt32(str);
Main(). This is the
entry point into the
program, and defines
the start and
end of the program.
It must be declared
inside a class, and
must be static.
mag=r.mag();
angle=r.angle();
System.Console.WriteLine("Mag is {0} and angle is {1}",mag,angle);
}
}
}
System.Console.ReadLine();
1.6.1 Namespace
For the namespace, the full name of the Complex() class, its full name would be:
ConsoleApplication2.Complex()
Thus we could have used:
ConsoleApplication2.Complex r = new ConsoleApplication2.Complex()
duction to .NET
Intro
but as we are in the same namespace it is possible to use the relative form.
1.6.2 using
The using keyword is used imports types from other namespaces. Figure 1.18 shows
types that are imported for System.Console.Writeln(). It is important to import the
required namespace for the classes that are required. Examples include:
System:
System.Collections:
System.IO:
Array, Boolean, Byte, Char, Convert, DateTime, Double,
Enum, Int16, Int32, Int64, Math, Random, String, Void
ArrayList, BitArray, Hashtable, Queue, Stack.
BinaryReader, BinaryWriter, File, Stream, StreamWriter,
StreamReader
Agilent .NET Course: Introduction 20

System.Console.Write("Enter real value >> ");
Figure 1.18: System namespace
Introduction to .NET
Agilent .NET Course: Introduction 21

Name:
Course: Introduction to .NET
Title: Module 2 Basics of C#
Instructor: Andrew Cumming
.NET

2 Module 2 Basics of C#
2.1 Introduction
Afternoon session
• Using types and variables.
• Statements ‐ for, while and if.
• File handling.
• Introducing methods and parameters
Tutorial
• Boxes
• CIA Data
Introduction to .NET
Agilent .NET Course: C# Basics 2

2.2 Types
The language C# is strongly typed. This means that a compile time error occurs if
we make a type error.
Some basic types are:
Type Example Notes
int ‐100 32‐bit
char ‘x’ Uni‐code
string “Andrew was here.” Strings are double quoted.
Object new String(‘a’,10) Object is the most general type of object.
Variables are declared by giving the type followed by the name of the variable. In
these examples the variables are declared and given an initial value in the same line.
Sample program fragment
char c = 'x';
string s = "Andrew was here.";
int i = -100;
double d = 3.1415;
Object s = new System.IO.StreamReader("file.txt");
Object h = new System.Collections.Hashtable();
.
2.3 Type Casting
duction to .NET
Intro
A type cast can be used to convert one type to another.
The cast may be either explicit of implicit.
Sample program fragment
char c0 = 'A';
int i0 = c0; // Implicit cast works
//string s0 = c; // This fails
//string s1 = (string) c; // This fails
string s2 = "A" + c0; // This succeeds
double d0 = i0;
float f0 = (float)d0;
//float f1 = d0; // This fails
int i1 = (int)d0;
//int i1 = d0; // This fails
int i2 = (int)c0;
Agilent .NET Course: C# Basics 3

2.4 Casting Objects
Sometimes we need to cast objects.
We may cast up or down the object hierarchy.
Casting down is dangerous and may result in a run time error.
Examples of casting Objects
Object sr0 = new StreamReader("file.txt");
Object ht0 = new Hashtable();
// Following fails at compile time
// StreamReader f1 = sr0;
StreamReader f2 = (StreamReader)sr0;
// Following generates run time error
StreamReader f3 = (StreamReader)ht0;
2.4.1 Self-test
For each of the following decide if the line will work OK or fail at design time or fail
at run time.
Which of these will compile and run
int i0 = 3.1;
string s0 = 'x';
char c0 = 'c';
string s1 = "x" + 'y';
char c1 = (char) "a";
float f0 = 3;
Compile Error
duction to .NET
Intro
float f1 = "3.1";
DateTime v0 = DateTime.Now;
Object v1 = DateTime.Now;
Object v2 = new Object();
DateTime v3 = (DateTime) new Object();
DateTime v4 = new Object();
OK
OK
Agilent .NET Course: C# Basics 4

2.5 Converting between types
A cast does not involve processing ‐ data is simply interpreted in a different way.
For example if we cast the character ʹ5ʹ to an integer we get the ASCII code for 5
(which is 53).
A conversion usually involves some processing.
2.5.1 Converting to a string
We often need to convert to a string.
2.5.1.1 ToString()
The method ToString() can be used for any object. We may optionally control the
format with a format string.
Examples of ToString on an integer
//No surprises here – it gives "3"
3.ToString();
//The stand currency format is used "£3.00" for the UK
3.ToString("c");
//Uses three digits both sides of the . "003.000"
3.ToString("000.000");
//Daisy chains a string method " 3"
3.ToString().PadLeft(5)
duction to .NET
Intro
2.5.1.2 String.Format()
The Format method of the String class may be used to construct strings with variable
components.
Examples of use:
Examples of String.Format
// {0} is a place holder "3 men went to mow"
String.Format("{0} men went to mow.",3)
//"The time is now 23/06/04 12:30"
String.Format("The time now is {0}.", DateTime.Now)
//The place holder {1} crops up with different formats
String.Format("I paid {0:c} on {1:%d} of {1:%MMM}.",
3,DateTime.Now));
In a string format {0} indicates the first parameter, {1} is the next…
Following this indicator we can specify the format to be used after a :
In the example above :c indicates currency ‐ £3.00.
Agilent .NET Course: C# Basics 5

2.6 The Convert class
The convert class includes many methods that may be used to convert from one
data type to another:
There are other mechanisms from translating. Some classes have a Parse method.
2.6.1 Exercises:
Set the following variables:
Variables to be used in the exercise
int i = 99;
DateTime w = Convert.ToDateTime("21 Jun 2004 12:30");
double d = 42.3;
Use these values as input to one String.Format or ToString to produce each of the
following:
1 Use i to produce ʺ0099ʺ
i.ToString(ʺ0000ʺ)
2 Use w to produce ʺ21/06/2004 12:30:00ʺ – The default local date format.
3 Use w to produce ʺMondayʺ ‐ The day of the week.
duction to .NET
Intro
4 Use d to produce ʺ42.300ʺ ‐ To exactly 3 decimal places.
5 Use i to produce 63 – The hex value of 99
Agilent .NET Course: C# Basics 6

2.7 Summary
The base types include
• char
• string
• int
• double
The Framework Class Library includes many other classes such as
• DateTime
• StreamReader
• HashTable
• Object
Variable declaration
• Variable may be declared with different scope.
• A typical declaration includes the type or class name followed by the variable
name.
• The declaration may include an initial value.
• Constants may be declared in a similar way ‐ the modifier const precedes the
type.
duction to .NET
Intro
Strings
• Strings literals have double quotes.
• Normally \ introduces codes ‐ for example \n and \t for new line and tab. For
file names we must escape the backslash ʺc:\\dir\\file.txtʺ
• A string literal preceded by @ prevents the backslash escape mechanism. We
can have line breaks in strings. File names may be simpler @ʺc:\dir\file.txtʺ
Converting to a string
• We may use String.Format
• We may use .ToString()
• Format codes may be used to dictate the way values are rendered.
Agilent .NET Course: C# Basics 7

2.7.1 Examples of output of the DateTime
Using the DateTime: 2 March 2004 05:06
{0:%d} 2
{0:dd} 02
{0:ddd} Tue
{0:dddd} Tuesday
{0:%m} 6
{0:mm} 06
{0:%M} 3
{0:MM} 03
{0:MMM} Mar
{0:MMMM} March
2.7.2 Help is available with the following headings
The standard and custom fpormats are explained in greater details in the help system.
They can be difficult to track down.
• Standard numeric format strings
• Custom numeric format strings
• Standard DateTime format strings
• Custom DateTime format strings
Introduction to .NET
Agilent .NET Course: C# Basics 8

2.8 Statements
The language C# includes statements for iteration and selection.
The for statement has three components in addition to the body.
Commonly the control variable in a for loop is declared as local to the loop.
A for loop – table of squares
for (int i = 1; i

2.9 StreamReader
The StreamReader class allows us to access data from files.
Useful methods of StreamReader:
• ReadLine() returns one line as a string
• Read() returns the ASCII for the next character and consumes it.
• Peek() returns the ASCII for the next character without consuming it.
When we hit the end of file Peek() returns –1 – this is useful to control a while loop
(although not as useful as EOF would have been).
A while loop to print the first non-space character of every line
System.IO.StreamReader fh =
new System.IO.StreamReader(@"..\..\Form1.cs");
while (fh.Peek() != -1)
{
string ln = fh.ReadLine().TrimStart();
if (ln.Length>0)
Console.WriteLine(ln[0]);
}
MessageBox.Show("Done!");
Notes:
• StreamReader is in the System.IO namespace
• ln.Length returns the length of a string
• ln[0] gives the first character of the string ln. We get a run time error if the
string is too short.
Introduction to .NET
Agilent .NET Course: C# Basics 10

2.10 Boxes tutorial
duction to .NET
Intro
Horizontal Stripes
private void HorizStripes_Click(object sender, System.EventArgs e)
{
for (int i=0;i

2.11 CIA tutorial (1)
In this tutorial we read the file ciaFixedWidth.txt
This file lists all coutries of the world, it gives their name, the region, the area in
km 2 , the population and the GDP in US dollars.
The strings name and region are in 50 characters each. The three numbers, area,
population and gdp are in 20 characters each.
Character positions…
0 50 100 120 140
Afghanistan Asia 647500 21251821 18100000000
Algeria Africa 2381740 28539321 97100000000
The first button includes code to read a single line of the file.
For the following questions we suggest that you read the entire file for each question.
Each of the further buttons is should report the answer as a message box:
duction to .NET
Intro
1 Find France – show all the details of France
2 Count countries – return the total number of countries in the file (this is same
as the number of lines)
3 Total population – calculate the total poulation of the world.
4 Total gdp – calculate the total gdp of the world.
5 Country with longest name – identify the country with the longest name.
6 Area of Africa – calculate the total area of all countries in Africa.
7 Country 42 – identify the country on line 42 of the file (Afganistan is 1).
8 Count the number of European countries with a per‐capita gdp more than that
of ʺUnited Kingdomʺ (per capital gdp is gdp/population).
Further questions need HashTables or other structures to be completed:
9 Population by region – show the total population for each region. You will
need to use a HashTable to do this.
10 List the countries with a gdp greater than the total gdp of Africa.
11 List the regions with a total population of more than 100 million.
12 Find the region(s) in which all countries have a population of less than 1 million.
13 A country has a population more than three times that of any of its neigbours
(in the same region). Find it (or them).
Agilent .NET Course: C# Basics 12

Name:
Course: Introduction to .NET
Title: Arrays and Collections
Instructor: Bill Buchanan
.NET

3 Arrays and Collections
3.1 Introduction
This module covers the key elements of arrays, indexers and collections. It covers:
• Arrays.
• Reading from CSV files.
• System.Collections.
• ArrayLists.
• HashTables.
3.2 Arrays
Simple variables, such as int, float, double and string only hold a single element.
This is fine when we have only a few things to store, but it is difficult to process data
elements in a sequential way. Thus, programming languages support arrays which
allow more than one element to be stored under a common name, which allows the
elements to be indexed.
In C# an array is created from an object of type System.Array, as illustrated in
Figure 3.1. The main methods are:
duction to .NET
Intro
BinarySearch()
Clear()
Clone()
Copy()
CopyTo()
CreateInstance()
GetLength()
IndexOf()
Initialize()
LastIndexOf()
Reverse()
SetValue()
Sort()
Performs a binary on a one‐dimensional array
Sets a range of elements to zero, False or NULL.
Make a shallow copy of the array.
Copies a range of values in an array.
Copies one array to another.
Create a multidimensional array.
Return the number of elements in the array.
Search for an object, and return the first index value of its place.
Set all the elements in the array to their default value.
Returns the last object in the array.
Reverses the array.
Sets a specific array element to a value.
Performs a sort on the array.
Agilent .NET Course: Arrays and Collections 2

and main properties are:
IsFixedSize
IsReadOnly
Length
Identifies if the array is a fixed size (get only)
Identifies if the array is read‐only (get only)
Identifies the length of the array (get only)
Figure 3.1: System.Array
C# contains the methods of the System.Array object. It also inherits the syntax of C
for representing an array index, which uses square brackets to identify the element,
such as:
duction to .NET
Intro
myArray[15];
for the element number 15. Note that C# starts its indexing at 0, thus myArray[15] is
the 16th element of the array. To declare an array:
type[] arrayName;
For example to declare an array of doubles:
double[] inputValues;
This declares the type of the array. To then to initialize it the following is used:
Agilent .NET Course: Arrays and Collections 3

inputValues = new double[5];
which creates a new array with 5 elements (0 to 4).
In Program 3.1 an array with 5 elements is created, after which the getValues()
method is used to get these values from the user, after which the average() method
is used to determine the average of the values. The v.Length property is used to determine
the size of the array.
Program 3.1: Program3_1_ArrayCalcAverage
using System;
namespace ConsoleApplication2
{
class ArrayExample01
{
static void getValues(double[] v)
{
int i;
}
for (i=0;i 1
Value >> 2
Value >> 3
Value >> 4
Value >> 5
Average is 3
Agilent .NET Course: Arrays and Collections 4

Note that the declaration of the array type does not actually create the array, and the
line:
double[] inputValues;
double av
av=inputValues[0];
will cause a build error of:
Use of unassigned local variable 'inputValues'
As the array can not been created yet, and just contains a null value.
3.2.1 Initializing arrays
The arrays when they are initialized are set to a default value, such as zero for numeric
data types, and null for strings. To initialise it with actual values, the required
values are contained within curly brackets, such as:
int i[] = {10,20,30,40,50}; // First element i[0], Last element i[4]
double[] vals = {1.2,1.4,1.6,1.8,2.0};
string[] menuItems = {"File", "Edit", "View", "Insert", "Tool", "Table"};
This performs both the declaration of the array and its initialization. Program 3.2
shows an example of the declaration of an array of strings.
Program 3.2: Program3_2_ArrayInitializationStrings
using System;
duction to .NET
Intro
namespace ConsoleApplication2
{
class ArrayExample01
{
static void Main(string[] args)
{
int i;
}
}
string[] ColourBands={"BLACK","BROWN","RED","ORANGE","YELLOW","GREEN"};
for (i=0;i

4 is YELLOW
5 is GREEN
Program 3.3 uses an array of doubles which are initialized with certain values. It
then uses a findSmallest() method to determine the lowest value. In this case the
array (vals) is declared with seven elements (0 to 6).
Program 3.3: Program3_3_ArrayInitializationNumeric
using System;
namespace ConsoleApplication2
{
class ArrayExample01
{
static double findSmallest(double[] v)
{
double smallest;
smallest=v[0];
for (int i=1; i

is replaced by (Program3_3_ArrayInitializationNumericForEach):
foreach (string band in ColourBands)
System.Console.WriteLine("{0}",band);
For the example in Program 3.2 we can replace:
for (int i=1; i

3.3 Reading from a CSV file
One of the best ways to transfer information between applications is to save the data
separated by commas. This format is known as CSV (Comma Separated Variables).
An example format is:
1,5,6,7,4,5,6,7,10,5,4,3,2,1
For this we can read the file one line at a time, and then split the string using the
Split() method. This can be contained with the foreach statement, to parse each part
of the split text. The code which fills the array v is:
do
{
text=reader.ReadLine();
if (text==null) break;
foreach (string substring in text.Split(','))
{
v[i]=Convert.ToDouble(substring);
i++;
}
} while (text != null);
Program 3.5 shows the complete code to read the data from the CSV file (using the
fillData()), and display it to the screen (using the showData() method).
Program 3.5: Program3_5_ArrayGenerateDataWithCSV
using System;
using System.IO;
duction to .NET
Intro
namespace ConsoleApplication2
{
class ArrayExample02
{
const int ARRAYLIMIT=100;
static void fillData(double[] v)
{
int i=0;
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
StreamReader reader = theSourceFile.OpenText();
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
foreach (string substring in text.Split(','))
{
v[i]=Convert.ToDouble(substring);
i++;
}
} while (text != null);
Agilent .NET Course: Arrays and Collections 8

}
reader.Close();
static void showData(double[] v)
{
int i;
}
for (i=0;i

ow. This is similar to a spreadsheet where the row is represented by a line, and the
columns are delimited by commas. For example:
Fred,20
Bert,10
Colin,15
Berty,26
Freddy,22
We can then modify the reading method to parse the input line from
the CSV file:
do
{
text=reader.ReadLine();
if (text==null) break;
string[] str =text.Split(',');
name[i]=str[0];
age[i]=Convert.ToInt32(str[1]);
i++;
} while (text != null);
The complete listing is given in Program 3.6.
Program 3.6: Program3_6_ArrayGenerateDataWithCSVParse
using System;
using System.IO;
namespace ConsoleApplication2
{
class ArrayExample02
{
const int ARRAYSIZE=100;
static void fillData(string[] name, int[] age)
{
int i=0;
duction to .NET
Intro
}
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
StreamReader reader = theSourceFile.OpenText();
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
string[] str =text.Split(',');
name[i]=str[0];
age[i]=Convert.ToInt32(str[1]);
i++;
} while (text != null);
reader.Close();
Agilent .NET Course: Arrays and Collections 10

static void showData(string[] names, int[] age)
{
int i;
}
for (i=0;i

• System.Runtime.Serialization • System.Security
• System.Runtime.Serialization.Formatters • System.Security.Cryptography
An important namespace is System.Collections which includes the following:
System.Collections
ArrayList
BitArray
CaseInsensitiveComparer
CaseInsensitiveHashCodeProvider
CollectionBase
Comparer
DictionaryBase
DictionaryEntry
Hashtable
Queue
ReadOnlyCollectionBase
SortedList
Stack
3.5 ArrayLists
As we have seen, the basic array declaration is rather limited in the methods that
can be applied to it. The ArrayList improves this greatly by creating an array object
that has many methods, such searching, deletion and insertion. Its main methods
include:
duction to .NET
Intro
Add(object)
Add an object to the end of an ArrayList.
ArrayList(int)
Initializes a new ArrayList with a given capacity.
ArrayList()
Initializes a new ArrayList with a default capacity.
BinarySearch(object)
Searches for a given object in an ArrayList.
Clear() Removes all elements from the System.Collections.ArrayList.
Clone()
Creates a shallow copy of an ArrayList.
Contains(object)
Determines if an object is in an ArrayList.
CopyTo(int,System.Array,int,int) Copies a range of elements from an ArrayList into a
one‐dimensional array, from a starting and ending
index value.
CopyTo(System.Array,int)
Copies a range of elements from an ArrayList into a
one‐dimensional array, from a starting and ending
index value.
CopyTo(System.Array)
Copies the entire ArrayList into a one‐dimensioanl
array.
Agilent .NET Course: Arrays and Collections 12

GetEnumerator(int,int)
GetEnumerator()
GetRange(int,int)
IndexOf(object,int,int)
IndexOf(object,int)
IndexOf(object)
Insert(int,object)
LastIndexOf(object,int,int)
LastIndexOf(object,int)
LastIndexOf(object)
Remove(object)
RemoveAt(int)
RemoveRange(int,int)
Repeat(object,int)
Reverse(int,int)
Reverse()
Sort()
ToArray(System.Type)
ToArray()
TrimToSize()
Returns an enumerator for a range within the Array‐
List.
Returns an enumerator for the entire ArrayList.
Gets an ArrayList for a range within an ArrayList
Returns the index value of an object within a given
index range, and contains a specific number of occurrences.
Returns the index value of an object from a given
starting point
Returns the index value of an object
Inserts an object at a given index value.
Returns the last index value of an object
Returns the last index value of an object
Returns the last index value of an object
Remove the first occurrence of an object.
Remove object at a certain index value.
Remove a range of objects.
Repeat a number of objects.
Reverse objects within a given range.
Reverse all the objects.
Sort the ArrayList.
Copies elements from ArrayList to a new array of a
given type.
Copies elements from ArrayList to a new array.
Set the capacity of the ArrayList.
And the properties for ArrayList are:
duction to .NET
Intro
Capacity
Count
IsFixedSize
IsReadOnly
Specifies the number of elements the ArrayList can
have (set/get).
Returns the number of elements in the ArrayList (get).
Returns whether the ArrayList has a fixed size (get).
Returns whether the ArrayList is read‐only (get).
Program 3.6 shows an enhancement to Program 3.5, but uses ArrayLists instead of
an array. For this uses the Add() to add a new element to the ArrayList. The Count
property thus correctly contains the number of elements added to the ArrayList.
Program 3.7: Program3_7_ArrayListGenerateDataWithCSV
namespace ConsoleApplication2
{
using System;
using System.Collections; // required for ArrayList
using System.IO; // required for File I/O
Agilent .NET Course: Arrays and Collections 13

class ArrayExample02
{
static void fillData(ArrayList v)
{
int i=0;
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
StreamReader reader = theSourceFile.OpenText();
}
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
foreach (string substring in text.Split(','))
{
v.Add(Convert.ToDouble(substring));
i++;
}
} while (text != null);
reader.Close();
static void showData(ArrayList v)
{
int i;
for (i=0;i

Program 3.8: Program3_8_ArrayListGenerateDataWithCSVFindAverage
namespace ConsoleApplication2
{
using System;
using System.Collections; // required for ArrayList
using System.IO; // required for File I/O
class ArrayExample02
{
static void fillData(ArrayList v)
{
int i=0;
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
StreamReader reader = theSourceFile.OpenText();
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
foreach (string substring in text.Split(','))
{
v.Add(Convert.ToDouble(substring));
i++;
}
} while (text != null);
}
reader.Close();
static void showData(ArrayList v)
{
int i;
for (i=0;i

Sample Run 3.8
Average is 4.71428571428571
The ArrayList is contains many more methods than for arrays. An important
method is sort(), which allows an ArrayList to be sorted. Program 3.9 shows an example
of using this method, and the same run shows a run with the CSV file of:
Smith,Fred
Bell,Bert
McDonald,Rory
Mitchel,Brian
Barr,Martin
Kinlock,Graham
Program 3.9: Program3_9_ArrayListGenerateDataWithCSVOrderedList
namespace ConsoleApplication2
{
using System;
using System.Collections; // required for ArrayList
using System.IO; // required for File I/O
class ArrayExample02
{
static void fillData(ArrayList v)
{
int i=0;
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
StreamReader reader = theSourceFile.OpenText();
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
v.Add(text);
} while (text != null);
duction to .NET
Intro
}
reader.Close();
static void showData(ArrayList v)
{
int i;
}
for (i=0;i

}
}
}
Vals.Sort();
showData(Vals);
System.Console.ReadLine();
Sample Run 3.8
0 Smith,Fred
1 Bell,Bert
2 McDonald,Rory
3 Mitchel,Brian
4 Barr,Martin
5 Kinlock,Graha
0 Barr,Martin
1 Bell,Bert
2 Kinlock,Graha
3 McDonald,Rory
4 Mitchel,Brian
5 Smith,Fred
3.6 HashTables
HashTables represents a collection of key‐and‐value pairs that are organized based
on the hash code of the key. They are particularly useful for fast retrieval of data
from a list. They are basically dictionaries of data. The main methods are:
duction to .NET
Intro
Add(object,object)
Clear()
Clone()
Contains(object)
ContainsValue(object)
CopyTo(System.Array,int)
GetEnumerator()
GetHash(object)
Hashtable(int)
Hashtable()
KeyEquals(object,object)
Remove(object)
And the main properties are:
Count
Adds elements with a specified key and value into the
Hashtable.
Removes the elements in Hashtable.
Creates a shallow copy of the Hashtable.
Determines whether the Hashtable contains a certain key.
Determines whether the Hashtable contains a certain value.
Copies a parts of a Hashtable to a one‐dimensional Array
instance.
Returns an enumerator value that can iterate through the
Hashtable.
Returns the hash code for the specified key.
Create a empty Hashtable.
Creates an empty Hashtable.
Compares an object with the key.
Removes the element with the specified key from the
Hashtable.
Gets the number of key‐pairs in the HashTable.
Agilent .NET Course: Arrays and Collections 17

Key
IsFixedSize
IsReadOnly
Value
Gets the keys of the HashTable.
Get whether the HashTable is fixed size.
Determines whether the HashTable is read‐only.
Get the values of the HashTable.
The Hashtable uses a similar technique to add data to its list (with the Add()
method). Once the table has been filled, the keys from the table can be generated
from (using a Hashtable of v):
ICollection keys = v.Keys;
And the values in the list by:
ICollection values = v.Values;
Program 3.10 shows an example of a Hashtable. The same run uses the following
data:
00001,Smith
00010,Bell
00033,McDonald
44444,Mitchel
55555,Martin
43251,Kinlock
Program 3.10: Program3_10_HashTableSimple
namespace ConsoleApplication2
{
using System;
using System.Collections; // required for HashTable
using System.IO; // required for File I/O
duction to .NET
Intro
class ArrayExample02
{
static void fillData(Hashtable v)
{
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
}
StreamReader reader = theSourceFile.OpenText();
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
string[] str = text.Split(',');
v.Add(str[0],str[1]);
} while (text != null);
reader.Close();
static void showData(Hashtable v)
Agilent .NET Course: Arrays and Collections 18

{
int i;
ICollection keys = v.Keys;
ICollection values = v.Values;
System.Console.WriteLine("Keys are: ");
foreach (string key in keys)
Console.WriteLine("{0}",key);
System.Console.WriteLine("Values are: ");
foreach (string val in values)
Console.WriteLine("{0}",val);
}
static void Main(string[] args)
{
Hashtable Vals = new Hashtable();
}
}
}
fillData(Vals);
showData(Vals);
System.Console.ReadLine();
duction to .NET
Intro
Sample Run 3.10
Keys are:
00001
00010
00033
44444
55555
43251
Values are:
Smith
Bell
McDonald
Mitchel
Martin
Kinlock
It is possible to browse through the dictionary by creating an enumerator (using the
GetEnumerator() method). This creates a list of references to the elements in the
hashtable. This is achieved with the following (for a hashtable of v):
System.Collections.IDictionaryEnumerator enumerator = v.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine("{0} {1}",enumerator.Key, enumerator.Value);
}
A complete program is shown in Program 3.11.
Agilent .NET Course: Arrays and Collections 19

Program 3.11: Program3_11_HashTableSimpleEnumerator
namespace ConsoleApplication2
{
using System;
using System.Collections; // required for HashTable
using System.IO; // required for File I/O
class ArrayExample02
{
static void fillData(Hashtable v)
{
FileInfo theSourceFile = new FileInfo("..\\..\\test.csv");
StreamReader reader = theSourceFile.OpenText();
string text;
do
{
text=reader.ReadLine();
if (text==null) break;
string[] str = text.Split(',');
v.Add(str[0],str[1]);
} while (text != null);
}
reader.Close();
static void showData(Hashtable v)
{
System.Collections.IDictionaryEnumerator enumerator = v.GetEnumerator();
}
while (enumerator.MoveNext())
{
Console.WriteLine("{0} {1}",enumerator.Key, enumerator.Value);
}
static void Main(string[] args)
{
Hashtable Vals = new Hashtable();
duction to .NET
Intro
}
}
fillData(Vals);
showData(Vals);
System.Console.ReadLine();
}
Sample Run 3.11
00001 Smith
00010 Bell
00033 McDonald
44444 Mitchel
55555 Martin
43251 Kinlock
Agilent .NET Course: Arrays and Collections 20

Name:
Course: Introduction to .NET
Title: Types and Debugging
Instructor: Bill Buchanan
.NET

4 Types and Debugging
4.1 Introduction
This module covers the key elements of arrays, indexers and collections. It covers:
• Reference types.
• Common reference type.
• Namespaces and object hierarchy.
• Debugging.
4.2 Reference Types
Parameters are passed into function member, such as methods or properties,
either using a value or a reference. If a value is passed, only the contents of
the value are used, thus it cannot be modified. It a reference it passed, the
function member can modify the value. A value passed by reference uses the
ref keyword, such as:
swap(ref int a, ref int b)
duction to .NET
Intro
4.2.1 Passing Value-Type Parameters
This is the simplest case, where a copy of the value of the data is passed. Thus an
changes to the parameters will be lost. For example in Figure 4.1 the value of val1 is
passed in x. This is then modified in the method to give the square of the value.
When it returns from the method, it can be seen from the sample run that the value
of val1 has not change (as it remains at 10).
Program 4.1: Program4_1_PassingByValue
using System;
namespace ConsoleApplication2
{
class Class1
{
static double findSquare(double x)
{
Agilent .NET Course: Type and Debugging 2

}
x *= x;
System.Console.WriteLine("Value in the method is {0}",x);
return(x);
static void Main(string[] args)
{
double val1,val2;
val1=10;
}
}
}
val2=findSquare(val1);
System.Console.WriteLine("Value now is {0}",val1);
System.Console.ReadLine();
Sample Run Error! Reference source not found.
Value in the method is 100
Value now is 10
4.2.2 Passing by reference
It is possible to pass a reference of a parameter, so that the parameter is changed by
the method. For this the ref keyword is inserted before the variable that is passed. It
can be see from the test run of Program 4.2 that the actual value of the parameter
can now be changed by the method.
Program 4.2: Program4_2_PassingByReference
using System;
namespace ConsoleApplication2
{
class Class1
{
duction to .NET
Intro
static double findSquare(ref double x)
{
x *= x;
System.Console.WriteLine("Value in the method is {0}",x);
return(x);
}
static void Main(string[] args)
{
double val1,val2;
}
val1=10;
val2=findSquare(ref val1);
System.Console.WriteLine("Value now is {0}",val1);
System.Console.ReadLine();
Agilent .NET Course: Type and Debugging 3

}
}
Sample Run Error! Reference source not found.
Value in the method is 100
Value now is 100
Array values are always passed by reference, thus there contents are changed if the
method changes them. For example in Program 4.3. the clampArray() method scans
an array, and if the value is greater than a certain value, the value is clamped. As
can be seen from the sample run some of the values in the array have been changed
by the method.
Program 4.3: Program4_3_PassingArrays
namespace ConsoleApplication2
{
class Class1
{
static void clampArray(double[] x, int c)
{
for (int i=0;iclamp) x[i]=c;
}
static void Main(string[] args)
{
double[] vals={0,1,2,3,4,5,6};
int clamp=3,i;
clampArray(vals,clamp);
duction to .NET
}
}
}
for (i=0;i

4.3 Common reference types
The common type system allows either value or reference types. A value contains
the normal data type declarations. Reference types relate to value’s actual memory
address, which is allocated on the heap. An example of reference types is an array
which is allocated as a pointer to the array elements. Referenced values can be used
to provide a reference for other variables, where a change in one while be reflected
in the other.
Program 4.4: Program4_3_PassingArrays
using System;
namespace ConsoleApplication2
{
class Test1
{
public int Value = 0;
}
class Class1
{
static void Main()
{
int val1 = 0;
int val2 = val1;
val1 = 99;
Test1 ref1 = new Test1();
Test1 ref2 = ref1;
ref2.Value = 123;
duction to .NET
Intro
Console.WriteLine("Values: {0}, {1}", val1, val2);
Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
Console.ReadLine();
}
}
}
Sample Run Error! Reference source not found.
Values: 99, 0
Refs: 123, 123
For example in the following code, arr2 is a reference to arr1. Thus if we change any
of the elements in arr1, the same change will be reflected in arr2.
double [] arr1={0,1,2,3};
double [] arr2=arr1;
arr1[0]=5;
Agilent .NET Course: Type and Debugging 5

Thus the result of this is that arr2[0] will be changed to 5.
4.4 Namespaces and Object Hierarchy
The .NET Framework supports a class library structure which has a number of
namespaces. These include:
• Microsoft.CSharp. These are the classes that relate to C#
• Microsoft.VisualBasic. These are the classes that relate to Visual Basic.
The System namespace contains all the fundamental classes that are commonly used
in programs, and include:
• Array.
• Buffer.
• Console.
• Convert.
• Enum.
• Math.
• String.
The complete object hierarchy is given in Appendix A. Some examples are:
duction to .NET
Intro
System.Object
Microsoft.CSharp.Compiler
Microsoft.CSharp.CompilerError
Microsoft.Win32.Registry
Microsoft.Win32.SystemEvents
System.Activator
System.AppDomainSetup
System.Array
System.Attribute
System.BitConverter
System.Buffer
System.IO.BinaryReader
System.IO.BinaryWriter
System.IO.Directory
System.IO.File
System.IO.Path
System.Collections.ArrayList
System.Collections.BitArray
System.Collections.CaseInsensitiveComparer
System.Collections.CaseInsensitiveHashCodeProvider
Agilent .NET Course: Type and Debugging 6

System.Collections.CollectionBase
System.Collections.Comparer
System.Collections.DictionaryBase
System.Collections.Hashtable
System.Collections.Queue
System.Net.AuthenticationManager
System.Net.Authorization
System.Net.Cookie
System.Net.CookieCollection
System.Net.CookieContainer
System.Net.CredentialCache
System.Net.Dns
System.Net.EndPoint
System.Net.EndpointPermission
System.Net.GlobalProxySelection
System.String
4.5 Debugging
There are normally two ways to debug a program:
• Human output. This is where extra debug information is outputted when the
program is run.
• Using the debugger. This is where the program can be stepped‐though, and the
variables in the program examined.
The main elements of the debugger are:
duction to .NET
Intro
• Watch window. This is opened when the debugger is running and is selected
from Debug ‐> Windows‐>Watch, and then clicking on Watch1, Watch2, Watch3,
or Watch4.
• QuickWatch dialog box. This is used when the debugger is in a break state, and
enables variables to be viewed.
• Memory Window. This is viewing when debugging, and is selected from Debug‐>
Windows, and then clicking on Memory, and choose Memory 1, Memory
2, Memory 3, or Memory 4.
The F11 key is used to step through the program, where the debugger goes into each
method, whereas the F10 key steps over methods. A break point is added with the
Ctrl‐B keystroke. Examples of a debugging process is shown next:
Agilent .NET Course: Type and Debugging 7

4.6 Converting data types
The System.Convert class has many methods including:
duction to .NET
Intro
• ToBoolean()
• ToByte()
• ToChar()
• ToDateTime()
• ToDouble()
• ToInt16()
• ToInt32()
4.7 Appendix A
System.Object
Microsoft.CSharp.Compiler
Microsoft.CSharp.CompilerError
Microsoft.Win32.Registry
Microsoft.Win32.SystemEvents
System.Activator
System.AppDomainSetup
System.Array
System.Attribute
System.BitConverter
Agilent .NET Course: Type and Debugging 8

duction to .NET
Intro
System.Buffer
System.CharEnumerator
System.CodeDom.CodeAttributeArgument
System.CodeDom.CodeAttributeDeclaration
System.CodeDom.CodeCatchClause
System.CodeDom.CodeLinePragma
System.CodeDom.CodeNamespaceImportCollection
System.CodeDom.CodeObject
System.CodeDom.Compiler.CodeGenerator
System.CodeDom.Compiler.CodeGeneratorOptions
System.CodeDom.Compiler.CodeParser
System.CodeDom.Compiler.CompilerError
System.CodeDom.Compiler.CompilerParameters
System.CodeDom.Compiler.CompilerResults
System.CodeDom.Compiler.Executor
System.CodeDom.Compiler.TempFileCollection
System.Collections.ArrayList
System.Collections.BitArray
System.Collections.CaseInsensitiveComparer
System.Collections.CaseInsensitiveHashCodeProvider
System.Collections.CollectionBase
System.Collections.Comparer
System.Collections.DictionaryBase
System.Collections.Hashtable
System.Collections.Queue
System.Collections.ReadOnlyCollectionBase
System.Collections.SortedList
System.Collections.Specialized.CollectionsUtil
System.Collections.Specialized.HybridDictionary
System.Collections.Specialized.ListDictionary
System.Collections.Specialized.NameObjectCollectionBase
System.Collections.Specialized.NameObjectCollectionBase.KeysCollection
System.Collections.Specialized.StringCollection
System.Collections.Specialized.StringDictionary
System.Collections.Specialized.StringEnumerator
System.Collections.Stack
System.ComponentModel.AttributeCollection
System.ComponentModel.ComponentEditor
System.ComponentModel.Container
System.ComponentModel.Design.CommandID
System.ComponentModel.Design.ComponentDesigner
System.ComponentModel.Design.ComponentDesigner.ShadowPropertyCollection
System.ComponentModel.Design.DesignerCollection
System.ComponentModel.Design.DesignerTransaction
System.ComponentModel.Design.DesigntimeLicenseContextSerializer
System.ComponentModel.Design.LocalizationExtenderProvider
System.ComponentModel.Design.MenuCommand
System.ComponentModel.Design.Serialization.CodeDomSerializer
System.ComponentModel.Design.Serialization.ContextStack
System.ComponentModel.Design.Serialization.DesignerLoader
System.ComponentModel.Design.Serialization.InstanceDescriptor
System.ComponentModel.Design.ServiceContainer
System.ComponentModel.Design.StandardCommands
System.ComponentModel.Design.StandardToolWindows
System.ComponentModel.EventDescriptorCollection
Agilent .NET Course: Type and Debugging 9

duction to .NET
Intro
System.ComponentModel.EventHandlerList
System.ComponentModel.License
System.ComponentModel.LicenseContext
System.ComponentModel.LicenseManager
System.ComponentModel.LicenseProvider
System.ComponentModel.MarshalByValueComponent
System.ComponentModel.MemberDescriptor
System.ComponentModel.PropertyDescriptorCollection
System.ComponentModel.TypeConverter
System.ComponentModel.TypeConverter.StandardValuesCollection
System.ComponentModel.TypeDescriptor
System.Configuration.AppSettingsReader
System.Configuration.ConfigurationSettings
System.Configuration.DictionarySectionHandler
System.Configuration.IgnoreSectionHandler
System.Configuration.Install.InstallContext
System.Configuration.NameValueSectionHandler
System.Configuration.SingleTagSectionHandler
System.Console
System.Convert
System.Data.Common.DbDataRecord
System.Data.Common.DbEnumerator
System.Data.Constraint
System.Data.DataRelation
System.Data.DataRow
System.Data.DataRowView
System.Data.DataViewSetting
System.Data.DataViewSettingCollection
System.Data.InternalDataCollectionBase
System.Data.Odbc.OdbcError
System.Data.Odbc.OdbcErrorCollection
System.Data.OleDb.OleDbError
System.Data.OleDb.OleDbErrorCollection
System.Data.OleDb.OleDbSchemaGuid
System.Data.SqlClient.SqlError
System.Data.SqlClient.SqlErrorCollection
System.Data.SqlServerCe.SqlCeError
System.Data.SqlServerCe.SqlCeErrorCollection
System.Data.TypedDataSetGenerator
System.DBNull
System.Delegate
System.Diagnostics.CounterCreationData
System.Diagnostics.CounterSampleCalculator
System.Diagnostics.Debug
System.Diagnostics.Debugger
System.Diagnostics.EventLogEntryCollection
System.Diagnostics.EventLogPermissionEntry
System.Diagnostics.FileVersionInfo
System.Diagnostics.InstanceData
System.Diagnostics.PerformanceCounterCategory
System.Diagnostics.PerformanceCounterPermissionEntry
System.Diagnostics.ProcessStartInfo
System.Diagnostics.StackFrame
System.Diagnostics.StackTrace
System.Diagnostics.Switch
Agilent .NET Course: Type and Debugging 10

duction to .NET
Intro
System.Diagnostics.SymbolStore.SymDocumentType
System.Diagnostics.SymbolStore.SymLanguageType
System.Diagnostics.SymbolStore.SymLanguageVendor
System.Diagnostics.Trace
System.Diagnostics.TraceListenerCollection
System.DirectoryServices.DirectoryEntries
System.DirectoryServices.DirectoryServicesPermissionEntry
System.DirectoryServices.PropertyCollection
System.DirectoryServices.SchemaNameCollection
System.DirectoryServices.SearchResult
System.DirectoryServices.SortOption
System.Drawing.Brushes
System.Drawing.ColorTranslator
System.Drawing.Design.PropertyValueUIItem
System.Drawing.Design.ToolboxItem
System.Drawing.Design.UITypeEditor
System.Drawing.Drawing2D.Blend
System.Drawing.Drawing2D.ColorBlend
System.Drawing.Drawing2D.PathData
System.Drawing.Drawing2D.RegionData
System.Drawing.ImageAnimator
System.Drawing.Imaging.BitmapData
System.Drawing.Imaging.ColorMap
System.Drawing.Imaging.ColorMatrix
System.Drawing.Imaging.ColorPalette
System.Drawing.Imaging.Encoder
System.Drawing.Imaging.EncoderParameter
System.Drawing.Imaging.EncoderParameters
System.Drawing.Imaging.FrameDimension
System.Drawing.Imaging.ImageAttributes
System.Drawing.Imaging.ImageCodecInfo
System.Drawing.Imaging.ImageFormat
System.Drawing.Imaging.MetafileHeader
System.Drawing.Imaging.MetaHeader
System.Drawing.Imaging.PropertyItem
System.Drawing.Imaging.WmfPlaceableFileHeader
System.Drawing.Pens
System.Drawing.Printing.Margins
System.Drawing.Printing.PageSettings
System.Drawing.Printing.PaperSize
System.Drawing.Printing.PaperSource
System.Drawing.Printing.PreviewPageInfo
System.Drawing.Printing.PrintController
System.Drawing.Printing.PrinterResolution
System.Drawing.Printing.PrinterSettings
System.Drawing.Printing.PrinterSettings.PaperSizeCollection
System.Drawing.Printing.PrinterSettings.PaperSourceCollection
System.Drawing.Printing.PrinterSettings.PrinterResolutionCollection
System.Drawing.Printing.PrinterUnitConvert
System.Drawing.SystemBrushes
System.Drawing.SystemColors
System.Drawing.SystemIcons
System.Drawing.SystemPens
System.Drawing.Text.FontCollection
System.EnterpriseServices.Activity
Agilent .NET Course: Type and Debugging 11

duction to .NET
Intro
System.EnterpriseServices.BYOT
System.EnterpriseServices.CompensatingResourceManager.Clerk
System.EnterpriseServices.CompensatingResourceManager.ClerkInfo
System.EnterpriseServices.CompensatingResourceManager.ClerkMonitor
System.EnterpriseServices.CompensatingResourceManager.LogRecord
System.EnterpriseServices.ContextUtil
System.EnterpriseServices.Internal.AppDomainHelper
System.EnterpriseServices.Internal.ClrObjectFactory
System.EnterpriseServices.Internal.ComManagedImportUtil
System.EnterpriseServices.Internal.Publish
System.EnterpriseServices.Internal.SoapClientImport
System.EnterpriseServices.Internal.SoapServerTlb
System.EnterpriseServices.Internal.SoapServerVRoot
System.EnterpriseServices.Internal.SoapUtility
System.EnterpriseServices.RegistrationConfig
System.EnterpriseServices.RegistrationErrorInfo
System.EnterpriseServices.ResourcePool
System.EnterpriseServices.SecurityCallContext
System.EnterpriseServices.SecurityCallers
System.EnterpriseServices.SecurityIdentity
System.EnterpriseServices.ServiceConfig
System.EnterpriseServices.ServiceDomain
System.EnterpriseServices.SharedProperty
System.EnterpriseServices.SharedPropertyGroup
System.EnterpriseServices.SharedPropertyGroupManager
System.Environment
System.EventArgs
System.Exception
System.GC
System.Globalization.Calendar
System.Globalization.CompareInfo
System.Globalization.CultureInfo
System.Globalization.DateTimeFormatInfo
System.Globalization.DaylightTime
System.Globalization.NumberFormatInfo
System.Globalization.RegionInfo
System.Globalization.SortKey
System.Globalization.StringInfo
System.Globalization.TextElementEnumerator
System.Globalization.TextInfo
System.IO.BinaryReader
System.IO.BinaryWriter
System.IO.Directory
System.IO.File
System.IO.Path
System.LocalDataStoreSlot
System.Management.Instrumentation.BaseEvent
System.Management.Instrumentation.Instance
System.Management.Instrumentation.Instrumentation
System.Management.ManagementDateTimeConverter
System.Management.ManagementObjectCollection
System.Management.ManagementObjectCollection.ManagementObjectEnumerator
System.Management.ManagementOperationObserver
System.Management.ManagementOptions
System.Management.ManagementPath
Agilent .NET Course: Type and Debugging 12

duction to .NET
Intro
System.Management.ManagementQuery
System.Management.ManagementScope
System.Management.MethodData
System.Management.MethodDataCollection
System.Management.MethodDataCollection.MethodDataEnumerator
System.Management.PropertyData
System.Management.PropertyDataCollection
System.Management.PropertyDataCollection.PropertyDataEnumerator
System.Management.QualifierData
System.Management.QualifierDataCollection
System.Management.QualifierDataCollection.QualifierDataEnumerator
System.MarshalByRefObject
System.Math
System.Messaging.AccessControlEntry
System.Messaging.ActiveXMessageFormatter
System.Messaging.BinaryMessageFormatter
System.Messaging.DefaultPropertiesToSend
System.Messaging.MessagePropertyFilter
System.Messaging.MessageQueueCriteria
System.Messaging.MessageQueuePermissionEntry
System.Messaging.MessageQueueTransaction
System.Messaging.Trustee
System.Messaging.XmlMessageFormatter
System.Net.AuthenticationManager
System.Net.Authorization
System.Net.Cookie
System.Net.CookieCollection
System.Net.CookieContainer
System.Net.CredentialCache
System.Net.Dns
System.Net.EndPoint
System.Net.EndpointPermission
System.Net.GlobalProxySelection
System.Net.HttpVersion
System.Net.IPAddress
System.Net.IPHostEntry
System.Net.NetworkCredential
System.Net.ServicePoint
System.Net.ServicePointManager
System.Net.SocketAddress
System.Net.Sockets.IPv6MulticastOption
System.Net.Sockets.IrDAClient
System.Net.Sockets.IrDADeviceInfo
System.Net.Sockets.IrDAListener
System.Net.Sockets.LingerOption
System.Net.Sockets.MulticastOption
System.Net.Sockets.Socket
System.Net.Sockets.TcpClient
System.Net.Sockets.TcpListener
System.Net.Sockets.UdpClient
System.Net.WebProxy
System.OperatingSystem
System.Random
System.Reflection.Assembly
System.Reflection.AssemblyName
Agilent .NET Course: Type and Debugging 13

duction to .NET
Intro
System.Reflection.Binder
System.Reflection.Emit.CustomAttributeBuilder
System.Reflection.Emit.EventBuilder
System.Reflection.Emit.ILGenerator
System.Reflection.Emit.LocalBuilder
System.Reflection.Emit.MethodRental
System.Reflection.Emit.OpCodes
System.Reflection.Emit.ParameterBuilder
System.Reflection.Emit.SignatureHelper
System.Reflection.Emit.UnmanagedMarshal
System.Reflection.ManifestResourceInfo
System.Reflection.MemberInfo
System.Reflection.Missing
System.Reflection.Module
System.Reflection.ParameterInfo
System.Reflection.Pointer
System.Reflection.StrongNameKeyPair
System.Resources.ResourceManager
System.Resources.ResourceReader
System.Resources.ResourceSet
System.Resources.ResourceWriter
System.Resources.ResXFileRef
System.Resources.ResXResourceReader
System.Resources.ResXResourceWriter
System.Runtime.CompilerServices.CallConvCdecl
System.Runtime.CompilerServices.CallConvFastcall
System.Runtime.CompilerServices.CallConvStdcall
System.Runtime.CompilerServices.CallConvThiscall
System.Runtime.CompilerServices.IsVolatile
System.Runtime.CompilerServices.RuntimeHelpers
System.Runtime.InteropServices.CurrencyWrapper
System.Runtime.InteropServices.CustomMarshalers.EnumerableToDispatchMarshaler
System.Runtime.InteropServices.CustomMarshalers.EnumeratorToEnumVariantMarshaler
System.Runtime.InteropServices.CustomMarshalers.ExpandoToDispatchExMarshaler
System.Runtime.InteropServices.CustomMarshalers.TypeToTypeInfoMarshaler
System.Runtime.InteropServices.DispatchWrapper
System.Runtime.InteropServices.ErrorWrapper
System.Runtime.InteropServices.ExtensibleClassFactory
System.Runtime.InteropServices.Marshal
System.Runtime.InteropServices.RegistrationServices
System.Runtime.InteropServices.RuntimeEnvironment
System.Runtime.InteropServices.TypeLibConverter
System.Runtime.InteropServices.UnknownWrapper
System.Runtime.Remoting.Channels.BaseChannelObjectWithProperties
System.Runtime.Remoting.Channels.BinaryClientFormatterSink
System.Runtime.Remoting.Channels.BinaryClientFormatterSinkProvider
System.Runtime.Remoting.Channels.BinaryServerFormatterSink
System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider
System.Runtime.Remoting.Channels.ChannelDataStore
System.Runtime.Remoting.Channels.ChannelServices
System.Runtime.Remoting.Channels.ClientChannelSinkStack
System.Runtime.Remoting.Channels.CommonTransportKeys
System.Runtime.Remoting.Channels.Http.HttpRemotingHandler
System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory
System.Runtime.Remoting.Channels.ServerChannelSinkStack
Agilent .NET Course: Type and Debugging 14

duction to .NET
Intro
System.Runtime.Remoting.Channels.SinkProviderData
System.Runtime.Remoting.Channels.SoapClientFormatterSink
System.Runtime.Remoting.Channels.SoapClientFormatterSinkProvider
System.Runtime.Remoting.Channels.SoapServerFormatterSink
System.Runtime.Remoting.Channels.SoapServerFormatterSinkProvider
System.Runtime.Remoting.Channels.Tcp.TcpChannel
System.Runtime.Remoting.Channels.Tcp.TcpClientChannel
System.Runtime.Remoting.Channels.Tcp.TcpServerChannel
System.Runtime.Remoting.Channels.TransportHeaders
System.Runtime.Remoting.Lifetime.LifetimeServices
System.Runtime.Remoting.Messaging.AsyncResult
System.Runtime.Remoting.Messaging.CallContext
System.Runtime.Remoting.Messaging.Header
System.Runtime.Remoting.Messaging.LogicalCallContext
System.Runtime.Remoting.Messaging.RemotingSurrogateSelector
System.Runtime.Remoting.Messaging.ReturnMessage
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapAnyUri
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapBase64Binary
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDate
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDateTime
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDay
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDuration
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntities
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntity
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapId
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdref
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdrefs
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapLanguage
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonth
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonthDay
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapName
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNcName
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNegativeInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtoken
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtokens
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonNegativeInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonPositiveInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNormalizedString
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNotation
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapPositiveInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapQName
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapTime
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapToken
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYear
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYearMonth
System.Runtime.Remoting.MetadataServices.MetaData
System.Runtime.Remoting.MetadataServices.SdlChannelSink
System.Runtime.Remoting.MetadataServices.SdlChannelSinkProvider
System.Runtime.Remoting.MetadataServices.ServiceType
System.Runtime.Remoting.ObjRef
System.Runtime.Remoting.Proxies.RealProxy
System.Runtime.Remoting.RemotingConfiguration
System.Runtime.Remoting.RemotingServices
Agilent .NET Course: Type and Debugging 15

duction to .NET
Intro
System.Runtime.Remoting.Services.EnterpriseServicesHelper
System.Runtime.Remoting.Services.TrackingServices
System.Runtime.Remoting.SoapServices
System.Runtime.Remoting.TypeEntry
System.Runtime.Serialization.Formatter
System.Runtime.Serialization.FormatterConverter
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
System.Runtime.Serialization.Formatters.ServerFault
System.Runtime.Serialization.Formatters.Soap.SoapFormatter
System.Runtime.Serialization.Formatters.SoapFault
System.Runtime.Serialization.Formatters.SoapMessage
System.Runtime.Serialization.FormatterServices
System.Runtime.Serialization.ObjectIDGenerator
System.Runtime.Serialization.ObjectManager
System.Runtime.Serialization.SerializationBinder
System.Runtime.Serialization.SerializationInfo
System.Runtime.Serialization.SerializationInfoEnumerator
System.Runtime.Serialization.SurrogateSelector
System.Security.CodeAccessPermission
System.Security.Cryptography.AsymmetricAlgorithm
System.Security.Cryptography.AsymmetricKeyExchangeDeformatter
System.Security.Cryptography.AsymmetricKeyExchangeFormatter
System.Security.Cryptography.AsymmetricSignatureDeformatter
System.Security.Cryptography.AsymmetricSignatureFormatter
System.Security.Cryptography.CryptoAPITransform
System.Security.Cryptography.CryptoConfig
System.Security.Cryptography.CspParameters
System.Security.Cryptography.DeriveBytes
System.Security.Cryptography.FromBase64Transform
System.Security.Cryptography.HashAlgorithm
System.Security.Cryptography.KeySizes
System.Security.Cryptography.MaskGenerationMethod
System.Security.Cryptography.RandomNumberGenerator
System.Security.Cryptography.SignatureDescription
System.Security.Cryptography.SymmetricAlgorithm
System.Security.Cryptography.ToBase64Transform
System.Security.Cryptography.X509Certificates.X509Certificate
System.Security.Cryptography.X509Certificates.X509CertificateCollection.X509CertificateEnumerator
System.Security.Cryptography.Xml.DataObject
System.Security.Cryptography.Xml.KeyInfo
System.Security.Cryptography.Xml.KeyInfoClause
System.Security.Cryptography.Xml.Reference
System.Security.Cryptography.Xml.Signature
System.Security.Cryptography.Xml.SignedInfo
System.Security.Cryptography.Xml.SignedXml
System.Security.Cryptography.Xml.Transform
System.Security.Cryptography.Xml.TransformChain
System.Security.Permissions.PrincipalPermission
System.Security.Permissions.ResourcePermissionBaseEntry
System.Security.Permissions.StrongNamePublicKeyBlob
System.Security.PermissionSet
System.Security.Policy.AllMembershipCondition
System.Security.Policy.ApplicationDirectory
System.Security.Policy.ApplicationDirectoryMembershipCondition
System.Security.Policy.CodeGroup
Agilent .NET Course: Type and Debugging 16

duction to .NET
Intro
System.Security.Policy.Evidence
System.Security.Policy.Hash
System.Security.Policy.HashMembershipCondition
System.Security.Policy.PermissionRequestEvidence
System.Security.Policy.PolicyLevel
System.Security.Policy.PolicyStatement
System.Security.Policy.Publisher
System.Security.Policy.PublisherMembershipCondition
System.Security.Policy.Site
System.Security.Policy.SiteMembershipCondition
System.Security.Policy.StrongName
System.Security.Policy.StrongNameMembershipCondition
System.Security.Policy.Url
System.Security.Policy.UrlMembershipCondition
System.Security.Policy.Zone
System.Security.Policy.ZoneMembershipCondition
System.Security.Principal.GenericIdentity
System.Security.Principal.GenericPrincipal
System.Security.Principal.WindowsIdentity
System.Security.Principal.WindowsImpersonationContext
System.Security.Principal.WindowsPrincipal
System.Security.SecurityElement
System.Security.SecurityManager
System.ServiceProcess.ServiceControllerPermissionEntry
System.String
System.Text.Decoder
System.Text.Encoder
System.Text.Encoding
System.Text.RegularExpressions.Capture
System.Text.RegularExpressions.CaptureCollection
System.Text.RegularExpressions.GroupCollection
System.Text.RegularExpressions.MatchCollection
System.Text.RegularExpressions.Regex
System.Text.RegularExpressions.RegexCompilationInfo
System.Text.StringBuilder
System.Threading.Interlocked
System.Threading.Monitor
System.Threading.ReaderWriterLock
System.Threading.Thread
System.Threading.ThreadPool
System.Threading.Timeout
System.TimeZone
System.UriBuilder
System.ValueType
System.Version
System.WeakReference
System.Web.Caching.Cache
System.Web.Caching.CacheDependency
System.Web.Configuration.HttpCapabilitiesBase
System.Web.Configuration.HttpConfigurationContext
System.Web.Hosting.ApplicationHost
System.Web.HttpApplication
System.Web.HttpCachePolicy
System.Web.HttpCacheVaryByHeaders
System.Web.HttpCacheVaryByParams
Agilent .NET Course: Type and Debugging 17

duction to .NET
Intro
System.Web.HttpContext
System.Web.HttpCookie
System.Web.HttpPostedFile
System.Web.HttpRequest
System.Web.HttpResponse
System.Web.HttpRuntime
System.Web.HttpServerUtility
System.Web.HttpStaticObjectsCollection
System.Web.HttpUtility
System.Web.HttpWorkerRequest
System.Web.Mail.MailAttachment
System.Web.Mail.MailMessage
System.Web.Mail.SmtpMail
System.Web.ProcessInfo
System.Web.ProcessModelInfo
System.Web.Security.DefaultAuthenticationModule
System.Web.Security.FileAuthorizationModule
System.Web.Security.FormsAuthentication
System.Web.Security.FormsAuthenticationModule
System.Web.Security.FormsAuthenticationTicket
System.Web.Security.FormsIdentity
System.Web.Security.PassportAuthenticationModule
System.Web.Security.PassportIdentity
System.Web.Security.UrlAuthorizationModule
System.Web.Security.WindowsAuthenticationModule
System.Web.Services.Description.DocumentableItem
System.Web.Services.Description.MimeTextMatch
System.Web.Services.Description.ServiceDescriptionFormatExtension
System.Web.Services.Description.ServiceDescriptionImporter
System.Web.Services.Description.ServiceDescriptionReflector
System.Web.Services.Description.SoapTransportImporter
System.Web.Services.Discovery.DiscoveryClientProtocol.DiscoveryClientResultsFile
System.Web.Services.Discovery.DiscoveryClientResult
System.Web.Services.Discovery.DiscoveryDocument
System.Web.Services.Discovery.DiscoveryReference
System.Web.Services.Discovery.SoapBinding
System.Web.Services.Protocols.LogicalMethodInfo
System.Web.Services.Protocols.SoapExtension
System.Web.Services.Protocols.SoapHeader
System.Web.Services.Protocols.SoapMessage
System.Web.Services.Protocols.WebClientAsyncResult
System.Web.SessionState.HttpSessionState
System.Web.SessionState.SessionStateModule
System.Web.TraceContext
System.Web.UI.AttributeCollection
System.Web.UI.BaseParser
System.Web.UI.Control
System.Web.UI.ControlBuilder
System.Web.UI.ControlCollection
System.Web.UI.CssStyleCollection
System.Web.UI.DataBinder
System.Web.UI.DataBinding
System.Web.UI.DataBindingCollection
System.Web.UI.Design.ColorBuilder
System.Web.UI.Design.ControlParser
Agilent .NET Course: Type and Debugging 18

duction to .NET
Intro
System.Web.UI.Design.ControlPersister
System.Web.UI.Design.DataBindingHandler
System.Web.UI.Design.DesignTimeData
System.Web.UI.Design.UrlBuilder
System.Web.UI.HtmlControls.HtmlTableCellCollection
System.Web.UI.HtmlControls.HtmlTableRowCollection
System.Web.UI.LosFormatter
System.Web.UI.Pair
System.Web.UI.PropertyConverter
System.Web.UI.StateBag
System.Web.UI.StateItem
System.Web.UI.Triplet
System.Web.UI.ValidatorCollection
System.Web.UI.WebControls.CalendarDay
System.Web.UI.WebControls.DataGridColumn
System.Web.UI.WebControls.DataGridColumnCollection
System.Web.UI.WebControls.DataGridItemCollection
System.Web.UI.WebControls.DataKeyCollection
System.Web.UI.WebControls.DataListItemCollection
System.Web.UI.WebControls.DayRenderEventArgs
System.Web.UI.WebControls.FontInfo
System.Web.UI.WebControls.ListItem
System.Web.UI.WebControls.ListItemCollection
System.Web.UI.WebControls.MonthChangedEventArgs
System.Web.UI.WebControls.PagedDataSource
System.Web.UI.WebControls.RepeaterItemCollection
System.Web.UI.WebControls.RepeatInfo
System.Web.UI.WebControls.SelectedDatesCollection
System.Web.UI.WebControls.TableCellCollection
System.Web.UI.WebControls.TableRowCollection
System.Windows.Forms.AmbientProperties
System.Windows.Forms.Application
System.Windows.Forms.ApplicationContext
System.Windows.Forms.AxHost.State
System.Windows.Forms.Binding
System.Windows.Forms.BindingContext
System.Windows.Forms.BindingManagerBase
System.Windows.Forms.CheckedListBox.CheckedIndexCollection
System.Windows.Forms.CheckedListBox.CheckedItemCollection
System.Windows.Forms.Clipboard
System.Windows.Forms.ComboBox.ObjectCollection
System.Windows.Forms.Control.ControlCollection
System.Windows.Forms.ControlPaint
System.Windows.Forms.CreateParams
System.Windows.Forms.Cursor
System.Windows.Forms.Cursors
System.Windows.Forms.DataFormats
System.Windows.Forms.DataFormats.Format
System.Windows.Forms.DataGrid.HitTestInfo
System.Windows.Forms.DataObject
System.Windows.Forms.Design.AxImporter
System.Windows.Forms.Design.AxImporter.Options
System.Windows.Forms.Design.PropertyTab
System.Windows.Forms.FeatureSupport
System.Windows.Forms.GridItem
Agilent .NET Course: Type and Debugging 19

duction to .NET
Intro
System.Windows.Forms.GridItemCollection
System.Windows.Forms.Help
System.Windows.Forms.ImageList.ImageCollection
System.Windows.Forms.ImageListStreamer
System.Windows.Forms.InputLanguage
System.Windows.Forms.LinkLabel.Link
System.Windows.Forms.LinkLabel.LinkCollection
System.Windows.Forms.ListBox.ObjectCollection
System.Windows.Forms.ListBox.SelectedIndexCollection
System.Windows.Forms.ListBox.SelectedObjectCollection
System.Windows.Forms.ListView.CheckedIndexCollection
System.Windows.Forms.ListView.CheckedListViewItemCollection
System.Windows.Forms.ListView.ColumnHeaderCollection
System.Windows.Forms.ListView.ListViewItemCollection
System.Windows.Forms.ListView.SelectedIndexCollection
System.Windows.Forms.ListView.SelectedListViewItemCollection
System.Windows.Forms.ListViewItem
System.Windows.Forms.ListViewItem.ListViewSubItem
System.Windows.Forms.ListViewItem.ListViewSubItemCollection
System.Windows.Forms.Menu.MenuItemCollection
System.Windows.Forms.MessageBox
System.Windows.Forms.MonthCalendar.HitTestInfo
System.Windows.Forms.PropertyGrid.PropertyTabCollection
System.Windows.Forms.Screen
System.Windows.Forms.ScrollableControl.DockPaddingEdges
System.Windows.Forms.SelectionRange
System.Windows.Forms.SendKeys
System.Windows.Forms.StatusBar.StatusBarPanelCollection
System.Windows.Forms.SystemInformation
System.Windows.Forms.TabControl.TabPageCollection
System.Windows.Forms.ToolBar.ToolBarButtonCollection
System.Windows.Forms.TreeNodeCollection
System.Xml.Schema.XmlSchemaCollection
System.Xml.Schema.XmlSchemaCollectionEnumerator
System.Xml.Schema.XmlSchemaDatatype
System.Xml.Schema.XmlSchemaObject
System.Xml.Schema.XmlSchemaObjectEnumerator
System.Xml.Schema.XmlSchemaObjectTable
System.Xml.Serialization.SoapAttributeOverrides
System.Xml.Serialization.SoapAttributes
System.Xml.Serialization.XmlAttributeOverrides
System.Xml.Serialization.XmlAttributes
System.Xml.Serialization.XmlSerializer
System.Xml.Serialization.XmlSerializerNamespaces
System.Xml.XmlConvert
System.Xml.XmlImplementation
System.Xml.XmlNamedNodeMap
System.Xml.XmlNamespaceManager
System.Xml.XmlNameTable
System.Xml.XmlNode
System.Xml.XmlNodeChangedEventArgs
System.Xml.XmlNodeList
System.Xml.XmlParserContext
System.Xml.XmlQualifiedName
System.Xml.XmlReader
Agilent .NET Course: Type and Debugging 20

System.Xml.XmlResolver
System.Xml.XmlWriter
System.Xml.XPath.XPathDocument
System.Xml.XPath.XPathExpression
System.Xml.XPath.XPathNavigator
System.Xml.XPath.XPathNodeIterator
System.Xml.Xsl.XsltArgumentList
System.Xml.Xsl.XslTransform
Introduction to .NET
Agilent .NET Course: Type and Debugging 21

Name:
Course: Introduction to .NET
Title: Module 5
Instructor: Andrew Cumming
.NET

5 Day 3 am
5.1 Contents
Morning session
• Methods and overloaded methods, Intellisense
• Exceptions
• Using Namespaces
• Using Modules and Assemblies
• Using non‐visual components
• Using regular expressions
• Searching help
• Creating and Using Delegates
• Defining and Using Events
Afternoon
• Introducing Cerebus
• The Agilent TM Limit components
Introduction to .NET
Agilent .NET Course: Module 5, page 2

5.2 Overloaded Methods
An overloaded method is one that has more than one pattern of parameters.
Consider the method MessageBox.Show
The Show method is overloaded 12 times. Two of these overloadings are shown below:
Signatures for MessageBox.Show
public static DialogResult Show(
string text
);
duction to .NET
Intro
public static DialogResult Show(
string text,
string caption,
MessageBoxButtons buttons,
MessageBoxIcon icon
);
At it’s simplest we might use just one parameter:
Simple use of MessageBox.Show()
MessageBox.Show("Make my day.");
In a more complex situation we include a caption, a question icon and specify two
buttons Yes and No. Moreover we make use of the return value.
A Less simple use of MessageBox.Show()
if (MessageBox.Show("Do you feel lucky",
"Clint asks:",
System.Windows.Forms.MessageBoxButtons.YesNo,
System.Windows.Forms.MessageBoxIcon.Question)
== System.Windows.Forms.DialogResult.Yes)
Console.WriteLine("Bang");
else
Console.WriteLine("You have the right to remain silent...");
We get a list of the overloading in the editor – when this box pops up we can run
through the options using the up and down arrow keys.
Agilent .NET Course: Module 5, page 3

5.3 Creating overloaded methods
We can create overloaded methods ourselves very simply. We need only repeat the
definition, but with a different parameter list.
Care should be takes with this – it is considered good practice if each overloading
performs essentially the same task. The MessageBox.Show is an excellent example
of good practice (if rather excessive in have 12 options).
• The same method can be used “quick‐and‐dirty” and “careful” users.
• Sensible default values are given when parameters are left unspecified.
During development of code we often find that we need to generalise. We start with
a simple method and find that it needs to be more complex.
The designers of MessageBox might have started with the notion of a simple alert
box that took a single string – they then found that their users required more and
more control.
Using overloading it is possible to publish a simple component then expand on it.
The advantage of this is that existing code that uses the simple interface does not
have to be re‐written when the new version of the class is released.
To avoid duplication of code we often have one “base” implementation that the others
call. The based should be the “largest” overloading – the one with the most
parameters.
5.4 Overloaded Method Example
The Country class records details of a single country – name, region, area, population
and gdp.
When the population increases (when a baby is born for example) we want to increment
the population. The method to do this is called IncPop.
duction to .NET
Intro
Examples of the definition of an overloaded method
public void IncPop(int increment)
{
this.population += increment;
}
public void IncPop()
{
IncPop(1);
}
Agilent .NET Course: Module 5, page 4

5.5 Contributing to Intellisense
We can comment our code so that out comments pop up in the intellisense pane.
Examples of the definition of an overloaded method
///
///Increase the population of this country
///
///Number of new people
public void IncPop(
int increment)
{
this.population += increment;
}
Comments need to be in xml tags such as or .
The tags must be in the triple stroke comments to be processed.
The comments should immediately precede the declaration line.
See the help section “Recommended Tags for Documentation Comments”.
5.6 Exceptions
duction to .NET
Intro
C# uses exceptions to deal with run time errors.
We protect areas of code that can possibly generate exceptions using a try block –
we must add a catch block and we may add a finally block.
Examples of Exceptions 3.2.1
Console.WriteLine("Test started.");
try
{
StreamReader fs = new StreamReader("c:\\nosuchfile.txt");
Console.WriteLine("The file stream has been opened.");
string s=fs.ReadLine();
Console.WriteLine("A line of text has been read.");
}
catch
{
Console.WriteLine("An exception was raised.");
}
finally
{
Console.WriteLine("Finished.");
}
Console.WriteLine("Test completed.");
Agilent .NET Course: Module 5, page 5

In the above example (assuming that the file c:\sosuchfile.txt does no exist) we get
the following output:
Output of Exceptions 3.2.2
Test started.
An exception was raised.
Finished.
Test completed.
The exception will be raised at the “new StreamReader” line – the following line
does not get executed, instead execution jumps to the catch block, then the finally
block then continues with the code outside the try/catch/finally structure.
Without the try blocks the whole method will fail and the stack will unwind.
There are different exceptions for different conditions.
Examples of Exceptions 3.2.3
System.NullReferenceException
System.DivideByZeroException
System.InvalidCastException
System.IO.FileNotFoundException
5.7 Finer control over exceptions
Introduction to .NET
A host of different exceptions exist. We can test for a specific exception by including
an exception reference in the catch clause. All exceptions inherit from System.Exception
– this will catch any exception.
We can perform further tests inside the catch block – we can examine ex.GetType()
to find out exactly what exception was raised.
Finer control
try
{
DateTime x = (DateTime) new Object();
}
catch (System.InvalidCastException ex)
{
MessageBox.Show("The cast was invalid");
}
catch (Exception ex)
{
MessageBox.Show("Some kind of error happened :^(\n"+
ex.ToString());
}
Agilent .NET Course: Module 5, page 6

5.8 Throwing Exceptions
We may deliberately choose to cause an exception. We use the throw statement for
this.
We may define our own Exceptions and throw them.
Choose one or neither of the below:
• There is no point in doing this unless we carefully document the circumstances.
If we cannot be bothered to do this we should not bother creating
custom exceptions.
• Exceptions are self‐documenting mechanisms. It is bad practice to throw
someone else’s exception.
5.9 Policy on when to catch and when to throw
The business of which exceptions to catch is complex. There are often good reasons
to not catch exceptions. An uncaught exception will propagate back up the stack.
• The Cerebus system has a mechanism for dealing with exceptions.
• Comment from Nick
Introduction to .NET
Agilent .NET Course: Module 5, page 7

5.10 Using non-visual components
We can import components onto our form at design time. These have properties
that we can conveniently set at design time.
An example of such a component is the file browser.
duction to .NET
Intro
The non‐visual components can have their properties set conveniently at design
time. The code to declare these components (globally to the project) are included
automatically – as is the code to set the design time property values.
We can use these controls in code.
Using OpenFileDialog
if (System.Windows.Forms.DialogResult.OK
== openFileDialog1.ShowDialog())
{
string s= openFileDialog1.FileName ;
MessageBox.Show(s);
}
Agilent .NET Course: Module 5, page 8

5.11 Regular Expressions
Use of regular expressions can simplify much of the hard work of string processing.
We can specify patterns that get matched against input strings.
Some simple patterns:
Simple Patterns
.
Matches any character
\s
Matches any white space character
\S
Matches any non white space characters
\d
Matches any digit
and
Matches the word and
.*
Matches any number of any characters – "greedy" match
^
Matches the beginning of the search string
$
Matches the end of the search string
duction to .NET
Intro
Because we make use of the \ character regular expressions are almost always defined
using @ʺ.
Simple Patterns
Regex re = new Regex(@"^B.*land");
StreamReader sr = new StreamReader(@"..\..\ciaTabbed.txt");
while (sr.Peek()>0)
{
string s = sr.ReadLine();
if (re.Match(s).Success)
Console.WriteLine(s);
}
The above section of code searches for strings that start with B and include ʺlandʺ
Matches for ^B.*land
Baker Island Oceania 1.4 0
Bouvet Island Antarctic Region 58.5 0
British Virgin Islands Central America and the Caribbean 150 19615 287000000
5.11.1 Extracting substrings using Regular Expressions
We can include brackets in our patterns and obtain the contents of these.
Agilent .NET Course: Module 5, page 9

The pattern @ʺ^(.*), Theʺ will match countries such as ʺBahamas, Theʺ. We can extract
the contents of the brackets by looking at structure Match or MatchCollection.
5.11.2 Match
Commonly we are only interested in one set of matches.
If this is the case we can use the Match object. We can get
Extracting substrings
Regex populationPattern = new Regex(@"Population: (\S*)");
while (sr.Peek()>0)
{
string s = sr.ReadLine();
Match m = populationPattern.Match(s);
if (m.Success)
{
MessageBox.Show(m.Groups[1].Value);
}
}
duction to .NET
Intro
5.11.3 MatchCollection
The match collection contains a list of lists. Commonly there is only one item in the
list. This item consists of the whole matching string followed by each of the brackets
in order.
Extracting substrings
Regex re = new Regex(@"^(.*), (The)\t");
StreamReader sr = new StreamReader(@"..\..\ciaTabbed.txt");
while (sr.Peek()>0)
{
string s = sr.ReadLine();
MatchCollection m = re.Matches(s);
if (m.Count>0)
{
Console.WriteLine(s);
Console.WriteLine("item 0,0:" + m[0].Groups[0]);
Console.WriteLine("item 0,1:" + m[0].Groups[1]);
Console.WriteLine("item 0,2:" + m[0].Groups[2]);
}
}
Output extracting substrings
Bahamas, The Central America and the Caribbean 13940 294982 5580000000
item 0,0:Bahamas, The
item 0,1:Bahamas
item 0,2:The
Gambia, The Africa 11300 1367124 1400000000
item 0,0:Gambia, The
item 0,1:Gambia
item 0,2:The
Agilent .NET Course: Module 5, page
10

The following problem appeared as ENIGMA 1168 in New Scientist
5.12 THRICE UNFACTORISED
5.12.1 Richard England
I have found a four‐digit number such that it is impossible
to factorise the numbers formed by its first digit or last
digit or first two digits or middle two digits or last two
digits or first three digits or last three digits or all four digits.
In other words all those eight numbers are prime
except that either or both of the single‐digit numbers may
be unity.
Harry and Tom have also found such a four‐digit number.
The four‐digit numbers that we have found are all different;
but Harryʹs number uses the same digits as Tomʹs
number, though in a different order. Which four‐digit
number have I found
http://www.cs.bris.ac.uk/~edwards/maths/primes.html
http://www.utm.edu/research/primes/lists/small/1000.txt
Introduction to .NET
Agilent .NET Course: Module 5, page
11

5.13 Exceptions Tutorial
duction to .NET
Intro
Tasks.
1) Try the Megalomania solution. Observe that we have a Class file Country and a
user interface Megalomania. We will try to keep the two parts of the system
separate. Observe the action of two existing buttons.
2) Trivial change to the user interface:
a) Add a new label to the project.
b) Change the action of the ʺUpdate worldLBʺ button so that the new label shows
a count of the number of items in worldLB. (worldLB.Items.Count contains
the number you need).
c) Check that the change works.
3) Trivial change to Country.cs:
a) Change the ToString method to include some more spaces in the format
string. This should make the text box contents easier on the eye.
4) Break the data 1:
a) Edit the file ciaFixedWidth.txt so that it includes a country with a non‐numeric
where a numeric value is expected. For example
ʺAndrew Land Europe 0 1 nixʺ
Observe that a run time error occurs when you try to load the file.
b) Enclose a section of code in a try block so that processing continues and such
duff lines are ignored.
c) Report the error by writing an appropriate message using the System.Diagnostics.Trace.WriteLine
method.
5) Break the data 2:
a) Change the file name of ciaFixedWidth.txt so that a different run time error is
generated.
b) Trap this error with a wider try block. We cannot continue with the routine after
such an error to an alert should be generated with an appropriate
MessageBox with an appropriate icon.
6) Generalise the file open procedure:
a) Allow the user to specify the location of the CIA file – use the open file dialog
control.
b) For the purposes of the next question you must ensure that the file dialog
permits you to enter files that do not exist and illegal file names. You need to
change three properties to allow this.
7) Allow some exceptions to be unhandled.
a) We want to ensure that only the ʺFile not foundʺ exception is caught. If the
Agilent .NET Course: Module 5, page
12

user enters an illegal filename (such as ʺ6:abcʺ) we want the exception to go
uncaught – in the debug environment the debugger starts.
i) Identify the exception we want to catch (you can set a breakpoint and
use the local window for this).
ii) Ensure the catch is specific to this exception only.
iii) Check your program completes successfully when given a good file
name.
iv) Check your program gives a fatal warning when given a file that does
not exist.
v) Check that your program generates an unhandled exception when given
an illegal file name.
Introduction to .NET
Agilent .NET Course: Module 5, page
13

5.14 Regular Expressions Tutorial
8) Open the project Regular. This application reads files taken from the CIA world
factbook and extracts features of a single country. Source files for United Kingdom,
France and Algeria are available in the project as uk.txt, fr.txt and ag.txt.
a) Execute the project and note that only the population details have been extracted.
b) Find the routine that performs the search. Use the break command to terminate
the loop once a successful match has been found.
9) The field Region appears on lines such as ʺMap references: Europeʺ. Create a
regular expression that finds such lines and extracts the required data.
10) With a little investigation you should find that name, the area and the GDP
could be extracted in a similar way. Note the following:
a) The name of the country appears at several places – you may choose any that
is convenient.
b) The GDP may be in millions or billions or trillions.
11) We want to exclude the commas from the numbers. We may use the static
method Regex.Replace to remove commas.
12) (Extra hard question – requires MatchCollection) Use the line ʺPolitical Parties
and leaders:ʺ to extract and print a list of parties.
Introduction to .NET
Agilent .NET Course: Module 5, page
14

5.15 Methods Tutorial
We return to the Megalomania solution for this tutorial. We will be creating methods
to process the Country class. In each case we should create methods in the
Country.cs file and call them from the interface.
13) Create routines to increment the population as in the lecture notes.
a) Create a button that increments the population of country index 5. Implement
IncPop so that the following code can be attached to a new button on the
form:
Country target = ((Country)world[5]);
target.IncPop(1000000);
You should notice the population of Angola go from about 10 million to
about 11 million.
b) Create the method Annex – this country adds in all of the population, area and
gdp of the victim country. The victim country still exists but with an area,
population and gdp of zero. Attach the following code to a new button and
observe what happens to Jersey and the Isle of Man.
private void button2_Click(object sender, System.EventArgs e)
{
Country uk = (Country) world[248];
Country jersey = (Country)world[121];
Country iom = (Country)world[150];
uk.Annex(jersey);
uk.Annex(iom);
}
duction to .NET
Intro
c) Create the + operator (See chapter 6 of Jesse Liberty). This is operator creates a
new country with the combined population, gdp and area of the two participants.
The name of the new country should be set to “New Country”. The
region should be set – if the two countries are in different regions an exception
should be raised. Create a button to unite North and South Korea with
the following code:
private void button3_Click(object sender, System.EventArgs e)
{
Country northKorea = (Country)world[129];
Country southKorea = (Country)world[130];
world.Add(northKorea+southKorea);
}
d) You should find the new country at the bottom of the list.
Agilent .NET Course: Module 5, page
15

5.16 Sorting and Interfaces
We return to the Megalomania solution for this tutorial. We examine how we may
use the Sort method.
14) Attempt to sort the ArrayList world.
a) Add a new button on the interface.
b) Make the code behind the button a simple statement world.Sort();
c) This should compile but fail at run time.
d) To make the Sort work we need to implement the IComparable interface –
the first step is to change the class declaration:
public class Country : IComparable
e) The code should now fail to compile – by insisting that Country satisfies the
IComparable interface we are claiming that it has the signature of IComparable.
f) Fortunately IComparable has a very simple signature – it simply requires that
there exist a method int CompareTo(obj Object) – this should return –1 or 0
or 1 depending on how this compares to obj. This is the comparison made
for sorting.
g) Implement the method and observe the sort.
h) Introduce another button to allow sorting by population – descending. Page
199 of Jesse Liberty’s book has the details.
Introduction to .NET
Agilent .NET Course: Module 5, page
16

Name:
Course: Introduction to .NET
Title: Module 6
Instructor: Andrew Cumming
.NET

6 Day 3 pm
6.1 Contents
Morning session
• Methods and overloaded methods, intellisense
• Exceptions
• Using Namespaces
• Using Modules and Assemblies
• Using non‐visual components
• Using regular expressions
• Searching help
• Creating and Using Delegates
• Defining and Using Events
Afternoon
• Introducing Cerebus
• The Agilent TM Limit components
Introduction to .NET
Agilent .NET Course: Module 6, page 2

6.2 Cerebus
The run time environment provides the
facilities to select the test dll and the test
sequence.
duction to .NET
Intro
We can select the dll from open and execute it using run.
Agilent .NET Course: Module 6, page 3

6.3 Adding Limit Checkers
We can open the Limits collection and add any of a variety of Limit Checker components.
The properties of these components can be set at design time. We use the Check()
method to perform the tests.
Introduction to .NET
Agilent .NET Course: Module 6, page 4

protected override void UserRun()
{
// TODO: Do the Test task here: perform the measurement and
limit checking
duction to .NET
Intro
}
Trace.WriteLine(new TmTraceEntry(this,
TmTraceSwitch.TestSwitch,
TmTraceLevel.Verbose,
"starting testpoint"));
MessageBox.Show("training example");
singleSidedLimit1.Check(-1);
Thread.Sleep(2000);
singleSidedLimit2.Check(-1);
powerMeter.reset();
Trace.WriteLine(new TmTraceEntry(this,
TmTraceSwitch.TestSwitch,
TmTraceLevel.Verbose,
"ending testpoint"));
Agilent .NET Course: Module 6, page 5

6.4 Tutorial
Starting with the AgilentTrainingFiles example complete the following tasks.
1) Execute the program from the test environment.
a) Observe the successful completion of the test sequence.
b) Make a note of the three messages that show up in the Log tab. The final message
should read “ending testpoint”
2) Make a trivial change to the code:
a) View the code of the TrainingTest.cs.
b) Find the method UserRun and note that the two Trace lines give the same
message.
c) Change the second Trace line so that it produces “ending testpoint”.
3) The powerMeter object is available within the TrainingTest.cs, include a call to
the reset method after the first trace statement. powerMeter.reset() should do the
trick – notice the new line in the Log produced by this call.
4) Create a new method in the power meter class.
a) The method should be called blink
b) It should write an appropriate message to the log using Trace.WriteLine.
c) Observe the Log for the new test.
5) Update the training sequence so that the test is run 3 times. You can do this by
editing the file TrainingTest_DrivingData.csv repeat the final line (use a different
name in the extra lines).
Introduction to .NET
Agilent .NET Course: Module 6, page 6

Name:
Course: Introduction to .NET
Title: Objects
Instructor: Bill Buchanan
.NET

7 Objects
7.1 Introduction
This module covers the key elements of arrays, indexers and collections. It covers:
• Classes and objects. This revises the material covered in Module 1.
• Using encapsulation.
• Defining Object‐Oriented Systems.
• Inheritance.
• Abstract classes.
• Sealed classes.
• Overriding classes.
7.2 Classes and objects
duction to .NET
Intro
We live in a world full of objects; so object‐oriented programming is a natural technique
in developing programs. For example, we have an object called a cup, and
each cup has a number of properties, such as its colour, its shape, its size, and so on.
It is efficient for us to identify it as a cup, as we know that cups should be able to
hold liquid, and we will place our cup beside all the other cups that we have. If we
were a cup designer then we could list all the possible properties of a cup, and for
each design, we could set the properties of the cup. Of course, some of the properties
might not actually be used, but for a general‐purpose design, we would specify
every property that a cup might have. For example, in a simple case we could have
the following properties:
Properties Cup 1 Cup 2 Cup3
Shape (Standard/Square/Mug) Standard Square Mug
Colour (Red/Blue/Green) Blue Red Green
Size (Small/Medium/Large) Small Large Small
Transparency (0 to 100%) 100% 50% 25%
Handle type (Small/Large) Small Small Large
Thus, we have three choices of shape (square, standard or mug), three choices of
colour (red, blue or green), three choices in size (small, medium or large) and two
Agilent .NET Course: Objects 2

choices of handle type (small or large). In addition, we can also choose a level of
transparency of the cup from 0 to 100% (in integer steps). In object‐oriented program,
the collection of properties is known as a class. Thus, we could have a class
for our cup which encapsulates all the design parameters for our cup. The instance
of our class, such as Cup 1, Cup 2 and Cup 3, are known as objects. We can create
many objects from our class. Along with this, there are certain things that we want
to do with the cup, such as picking it up, painting it, or even dropping it. In objectorientation,
these are known as methods, and are the functions that can be allowed
to operate on our objects.
Program 7.1 shows an object‐oriented example of the cup, where a class named
Cup is created, of which an instance is named cup. A full description on this program
will be discussed in a later module. It uses variables, such as Shape, Colour, and Size
to define the property of an object.
Program 7.1: Program1_1_ClassSimpleCup
using System;
namespace ConsoleApplication2
{
public class Cup
{
public string Shape;
public string Colour;
public string Size;
public int Transparency;
public string Handle;
duction to .NET
Intro
public void DisplayCup()
{
System.Console.WriteLine("Cup is {0}, {1}", Colour, Handle);
}
}
class Class1
{
static void Main(string[] args)
{
Cup cup = new Cup();
cup.Colour = "Red"; cup.Handle = "Small";
cup.DisplayCup();
cup.Colour = "Green"; cup.Handle = "Small";
cup.DisplayCup();
System.Console.ReadLine();
}
}
}
Sample Run
Cup is Red, Small
Cup is Green, Small
In the following example, we create a class named Circuit, of which we create a
new instance of it named cir. The class then has two methods, named Serial and
Parallel.
Agilent .NET Course: Objects 3

Program 7.2:
using System;
namespace ConsoleApplication2
{
public class Circuit
{
public string name;
}
public double Parallel(double r1, double r2)
{
return((r1*r2)/(r1+r2));
}
public double Series(double r1, double r2)
{
return(r1+r2);
}
class Class1
{
static void Main(string[] args)
{
double v1=100,v2=100;
double res;
Circuit cir = new Circuit();
cir.name="Circuit 1";
res=cir.Parallel(v1,v2);
System.Console.WriteLine("[{0}] Parallel resistance is {1} ohms",
cir.name,res);
cir.name="Circuit 2";
res=cir.Series(v1,v2);
System.Console.WriteLine("[{0}] Series resistance is {1} ohms ",
cir.name,res);
duction to .NET
Intro
System.Console.ReadLine();
}
}
}
Sample Run
[Circuit 1] Parallel resistance is 50 ohms
[Circuit 2] Series resistance is 200 ohms
In this case, we have used a single object (cir). Of course, we could have created
two objects, with:
Circuit cir1 = new Circuit();
Circuit cir2 = new Circuit();
cir1.name="Circuit 1"; res1=cir1.Parallel(v1,v2);
cir2.name="Circuit 2"; res2=cir.Series(v1,v2);
Agilent .NET Course: Objects 4

Finally, for this section, Program 7.3 shows an example of a complex number class,
where a complex number object is created (r), which is made up of two components
(r.real and r.imag). The class defines two methods: mag() and angle(), which calculate
the magnitude and the angle of the complex number, using:
z = x + jy
z
z
=
x
2
= tan
+ y
−1
⎛
⎜
⎝
2
y
x
⎞
⎟
⎠
Program 7.3:
using System;
namespace ConsoleApplication2
{
public class Complex
{
public double real;
public double imag;
public double mag()
{
return (Math.Sqrt(real*real+imag*imag));
}
public double angle()
{
return (Math.Atan(imag/real)*180/Math.PI);
}
}
class Class1
{
static void Main(string[] args)
{
string str;
double mag,angle;
Complex r = new Complex();
duction to .NET
Intro
}
}
System.Console.Write("Enter real value >>");
str=System.Console.ReadLine();
r.real = Convert.ToInt32(str);
System.Console.Write("Enter imag value >>");
str=System.Console.ReadLine();
r.imag = Convert.ToInt32(str);
mag=r.mag();
angle=r.angle();
System.Console.WriteLine("Mag is {0} and angle is {1}",mag,angle);
System.Console.ReadLine();
}
Sample Run
Enter real value >> 3
Enter imag value >> 4
Mag is 5 and angle is 53.130102354156
Agilent .NET Course: Objects 5

7.3 Using encapsulation
Properties are useful techniques in defined the state of a class. For example, a car
might have the following properties:
• Make. This could be Ford, Vauxhall, Nissan or Toyota.
• Type. This could be Vectra, Astra, or Mondeo.
• Colour. This could be colours such as Red, Green or Blue.
• Country of Manufacture. This could be countries such as UK, Germany or
France.
Normally in object‐oriented programs, the variable members of the class are not
make public, thus we can defined a property which can be used to set these variables.
Program 7.4 shows an example where the variables make, type, colour and
country are made private, but properties are defined for these, in order to set them.
Program 7.4:
using System;
namespace sample01
{
public class Car
{
private string colour;
private string type;
private string make;
private string country;
private double cost;
public string Colour
{
get { return colour; }
set { colour=value; }
}
duction to .NET
Intro
public string Type
{
get { return type; }
set { type=value; }
}
public string Country
{
get { return country; }
set { country=value; }
}
public string Make
{
get { return make; }
set { make=value; }
}
public double Cost
{
get { return cost; }
set { cost=value; }
}
Agilent .NET Course: Objects 6

}
class Class1
{
static void Main(string[] args)
{
Car car1 = new Car();
}
}
car1.Colour="Red";
car1.Make="Ford";
car1.Type="Mondeo";
car1.Colour="UK";
car1.Cost=15000;
Console.WriteLine("Car is a " + car1.Make + " " + car1.Type);
Console.ReadLine();
}
Sample Run
Car is a Ford Mondeo
It can be seen that the properties defines a set and get definitions. These are named
the get and set accessors, and are similar to methods. The get accessor reads the
value of the field, while the set accessor reads its value. In most cases, the .NET environment
senses the use of the property and shows the options for it as the user
types the statement, such as:
duction to .NET
The value part of the set in Program 7.4 defines that the value from the property
which is set is taken from. For example:
public double Cost
{
get { return cost; }
set { cost=value; }
}
The value of cost will take the value from object.Cost.
Intro
Agilent .NET Course: Objects 7

7.3.1 Read-only fields
A property with only a get accessor is read‐only, whereas a property with only a
set is write‐only. If it has both a set and get assess it is a read/write property. It is
important to encapsulate the class correctly so that the objects cannot be accessed in
an incorrect way. For example if we change the Cost property to make it read‐only:
public double Cost
{
get { return cost; }
}
and try to use it:
car1.Cost=15000;
The builder will return an error of:
Property or indexer 'sample01.Car.Cost' cannot be assigned to -- it is read
only
But, we could use it, such as:
Console.WriteLine("The cost is " + car1.Cost);
7.4 Defining Object-Oriented Systems
duction to .NET
Intro
Classes exist within a structure and interlink with others. For example if we think
animals we can group them animals into a generalisation, which has a common behaviour
and characteristics. We could then sub‐divide mammals up into different
classifications, such cats, dog and horses (as illustrated in Figure 7.1). From there we
can further subdivide until we get to actual species. Thus we generalise at the top of
the hierarchy, and specialise as we move down it. In object‐orient techniques, we
create a hierarchy such as this, which starts with generalised class, which then future
sub‐divide into specialisations. In C# the top level is System namespace, which
has certain splits of into other namespaces, such as Windows, IO, and Drawing, as
illustrated in Figure 7.2. Below System.Windows is System.Windows.Forms,
which has a number of classes assigned to it. These include:
• Form. To add a form.
• TextBox. Which creates a textbox.
• ComboBox. Which creats a combobox.
• ScrollBar. Which creates a scrollbar.
Agilent .NET Course: Objects 8

Mammals
Increasing
generalisation
Cats Cats
Dogs Dogs
Horses Horses
Lion Lion
Tiger Tiger
Domestic
Shared
behaviours
and
characteristics
Increasing
specialisation
Figure 7.1: Animal classifications
containers
System System
Increasing
generalisation
Windows
IO IO
Drawing
duction to .NET
Intro
Component
Component
Model
Model
Design Design
Forms Forms
Label Label
Combo Combo
Box Box
Button Button
Form Form
Class
Figure 7.2: Object hierarchy in C#
Increasing
specialisation
Agilent .NET Course: Objects 9

Thus, we can say that a Button is a kind of Forms (excuse the poor use of English,
though). Program 7.5 shown an example program with a form, a textbox and a button.
It can be seen that the form is defined as a class with:
Derived class
public class Form1 : System.Windows.Forms.Form
Base class
which means that our form derives from System.Windows.Forms.Form. The
button and the text box are defined with:
private System.Windows.Forms.Button button1;
private System.Windows.Forms.TextBox textBox1;
Which means they derive from System.Windows.Forms.Button and System.Windows.Forms.TextBox,
respectively.
Program 7.5:
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace WindowsApplication3
{
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Button button1;
private System.Windows.Forms.TextBox textBox1;
Base class
public Form1() { InitializeComponent(); }
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.textBox1 = new System.Windows.Forms.TextBox();
duction to .NET
Intro
}
this.button1.Location = new System.Drawing.Point(152, 192);
this.button1.Name = "button1";
this.button1.TabIndex = 0;
this.button1.Text = "button1";
this.textBox1.Location = new System.Drawing.Point(80, 64);
this.textBox1.Name = "textBox1";
this.textBox1.TabIndex = 1;
this.textBox1.Text = "textBox1";
this.Controls.Add(this.textBox1);
this.Controls.Add(this.button1);
this.Name = "Form1";
this.Text = "Form1";
this.Load += new System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);
Agilent .NET Course: Objects 10

}
}
static void Main()
{
Application.Run(new For m1());
}
private void Form1_Load(object sender, System.EventArgs e)
{
// event for the loading of the form
}
7.4.1 Inheritance
Inheritance is a key factor in C#, where derived classes inherit all the members of
the base classes. In Program 7.6 a class named People is created. This has a property
of name, and a method of ToLowerCase(). Next a Profile class is created,
which derives from People. Profile thus inherits all the members of People.
Program 7.6:
using System;
namespace ConsoleApplication1
{
class People
{
private string name;
}
public string Name {
get {return name;}
set {name=value;}
}
public void ToLowerCase()
{
name=name.ToLower();
}
People
Profile Profile
duction to .NET
Intro
class Profile : People
{ // Inherit from People
public void Display()
{
Console.WriteLine("Name: "+Name);
}
}
class Test
{
static void Main()
{
Profile p1 = new Profile();
p1.Name="Fred";
p1.ToLowerCase();
p1.Display();
Method inherited
from People
Agilent .NET Course: Objects 11

System.Console.ReadLine();
}
}
}
Sample Run
Name: fred
If we now change the class to:
class Test
{
static void Main()
{
Profile p1 = new Profile();
Profile p2 = new Profile();
p1.Name="Fred";
p2.Name="Bert";
}
}
p1.ToLowerCase();
p1.Display();
p2.Display();
System.Console.ReadLine();
Then the output will become:
Name: fred
Name: Bert
Where the first name (Fred) has had the ToLowerCase() method applied to it, but
the second one (Bert) has not.
duction to .NET
Intro
7.5 Sealed classes
The sealed modifier is used to bar classes from deriving its members, and is used to
prevent deviation from the original purposes of a class. For example, if in Program
7.6 we change the People class to:
sealed class People
{
private string name;
public string Name {
get {return name;}
set {name=value;}
}
Agilent .NET Course: Objects 12

}
public void ToLowerCase()
{
name=name.ToLower();
}
When the program is now built an error messages is displayed:
'ConsoleApplication1.Profile' : cannot inherit from sealed class
'ConsoleApplication1.People'
7.6 Overriding classes
Sometimes a developer might want to implement their own methods. This could be
to enhance the operation of the method, or to refine it for a certain application or
system. For this the override keyword is used to identify that a method overrides a
method from the base class. An example in Program 7.7 shows that the overriding
class is defined with:
public override void ToLowerCase()
{
Console.WriteLine("Method has been overwritten");
}
and the virtual keyword is used in the definition of the method in the base class,
such as:
public virtual void ToLowerCase()
{
name=name.ToLower();
}
duction to .NET
Intro
Program 7.7:
using System;
namespace ConsoleApplication1
{
class People
{
private string name;
public string Name
{
get {return name;}
set {name=value;}
}
public virtual void ToLowerCase()
{
name=name.ToLower();
Agilent .NET Course: Objects 13

}
}
class Profile : People
{ // Inherit from People
public void Display()
{
Console.WriteLine("Name: "+Name);
}
public override void ToLowerCase()
{
Console.WriteLine("Method has been overwritten");
}
}
class Test
{
static void Main()
{
Profile p1 = new Profile();
p1.Name="Fred";
p1.ToLowerCase();
p1.Display();
System.Console.ReadLine();
}
}
}
Sample Run
Method has been overwritten
Name: Fred
Every class derives from the Object, of which the main methods are:
duction to .NET
• Equals(). Determines if two objects are the same.
• Finalize(). Cleans up the object (the destructor).
• GetHashCode(). Allows an object to define its hash code.
• GetType(). Determine the type of an object.
• MemberwiseClone(). Create a copy of the object.
• ReferenceEquals(). Determines whether two objects are of the same instance.
• ToString(). Convert an object to a string.
It can be seen from Figure 7.3 that some of these methods have been derive from the
main object model. As an example, we can override these methods for any object
that is created.
Intro
Agilent .NET Course: Objects 14

Program 7.8:
using System;
namespace ConsoleApplication1
{
class People
{
private string name;
Figure 7.3: Example of object method
}
public string Name
{
get {return name;}
set {name=value;}
}
public virtual void ToLowerCase()
{
name=name.ToLower();
}
duction to .NET
Intro
class Profile : People
{ // Inherit from People
public void Display()
{
Console.WriteLine("Name: "+Name);
}
}
public override string ToString()
{
return("Cannot implement this method");
}
class Test
{
static void Main()
{
Profile p1 = new Profile();
Agilent .NET Course: Objects 15

p1.Name="Fred";
string str=p1.ToString();
Console.WriteLine(str);
System.Console.ReadLine();
}
}
}
Sample Run
Method has been overwritten
Name: Fred
7.7 Abstract classes
There are times in programming
Okay. Okay. It’s It’s
when the developer of a class wants
worth worth it. it.
I’ll
Here
to force the classes which derive the
Here is is the
I’ll do do that. that.
the
new new class, class, but but you you
can’t
class to write their own methods.
can’t use use it it unless unless you you
implement your your own own
OpenTheBox()
This might be where a system could
method!
use different types of graphics displays,
and that the developer should
write their own implementation of a
DrawWindow() method. An abstract
class can be used for this,
where the class contains an abstract
definition of the format of the At times a new class must be forced to create a new
method. In C# it is not possible to derive a class if there is not an implementation of
an abstract method contained in it.
For example if we have an abstract class for a Car:
duction to .NET
Intro
public abstract class Car
{
public abstract void ShowColour();
public abstract void ShowType();
}
This defines that the deriving class must implement these methods. As it is an abstract
class, there is no implementation as this is up to the derived class to
implement it. Using the previous example, we can force the derived class (Profile) to
implement the DisplayLower() method with the addition of the line:
public abstract void DisplayLower();
in the People class.
Agilent .NET Course: Objects 16

Program 7.9:
using System;
namespace ConsoleApplication1
{
class People
{
private string name;
}
public string Name
{
get {return name;}
set {name=value;}
}
public void ToLowerCase()
{
name=name.ToLower();
}
public abstract void DisplayLower();
class Profile : People
{ // Inherit from People
public void Display()
{
Console.WriteLine("Name: "+Name);
}
}
class Test
{
static void Main()
{
Profile p1 = new Profile();
p1.Name="Fred";
p1.ToLowerCase();
p1.Display();
duction to .NET
Intro
}
}
}
System.Console.ReadLine();
The builder will give the following error:
'ConsoleApplication1.Profile' does not implement inherited abstract
member 'ConsoleApplication1.People.DisplayLower()'
To overcome this we would have to add the following method:
Agilent .NET Course: Objects 17

public override void DisplayLower()
{
Console.WriteLine("Name: "+Name.ToUpper());
}
which will implement the required method. Program 7.10 shows the full implementation
of the program.
Program 7.10:
using System;
namespace ConsoleApplication1
{
abstract class People
{
private string name;
}
public string Name
{
get {return name;}
set {name=value;}
}
public void ToLowerCase()
{
name=name.ToLower();
}
abstract public void DisplayLower();
class Profile : People
{ // Inherit from People
public void Display()
{
Console.WriteLine("Name: "+Name);
}
public override void DisplayLower()
{
Console.WriteLine("Name: "+Name.ToUpper());
}
}
duction to .NET
Intro
}
class Test
{
static void Main()
{
Profile p1 = new Profile();
}
}
p1.Name="Fred";
p1.ToLowerCase();
p1.Display();
p1.DisplayLower();
System.Console.ReadLine();
Agilent .NET Course: Objects 18

Sample Run
Name: fred
Name: FRED
Obviously, the developer does not actually need to put anything in the implementation
of the code, if they do not want to. For this, they can create an empty method.
public override void DisplayLower() { }
Intro
duction to .NET
Agilent .NET Course: Objects 19

Name:
Course: Introduction to .NET
Title: More Objects
Instructor: Bill Buchanan
.NET

8 More Objects
8.1 Introduction
This module covers the key elements of arrays, indexers and collections. It covers:
• Interfaces.
• Constructors.
• Destructors.
• Static and instance members.
• Practical example.
8.2 Interfaces
An interface is an alternative method of creating an abstract, but it does not contain
any implementation of the methods, at all. It provides a base class for all the derived
classes. For example, in Figure 8.1 we have a circuit which can either have a series or
a parallel resistance.
Series circuit: R T
= R 1
+ R2
Parallel circuit:
R1
⋅ R2
R T
=
R + R
1
2
duction to .NET
Intro
Circuit
R T
= R 1
+ R2
r 1 r 2
r 1
r 2
R ⋅ R2
R
1
R T
=
R1
+
Figure 8.1: Circuit with series and parallel resistance
2
Agilent .NET Course: More Objects 2

An interface can be created for this circuit to define the components of the circuit
(r1 and r2), and the method (calcParallel() and calcSeries()) with:
interface NewCircuit
{
double r1 { set; get;}
double r2 { set; get;}
double calcParallel();
double calcSeries();
}
which defines that the base class has two properties and two methods. The derived
class can then be defined with:
public class Circuit: NewCircuit
{
private double res1, res2;
}
public double r1
{
set { res1=value;}
get { return res1; }
}
public double r2
{
set { res2=value;}
get { return res2; }
}
public double calcParallel()
{
return((r1*r2)/(r1+r2));
}
public double calcSeries()
{
return(r1+r2);
}
duction to .NET
Intro
and called with:
Circuit cir = new Circuit();
cir.r1=1000;
cir.r2=1000;
double res = cir.calcParallel();
The full program is given in Program 8.1
Agilent .NET Course: More Objects 3

Program 8.1:
using System;
interface NewCircuit
{
double r1 { set; get;}
double r2 { set; get;}
double calcParallel();
double calcSeries();
}
public class Circuit: NewCircuit
{
private double res1, res2;
public double r1
{
set { res1=value;}
get { return res1; }
}
public double r2
{
set { res2=value;}
get { return res2; }
}
public double calcParallel()
{
return((r1*r2)/(r1+r2));
}
public double calcSeries()
{
return(r1+r2);
}
}
public class Class1
{
static void Main()
{
Circuit cir = new Circuit();
duction to .NET
cir.r1=1000;
cir.r2=1000;
double res = cir.calcParallel();
System.Console.WriteLine("Parallel Resistance is " + res);
System.Console.ReadLine();
}
}
Sample Run
Parallel Resistance is 500
An interface is defined with a special symbol. Figure 8.2 shows some sample interfaces.
In this case the interfaces are:
Intro
Agilent .NET Course: More Objects 4

• IOCollection. Defines size, enumerators and synchronization methods for all
collections. The public properties are: Count, IsSynchronized and SyncRoot, and
a method of CopyTo().
• IComparer. Compares two objects. The associated method is Compare().
• IEnumerator. Supports iteration over a collection. The properties are Current,
and the methods are MoveNext() and Reset().
• IList. Represents a collection of objects that are accessed by an index. The properties
are IsFixedSize, IsReadOnly, Item, and the methods are: Add(), Clear(),
Contains(), IndexOf(), Insert(), Remove() and RemoveAt().
The classes which implement IOCollection include:
• Array.
• ArrayList.
• Hastable.
Thus an array will have the following properties:
• Count.
• IsSynchronized.
• SyncRoot
And a method of:
• CopyTo().
duction to .NET
Intro
Figure 8.2: Sample interfaces
Agilent .NET Course: More Objects 5

8.2.1 Combining interfaces
New interaces can be created by combining two of more base interfaces. For example,
based on the previous example, we can add another interface which defines a
calcDifference() method:
interface NewCircuit
{
double r1 { set; get;}
double r2 { set; get;}
double calcParallel();
double calcSeries();
}
interface NewCircuit2
{
double calcDifference();
}
These interfaces can be merged with:
interface NewCircuitTotal : NewCircuit, NewCircuit2
{}
Then the class is derived with:
public class Circuit: NewCircuitTotal
{
private double res1, res2;
duction to .NET
Intro
public double r1
{
set { res1=value;}
get { return res1; }
}
public double r2
{
set { res2=value;}
get { return res2; }
}
public void Setr2(double r)
{
r2=r;
}
public double calcParallel()
{
return((r1*r2)/(r1+r2));
}
public double calcSeries()
{
return(r1+r2);
}
public double calcDifference()
{
return(r1-r2);
Agilent .NET Course: More Objects 6

}
}
The complete code is given in Program 8.2
Program 8.2:
using System;
using System.Collections;
interface NewCircuit
{
double r1 { set; get;}
double r2 { set; get;}
double calcParallel();
double calcSeries();
}
interface NewCircuit2
{
double calcDifference();
}
interface NewCircuitTotal : NewCircuit, NewCircuit2
{}
public class Circuit: NewCircuitTotal
{
private double res1, res2;
public double r1
{
set { res1=value;}
get { return res1; }
}
public double r2
{
set { res2=value;}
get { return res2; }
}
duction to .NET
Intro
public void Setr2(double r)
{
r2=r;
}
public double calcParallel()
{
return((r1*r2)/(r1+r2));
}
public double calcSeries()
{
return(r1+r2);
}
public double calcDifference()
{
return(r1-r2);
}
}
public class Class1
Agilent .NET Course: More Objects 7

{
static void Main()
{
Circuit cir = new Circuit();
cir.r1=1000;
cir.r2=1000;
double res = cir.calcDifference();
System.Console.WriteLine("Parallel Resistance is " + res);
System.Console.ReadLine();
}
}
Sample Run
Parallel Resistance is 500
It can be seen in Figure 8.3 that the method has been derived in the object.
Figure 8.3: Derived classes
duction to .NET
Intro
8.3 Constructors
A constructor is a method which is automatically called when the object of created.
This is useful in initially setting values to an object. It is defined within the class
with the same name as class. For example to initialize a previous example if we had
a class named Profile, then the constructor within the class will also be named Profile,
such as:
public Profile(string c)
{
code=c;
}
public string Name
{
Agilent .NET Course: More Objects 8

}
set { name=value; }
get { return name; }
}
public string Telephone
{
set { telephone=value; }
get { return telephone; }
}
public void Display()
{
Console.WriteLine("Code: " + code +
" Name: " + name + " Telephone: " + telephone);
Console.ReadLine();
}
The constructor, in this case, can be called by passing a string into the new object,
such as:
Profile pf1=new Profile("00000");
Program 8.3 shows a complete program.
Program 8.3:
using System;
namespace ConsoleApplication5
{
class Profile
{
string code, name, telephone;
duction to .NET
Intro
}
// Constructor
public Profile(string c)
{
code=c;
}
public string Name
{
set { name=value; }
get { return name; }
}
public string Telephone
{
set { telephone=value; }
get { return telephone; }
}
public void Display()
{
Console.WriteLine("Code: " + code + " Name: " +
name + " Telephone: " + telephone);
Console.ReadLine();
}
Agilent .NET Course: More Objects 9

class Class1
{
static void Main(string[] args)
{
Profile pf1=new Profile("00000");
pf1.Name="Fred Smith";
pf1.Telephone="123456";
pf1.Display();
}
}
}
Sample Run
Code: 00000 Name: Fred Smith Telephone: 123456
8.4 Destructors
A destructors is the opposite of a constructor, and occur when an object is deleted. It
is defined in the class with:
~ClassName()
{
// Destructor coce
}
For example in the previous example we could have added:
~Profile()
{
Console.WriteLine("Getting rid of object .. " + this.ToString());
}
To display when the objects were deleted.
duction to .NET
Intro
8.5 Static and Instance Members
A class can either have static members of instance members. Instance members relate
to the object created, while static members can be used by referring to the name
of the method within the class. For example the following are calls to static members:
Convert.ToInteger("str");
Console.WriteLine("Hello");
Whereas in the following, there are two instance methods (Read() and Write()),
Agilent .NET Course: More Objects 10

these operate on the created data type:
System.IO.StreamReader nn = new StreamReader();
nn.Read();
nn.Write();
Static members thus operate on an instance of a class.
Along with static member, it is possible to create static variables. These are often
used to keep track of the number of instances of a class. An example is shown in
Program 8.4 where a static member variable of numberProfile is created to count
the number of instances of the class. This is part of the class, and not part of any instance
of it.
Program 8.4:
using System;
namespace ConsoleApplication5
{
class Profile
{
static int numberProfile=0;
string code, name, telephone;
duction to .NET
Intro
}
// Constructor
public Profile(string c)
{
numberProfile++;
code=c;
}
public string Name
{
set { name=value; }
get { return name; }
}
public string Telephone
{
set { telephone=value; }
get { return telephone; }
}
public void Display()
{
Console.WriteLine("Code: " + code + " Name: " + name +
" Telephone: " + telephone);
Console.ReadLine();
}
public static void HowMany()
{
Console.WriteLine("There are " + numberProfile + " profiles ");
Console.ReadLine();
}
Agilent .NET Course: More Objects 11

class Class1
{
static void Main(string[] args)
{
Profile pf1=new Profile("00000");
pf1.Name="Fred Smith"; pf1.Telephone="123456";
Profile pf2=new Profile("00001");
pf2.Name="Fred Cannon"; pf2.Telephone="223456";
Profile pf3=new Profile("00002");
pf3.Name="Fred McDonald"; pf3.Telephone="323456";
Profile.HowMany();
}
}
}
Sample Run
There are 3 profiles
Intro
duction to .NET
Agilent .NET Course: More Objects 12

8.6 IIInstrument example
///copyright agilent technologies 2003
///filename: IInstrumentMeasModule.cs
///author: Nick McALonan
///date: Oct 2003
///change history -
///module testing history -
///description - This file is the Measurement level public I/F for generic
instrument calls
///and as such the implemeation should be contained within each measurement
module project that requires it.
using System;
namespace Agilent.Sqf.Of.Instrument
{
///copyright agilent technologies 2003
///filename: IInstrumentMeasModule.cd
///author: NickMcALonan
///date: October 2003
///change history -
///module testing history -
///description - This file is the Measurement level public I/F for generic
instrument calls
///and as such contains only declarations of the methods that applly at ALL
instruments.
///This interface should be ///inherited by all other measurement interfaces
public interface IInstrumentMeasModule
{
void QueryFirmware(out string Firmware);
void Reset();
}
}
duction to .NET
Intro
using System;
namespace Agilent.Sqf.Of.PPMC
{
///
/// Summary description for IPPMCInstrument.
///
public interface IPPMCInstrument
{
int StartUpPPMC(int comPort);
void RebootPPMC(int comPort);
void SetupPPMCParams(int comPort, string pathToFirmware, string
downloadParamsFile);
void DownloadFirmware(string pathToFirmware, string downloadFilename);
void UpdateBootSettings(string pathToFirmware, string bootFileInfo);
}
}
///copyright agilent technologies 2003
///filename: IPowerMeterMeasModule.cs
///author: Steve Welsh
Agilent .NET Course: More Objects 13

date: September 2003
///change history -
///module testing history -
///description - This file is the Measurement level public I/F for PowerMeterMeasImp.cs
///and as such contains only declarations of the methods defined within the
implementation
///
using System;
//using agilent.sqf.of.common_enums;
using Agilent.Sqf.Of.Common_enums;
using Agilent.Sqf.Of.Instrument;
using System.Collections;
namespace Agilent.Sqf.Of.PowerMeter
{
public interface IPowerMeterMeasModule
:Agilent.Sqf.Of.Instrument.IInstrumentMeasModule,
Agilent.Sqf.Of.PPMC.IPPMCInstrument
{
void CalibratePowerMeter(CommonEnums.CHANNEL Channel,
CommonEnums.CALIBRATE ZeroOrAuto);
void SetRefPortState(bool On);
double MeasurePower(CommonEnums.POWER_MEAS_TYPE MeasType,
CommonEnums.CHANNEL PrimaryChannel, CommonEnums.CHANNEL
SecondaryChannel);
}
}
Introduction to .NET
Agilent .NET Course: More Objects 14

Name:
Course: Introduction to .NET
Title: Module 10
Instructor: Andrew Cumming
.NET

10 Day 5 pm
10.1 Contents
Morning session
• 1 mW Test
Afternoon
• More on Sorting
• Events and Delegates
• Attributes
• Review
Introduction to .NET
Agilent .NET Course: Module 10,page 2

10.2 Implementing an interface
In Module 3 we saw that to use the Sort() method on our ArrayList world we had to
implement the IComparable interface in the Country class.
This is achieved with two steps:
1. Include the restriction : IComparable in the declaration of the Country class
2. Fill in the method .CompareTo(Object obj) in the Country class.
Code to allow Sort of an ArrayList of Country
public class Country : IComparable
. . .
#region IComparable Members
///
/// Compare two countries by name
///
/// The other country
///
public int CompareTo(object obj)
{
return this.Name.CompareTo(((Country) obj).Name);
}
#endregion
In order to sort by another field (for example population) we must use a different
overloading of the Sort method.
duction to .NET
Intro
public virtual void Sort(
IComparer comparer
);
Despite the similar name IComparer has a different signature. It requires exactly
one method Compare:
int Compare(
object x,
object y
);
Agilent .NET Course: Module 10,page 3

We can create the required method in the user interface – this involves creating an
“empty” class.
Code to allow Sort of an ArrayList of Country
private class PopComparer : IComparer
{
int IComparer.Compare(Object x, Object y )
{
//x and y are both countries.
//We must return...
// -1 if population of x is less than population of y
// 0 if populations are equal
// 1 otherwise
throw new Exception("Not implemented yet!");
return 0;
}
}
private void SortPop_Click(object sender, System.EventArgs e)
{
world.Sort(new PopComparer());
}
In this code we are creating object simply to satisfy interfaces.
Introduction to .NET
Agilent .NET Course: Module 10,page 4

10.3 Review of terms
For each of the following terms give an example from the Megalomania code or
elsewhere:
Term Example Explanation
Class
Namespace
Parameter
Method
Accessor
private property
public method
duction to .NET
Intro
override
method
ArrayList
Constructor
Agilent .NET Course: Module 10,page 5

10.4 Any Others
Term Example Explanation
Intro
duction to .NET
Agilent .NET Course: Module 10,page 6

10.5 Hiding members
We can hide the properties of our classes so that they may not be directly accessed.
Many object‐oriented practitioners regard this as good practice.
Before protection
public class Country
{
public string name;
public string region=null;
public int area=-1;
public int population=-1;
public long gdp=-1;
After protection
public class Country
{
private string name;
private string region;
private int area;
private int population;
private long gdp;
duction to .NET
Intro
public string Name{get{return this.name;}}
public string Region{get{return this.region;}}
public int Area{get{return this.area;}}
public int Population
{
get{return this.population;}
set{this.population=value;}
}
public long Gdp{get{return this.gdp;}}
In this case have hidden the private members – they can only be accessed from
within the Class. We have exposed members with slightly different names. From
outside the class we may refer to uk.Name but not uk.name (where uk is a Country).
Also we have made most of these exposed properties read only.
The Population member is writeable – this means we can assign uk.Population just
as we used to be able to do.
Which of these is permitted from outside the class
int a = uk.population;
string s = uk.Name;
long b = uk.Gdp; uk.Population = 58000000;
Agilent .NET Course: Module 10,page 7

uk.Gdp = 1000000000;
int c = uk.Region;
10.6 Creating an event
10.6.1 Why would we want to create an event
We use events in the user interface. The details are normally hidden – but the code
to our methods to the interface components is there:
private System.Windows.Forms.Button SortPop;
. . .
#region Windows Form Designer generated code
this.SortPop.Text = "Sort By Population";
this.SortPop.Click += new System.EventHandler(this.SortPop_Click);
. . .
private void SortPop_Click(object sender, System.EventArgs e)
Aside from the standard user interface components that do the hard work for us it is
a relatively unusual requirement to implement our own events. We might want to
create our own events if we want to be notified of some occurrence – but we do not
know what that might cause that.
We certainly want to create events if we want to implement our own components.
duction to .NET
Intro
10.6.2 What is involved in creating an event
We require the following
• An action to perform when the event is triggered (other people may create
other actions of the same type).
• A handler delegate – this restricts the signature of the actions that may subscribe.
• An event that holds a list of all subscribed actions.
The tasks that are required:
• In the publishing class we declare the delegate.
• In the publishing class we declare the event.
• In the publishing class we insert code to trigger the event under some circum‐
Agilent .NET Course: Module 10,page 8

stance.
• In the subscribing class we create a method that matches the delegate.
• In the subscribing class we subscribe to the event.
10.7 Megalomania2
10.7.1 How to subscribe
We require the detail section to be updated automatically whenever a change is
made to the country that is currently on display.
We have a method ShowDetailsOfCountry that updates this display:
private void ShowDetailsOfCountry(Object oCountry, EventArgs e)
{
Country c = oCountry as Country;
if (c!=null)
{
detailName.Text =c.Name;
detailRegion.Text =c.Region;
detailPopulation.Text = c.Population.ToString();
}
}
This takes in country and updates the three text boxes to reflect that country.
We call this routine whenever the user clicks on the list box.
duction to .NET
Intro
We want this routine to be called whenever the currently selected country is
changed. We want to be sure that it is not possible for the country to be changed
without this routine being fired.
Every time the user click on the list box we subscribe to the selected country’s On‐
Change event. This ensures that if the country gets changed the display will be
updated. Before we subscribe however we must un‐subscribe the previously selected
country.
Agilent .NET Course: Module 10,page 9

We keep a record of the country that is currently on display
//We do this so that we can "unsubscribe" it when the user
//selects a different item
Country CurrentlyFocussed = null;
Country.changeHandler CurrentlyFocussedCH = null;
//This is the action that causes the subject of the detail panel
//to change
private void worldLB_SelectedIndexChanged(object sender, System.EventArgs
e)
{
//Put details of the currently selected country
//in the detail text boxes
Country c =
world[worldLB.SelectedIndex] as Country;
ShowDetailsOfCountry(c,e);
//Now we want to subscribe to the OnChange event for this
//country.
//First we must unsubscribe whoever was registered before
if (CurrentlyFocussed!=null)
CurrentlyFocussed.OnChange -= CurrentlyFocussedCH;
//We create a new handler
CurrentlyFocussedCH = new
cia.Country.changeHandler(ShowDetailsOfCountry);
//We subscribe our new handler to the OnChange event of c
c.OnChange += CurrentlyFocussedCH;
//Remember the currently focussed item so we can unsubscribe
CurrentlyFocussed = c;
duction to .NET
Intro
}
//Show the user which record we are on
label6.Text = String.Format("{0}/{1}",
worldLB.SelectedIndex.ToString(),
worldLB.Items.Count);
Agilent .NET Course: Module 10,page
10

10.7.2 How to publish
The class Country is the publisher.
public delegate void changeHandler
(object country, System.EventArgs e);
public event changeHandler OnChange;
public int Population
{
get{return this.population;}
set
{
this.population=value;
if (OnChange!=null)
OnChange(this,null);
}
}
10.8 Benefits of using events
We have created an application in which the user interface is able to respond to
changes in the data.
Crucially the Country class has no connection with the user interface – even though
the trigger action takes place inside the Country class we do not have to recompile
the Country class to take account of changes to the user interface.
duction to .NET
Intro
Our interface will respond to changes even if third parties. Some other user who has
no interest in our interface may make changes. We are monitoring the objects “invisibly”.
Agilent .NET Course: Module 10,page
11

10.9 Tutorial
duction to .NET
Intro
1. In Megalomania2.cs implement the “Sort By Population” button.
a. Find the PopComparer.Compare method.
b. Remove the exception that is currently thrown.
c. Implement a comparison based on the population. You will need to:
i. Cast both objects x and y as Country
ii. Use the Population property (note that the member population
with lower case has been hidden now and Population exposed
as read only).
iii. Population is an int – this supports a CompareTo method – it
works just like the one we used with strings.
2. Complete the button “Show UK region”. Note that we now have to use
uk.Region and that uk.region is unavailable.
3. Complete the button “Change UK region” – you may move the UK to Africa.
Initially the Region property is read only. You will have to change this in
Country.cs
a. Use the set statement for Population as an example.
b. If you include all three of the lines then the Region should automatically
be updated.
c. If you do not include the OnChange lines then the event will not get
triggered.
4. Page 630 includes an example of how to Serialize an object. We can use this
technique to make the world persistent.
a. In the Closing event of the form we can add code to write world to a
file.
i. Use the object browser to find details of the BinaryFormatter
ii. Use the object browser to find details of the FileStream
b. Currently the OnLoad event of the form reads world in from a text
file. This can be changed so that it DeSerializes instead.
Agilent .NET Course: Module 10,page
12