Introduction to C# Hands-On Lab for Embedded Windows Developers

C# Hands On Lab Embedded Windows Developers Conference

Microsoft Windows Embedded Developers Conference
HANDS-ON LAB

Introduction to C#

Developed by
Paul Yao
The Paul Yao Company
http://www.paulyao.com

© Copyright 2001-2002 The Paul Yao Company Page 1 of 28


HANDS-ON LAB

Introduction to C#

Copyright © 2001-2002 The Paul Yao Company. All Rights Reserved.
This document may be reproduced provided that the document is reproduced in its entirety, and
provided that the original copyright notice is included.

Windows is a registered trademark of Microsoft Corporation



Introduction
This hands-on lab introduces programmers to key features of the C#
language, the Common Language Runtime (CLR), and the Visual
Studio .NET development environment.

Objectives.
In this Hands-On session, you work with Visual Studio .NET to build C# applications.
You can build applications for either the desktop, using the .NET Framework, or for
Windows CE-based platforms, using the .NET Compact Framework.

The six exercises in this lab period introduce you to using Visual Studio. NET to build
character-based applications. The emphasis is on features unique to C#, to .NET, from
the perspective of a C or C++ programmer. Programmers familiar with Visual Basic
.NET will find many familiar concepts, and will get from these exercises an appreciation
for differences between the syntax of Visual Basic .NET and the syntax of C#.

After completing this set of exercises, you will be able to:
• Use Visual Studio.NET to create C# applications.
• Build, run, and debug C# programs using Visual Studio.NET.
• Work with basic data types, convert data types, and perform string operations.
• Define and use the elements of C# classes
• Use container classes and enumerate through containers
• Write code to intercept and handle exceptions; raise exceptions.

Lab Configuration
Each workstation has the following software installed.
• Windows XP Professional
• Visual Studio.NET "Everett"
• .NET Framework Libraries

For More Information on C#
http://msdn.microsoft.com/vstudio/techinfo/articles/upgrade/Csharpintro.asp

Estimated Time to Complete These Labs
60 Minutes

Index of Exercises
Exercise 1 – Creating Character-Based Console I/O...........................................................4
Exercise 2 – Common C# Value Types...............................................................................8
Exercise 3 – Defining Classes............................................................................................12
Exercise 4 – Containers.....................................................................................................18
Exercise 5 – Enumerating Objects.....................................................................................22
Exercise 6 – Exception Handling.......................................................................................25



Exercise 1 – Creating Character-Based Console I/O
This exercise shows you how to create the classic Hello World program using the C#
programming language and the Microsoft Visual Studio.NET development environment.

Objectives
After completing this exercise, you will be able to:
 Create a new project in Visual Studio.NET. (step 1-2)
 Write a character-based program to display a character string. (step 3-5)
 Identify the entry point to a C# program. (step 6)

Steps
Instructions. The left column describes the purpose of a given step. The right column
provides detailed directions to accomplish the step.

Objective 1: Create a new project in Visual Studio.NET
1. Start Visual Studio.NET a. Click the following menu item: Start -> Programs ->
Microsoft Visual Studio.NET -> Microsoft Visual
Studio.NET

2. Create a new Empty a. Within the Visual Studio.NET IDE, select this menu:
project File->New->Project…
b. In the Project Types list, select "Visual C# Projects"
(See below for .NET c. In the templates list, select "Empty Project"
Compact Framework) d. In the project Name, type a project name with your
name (first or last) followed by the number '1' (for
exercise 1) as in "PaulYao1".
e. Click Ok.

.NET Compact Framework Changes
To build for the .NET Compact Framework, follow steps 'a' and 'b' as
listed above. Then, continue with step 'c', below:
c. In the template list, select "Smart Device Application".
d. Name your project with your name + '1" (example: PaulYao1).
e. Click Ok.
f. In the "Smart Device Application Wizard", do not pick Pocket PC
since it does not support console applications. Instead::
• For platform, pick "Windows CE"
• For project type, pick "Empty Project"



Objective 2: Write a character-based program to display a character
string
3. Add a new code file to a. Select the File -> Add New Item… menu
the project b. In the Templates window, click on the "Code File"
icon.
c. Click Open.

4. Write a program that a. Add the code listed below to your source file.
displays the character string
"Hello Character World" on
the command line.

using System;

class Hello
{
static void Main()
{
System.Console.WriteLine("Hello Character World");
System.Console.ReadLine();
}
}

Things To Note:
 The using keyword identifies the assemblies that we expect to use in our program.
Visual Studio.NET uses the metadata found in each assembly to learn about the
available namespaces, classes, and methods. The metadata also describes the



number of parameters, the type of parameters, and the return type for each
method.
 C# code is organized using namespaces and classes. This code calls a method
named WriteLine, a method in a class named Console. The Console class resides
in the System namespace. A period (".") separates a namespace name from a
class, and a class name from a method name.

5. Build and run your a. Build your program using the menu command Build ->
program Build Solution. As an option, you can also use the
shortcut key, namely Ctrl+Shift+B.
b. Run your program using the menu command Debug-
>Start Without Debugging. As an alternative, you
could hit the Ctrl+F5 shortcut keystroke.
c. You see a window open, like the fragment shown here:

Hello Character World
Press any key to continue

.NET Compact Framework Changes
To run in the Windows CE emulator:
• Make sure the "Device" selection toolbar is visible – Right-Click
on the menu, then make sure there is a checkmark next to the
"Device" item.
• In the device toolbar, make sure that "Windows CE .NET
Emulator" is highlighted, as shown here:

• Start running as indicated above – by selecting Debug -> Start
Without Debugging, or by hitting <Ctrl>+F5.

Objective 3: Identify the entry point to a C# program
6. Use the debugger to find a. If the program is running, stop it.
the program entry point. b. Step into the debugger, using either a menu selection or
a keystroke:
• Menu: Debug -> Step Into
• Key: <F11>
c. Experiment with using the following keys to learn
about the built-in debugger:



• <F9> - Set breakpoint at current cursor position
• <F10> - Step Over (single-step, stay in current
function)
• <F11> - Step Into (single-step, follow calls into
functions)
• <F5> - Continue (resume normal execution)

Things To Note:
 The entry point for a C# program is the method Main.
 Main must be a static method (note the keyword "static" in the code).
 In C#, methods must appear inside classes – the is no such thing as a global
function as in C or C++. That is why Main is in the Hello class.

More Things To Try
If you have extra time, here are some things to try. For each numbered item, build and
run your program:
1. What happens if you remove the using System; statement? What if, in addition, you
remove the System reference in the call to System.Console.WriteLine? Hint: don't
forget to remove the period that follows System., so that the resulting call is

Console.WriteLine("Hello Character World");

2. Move the Main method out of the Hello class? (That is, delete the keywords class
Hello and the associated curly braces.)

3. What happens if you clone class Hello - copy it, paste it, and rename it to something
like Hello2?



Exercise 2 – Common C# Value Types
This exercise introduces you to basic C# data types, shows how to convert between data
types, and introduces basic string operators.

Objectives
 Write code to allocate fundamental C# Value types, including byte, int, and long.
 Write code to use the allocated Value types
 Write code to convert different Value types to a string for display to the user.
 Perform various string operations.

Steps

1. Create a new Windows a. Within the Visual Studio.NET IDE, select this menu:
Application project File->New->Project…
c. In the templates list, select "Console Application"
Note: select "Smart Device Application" for .NET
Compact Framework; then for the platform select
"Windows CE".
d. In the project Name, type a project name with your
e. Click Ok.

2. Allocate a variable of a. Within the Main method, allocate a local variable of
type byte, determine the type byte named b. At the start of Main, type the
maximum value that can be following line of code:
stored, convert that value to byte b;
a string, and display it.
b. Set the initial value of this byte to the maximum value
that can be stored in a byte. Do this by accessing the
static byte.MaxValue() method, as in:
b = byte.MaxValue;

c. Convert this to a string by calling the static method
byte.ToString(). Display the results in the console
window:
Console.WriteLine("Maximum Byte is " +
b.ToString());

3. Allocate a 32-bit variable a. Within the Main method, allocate a local variable of
of type int, determine the type int named i. At the start of Main, type the



stored, and display it. int i;

b. Set the initial value of this 32-bit integer to the
maximum value that can be stored in an integer. Do
this by accessing the static int.MaxValue() method, as
in:
b = int.MaxValue;

int.ToString(). Display the results:
Console.WriteLine("Maximum int is " +
i.ToString());

4. Allocate a 64-bit variable a. Within the Main method, allocate a local variable of
of type long, determine the type long named l. At the start of Main, type the
stored, and display it. long l;

b. Set the initial value of this 64-bit integer to the
maximum value that can be stored in a long value. Do
this by accessing the static method long.MaxValue(),
as in:
l = long.MaxValue;

long.ToString(). Display the results:
Console.WriteLine("Maximum long is " +
l.ToString());

5. Allocate two strings, then a. Allocate two strings using the type string, as shown
concatenate them – using here:
the “+” operator – to form a string strFirst = "Hello ";
string strSecond = "World";
third string. Display the
resulting string.
b. Allocate a third string, and initialize it with the
previous two strings appended together – as in:
String strThird = strFirst + strSecond;

c. Display the resulting string using the following code:
Console.WriteLine(strThird);

6. Determine the length of a a. Calculate the size length of a string, strThird, using
string using the public code like the following:
property String.Length. int cchLength = strThird.Length;
Call the String.Substring
method to cut some b. Allocate a string holding the length, and display it
characters from the middle using code like this:
string strFourth = "Length is " +



of a string. Display the cchLength.ToString();
Console.WriteLine(strFourth);
results of both operations.
c. Call the String.Substring to cut a string out from
another string. Display the string:
Console.WriteLine(strThird.Substring(0,5))
;

7. Allocate a DateTime a. To allocate a DateTime object, you must call the new
object, initialize its contents operator, as in this code:
to today's date, and display DateTime dt = new DateTime(2002, 10, 24);
the string.
b. Like other types, the DateTime class has a ToString
method to convert the object to a string, using code like
this:
string strFifth = dt.ToString();

c. Display this string using code like this:
Console.WriteLine(strFifth);

Things To Note:
 C# provides two basic categories of types: Value types and Reference types.
Value types directly hold their data, while reference types hold a reference - a
pointer - to the value on the heap. In the code you wrote, all of the integer types
are Value types. DateTime is also a Value type. The String class, on the other
hand, is a Reference type.
 You created several different types of integers, each with a different maximum
value. You saw that C# provides 8-bit, 32-bit, and 64 bit integers. Each of these
types is fully supported in the .NET Common Language Runtime (CLR). There is
one more integer size that you did not create - a 16-bit integer, which is available
using the short keyword. The C# types byte, short, int, and long are aliases for
the following CLR Value types: System.Byte, System.Int16, System.Int32, and
System.Int64.
 There is a rich set of string operators that make it easy to create, concatenate, and
perform operations on strings. If you do a lot of string operations, you should look
into the StringBuilder class instead of the String class. The String class creates a
new memory object for each operation, while StringBuilder performs most of its
operations on a single string – thus making it more efficient from the perspective
of memory usage.
 The DateTime class stores dates and times. A related structure, TimeSpan, can
be used to store the results of subtracting one date from another.

More Things To Try
If you have extra time, here are some things to try. For each numbered item, build and
run your program:
1. In addition to its integer types, C# also supports float (32-bit floating point), double
(64-bit floating point), as well as decimal (128-bit floating point) which guarantees



precision when performing operations on monetary values. Write some code using all
of these types, and display the results in the console window. (Each type provide a
ToString method.)
2. Search the help database for other members of the String class, and experiment with
them. Display your results in the console window.
3. Experiment with the StringBuilder class to create strings, concatenate strings, and
display strings in the console window.
4. Experiment with creating a TimeSpan by subtracting one DateTime from another.
Display the results in the console window.



Exercise 3 – Defining Classes
This exercise introduces you to some of the unique features of C# classes.

Objectives
 Describe the difference between static & instance methods (steps 1-4).
 Inherit from an existing class to create a new class (steps 5-6)
 Add properties to a class, including read-only properties, write-only properties,
and read/write properties (steps 7-8)
 Implement a dynamic link library which contains a class (steps 9-14).

Steps

Objective 1: Describe the difference between static and instance
methods.
"Windows CE".
e. Click Ok.

2. Create a class named 'A' a. Browse the source file window that is open. Look for
that contains an instance the "namespace" keyword, which appears in blue, and
method and a static method. the curley-brace "{" that follows that keyword.
b. In the line following the two lines mentioned above,
define a new class by typing code like the following:

class A
{
static public void Static_Member()
{
Console.WriteLine("Calling from Static_Member");
}
public void Instance_Member()
{
Console.WriteLine("Calling from Instance_Member");
}
}



Things To Note:
 A static functions starts with the keyword 'static'.
 The 'public' keyword says that methods are accessible from outside the class.

3. Within the body of the a. Locate the Main function.
Main function, call each of b. Add code like the following:
these functions.

A myA = new A();
A.Static_Member(); // Call static methods with class name.
myA.Instance_Member(); // Use instance to call instance method.

Things To Note:
 Call static functions by specifying the name of the class followed by the name of
the function.
 Call instance functions by specifying an instance of the object, followed by the
name of the function.

4. Build and run your a. You should see output like the following:
program.

Objective 2: Inherit from an existing class to create a new class
5. Create a class named 'B' a. Add code like the following:
that inherits from class 'A'.
Create three private integer
values in the class.

class B : A
{
private int m_x;
private int m_y;
private int m_z;
}

Things To Note:
 Just like in C++, the colon operator indicates inheritance from a base class.
 C# classes can hold data members and member functions, just as in C++.
6. Create an instance of B. a. Within the Main function, type code like the
Call its member functions, following:
and attempt to access its



private data members.

B myB = new B();
B.Static_Member();
myB.Instance_Member();
m_x = 1;
m_y = 2;
m_z = 3;

Things To Note:
 You will be able to call the member functions, but the private data members are
not accessible. For that you need to define properties. A property looks like a data
member, but it has a public "get" and/or "set" member that allows the reading or
writing of a value that is controlled by a function call.

Objective 3: Add properties to a class, including read-only properties,
write-only properties, and read/write properties
7. Modify class B to add a a. Within the Main function, type code like the following:
read-only property (X), a
write-only property (Y), and
a read/write property (Z).

public int X
{
get { return m_x; }
}

public int Y
{
set { m_y = value; }
}

public int Z
{
get { return m_z; }
set { m_z = value; }
}

8. Write code to read from a. Type the following code in the Main function.
& write to each of these b. Build your program.
properties. c. When you get errors – and you will – jump to each
error message in turn by hitting these keys: <Alt> +
<F12>.
d. Comment out the lines that cause errors until you can
build without errors. Run your program.

myB.X = 1;
myB.Y = 1;



myB.Z = 1;
Console.WriteLine(myB.X.ToString());
Console.WriteLine(myB.Y.ToString());
Console.WriteLine(myB.Z.ToString());

Things To Note:
 Uninitialized data members have a default value of zero.

Objective 4: Implement a dynamic link library which contains a class.
9. Create a new dynamic a. Create a second project in Visual Studio .NET. Do this
link library. by following these steps:
• Open the Solution Explorer window (menu View ->
Solution Explorer)
• Right-Click the top-line – the one that says
"Solution" on it – and from the popup menu picking
the command Add -> New Project . . .
• You see the "Add New Project" window.
b. The item you select depends on whether you are
building for the desktop or for Smart Devices:
• For the desktop, select "Class Library"
• For a .NET Compact Framework library, select
"Smart Device Application" template, then pick
"Class Library in the Smart Device application
wizard.
c. For the project name, use your name followed by the
letters "ALib" as in "PaulYaoALib".
d. Click Ok.

10. Move class 'A' from a. Delete (Cut) the source file from the application
your application to the DLL source file and copy it (Paste) to the DLL source file.
source file.

11. Build library & a. Select menu Build -> Build Solution.
application b. Fix whatever build errors you encounter. The next step
fixes a build error by creating a reference to the library
in the application project.
12. Fix missing assembly a. If you deleted class A, you see this error message:
reference.
"The type or namespace name 'A' could not be
found (are you missing a using directive or an
assembly reference?)"

b. Open the Solution Explorer window – select the
following menu item: View -> Solution Explorer. In
the Solutions Explorer window:



• Find the application tree (example: 'PaulYao3')
• Find the "References" folder in the application tree
and Right-click on this folder
• Select Add Reference. . . in the popup menu. This
opens the Add Reference window.
c. In the Add Reference window:
• Click the [Projects] tab.
• Double-click on the library project.
• Click Ok.

14. Make sure that class is a. In the Solution Explorer window:
public and add a 'using' • Right-Click the library you added in the previous
directive step.
• Select the View In Object Browser menu item.
b. You see output like the following in the object browser
window:

The library "paulyaoalib" contains namespace
"paulyaoalib" which contains two public classes, A
and Class1.
c. If you do not see class A, modify your library by
appending the keyword "public" to the class A
declaration, like this:

public class A

Rebuild your library. Note that the Object Browser
caches its information. To see changes, you need to
add the library to the Object Browser window a second
time.
d. In the application, add a reference to the library
namespace with the 'using' directive:
using PaulYaoALib;



Things To Note:
 You can use the object browser to explore all of the system libraries, and it will
provide lots of interesting details. For example, the object browser shows that the
base class for the class we created, class A, is System.Object. This is the
case, even though we did not explicitly name this as our base class.



Exercise 4 – Containers
This exercise introduces you to three types of containers: fixed-length arrays, variable-
length arrays, and queues. These are three of the many kinds of container classes – also
known as "collection classes" – available to .NET programmers.

Objectives
 Write code to allocate, initialize, and access data in fixed-length arrays
(steps 1 – 4).
 Write code to allocate, initialize, and access data in variable-length arrays
(step 5).
 Write code to allocate, initialize, and access data in a queue (step 6).

Steps

Objective 1 – Write code to allocate, initialize, and access data in
fixed-length arrays.
"Windows CE".
e. Click Ok.

2. Create and initialize an a. Here is what the desired output looks like:
array of 5 integers. Dump
the contents of the array to
the console:
b. Enter code like that shown below.
c. Build and run your program

int[] i = new int[5] {10, 20, 30, 40, 50};
int j;

for (j = 0; j < 5; j++)
{
Console.WriteLine("Index= " + j.ToString() +



" & Value = " +
i[j].ToString());
}

array of 3 strings. Dump the
contents of the array to the
console. b. Enter code like that shown below.

string[] str = new string[3] {"One", "Two", "Three" };
int iStr;

for (iStr = 0; iStr < 3; iStr++)
{
Console.WriteLine("Index= " + iStr.ToString() +
" & Value = " + str[iStr]);
}

array of 2 dates. Dump the
contents of the array to the
console. b. Enter code like that shown below.

DateTime[] dt = new DateTime[2]
{
new DateTime(2002,5,1), new DateTime(2002, 6,1)
};
int iDate;

for (iDate = 0; iDate < 2; iDate++)
{
Console.WriteLine("Index= " + iDate.ToString() +
" & Date = " + dt[iDate].ToShortDateString());
}

Things To Note:
 Array support built into C# creates fixed size arrays.
 Arrays are allocated using the 'new' operator, just like other objects. Like other
objects, the memory management is the same – the garbage collector reclaims the
memory for objects that are unreachable.
 You can create arrays for int, string, and date types, as shown here, and also for
other value types including float, decimal, etc. In addition, array elements can be



of any type, including an array type. When building .NET Windows Forms
applications, for example, the following two lines would be valid:

// Arrays can be created for any type, including
// for Windows Forms controls and fonts, as shown here:
Control [] acc = new System.Windows.Forms.Control[4];
System.Drawing.Font [] myFonts = new System.Drawing.Font[15];

Objective 2 – Write code to allocate, initialize, and access data in
variable-length arrays.
5. Create an ArrayList a. The desired output is shown here:
and add three elements of
different types – say a
string, an integer, and a
date. Display the contents of b. Enter code like that shown below.
the array on the console. c. Build and run your program

ArrayList al = new ArrayList();

al.Add("Hello");
al.Add(new DateTime(2002,10,23));
al.Add(15);

Console.WriteLine(al[0]);

Things To Note:
 Fixed-length arrays must contain objects of the same type. An ArrayList array can
hold objects of different types.

Objective 3 – Write code to allocate, initialize, and access data in a
queue.
6. Create a Queue and add a. The desired output is shown here:
three elements of different
types. Display the elements
on the console.
b. Enter code like that shown below.

Queue q = new Queue();
q.Enqueue("Compact Framework");
q.Enqueue(new Decimal(123.456) );
q.Enqueue(654.321);



Console.WriteLine(q.Dequeue());

Things To Note:
 A .NET Queue can hold any type of object.
 Add elements to a queue by calling Queue.Enqueue.
 Remove elements from a queue by calling Queue.Dequeue.



Exercise 5 – Enumerating Objects
This exercise introduces you to the basics of enumerating objects in the .NET framework
using the C# foreach keyword.

Objectives
 Enumerate through a fixed-length array (steps 1-2)
 Enumerate through an ArrayList collection (step 3)
 Enumerate through a Queue collection (step 4)

Steps

Objective 1: Enumerate through a fixed-length array
1. Open the project from a. Within the Visual Studio.NET IDE, select this menu:
exercise 4 File->Open->Project…
b. Select the project name from the previous exercise. If
you had been following the established convention, you
have been using <your-name>4 – for example,
PaulYao4.
c. Click Ok.

2. Use the foreach statement a. Locate the three simple arrays created – one for string,
to enumerate through the array, and integer.
contents of a simple array. b. Modify the loop to use the foreach statement, as shown
in the following code:

// Integer array
int[] i = new int[5] {10, 20, 30, 40, 50};
foreach (int j in i)
{
Console.WriteLine("Value = " + j.ToString());
}

// String array
string[] str = new string[3] {"One", "Two", "Three" };
foreach (string s in str)
{
Console.WriteLine("Value = " + s);
}

// DateTime array
DateTime[] dt = new DateTime[2]
{
new DateTime(2002,5,1), new DateTime(2002, 6,1)



};
foreach (DateTime thisdate in dt)
{
Console.WriteLine("Value = " + thisdate.ToShortDateString());
}

Things To Note:
 An index to count items is not required – the iteration walks though the exact
number of items in each array.

Objective 2: Enumerate through an ArrayList collection
3. Use the foreach a. Locate the ArrayList defined in the last exercise.
statement to access the b. Modify the code to use the foreach iterator to display
elements of an the contents of the array, using code like the following:
ArrayList.

ArrayList al = new ArrayList();
al.Add("Hello");
al.Add(new DateTime(2002,10,23));
al.Add(15);

foreach (object ob in al)
{
Console.WriteLine(ob);
}

Things To Note:
 Since an ArrayList can hold different kinds of objects, you use the base type
object for the iteration.
 You can enumerate any class with the C# foreach statement if the class
supports a GetEnumerator method. To enumerate programming languages
besides C# - say Visual Basic .NET – a class must implement the IEnumerable
interface.

Objective 3: Enumerate through a Queue collection.
4. Use the foreach a. Locate the Queue in the last exercise.
statement to access the b. Modify the code to use the foreach iterator to display
elements of a Queue. the contents of the queue, using code like the
following:

Queue q = new Queue();
q.Enqueue("Compact Framework");
q.Enqueue(new Decimal(123.456) );
q.Enqueue(654.321);



foreach (object o in q)
{
Console.WriteLine(o);
}

Things To Note:
 Since a Queue can hold different kinds of objects, you use the base type object
for the iteration.
 When you access the elements of a queue with an iterator, it does not change the
contents of the queue. The other technique for accessing queue elements – using
the Dequeue statement – does cause elements to be removed.



Exercise 6 – Exception Handling
This exercise introduces you to the syntax for C# exceptions.

Objectives
 Write code to catch exceptions. (steps 1-5)
 Write termination handling code. (steps 6-7)
 Write code that throws an exception. (step 8)

Steps

Objective 1: Write code to catch exceptions.
1. Create a new Windows c. Within the Visual Studio.NET IDE, select this menu:
d. In the Project Types list, select "Visual C# Projects"
e. In the templates list, select "Console Application"
"Windows CE".
f. In the project Name, type a project name with your
g. Click Ok.

2. Create the skeleton code a. Basic exception handling involves the key words try
for an exception and catch. The basic skeleton appears here:
try
{
}
catch (System.Exception except)
{
}

Things To Note:
 C# exception syntax is the same as that for C++ exception handling.
 The try block contains the mainline execution code.
 The catch block contains the exception handling code.

3. Add code that displays a a. Add in four calls to Console.WriteLine, as in the
message before, during, and example below.
after the exception block. b. Build and run your program.
Test your code.



Console.WriteLine("1. Before");
try
{
Console.WriteLine("2. In try block");
}
catch (System.Exception e)
{
Console.WriteLine("3. In exception block");
}
Console.WriteLine("4. After");

The output looks like this:

Things To Note:
 During normal program execution, the exception block does not execute.

4. Add code that generates a. The sample code, below, creates an array overflow
an exception. Examples exception.
worth trying include divide- b. Put the exception code OUTSIDE the exception block.
by zero, array overflow. c. Build and run your program – what happens to an
unhandled exception?
d. Move the exception code INSIDE the try block.
e. Build and run your program..

int[] i = new int[2];
i[2] = 5;

5. To determine the cause of a. Add the following code to the catch block of your
an exception, you can exception handling code.
examine members of the
System.Exception-
based objects. Add code to
do that in your program

Console.WriteLine("Type = " + e.GetType());
Console.WriteLine("Message = " + e.Message);
Console.WriteLine("Source = " + e.Source);
Console.WriteLine("StackTrace = " + e.StackTrace );
Console.WriteLine("TargetSite = " + e.TargetSite);

Objective 2: Write termination handling code.
6. Create an empty try – a. Enter code like the following.
finally block. b. Build and run your program.



Console.WriteLine("A. Before");
try
{
Console.WriteLine("B. During");
}
finally
{
Console.WriteLine("C. In finally block");
}
Console.WriteLine("D. After finally block");

Things To Note:
 The finally block is part of normal program execution.
 The finally block executes whatever cleanup might be needed for the try
block – closing a network connection, closing a file, writing a record to a
database.
 Termination handling (try-finally) can be integrated with an exception
(try-catch) block to guarantee cleanup even when an exception has occurred.
 There is no C++ support for try/finally. However, Win32 does have support that is
provided with the __try and __finally keywords (note the leading pair of
underscores, "__", for each of these keywords).

7. Add a catch block to the a. Your code appears as below – new items are in bold.
existing try-finally block. b. Build and run the program.

Console.WriteLine("A. Before");
try
{
Console.WriteLine("B. During");
}
catch (System.Exception e)
{
Console.WriteLine("B.5. In exception block");
}
finally
{
Console.WriteLine("C. In finally block");
}
Console.WriteLine("D. After finally block");



Objective 3: Write code that throws an exception.
8. Throw an exception using a. Add code, like that shown below, to your program –
the C# throw statement. first OUTSIDE a try-block.
b. Build and run the program.
c. Move the code to inside a try-block.
d. Build and run your program again.

throw(new System.Exception("Whoops - hens do not have teeth"));

Things To Note:
 To generate an exception, you create a new object – either of type
System.Exception, or of a type derived from System.Exception.
 There are three constructors for System.Exception, allowing you to modify the
type of exception you create.


Introduction to C# Hands-On Lab for Embedded Windows Developers

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (18)

Ähnlich wie Introduction to C# Hands-On Lab for Embedded Windows Developers

Ähnlich wie Introduction to C# Hands-On Lab for Embedded Windows Developers (18)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Introduction to C# Hands-On Lab for Embedded Windows Developers