|
Author |
Hitesh Seth |
Title |
Microsoft .NET Kick Start |
Publisher |
Sams |
Published |
DEC 24, 2003 |
ISBN |
0672325748 |
Price |
US$ 34.99 |
Pages |
504 | |
Programming with .NET
In This Chapter
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
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 "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# Programming Language: The Standard - A key aspect of the .NET platform is that it is based on top of existing and new standards. For instance, the C# programming language has been approved as an ISO standard (23270). More details about the standardization 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 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
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;
namespace hks
{
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;
namespace hks
{
public class Comments
{
public static void Main()
{
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 , single |
System.Decimal , System.Double , System.Single |
short , ushort , int , uint , long , ulong |
System.Int16 , System.UInt16 , System.Int32 , System.UInt32 , System.Int64 , System.UInt64 |
Object |
System.Object |
String |
System.String |
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 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;
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 using the variable =
value construct, whereas reference types are required to use 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 language includes 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 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;
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 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;
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());
}
}
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;
}
}
}
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.
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 implemented by 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 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;
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 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;
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 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;
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 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
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 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
Leverage Your VB Skills with Visual Basic .NET - A key highlight of the Visual Basic .NET programming language is that it allows developers to utilize their existing skills in Visual Basic development. Apart from skills reuse, Visual Basic .NET supports importing 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()
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 Type |
Corresponding .NET Framework Type |
Boolean |
System.Boolean |
Byte |
System.Byte |
Char |
System.Char |
Decimal , Double , Single |
System.Decimal , System.Double , System.Single |
Short , Integer , Long |
System.Int16 , System.Int32 , 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
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
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
Namespace hks
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
Visual J#
With Visual Studio, Microsoft introduced the Visual J++ programming language and development tool. Visual J++ provided Java-based application development on the Microsoft Windows platform. Programs and components developed with Visual J++ executed on the Microsoft Java Virtual Machine. Visual J#, however, is quite different because it provides for Java-based programs to be compiled into .NET components and applications using MSIL. Therefore, the J# programming language is really like C# or Visual Basic .NET, but the programming language syntax is that of the Java programming language. J# still has all the benefits of the Java programming language as a simplified object-oriented programming language (no pointers, and so on). It is based on JDK 1.1.4.
Why J#? - J# was introduced by Microsoft to leverage the large pool of skills available through Java developers worldwide and provide them with the capability to utilize their existing skills and language experience to develop .NET applications.
Using the Visual J# programming language, existing Java developers can do the following:
- Utilize the knowledge of Java programming for .NET application development
- Support JDK 1.1.4 Class Library and most JDK 1.2
java.util
class libraries
- Utilize extensions to the Java programming language for properties, delegates, and events
- Convert existing Visual J++ projects to Visual J# using the Project Import Wizard
- Create Javadoc-based documentation
- Provide support for applets, like the deployment model, known as J# Browser Controls
Hello World
A simple Hello World J# application looks pretty much like a typical Java application. The only difference is the use of the .NET Framework class library (System.Console.WriteLine
) instead of the typical Java System.out.println
. Java supports the notion of namespaces through packages, and that has been incorporated into J# for .NET namespaces. Also, Java provides the capability of using external class libraries with the import
keyword. This has also been utilized with J# as well. (Note: J# requires a ".*" to be attached to the namespace.)
package hks;
import System.*;
public class HelloWorld
{
public static void main()
{
Console.WriteLine("Hello World in J#");
}
}
J# programs are stored with the .jsl extension. To compile a J# application, use the .NET J# compiler, vjc.exe.
vjc HelloWorld.jsl
Comments
In addition to the single-line and multiline comments that are similar to those of C#, J# also supports and extends the traditional Javadoc-style comments. (For non-Java programmers, Javadoc-style comments are special comments similar to XML comments in C#, used to automatically generate HTML documentation from Java programs.)
package hks;
import System.*;
public class Comments
{
public static void main()
{
Console.WriteLine("Hello World in J#");
}
}
Data Types
Table 3.3 shows how the Visual J# types map to the corresponding .NET Framework types.
Table 3.3 Visual J# Data Types
Visual J# Type |
Corresponding .NET Framework Type |
boolean |
System.Boolean |
byte |
System.Byte , System.SByte |
char |
System.Char |
double , float |
System.Double , System.Single |
short , int , long |
System.Int16 , System.Int32 , System.Int64 |
Object |
System.Object |
String |
System.String |
Enumerations
J# doesn't support the creation of enumerations. However, the language does provide the capability to utilize enumerations that have been already defined in the .NET Framework or any custom .NET assemblies. Enumerations are treated as reference types as well.
Arrays
As shown in the program that follows, using arrays is very similar to C#. Notice the get_Length()
method used to get an array's length, as properties are not supported in J#.
package hks;
import System.*;
public class UseArrays
{
public static void main()
{
String[] days_of_week = {
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
};
for (int i=0;i<days_of_week.get_Length();i++)
{
Console.WriteLine(days_of_week[i]);
}
}
}
Variables and Constants
Constants in J# are prefixed by the final
keyword. All the other mechanisms of creating new value types and reference types are similar to those of C#.
package hks;
import System.*;
public class UseVariables
{
public static void main()
{
final String HELLO_WORLD = "Hello World";
String message = HELLO_WORLD + " in VJ#";
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
Basic expressions in J# are very similar to those in C#.
package hks;
import System.*;
public class UseExpressions
{
public static void main()
{
int a = 10;
int b = 10;
int result = a*10;
boolean check = (a==b);
Console.WriteLine(result);
Console.WriteLine(check);
}
}
Statements
Statements in J# are very similar to those in C#.
package hks;
import System.*;
public class UseStatements
{
public static void main()
{
String[] message = {"Hello","World","in","VJ#"};
for (int i=0;i<message.get_Length();i++)
{
Console.Write(message[i]+" ");
}
int a = 10;
int b = 10;
if (a<b) {
Console.WriteLine("a<b");
} else {
Console.WriteLine("a>=b");
}
}
}
Classes
Constructs such as class definition, abstract classes, inheritance, and so on in J# are all very similar to C# (Listing 3.17). However, properties are not supported within the Java programming language; this is carried on with J#. But J# does support properties using the property accessor methods (set_
, get_
).
Listing 3.17 Using Classes (Visual J#)
package hks;
import System.*;
public class Useclasses
{
public static void main()
{
Person hs = new Person("Hitesh","Seth");
Person jd = hs;
jd.set_FirstName("John");
jd.set_LastName("Doe");
Console.WriteLine(hs.GetFullName());
}
}
public class Person
{
private String sFirstName, sLastName;
public Person(String FirstName, String LastName)
{
this.sFirstName = FirstName;
this.sLastName = LastName;
}
public void set_FirstName(String FirstName) {
this.sFirstName = FirstName;
}
public String get_FirstName()
{
return sFirstName;
}
public void set_LastName(String LastName) {
this.sLastName = LastName;
}
public String get_LastName()
{
return sLastName;
}
public String GetFullName() {
return sFirstName +"."+sLastName;
}
}
Similar to C#, J# also supports single inheritance, including overriding base class methods (Listing 3.18). However, unlike C#, all nonprivate methods can be overridden by a derived class. In essence, then, J# methods behave like virtual methods.
Listing 3.18 Inheriting Classes (Visual J#)
package hks;
import System.*;
public class UseInheritance
{
public static void main()
{
FullPerson hs = new FullPerson("Hitesh","K","Seth");
Console.WriteLine(hs.GetFullName());
Object oHs = hs;
if (oHs instanceof 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 String GetFullName() {
return FirstName + "." + LastName;
}
}
public class FullPerson extends Person
{
public String MiddleInitial;
public FullPerson(String FirstName, String MiddleInitial, String LastName)
{
super(FirstName,LastName);
this.MiddleInitial = MiddleInitial;
}
public String GetFullName() {
return FirstName + "." + MiddleInitial + "." + LastName;
}
}
Abstract classes are supported in a way similar to C# (Listing 3.19).
Listing 3.19 Using Classes (Visual J#)
package hks;
import System.*;
public class UseAbstractClasses
{
public static void main()
{
Person hs = new Person("Hitesh","Seth");
Console.WriteLine(hs.GetFullName());
}
}
public abstract 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 extends Abstract
{
public Person(String FirstName, String LastName)
{
super(FirstName, LastName);
}
public String GetFullName()
{
return FirstName+"."+LastName;
}
}
Interfaces
With constructs very similar to C#, the J# programming language also supports multiple inheritance using Interfaces (Listing 3.20). Actually, the simple mechanism of interface was in some sense introduced by Java and adopted by C#.
Listing 3.20 Using Interfaces (Visual J#)
package hks;
import System.*;
public class UseInterfaces
{
public static void main()
{
Person hs = new Person();
hs.set_Name("Hitesh Seth");
hs.set_Address("1 Executive Driver, City, NJ 08520");
Console.WriteLine(hs.GetName());
Console.WriteLine(hs.GetAddress());
}
}
public interface IName
{
public String GetName();
}
public interface IAddress
{
public String GetAddress();
}
public class Person implements IName, IAddress
{
private String name, address;
public Person()
{
}
public void set_Name(String value)
{
name = value;
}
public void set_Address(String value)
{
address = value;
}
public String GetName()
{
return name;
}
public String GetAddress()
{
return address;
}
}
Exception Handling
Exception handling has always been supported in the Java programming language, and that capability is easily reused with the .NET exception model as well.
package hks;
import System.*;
public class UseExceptions
{
public static void main()
{
try
{
int a = 10;
int b = 10;
int c = a/(a-b);
}
catch (System.Exception ex)
{
Console.WriteLine("Exception Caught");
Console.WriteLine(ex.get_Message());
}
}
}
Custom exceptions are supported in J#, again, this is very similar to C# (Listing 3.21).
Listing 3.21 Creating Custom Exceptions (Visual J#)
package hks;
import 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.get_Message());
}
}
}
public class Discount
{
private int percent;
public Discount(int percent) throws TooBigDiscountException
{
this.percent = percent;
if (percent > 50)
throw new TooBigDiscountException("Discount > 50%");
}
}
public class TooBigDiscountException extends System.Exception
{
public TooBigDiscountException(String msg)
{
super(msg);
}
}
Delegates and Events
Because the Java programming language has no built-in support for delegates and events, the J# implementation provides a set of extensions for creating this capability. Delegates are tagged with a special comment
before its definition and so are events (using
). Also, the class implementing the events needs to keep a reference to all the listeners assigned for the particular events by creating an ArrayList
or a similar collection. After the listeners have been assigned, they are invoked using the Invoke
method (Listing 3.22).
Listing 3.22 Using Delegates and Events (Visual J#)
package hks;
import System.*;
import System.Collections.*;
public delegate void EventHandler();
public class Button
{
ArrayList listeners = new ArrayList();
public static void main()
{
Button button = new Button();
button.add_OnClick(new EventHandler(Button_OnClick));
button.Click();
}
public void add_OnClick(EventHandler listener) {
listeners.Add(listener);
}
public void remove_OnClick(EventHandler listener) {
listeners.Remove(listener);
}
public void Click()
{
Object [] olisteners = listeners.ToArray();
for (int i = 0;i < olisteners.length ;i++)
{
((EventHandler)(olisteners[i])).Invoke();
}
}
public static void Button_OnClick()
{
Console.WriteLine("Button Clicked");
}
}
Managed C++
Managed C++ doesn't really represent a separate programming language. A number of features introduced by the .NET Framework aren't supported through the standard C++ programming language, Visual C++ 2003, also better known as Managed C++. Managed C++ extensions represent an additional set of keywords that provide the necessary extensions to C++ for development of .NET constructs.
Called a power-oriented programming language, Visual C++ .NET provides .NET application developers the ultimate combination of power, control, and performance-centric bridging of the native and managed code environments. Key highlights of the Visual C++ .NET programming language include:
- Utilization of Win32/local Windows and CLR environments together
- Continued support of Standard ISO C++ for portability across C++ implementation environments
- Support for advanced C++ features such as templates, pointers, and intrinsic features (such as processor-specific instructions)
- A highly optimizing compiler with support for 32/64 bit microprocessors
- Advanced error reporting and debugging
Hello World
#using <mscorlib.dll>
using namespace System;
void main()
{
Console::WriteLine(S"Hello World in Managed C++");
}
Compiling a Managed Extensions�enabled C++ program requires using the /CLR compiler option, which indicates to the compiler that the C++ programs must be compiled into a .NET assembly.
cl /CLR HelloWorld.cpp
Managed Extensions
Table 3.4 provides a quick list of key managed extensions to the C++ programming language.
Table 3.4 Key Managed C++ Extension Keywords
Managed C++ Extension |
Description |
__gc |
Indicates that the struct/class identified is managed (garbage collected) |
__value |
Indicates a value type |
__interface |
Interface |
__delegate |
Delegates |
__event |
Events |
__property |
Properties |
__abstract |
Abstract classes: Must be derived for creating instances |
__sealed |
Sealed (Final) class: cannot be derived |
__identifier |
Use C++ keyword as an identifier |
__typeof |
Provides access to type of the object |
__try_cast |
Provides a dynamic checked cast |
To create a managed class (which means that no allocation is required), prefix the __gc
keyword to a C++ class definition. This indicates to the C++ compiler that what is going to be declared is a managed C++ class (Listing 3.23).
Listing 3.23 Creating Managed Classes (Managed C++)
#using <mscorlib.dll>
namespace hks {
__gc class Person
{
public:
System::String* FirstName;
System::String* LastName;
Person(System::String* FirstName, System::String* LastName)
{
this->FirstName = FirstName;
this->LastName = LastName;
}
};
};
void main()
{
hks::Person* p1 = new hks::Person(S"Hitesh",S"Seth");
hks::Person* p2 = p1;
p1->FirstName = S"John";
p2->LastName = S"Doe";
System::Console::WriteLine("{0}.{1}",p1->FirstName,p1->LastName);
System::Console::WriteLine("{0}.{1}",p2->FirstName,p2->LastName);
}
Listing 3.24 is another example of using managed extensions, this time to create events and delegates.
Listing 3.24 Using Events and Delegates Managed Extensions (Managed C++)
#using <mscorlib.dll>
namespace hks {
__delegate void MyDelegate(System::String *msg);
__gc class HelloWorld
{
public:
void PrintOnce(System::String *msg)
{
System::Console::WriteLine(msg);
}
void PrintTwice(System::String *msg)
{
System::Console::WriteLine("1.{0}",msg);
System::Console::WriteLine("2.{0}",msg);
}
};
};
int main()
{
hks::HelloWorld* hw = new hks::HelloWorld();
System::String *msg = S"Hello Delegates";
hks::MyDelegate *d1 = new hks::MyDelegate(hw,&hks::HelloWorld::PrintOnce);
hks::MyDelegate *d2 = new hks::MyDelegate(hw,&hks::HelloWorld::PrintTwice);
d1->Invoke(msg);
d2->Invoke(msg);
}
Other .NET Programming Languages
If you thought support for four programming languages (C#, Visual Basic .NET, C++, and J#) made .NET programming flexible, you haven't realized the whole story yet. Because every program will end up in MSIL and then be executed later by the CLR, it is possible to write a compiler for practically any programming language, whether it supports object-oriented constructs, functional programming constructs, modular programming constructs, or plain-old procedural constructs, so that it can be compiled into MSIL. This has been the drive behind extensive third-party programming language support for .NET. Chances are that if you know a programming language, it has already been ported to .NET. This goes for APL, COBOL, Delphi, Eiffel, Fortran, Forth, Haskell, Prolog, Pascal, Perl, Python, Scheme, and so on. As you can see, the CLR allows developers to utilize their skills in whatever programming language they have and apply them to the .NET environment. Applying COBOL skills to .NET means that you can develop rich Windows forms applications, Web applications, or even Web services using COBOL. These are programming constructs that were never thought about when these languages were designed originally. It is really because of the richness and flexibility of the CLR that such a thing is possible.
Microsoft research itself has been quite active when it comes to designing and implementing new programming languages for .NET. ASML (Abstract State Machine Language), F# (an implementation of the Caml programming language), and SML.NET (an implementation of the Standard ML) are some of the initiatives from Microsoft research, exploring newer programming models with .NET.
Languages come and go; third-generation programming languages will evolve into fourth-generation programming languages, and so on. With the CLR, the .NET programming model is set to evolve with this change and also utilize the technology excellence and research in the computer science community.
An updated list of .NET programming languages is available at http://www.jasonbock.net/dotnetlanguages.html.
Interoperating with Different Programming Languages
The objective of this section is to illustrate that .NET really supports cross-programming language use. You will learn how classes defined in one programming language can be subclassed in another and utilized in yet another. First, define the Base
class in C#.
using System;
namespace mixed
{
public class Base
{
public Base()
{
}
public virtual String GetLanguage()
{
return "C#";
}
}
}
This program is compiled into a library using the C# compiler.
csc /t:library CSharp.cs
Next, a Visual Basic .NET class is declared as a subclass of the Base
class.
Imports System
Namespace mixed
Public class Derived
Inherits Base
Public Sub New()
End Sub
Public Overrides Function GetLanguage() As String
return "Visual Basic .NET"
End Function
End Class
End Namespace
To compile the Visual Basic program, the Visual Basic .NET compiler is invoked, passing the reference to the previously created base class assembly.
vbc /reference:CSharp.dll /target:library VBasic.vb
Now you eventually develop a Java class that actually uses the classes defined earlier. The Java class has a main
method and so can be compiled into an executable.
vjc /reference:CSharp.dll,VBasic.dll VJSharp.jsl
The program VJSharp.exe can be executed to get the results:
Visual Basic .NET
Derived is an instance of Base
This small exercise should remove any doubts regarding the .NET interoperability of the various programming languages.
Selecting the Right Programming Language - The .NET programming model provides developers a true choice when selecting a programming language to implement an application or when creating a component library. Selecting the language to use primarily depends on your existing skills and is your personal choice. If you are a Visual Basic programmer, you will probably pick Visual Basic .NET. If you are a C++ programmer, you will either continue with Visual C++ .NET or consider C# as your major programming language. If you have come from a Java programming background, you will probably end up with either Visual J# or Visual C#. Another factor that would influence the choice of programming language is ubiquity and market demand in your area. For instance, currently the New York City metropolitan area (where I live) seems to be headed in the C# direction, based on its high C++ influence. Although it is definitely possible to mix different programming languages in a single solution, in my opinion, it is rarely done. In many ways, different programming languages can be utilized to achieve similar results; sometimes the choice of a language is influenced by what sort of application is being written. For instance, Perl might be an excellent candidate for a bunch of .NET components that do heavy pattern matching and text processing. In a nutshell, when you select a programming language, you should look at your existing skills and combine them with the programming constructs provided to you by the different languages to make an informed decision.
In Brief
- The .NET Framework programming model provides the developer with a true choice when it comes to selecting a programming language for a .NET application, Web services, or a component.
- C#, Visual Basic, C++, and J# are the four main programming languages for .NET, at least out of the box with the Framework and the Visual Studio .NET tool.
- Whereas C# represents the most modern, current, and innovative programming language, Visual Basic .NET stands for high ease of use and developer productivity. C++ provides .NET developers immense power, especially when it comes to lower-level operating systems, Win32 API access, and the most efficient interoperability with existing applications and components. J# provides Java developers with the ease of moving into the .NET programming model.
- A number of ISVs have ported various programming languages to output MSIL for the CLR.
- Choosing the right programming language primarily depends on your existing skills and the usage. For instance, C++ would be the language of choice for efficient interoperability with the Windows operating system APIs and existing applications.