Programming with .NET and C#

In This Chapter

• Introduction

• C#

• Visual Basic .NET

• Visual J#

• Managed C++

• Other .NET Programming Languages

• Interoperating with Different Programming Languages

Introduction

Microsoft developers working with VisualStudio and COM/OLE technologies have always enjoyed the benefits of achoice of programming languages for development of applications andcomponents. Well, sort of. (For instance, components developed in oneprogramming language couldn't be "inherited" from another programminglanguage.) With the introduction of the CLR and the .NET Framework,this flexibility in the choice of any supported programming languagefor .NET components and applications still remains a key requirement.Out of the box, the .NET Framework and the key tool supporting thedevelopment, 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 beenrecognized as a developing standard, third-party Independent SoftwareVendors (ISVs) and researchers can "port" other programming languagesto compile to the .NET runtime.

The genesis to this programming flexibilityoccurred for two reasons: flexibility and ease of migration and skillsreuse. For instance, millions of Visual Basic developers worldwide canchoose the Visual Basic .NET programming language for utilizing andenhancing their existing skills; C++ and Java developers have theoption of using either Managed C++, Visual J#, or the new, innovativeC# programming language. All four programming languages have similarcommon features; most can be used for achieving similar results. Each,however, has its own benefits and differentiators, but most of thedifferences lie in the language syntax.

This chapter briefly discusses fourprogramming languages. A full description of all the features of eachof the individual programming languages deserves a book by itself;there are, in fact, multiple sets of books that discuss each languageindividually. The rest of this chapter follows a hands-on,down-to-the-code style of introduction to programming languages. Eachof 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

You'll use sample programs for a hands-on understanding of the key capabilities of the various programming languages.

C#

The C# programming language (pronounced "Csharp") was introduced with the .NET Framework. It represents amilestone in the area of programming language development. Even thoughthe genesis of the new C# language is in existing programming languagessuch as Java and C++, it represents the most innovative, modern, andeven—in most areas—the preferred .NET programming language. C# wasintroduced to combine the key values of Visual Basic and C++. WhereasVisual Basic had ease of use and high developer productivity, C++represented the ultimate flexibility and control. C# merges the two; itis relatively simpler than C++ (no pointers, templates, and so on), andit has all the nice object-oriented features of C++ and the ease of useof Visual Basic. No more specific memory allocation is required, aseverything is "garbage collected" by the common runtime. In variousways, C# is also similar to the Java programming language, which hasgained wide developer support as well. However, whereas Java isintended to be a platform-neutral programming language compiling intobyte code and then executed on a virtual machine, C# programs arecompiled (like all .NET programming languages) into MSIL (MicrosoftIntermediate Language) and, like all applications, are ultimatelyconverted into machine code before execution.

---

C# Programming Language: The Standard -A key aspect of the .NET platform is that it is based on top ofexisting and new standards. For instance, the C# programming languagehas been approved as an ISO standard (23270). More details about thestandardization initiative and the standard itself are available at http://msdn.microsoft.com/net/ecma/.

---

C# follows a code-focused model,targeted for developers who like the simplicity of a modern programminglanguage but typically prefer to write programs by hand instead ofgenerating them with wizards. This enables easier reuse because thecode 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

Hello World

In this section, you'll take a look at aHello World C# program. Each C# application is composed of a class. Ifit is an executable application, one of the classes available shouldhave a static Main() method that serves as the entry point.(The compiler would warn if Main was not declared or improperlydeclared.) The Main method is overloaded and can have a String arraypassed to it as well for any command-line parameters.

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

C# classes are stored in .cs files. Afteryou 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 toinclude the .NET Framework SDK's bin folder in your PATH variable. Ifyou have installed Visual Studio .NET, you have a shortcut under VisualStudio .NET Tools called Visual Studio .NET 2003 Command Prompt. Thisshortcut initializes all the environment variables and provides accessto 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 introducecomments in a program; the two most popular are the traditionalsingle-line comments (//) and the multiline comments (/* */). Inaddition, C# provides XML-based comments that can be used to create XMLdocumentation from a set of code files. These XML files can then beprocessed with an XSLT (XML Style
sheet Language) to convert into onlineHTML documentation, and so on.

using System;
namespace hks
{
/// <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 aremapped 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

Enumerations

C# provides the enumerations programming construct, which provides a human-readable form of a series of related constant values.

using System;
namespace hks
{
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);
}
}
}

Arrays

Arrays provide developers with a structurefor storing a collection of values. Apart from arrays, the .NETFramework provides a series of Collections constructs, including HashTables and ArrayList, which provide capabilities such as dynamicsizing. You will look at some of those constructs in the next chapter.Arrays can be processed by a foreach construct.

using System;
namespace hks
{
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);
}
}
}
}

Variables and Constants

Simple value types can be assigned usingthe variable = value construct, whereas reference types are required touse the new keyword for creating a new instance.

using System;
namespace hks
{
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);
}
}
}

Expressions

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

using System;
namespace hks
{
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 languageincludes several procedural programming constructs, including if-else,for loop, while loop, switch statements, and so on.

using System;
namespace hks
{
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");
}
}
}
}

Structures

Structures are simply an aggregation ofvalue types and are allocated on the stack and not on the heap.Structures are useful for passing a logical and related set of datavalues. Structures don't support inheritance but can implementinterfaces. For instance, the following program would print Hitesh.Sethfollowed by John.Doe and illustrates that structures are not referencetypes.

using System;
namespace hks
{
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;
}
}
}

Classes

Classes, on the other hand, are referencetypes and hence are allocated on the heap. Classes provideobject-oriented constructs such as encapsulation, polymorphism, andinheritance. For instance, the following program would print John.Doetwice, illustrating that objects are reference types, allocated on theheap.

using System;

namespace hks
{
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());
}
}
publ
ic 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;
}
}
}

Inheritance

Classes provide inheritance capability,which allows the derived class to inherit the functionality of a baseclass and potentially override some of the methods. A class definitionconsists 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 areoverridden must be marked as virtual in the base class. The isoperator provides runtime validation if an object is of a particulartype. For instance, the following program will return that a FullPersonobject 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 eitherabstract (Listing 3.1), which means they have to be subclassed for anyinstances to be created, or sealed, which does not allow anysubclassing.

Listing 3.1 Using Abstract Classes (C#)

using System;
namespace hks
{
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;
}
}
}

Interfaces

C# provides the concept of interfaces.Interfaces really represent a signature of what needs to be implementedby a derived class. C# supports multiple inheritances of interfaces(Listing 3.2).

Listing 3.2 Using Interfaces (C#)

using System;
namespace hks
{
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;
}
}
}

Exception Handling

C# provides robust exception handlingcapabilities. For instance, the program that follows catches theexception at runtime and allows messages to be displayed to the enduser without requiring an intermediate exit.

using System;
namespace hks
{
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 moreinformation 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 beingdeclared and thrown by the constructor.

Listing 3.3 Creating Custom Exceptions (C#)

using System;
namespace hks
{
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)
{
}
}
}

Delegates

Delegates give C# programmers thecapability of function pointers, basically passing a function as aparameter. For instance, Listing 3.4 shows two delegates to be createdand then invoked.

Listing 3.4 Using Delegates (C#)

using System;
namespace hks
{
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);
}
}
}

Events

A typical use of delegates is in eventhandling. For instance, take a look at Listing 3.5. It defines a classcalled Button, which has a Delegate called EventHandler. Event handlerscan be assigned for the event OnClick and allow the calling applicationto pass in the reference of the method Button_Click as the callbackmethod to invoke after the button is clicked. In this program, thebutton clicking is done by explicitly invoking the Click method; in areal GUI application, the Click() method would beautomatically invoked on user input. In Chapter 7, "Developing WindowsApplications Using Windows Forms," you will see that the code is verysimilar 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 onthe C# programming language. Beyond what is covered in this chapter, amajor 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 ofthe popular Visual Basic programming language, which has roots in theBASIC programming language itself. Known for its rapid applicationdevelopment capability, Visual Basic .NET provides developers with thebenefits of rapid development with a full-blown object-oriented (OO)programming language. Visual Basic .NET builds on the basic OO featurespresent in Visual Basic and makes the object- orientedness of thelanguage 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 mantrafor Visual Basic. Key features of the Visual Basic .NET programminglanguage 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 lookboth familiar and different to existing Visual Basic programmers.Familiar is the overall style, subroutines, and modules. What isdifferent in the program is really the additional keyword—Namespace—andthe use of -the .NET Framework class library. An important thing tokeep in mind is that Visual Basic .NET not a case-sensitive programminglanguage.

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

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

vbc HelloWorld.vb

---

Leverage Your VB Skills with Visual Basic .NET -A key highlight of the Visual Basic .NET programming language is thatit allows developers to utilize their existing skills in Visual Basicdevelopment. Apart from skills reuse, Visual Basic .NET supportsimporting existing Visual Basic projects for migration.

---

Comments

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

Imports System
Namespace hks
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

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
Namespace hks
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

"Heading25">

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 Enumerations (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 usingthe Class keyword. Like C#, VB classes can have members, constructorsand destructors, properties, methods (which are classified intosubroutines 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 andextending functionality present in the base class. The keywordsOverridable and Overrides are used to set a method in base class asoverridable and implementation of the overridden method in the derivedclass, respectively (Listing 3.10). Similar to C#, Visual Basic .NETalso 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 interfacesthrough the Interface keyword. A derived class can implement multipleinterfaces and specifies the specific function/subroutine signatureimplemented through the Interface keyword (Listing 3.12).