Professional ASP.NET 1.1 [Electronic resources] نسخه متنی

C#

Like .NET itself, C# has raised a fair amount of discussion, much of it based around raising questions such as "Another language? Why?" and "Isn't it just Java?". To understand why a new language has been introduced, think about what Microsoft is trying to achieve with .NET. Some of the key ideas are:

Cross-language development.

A unified type system.

Extensibility and security.

Greater support for development tools.

These are not the only goals, nor are they specific reasons for creating a new language, but it was clear that to build the .NET Framework the existing languages wouldn't meet these requirements. C++, for example, isn't truly component oriented, and still has many hang-ups from the C language. Java is bound by its ownership by Sun (not to mention lawsuits) and is interpreted, which leads to performance problems. Object-oriented languages such as Smalltalk and Eiffel have the stigma of being considered obscure, and would need performance increases and structural changes.

Therefore, a new language was the simplest answer, but not so new, that it wouldn't feel familiar. You can think of C# as a member of the C/C++ family – a fact that's not surprising, since the majority of development at Microsoft is done in these languages. As such, C# contains the best features of C++, but leaves out all of the bits that aren't required for a language to be part of the framework (such as typedefs, templates, and so on). Leaving out functionality hasn't been a hindrance, rather, it has made the language simpler to use and more efficient. In addition, it's not just a language being pushed on the public – ASP.NET is entirely written in C#.

Classes

Even though C# is more like C and C++, Visual Basic or VBScript programmers won't have too much trouble with this new language. Classes are defined using the following syntax:

[public | protected | internal | protected internal | private | 
 
abstract | sealed ] class className 
{ 
} 

Let's look at the keywords here in more detail:

For example:

public class Calculator 
{ 
// implementation goes here 
} 

Methods

In C# there is no direct distinction between a

Sub and a

Function , and members are just implemented as functions (that may or may not return data). The syntax is:

[ public | protected | internal | protected internal | private | static |
virtual | override | abstract | extern ] 
[ type | void ] memberName([parameters]) 
{ 
} 

The various keywords are described as follows:

For example:

public class calculator 
{ 
public double Add(double op1, double op2) 
{ 
return op1 + op2; 
} 
} 

For a method that does not return a result, we declare the type as

void :

public void updateSomething() 
{ 
} 

Properties

Properties in C# are very similar to Visual Basic .NET, and can be implemented as

public member variables or by using the property accessors. For example, the following class uses public variables:

public class calculator
{
public double Op1; 
public double Op2; 
public double Add()
{
return Op1 + Op2;
}
}

The alternative (and preferred) approach is to use property accessors. For example:

public class calculator 
{ 
private double _op1; 
private double _op2; 
 
public double Operand1 
{ 
get 
{ 
return _op1; 
} 
set 
{ 
_op1 = value; 
} 
} 
 
public double Operand2 
{ 
get 
{ 
return _op2; 
} 
set 
{ 
_op2 = value; 
} 
} 
 
} 

Unlike Visual Basic, there are no specific keywords to identify

read-only and

write-only properties. If only the

get accessor is provided, the property is

read-only , and if only the

set accessor is provided, the property is

write-only . Both accessors imply a

read-write property.

Constructors

Rather than using

New for constructors, the C# syntax is to use a method with the same name as the class. For example:

public class person 
{ 
private string _firstName; 
private string _lastName; 
 
public person() {} 
 
public person(string firstName, string lastName) 
{ 
_firstName = firstName; 
_lastName = lastName; 
} 
public string FirstName 
{ 
// property accessors here 
} 
 
public string LastName 
{ 
// property accessors here 
} 
} 

Destructors

For destructors there is no

Destruct keyword. This functionality is provided by a method with the same name as the class, but with a tilde (

~ ) preceding it. For example:

public class person
{
private string _firstName;
private string _lastName;
public person() {}
public person(string firstName, string lastName) { }
~person() 
{ 
// destructor code here 
} 
}

Inheritance

Inheritance in C# looks more like C++, where a colon (

: ) is used to separate the class and the base class. For example:

public class programmer : person 
{ 
private int _avgHoursSleepPerNight; 
 
public programmer(): base() 
{ 
} 
 
public programmer(string firstName, string lastName): 
base(firstName, lastName) 
{ 
} 
public programmer(string firstName, string lastName, int hoursSleep): 
base(firstName, lastName) 
{ 
_avgHoursSleepPerNight = hoursSleep; 
} 
public int AvgHoursSleepPerNight 
{ 
get { return _avgHoursSleepPerNight; } 
set { _avgHoursSleepPerNight = value; } 
} 
} 

The class definition defines that the class is called

programmer and the base class is called

person :

public class programmer : person
{

Next, you need to provide the constructors. Here specify the same constructors as the base class, and use the same inheritance syntax (

: ) to indicate that this method inherits its implementation from the base class. Any parameters should be passed to the base class constructor:

public programmer(): base()
{
}
public programmer(string firstName, string lastName):
base(firstName, lastName)
{
}

To declare an additional constructor, follow the same rules, invoking the base constructor, but also providing additional functionality:

public programmer(string firstName, string lastName, int hoursSleep):
base(firstName, lastName)
{
_avgHoursSleepPerNight = hoursSleep;
}

Finally, you have the

new property:

   public int AvgHoursSleepPerNight
{
get { return _avgHoursSleepPerNight; }
set { _avgHoursSleepPerNight = value; }
}
}

The

value keyword is implemented automatically by the CLR, providing the property with the supplied value from the calling program.

Interfaces

Interfaces work the same as in Visual Basic .NET, providing an immutable contract to the external world.

To create an interface, use the

interface construct. For example:

public interface IPerson
{
string FirstName(get; set;)
string LastName(get; set;)
string FullName();
}

To derive a class from an interface, use the same method as inheritance:

public class Person : IPerson
{
private string _firstName;
private string _lastName;
public string FirstName()
{
// implementation goes here
}
public string LastName()
{
// implementation goes here
}
public string FullName()
{
return _firstName + " " + _lastName;
}
}

Notice that unlike Visual Basic .NET, only the class needs to specify the interface inheritance.

References

References use the same method as Visual Basic .NET, but with the keyword

using instead of

Imports:

using System; 
using MyComponent; 

It's also possible to alias references using the following syntax:

using aliasName = Namespace; 

If an alias is used, the alias must be included in references to classes that the namespace contains. For example, if you have a namespace called

MyComponent containing a class called

MyClass , and import the namespace like this:

using foo = MyComponent; 

You can't then access the class like this:

MyClass comp = MyClass 

You have to use the following syntax:

foo.MyClass comp = foo.MyClass 

Exception Handling

The

try …

catch …

finally combo is another way of performing exception handling in C#, using the following syntax:

try 
{ 
// code block to try 
} 
[catch[(type exception)] 
{ 
// code block to run if the exception matches the type above 
}] 
catch[(type exception)] 
{ 
// code block to run if the exception matches the type above 
} 
finally 
{ 
' code that always runs, whether or not 
' an exception was caught 
} 

For example:

try 
{ 
// connect to a database and 
// retrieve some data 
// ... code left out for clarity ... 
} 
catch(SQLException exSQL) 
{ 
ErrorLabel.Text = "SQL Error: " + exSQL.ToString(); 
} 
catch(Exception ex) 
{ 
ErrorLabel.Text = "Other error: " + ex.ToString(); 
} 
finally 
{ 
FinishedLabel.Text = "Finished"; 
} 

The

throw statement can be used to raise errors, even when in

try …

catch blocks. For example:

try 
{ 
// some code here 
} 
catch(SQLException exSQL) 
{ 
if (some expression) 
throw(exSQL); 
} 

XML Documentation

One great feature that C# has over Visual Basic is the ability to include inline documentation. This is done by placing a set of XML tags at various places in code, and then adding a compiler directive to pull out the comments. For example:

using System;
namespace peopleCS
{
///<remarks> 
///The <c>programmer</c>class defines the salient 
///attributes of every fine programmer. 
///<seealso cref="person">Inherits from person</seealso> 
///</remarks> 
public class programmer : person
{
private int _avgHoursSleepPerNight;
///<summary>Default constructor</summary> 
public programmer(): base()
{ }
///<summary>Constructor using first and last names</summary> 
 
///<param name="firstName">The first name of the programmer</param> 
 
///<param name="lastName">The last name of the programmer</param> 
 
///<seealso cref="string"/> 
 
public programmer(string firstName, string lastName): 
base(firstName, lastName) 
{ } 
 
///<summary>Constructor using first and last names and 
 
///the hours of sleep</summary> 
 
///<param name="firstName">The first name of the programmer</param> 
 
///<param name="lastName">The last name of the programmer</param> 
 
///<param name="hoursSleep">The average number of hours of sleep</param> 
 
///<seealso cref="string"/> 
 
///<seealso cref="int"/> 
public programmer(string firstName, string lastName, int hoursSleep):
base(firstName, lastName)
{
_avgHoursSleepPerNight = hoursSleep;
}
///<value>Defines the average number of hours of sleep.</value> 
public int AvgHoursSleepPerNight
{
get { return _avgHoursSleepPerNight; }
set { _avgHoursSleepPerNight = value; }
}
}
}

The tags are as follows:

In Visual Studio, these tags can be processed to form HTML pages that become part of the project documentation. Outside Visual Studio, you can produce an XML file for the comments by using the

/doc compiler switch (more on these in The .NET Language Compilers section), which produces the file as follows:

<?xml version="1.0"?> 
<doc> 
 
<assembly> 
<name>PeopleCS</name> 
</assembly> 
 
<members> 
 
<member name="T:peopleCS.programmer"> 
<remarks> 
The <c>programmer</c>class defines the salient 
attributes of every fine programmer. 
<seealso cref="T:peopleCS.person">Inherits from person</seealso> 
</remarks> 
</member> 
 
<member name="M:peopleCS.programmer.#ctor"> 
<summary>Default constructor</summary> 
</member> 
 
<member name="M:peopleCS.programmer.#ctor(System.String,System.String)"> 
<summary>Constructor using first and last names</summary> 
<param name="firstName">The first name of the programmer</param> 
<param name="lastName">The last name of the programmer</param> 
<seealso cref="T:System.String"/> 
</member> 
 
<member name="M:peopleCS.programmer.#ctor(System.String, 
System.String,System.Int32)"> 
<summary>Constructor using first and last  
names and the hours of sleep</summary> 
<param name="firstName">The first name of the programmer</param> 
<param name="lastName">The last name of the programmer</param> 
<param name="hoursSleep">The average number of hours of sleep</param> 
<seealso cref="T:System.String"/> 
<seealso cref="T:System.Int32"/> 
</member> 
 
<member name="P:peopleCS.programmer.AvgHoursSleepPerNight"> 
<value>Defines the average number of hours of sleep.</value> 
</member> 
 
</members> 
 
</doc> 

The compiler automatically includes the namespace and builds tags for the member names. The members are given a fully qualified name starting with one of the following prefixes:

You could then use an XSLT stylesheet, or XML processing code to style this into your own documentation. You could also add your own XML elements to the class descriptions, and these would be extracted along with the predefined elements.

Unsafe Code

Although C# is part of the managed code environment, Microsoft has realized that sometimes developers need total control, such as when performance is an issue, when dealing with binary structures, or for some advanced COM support. Under these circumstances, you are able to use C# code in an unsafe manner, using pointers, unsafe casts, and so on.

As an ASP.NET developer it's unlikely you'll ever need this, but knowing it's available gives you the flexibility to choose, should the need arise.

Operator Overloading

C# is the only one of the supplied languages that supports operator overloading. This works in the same way as method overloading, except for operators. The reason for this is to allow the standard operators to be used on objects such as classes.

The classic example given is a class for handling complex numbers, which have a real and imaginary part (stored as integers). Imagine a class that has two properties for these two parts, and a constructor that takes two arguments to match the properties:

CNumber c1 = new CNumber(12, 4); 
CNumber c2 = new CNumber(5, 6); 

When performing addition on complex numbers, you must add the real part and imaginary part independently of each other, and might consider creating this method:

public CNumber Add(CNumber c1, CNumber c2) 
{ 
return new CNumber(c1.real + c2.real, c1.imag + c2.imag); 
} 

You could then call this by:

CNumber c3 = CNumber.Add(c1, c2); 

There's nothing wrong with that per se, but it would be far better to use:

CNumber c3 = c1 + c2; 

To achieve this, you would have to overload the

+ operator:

public static CNumber operator +(CNumber c1, CNumber c2); 
{ 
return new CNumber(c1.real + c2.real, c1.imag + c2.imag); 
} 

This provides a much more intuitive way of developing, and is especially useful when building class libraries for other developers.