Institute of Information and Technology

Lab Manual

Dot NET

2014-2015
 Programming with .NET

Introduction

Microsoft developers working with Visual Studio and COM/OLE

technologies have always enjoyed the benefits of a choice of
programming languages for development of applications and
components. Well, sort of. (For instance, components developed in one
programming language couldn't be "inherited" from another
programming language.) With the introduction of the CLR and the .NET
Framework, this flexibility in the choice of any supported programming
language for .NET components and applications still remains a key
requirement. Out of the box, the .NET Framework and the key tool
supporting the development, Visual Studio .NET, support four
programming languages: Visual C#, Visual Basic .NET, Managed C++
(also known as Visual C++ .NET), and Visual J#. In addition, because
CLR has already been recognized as a developing standard, third-party
Independent Software Vendors (ISVs) and researchers can "port" other
programming languages to compile to the .NET runtime.

The genesis to this programming flexibility occurred for two reasons:

flexibility and, ease of migration and skills reuse. For instance, millions
of Visual Basic developers worldwide can choose the Visual Basic .NET
programming language for utilizing and enhancing their existing skills;
C++ and Java developers have the option of using either Managed C++,
Visual J#, or the new, innovative C# programming language. All four
programming languages have similar common features; most can be
used for achieving similar results. Each, however, has its own benefits
and differentiators, but most of the differences lie in the language
syntax.

This chapter briefly discusses four programming languages. A full

description of all the features of each of the individual programming
languages deserves a book by itself; there are, in fact, multiple sets of
books that discuss each language individually. The rest of this chapter
follows a hands-on, down-to-the-code style of introduction to
programming languages. Each of the language sections is divided into
similar sections:

Hello World
Comments
Data types
Enumerations
Arrays
Variables and constants
Expressions
Statements
Classes
Inheritance
Interfaces
Exception handling
Events
Delegates
C#

The C# programming language (pronounced "C sharp") was introduced

with the .NET Framework. It represents a milestone in the area of
programming language development. Even though the genesis of the
new C# language is in existing programming languages such as Java and
C++, it represents the most innovative, modern, and even—in most
areas—the preferred .NET programming language. C# was introduced to
combine the key values of Visual Basic and C++. Whereas Visual Basic
had ease of use and high developer productivity, C++ represented the
ultimate flexibility and control. C# merges the two; it is relatively
simpler than C++ (no pointers, templates, and so on), and it has all the
nice object-oriented features of C++ and the ease of use of Visual Basic.
No more specific memory allocation is required, as everything is
"garbage collected" by the common runtime. In various ways, C# is also
similar to the Java programming language, which has gained wide
developer support as well. However, whereas Java is intended to be a
platform-neutral programming language compiling into byte code and
then executed on a virtual machine, C# programs are compiled (like all
.NET programming languages) into MSIL (Microsoft Intermediate
Language) and, like all applications, are ultimately converted into
machine code before execution.
C# follows a code-focused model, targeted for developers who like the
simplicity of a modern programming language but typically prefer to
write programs by hand instead of generating them with wizards. This
enables easier reuse because the code is relatively easier to understand
by other developers using it. Key highlights of the C# programming
language are the following:

Ease of Visual Basic with the power of most C++ features

Similar programming language syntax for C++ and Java
developers
Support for all CLR data types
Pass by reference and value for parameters
Operator overloading (not found in Java)
Capability to run clearly marked "unsafe" code
XML-based documentation, using special comments
Integration with Visual Studio .NET for rapid development
 PROGRAM 1

Hello World

In this section, you'll take a look at a Hello World C# program. Each C#

application is composed of a class. If it is an executable application, one
of the classes available should have a static Main() method that serves
as the entry point. (The compiler would warn if Main was not declared
or improperly declared.) The Main method is overloaded and can have a
String array passed to it as well for any command-line parameters.

using System;
{
public class HelloWorld
{
public static void Main()
{
Console.WriteLine("Hello World in C#");
}
}
}

C# classes are stored in .cs files. After you have saved the preceding
program in a file, let's say Hello World, you can compile the program
into a .NET executable. You will need to include the .NET Framework
SDK's bin folder in your PATH variable. If you have installed Visual
Studio .NET, you have a shortcut under Visual Studio .NET Tools called
Visual Studio .NET 2003 Command Prompt. This shortcut initializes all
the environment variables and provides access to the command-line
compilers as well.
csc HelloWorld.cs

Now enter HelloWorld.exe to run the application, and you should see
"Hello World in C#" echoed on the screen.
Comments

C# provides a couple of ways to introduce comments in a program; the

two most popular are the traditional single-line comments (//) and the
multiline comments (/* */). In addition, C# provides XML-based
comments that can be used to create XML documentation from a set of
code files. These XML files can then be processed with an XSLT (XML
Stylesheet Language) to convert into online HTML documentation, and
so on.
using System;
{
/// <summary>
/// A Simple Class
/// </summary>
public class Comments
{
public static void Main()
{
// A Simple comment
/*
A multi
line comment
*/
Console.WriteLine("Hello World in
C#");
}
}
}
Data Types

Table 3.1 describes how the C# types are mapped into the corresponding
.NET Framework types. In a true sense, the C# keywords are really a
compact representation for the .NET type.

Table 3.1 C# Data Types

C# Type Corresponding .NET Framework Type

Bool System.Boolean
byte, sbyte System.Byte, System.SByte
Char System.Char
decimal, double, System.Decimal, System.Double,
single System.Single
short, ushort, System.Int16, System.UInt16,
int, uint, long, System.Int32, System.UInt32,
ulong System.Int64, System.UInt64
Object System.Object
String System.String
 PROGRAM 2

Enumerations

C# provides the enumerations programming construct, which provides a

human-readable form of a series of related constant values.
using System;
{
public class UseEnumerations
{
enum CreditCard
{
Visa = 0,
MasterCard = 1,
AmericanExpress = 2,
Discover = 3
}
public static void Main()
{
CreditCard mycard = CreditCard.Discover;
Console.WriteLine(mycard);
Console.WriteLine((int) mycard);
}
}
}
 PROGRAM 3

Arrays

Arrays provide developers with a structure for storing a collection of

values. Apart from arrays, the .NET Framework provides a series of
Collections constructs, including Hash Tables and ArrayList, which
provide capabilities such as dynamic sizing. You will look at some of
those constructs in the next chapter. Arrays can be processed by a
foreach construct.

using System;
{
public class UseArrays
{
public static void Main()
{
String[] days_of_week = {
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
};
foreach (string day in days_of_week)
{
Console.WriteLine(day);
}
}
}
}
 PROGRAM 4

Variables and Constants

Simple value types can be assigned using the variable = value construct,
whereas reference types are required to use the new keyword for
creating a new instance.
using System;
{
public class UseVariables
{
public static void Main()
{
const string HELLO_WORLD = "Hello World";
string message = HELLO_WORLD+ " in C#";
MyClass mc = new MyClass(message);
mc.Print();
}
}
public class MyClass
{
private String message;
public MyClass(String message)
{
this.message = message;
}
public void Print()
{
Console.WriteLine(message);
}
}
}
 PROGRAM 5

Expressions

Expressions in C# are very similar to those provided by Java and C++

programming languages.
using System;
{
public class UseExpressions
{
public static void Main()
{
int a = 10;
int b = 10;
int result = a * b;
bool check = (a == b);
Console.WriteLine(result);
Console.WriteLine(check);
}
}
}

Statements

As expected, the C# programming language includes several procedural

programming constructs, including if-else, for loop, while loop,
switch statements, and so on.

using System;
{
public class UseStatements
{
public static void Main()
 {
string[] message = {"Hello", "World",
"in", "C#"};
foreach (string msg in message)
{
Console.Write(msg+" ");
}
Console.WriteLine("");
int a = 10;
int b = 20;
if (a < b)
{
Console.WriteLine("a<b");
}
else
{
Console.WriteLine("a>=b");
}
}
}
}
 PROGRAM 6

Structures

Structures are simply an aggregation of value types and are allocated on

the stack and not on the heap. Structures are useful for passing a logical
and related set of data values. Structures don't support inheritance but
can implement interfaces. For instance, the following program would
print Hitesh.Seth followed by John.Doe and illustrates that structures are
not reference types.
using System;
{
public class UseStructures
{
public static void Main()
{
Person hs = new Person("Hitesh","Seth");
Person jd = hs;
jd.FirstName = "John";
jd.LastName = "Doe";

Console.WriteLine(hs.FirstName+"."+hs.LastName);

Console.WriteLine(jd.FirstName+"."+jd.LastName);
}
}
public struct Person
{
public string FirstName, LastName;
public Person(string FirstName, string
LastName)
{
this.FirstName = FirstName;
 this.LastName = LastName;
}
}
}
 PROGRAM 7

Classes

Classes, on the other hand, are reference types and hence are allocated
on the heap. Classes provide object-oriented constructs such as
encapsulation, polymorphism, and inheritance. For instance, the
following program would print John.Doe twice, illustrating that objects
are reference types, allocated on the heap.
using System;

{
public class UseClasses
{
public static void Main()
{
Person hs = new Person("Hitesh","Seth");
Person jd = hs;
jd.FirstName = "John";
jd.LastName = "Doe";
Console.WriteLine(hs.GetFullName());
Console.WriteLine(jd.GetFullName());
}
}
public class Person
{
private string sFirstName, sLastName;
public Person(string FirstName, string
LastName)
{
this.sFirstName = FirstName;
this.sLastName = LastName;
}
public string FirstName
{
 get
{
return sFirstName;
}
set
{
sFirstName = value;
}
}
public string LastName
{
get
{
return sLastName;
}
set
{
sLastName = value;
}
}
public String GetFullName()
{
return this.FirstName + "."+
this.LastName;
}
}
}
 PROGRAM 8

Inheritance

Classes provide inheritance capability, which allows the derived class to

inherit the functionality of a base class and potentially override some of
the methods. A class definition consists of constructors and destructors,
members, methods, properties, and events. (You will learn more about
events later in this section.) Unlike the Java programming language, in
C# all methods that are overridden must be marked as virtual in the
base class. The is operator provides runtime validation if an object is of
a particular type. For instance, the following program will return that a
FullPerson object is always a Person.

using System;
namespace hks
{
public class UseInheritance
{
public static void Main()
{
FullPerson hs = new
FullPerson("Hitesh","K","Seth");
Console.WriteLine(hs.GetFullName());
Object oHs = hs;
if (oHs is Person)
{
Console.WriteLine("I am still a
Person");
}
}
}
public class Person
{
 public string FirstName, LastName;
public Person(string FirstName, string
LastName)
{
this.FirstName = FirstName;
this.LastName = LastName;
}
public virtual string GetFullName() {
return this.FirstName + "." +
this.LastName;
}
}
public class FullPerson : Person
{
public string MiddleInitial;
public FullPerson(string FirstName, string
MiddleInitial,
string LastName) :
base(FirstName,LastName)
{
this.MiddleInitial = MiddleInitial;
}
public override string GetFullName() {
return this.FirstName + "." +
this.MiddleInitial + "." + this.LastName;
}
}
}

Classes can also be marked as either abstract (Listing 3.1), which

means they have to be subclassed for any instances to be created, or
sealed, which does not allow any subclassing.
 PROGRAM 9

Listing 3.1 Using Abstract Classes (C#)

using System;
{
public class UseAbstractClasses
{
public static void Main()
{
Person hs = new Person("Hitesh","Seth");
Console.WriteLine(hs.GetFullName());
}
}
abstract public class Abstract
{
protected string FirstName, LastName;
public Abstract(string FirstName, string
LastName)
{
this.FirstName = FirstName;
this.LastName = LastName;
}
abstract public string GetFullName();
}
public class Person : Abstract
{
public Person(string FirstName,
string LastName) : base(FirstName,
LastName)
{
}
public override string GetFullName()
{
return FirstName+"."+LastName;
}
 }
}

PROGRAM 10

Interfaces

C# provides the concept of interfaces. Interfaces really represent a

signature of what needs to be implemented by a derived class. C#
supports multiple inheritances of interfaces (Listing 3.2).

Listing 3.2 Using Interfaces (C#)

using System;
{
public class UseInterfaces
{
public static void Main()
{
Person hs = new Person();
hs.Name = "Hitesh Seth";
hs.Address = "1 Executive Drive, City, NJ
08520";
Console.WriteLine(hs.GetName());
Console.WriteLine(hs.GetAddress());
}
}
public interface IName
{
string GetName();
}
public interface IAddress
{
string GetAddress();
 }
public class Person : IName, IAddress
{
private string name, address;
public Person()
{
}
public string Name
{
set
{
name = value;
}
}
public string Address
{
set
{
address = value;
}
}
public string GetName()
{
return name;
}
public string GetAddress()
{
return address;
}
}
}
 PROGRAM 11

Exception Handling

C# provides robust exception handling capabilities. For instance, the

program that follows catches the exception at runtime and allows
messages to be displayed to the end user without requiring an
intermediate exit.
using System;
{
public class UseExceptions
{
public static void Main()
{
try
{
int a = 10;
int b = 10;
int c = a/(a-b);
}
catch (Exception ex)
{
Console.WriteLine("Exception Caught");
Console.WriteLine(ex.Message);
}
}
}
}
Custom exceptions, which contain more information related to the
underlying application, can also be created. Custom exceptions derive
from the System.Exception class. For instance, Listing 3.3 shows
the custom exception TooBigDiscountException being declared
and thrown by the constructor.

Listing 3.3 Creating Custom Exceptions (C#)

using System;
{
public class UseCustomExceptions
{
public static void Main()
{
try
{
Discount big_discount = new
Discount(56);
}
catch (TooBigDiscountException ex)
{
Console.WriteLine("Exception Caught");
Console.WriteLine(ex.Message);
}
}
}
public class Discount
{
private int percent;
public Discount(int percent)
{
this.percent = percent;
if (percent > 50)
throw new
TooBigDiscountException("Discount > 50%");
 }
}
public class TooBigDiscountException :
Exception
{
public TooBigDiscountException(String msg) :
base (msg)
{
}
}
}
 PROGRAM 12

Delegates

Delegates give C# programmers the capability of function pointers,

basically passing a function as a parameter. For instance, Listing 3.4
shows two delegates to be created and then invoked.

Listing 3.4 Using Delegates (C#)

using System;
{
public class UseDelegates
{
public delegate void MyDelegate(string
message);
public static void Main()
{
String message = "Hello Delegates";
MyDelegate d1 = new MyDelegate(PrintOnce);
MyDelegate d2 = new
MyDelegate(PrintTwice);
d1(message);
d2(message);
}
public static void PrintOnce(String message)
{
Console.WriteLine(message);
}
public static void PrintTwice(String
message)
{
Console.WriteLine("1."+message);
Console.WriteLine("2."+message);
}
}
}
 PROGRAM 13

Events

A typical use of delegates is in event handling. For instance, take a look

at Listing 3.5. It defines a class called Button, which has a Delegate
called EventHandler. Event handlers can be assigned for the event
OnClick and allow the calling application to pass in the reference of
the method Button_Click as the callback method to invoke after the
button is clicked. In this program, the button clicking is done by
explicitly invoking the Click method; in a real GUI application, the
Click() method would be automatically invoked on user input. In
Chapter 7, "Developing Windows Applications Using Windows Forms",
you will see that the code is very similar to this application.

Listing 3.5 Using Events (C#)

using System;
public class Events
{
public static void Main()
{
Button button = new Button();
button.OnClick+= new
Button.EventHandler(Button_Click);
button.Click();
}
public static void Button_Click()
{
Console.WriteLine("Button Clicked");
}
}
public class Button
{
public delegate void EventHandler();
 public event EventHandler OnClick;
public void Click()
{
OnClick();
}
}

That is really all this chapter covers on the C# programming language.

Beyond what is covered in this chapter, a major part of this book uses
C# as the primary programming language. For further explorations of
the C# programming language, see Visual C# .NET 2003 Kick Start by
Steve Holzner.
Visual Basic .NET

Visual Basic .NET is the next revision of the popular Visual Basic
programming language, which has roots in the BASIC programming
language itself. Known for its rapid application development capability,
Visual Basic .NET provides developers with the benefits of rapid
development with a full-blown object-oriented (OO) programming
language. Visual Basic .NET builds on the basic OO features present in
Visual Basic and makes the object- orientedness of the language on par
with that of Visual C# and even C++.

With its human-readable code syntax, Visual Basic .NET follows a task-
oriented model. Focus on increased developer productivity still remains
the core mantra for Visual Basic. Key features of the Visual Basic .NET
programming language include the following:

A full, object-oriented, yet intuitive, programming language

Typical VB features such as implicit typing, late binding, default
variable initialization, and optional parameters Enhanced event
handling
Parameterized properties
-Redeclaration of interface members on implementation
Command-line/SDK compilers

Hello World

The program listing that follows will look both familiar and different to
existing Visual Basic programmers. Familiar is the overall style,
subroutines, and modules. What is different in the program is really the
additional keyword—Namespace—and the use of -the .NET
Framework class library. An important thing to keep in mind is that
Visual Basic .NET is not a case-sensitive programming language.
Imports System

Module HelloWorld
Public Sub Main()
Console.WriteLine("Hello World in VB")
End Sub
End Module
End Namespace

Visual Basic .NET programs are stored with the .vb extension. To
compile a Visual Basic .NET program, use the Visual Basic. NET J#
command-line compiler, vbc.exe.
vbc HelloWorld.vb

Comments

Visual Basic comments are plain old ' style line comments or are
identified by Rem.

Imports System
Module Comments
Rem Implement the Main Method
Public Sub Main()
' Print Out Hello World
Console.WriteLine("Hello World in VB")
End Sub
End Module
End Namespace
Data Types

Table 3.2 describes how the Visual Basic .NET types are mapped to
their corresponding .NET Framework types.

Table 3.2 Visual Basic .NET Data Types

Visual Basic .NET

Corresponding .NET Framework Type
Type
Boolean System.Boolean
Byte System.Byte
Char System.Char
Decimal, Double, System.Decimal, System.Double,
Single System.Single
Short, Integer, System.Int16, System.Int32,
Long System.Int64
Object System.Object
String System.String

Enumerations

Enumerations are supported in Visual Basic .NET. Listing 3.6 illustrates

a potential use.

Listing 3.6 Using Enumerations (Visual Basic .NET)

Imports System
Module UseEnumerations
Public Enum CreditCard
Visa
MasterCard
 AmericanExpress
Discover
End Enum
Public Sub Main()
Dim cc as CreditCard
cc = CreditCard.Visa
Console.WriteLine(cc)
End Sub
End Module
End Namespace

Arrays

Arrays, which are subclasses of the System.Array type, are

supported in Visual Basic .NET (Listing 3.7).

Listing 3.7 Using Arrays (Visual Basic .NET)

Imports System
Namespace hks
Module UseArrays
Public Sub Main()
Dim days_of_week() as String = { _
"Sunday", _
"Monday", _
"Tuesday", _
"Wednesday", _
"Thursday", _
"Friday", _
"Saturday" _
}
Dim I as Integer
For I = 0 to days_of_week.Length-1
Console.WriteLine(days_of_week(I))
Next I
 End Sub
End Module
End Namespace

Variables and Constants

Using variables is similar to the traditional Visual Basic programming,

using the Dim keyword (see Listing 3.8).

Listing 3.8 Using Variables and Constants (Visual Basic .NET)

Imports System
Namespace hks
Module UseVariables
Public Sub Main()
Const HELLO_WORLD as String = "Hello
World"
Dim msg as String = HELLO_WORLD & " in VB"
Dim mc as New MClass(msg)
Call mc.Print
End Sub
End Module
Class MClass
private message as String
Public Sub New(ByVal message as String)
Me.message = message
End Sub
Public Sub Print()
Console.WriteLine(message)
End Sub
End Class
End Namespace
Expressions

Expressions provide the capability to computerize and manipulate data.

Imports System
Namespace hks
Module UseExpressions
Public Sub Main()
Dim a as Integer = 10
Dim b as Integer = 10
Dim result as Integer = a * b
Dim check as Boolean = (a = b)
Console.WriteLine(result)
Console.WriteLine(check)
End Sub
End Module
End Namespace

Statements

Statements provide the necessary programming language procedural

constructs.
Imports System
Namespace hks
Module UseStatements
Public Sub Main()
Dim msg() as String =
{"Hello","World","in","Visual Basic.NET"}
Dim i as Integer
For i = 0 to (msg.Length-1)
Console.Write(msg(i))
Next
Console.WriteLine("")
Dim a as Integer = 10
 Dim b as Integer = 20
If (a<b) Then
Console.WriteLine("a<b")
Else
Console.WriteLine("a>=b")
End If
End Sub
End Module
End Namespace
Structures

Structures can be used for basic encapsulation of data.

Imports System
Namespace hks
Module UseStructures
Public Sub Main()
Dim hs as New Person("Hitesh","Seth")
Dim jd as Person = hs
jd.FirstName = "John"
jd.LastName = "Doe"
Console.WriteLine(hs.FirstName & "." &
hs.LastName)
Console.WriteLine(jd.FirstName & "." &
jd.LastName)
End Sub
End Module
Structure Person
Public FirstName, LastName as String
Public Sub New(ByVal FirstName as String,
ByVal LastName as String)
Me.FirstName = FirstName
Me.LastName = LastName
End Sub
End Structure
End Namespace
Classes

Classes in Visual Basic are defined using the Class keyword. Like C#,
VB classes can have members, constructors and destructors, properties,
methods (which are classified into subroutines and functions, depending
on whether they return a value), and events (Listing 3.9).

Listing 3.9 Using Classes (Visual Basic .NET)

Imports System
Namespace hks
Module Useclasses
Public Sub Main()
Dim hs as New Person("Hitesh","Seth")
Dim jd as Person = hs
jd.FirstName = "John"
jd.LastName = "Doe"
Console.WriteLine(hs.FirstName & "." &
hs.LastName)
Console.WriteLine(jd.FirstName & "." &
jd.LastName)
End Sub
End Module
Public Class Person
Private sFirstName, sLastName as String
Public Property FirstName() as String
Get
Return sFirstName
End Get
Set(ByVal Value as String)
sFirstName = Value
End Set
End Property
Public Property LastName() as String
Get
Return sLastName
 End Get
Set(ByVal Value as String)
sLastName = Value
End Set
End Property
Public Sub New(ByVal FirstName as String,
ByVal LastName as String)
Me.FirstName = FirstName
Me.LastName = LastName
End Sub
Public Function GetFullName() as String
Return Me.FirstName & "." & Me.LastName
End Function
End Class
End Namespace

Classes can be inherited for overriding and extending functionality

present in the base class. The keywords Overridable and
Overrides are used to set a method in base class as overridable and
implementation of the overridden method in the derived class,
respectively (Listing 3.10). Similar to C#, Visual Basic .NET also
supports only single inheritance.

Listing 3.10 Using Inheritance (Visual Basic .NET)

Imports System
Namespace hks
Module HelloWorld
Public Sub Main()
Dim hs as New
FullPerson("Hitesh","K","Seth")
Console.WriteLine(hs.GetFullName)
End Sub
End Module
Public Class Person
Public FirstName, LastName as String
 Public Sub New(ByVal FirstName as String,
ByVal LastName as String)
Me.FirstName = FirstName
Me.LastName = LastName
End Sub
Public Overridable Function GetFullName() as
String
Return Me.FirstName & "." & Me.LastName
End Function
End Class
Public Class FullPerson
Inherits Person
Public MiddleInitial as String
Public Sub New(ByVal FirstName as String, _
ByVal MiddleInitial as String, ByVal
LastName as String)
MyBase.New(FirstName,LastName)
Me.MiddleInitial = MiddleInitial
End Sub
Public Overrides Function GetFullName() as
String
Return Me.FirstName & "." &
Me.MiddleInitial & "." & Me.LastName
End Function
End Class
End Namespace

Visual Basic .NET supports abstract classes by using the

MustInherit and MustOverride keywords (Listing 3.11).
Listing 3.11 Using Abstract Classes (Visual Basic .NET)
Imports System
Namespace hks
Module UseAbstractClasses
Public Sub Main()
Dim hs as New Person("Hitesh","Seth")
Console.WriteLine(hs.FirstName & "." &
hs.LastName)
End Sub
End Module
Public MustInherit Class Abstract
Public FirstName, LastName as String
Public Sub New(ByVal FirstName as String,
ByVal LastName as String)
Me.FirstName = FirstName
Me.LastName = LastName
End Sub
Public MustOverride Function GetFullName as
String
End Class
Public Class Person
Inherits Abstract
Public Sub New(ByVal FirstName as String,
ByVal LastName as String)
MyBase.New(FirstName,LastName)
End Sub
Public Overrides Function GetFullName as
String
GetFullName = FirstName & "." & LastName
End Function
End Class
End Namespace
Interfaces

Visual Basic .NET supports interfaces through the Interface

keyword. A derived class can implement multiple interfaces and
specifies the specific function/subroutine signature implemented through
the Interface keyword (Listing 3.12).

Listing 3.12 Using Interfaces (Visual Basic .NET)

Imports System
Module UseInterfaces
Public Sub Main()
Dim hs as New Person
hs.Name = "Hitesh Seth"
hs.Address = "1 Executive Drive, City, NJ
08520"
Console.WriteLine(hs.GetName())
Console.WriteLine(hs.GetAddress())
End Sub
End Module
Public Interface IName
Function GetName() as String
End Interface
Public Interface IAddress
Function GetAddress() as String
End Interface
Public Class Person
Implements IName, IAddress
Private s_name, s_address as String
Public Sub New()
End Sub
Public WriteOnly Property Name() as String
Set
s_name = value
End Set
End Property
 Public WriteOnly Property Address() as
String
Set
s_address = value
End Set
End Property
Public Function GetName() as String
Implements IName.GetName
GetName = s_name
End Function
Public Function GetAddress() as String
Implements IAddress.GetAddress
GetAddress = s_address
End Function
End Class
End Namespace

Exception Handling

New to Visual Basic .NET is structured exception handling, as

illustrated in Listing 3.13. Visual Basic typically had the
OnError/Goto construct for handling exceptions.

Listing 3.13 Exception Handling (Visual Basic .NET)

Imports System
Namespace hks
Module UseExceptions
Public Sub Main()
Try
Dim a as Integer = 10
Dim b as Integer = 10
Dim c as Integer
c = a/(a-b)
Catch ex as Exception
Console.WriteLine(ex.Message)
 End Try
End Sub
End Module
End Namespace
Imports System

Similar to C#, apart from handling the extensive set of exceptions

defined by the .NET Framework library, custom exceptions can also be
defined by subclassing the Exception class (Listing 3.14).

Listing 3.14 Creating Custom Exceptions (Visual Basic .NET)

Namespace hks
Module UseCustomExceptions
Public Sub Main()
Try
Dim big_discount as new Discount(56)
Catch ex as Exception
Console.WriteLine(ex.Message)
End Try
End Sub
End Module
Public Class Discount
Private percent as Integer
Public Sub New(ByVal percent as Integer)
Me.percent = percent
If (percent > 50) Then
Throw New
TooBigDiscountException("Discount > 50%")
End If
End Sub
End Class
Public Class TooBigDiscountException
Inherits Exception
Public Sub New(ByVal msg as String)
MyBase.New(msg)
 End Sub
End Class
End Namespace

Delegates

New to Visual Basic .NET is the capability of using delegates or

function pointers (Listing 3.15).

Listing 3.15 Using Delegates (Visual Basic .NET)

Imports System
Namespace hks
Module Use Delegates
Delegate Sub MyDelegate(ByVal msg as String)
Public Sub Main()
Dim msg As String = "Hello Delegates"
Dim d1 as MyDelegate = AddressOf PrintOnce
Dim d2 as MyDelegate = AddressOf
PrintTwice
d1(msg)
d2(msg)
End Sub
Public Sub PrintOnce(ByVal msg as String)
Console.WriteLine(msg)
End Sub
Public Sub PrintTwice(ByVal msg as String)
Console.WriteLine("1." & msg)
Console.WriteLine("2." & msg)
End Sub
End Module
End Namespace
Events

Visual Basic developers have traditionally enjoyed the benefits of an

easy-to-use event-handling system (Listing 3.16).

Listing 3.16 Using Events (Visual Basic .NET)

Imports System
Namespace hks
Module Events
Friend WithEvents button As Button
Public Sub Main()
button = New Button()
button.Click
End Sub
Public Sub Button_OnClick Handles
button.OnClick
Console.WriteLine("Button Clicked")
End Sub
End Module
Public Class Button
Public Event OnClick
Public Sub Click()
RaiseEvent OnClick()
End Sub
End Class
End Namespace