Professional ASP.NET 1.0 Special Edition- P4

Chia sẻ: Cong Thanh | Ngày: | Loại File: PDF | Số trang:40

Thêm vào BST

Báo xấu

72
lượt xem 9
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

Professional ASP.NET 1.0 Special Edition- P4:Those of us who are Microsoft developers can't help but notice that .NET has received a fair amount of visibility over the last year or so. This is quite surprising considering that for most of this period, .NET has been in its early infancy and beta versions. I can't remember any unreleased product that has caused this much interest among developers. And that's really an important point, because ignoring all the hype and press, .NET really is a product for developers, providing a great foundation for building all types of applications....

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: Professional ASP.NET 1.0 Special Edition- P4

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 below: Keyword Description public The member is publicly accessible. protected The member is only accessible from the containing class or types derived from the containing member. internal The member is only accessible from this program. Equivalent to Friend in Visual Basic. Table continued on following page Keyword Description protected The member is only accessible from this program, or types derived from the containing member. internal Equivalent to Protected Friend in Visual Basic. private The member is only accessible from within the containing member. The member is shared by all instances of the class, and exists independently of a class instance. static Equivalent to Shared in Visual Basic. virtual The member can be overridden by a sub-class. The member overrides an identically named member from a base class, with the same signature. The override base class member must be defined as virtual, abstract or override. abstract This member is an abstract member, and must be implemented by a sub-class. extern The member is implemented in an external assembly. 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 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- and write-only properties. If only the get accessor is provided then the property is read-only, and if only the set accessor is provided then 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 (~) in front of it. For example: public class person { private string _firstName; private string _lastName; public person() {} public person(string firstName, string lastName) { } ~person() { // destructor code here } } Like Visual Basic .NET, destructors in C# are called by the garbage collector, and are not guaranteed to be executed at the time you destroy the class.
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 our class is called programmer and the base class is called person: public class programmer : person { Next we need to provide the constructors. Here we specify the same constructors as the base class, and use the same inheritance syntax (the :) 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 we 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; } And finally we 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, we 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, we 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. For example: 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 we have a namespace called MyComponent containing a class called MyClass, and import the namespace like this: using foo = MyComponent; we can't then access the class like this: MyClass comp = MyClass
We have to use this syntax: foo.MyClass comp = foo.MyClass Exception Handling The try … catch … finally combo is also the way exception handling is performed 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 really 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 our code, and then adding a compiler directive to pull out the comments. For
example: using System; namespace peopleCS { /// ///The programmerclass defines the salient ///attributes of every fine programmer. ///Inherits from person /// public class programmer : person { private int _avgHoursSleepPerNight; ///Default constructor public programmer(): base() { } ///Constructor using first and last names ///The first name of the programmer ///The last name of the programmer
/// public programmer(string firstName, string lastName): base(firstName, lastName) { } ///Constructor using first and last names and ///the hours of sleep ///The first name of the programmer ///The last name of the programmer ///The average number of hours of sleep /// /// public programmer(string firstName, string lastName, int hoursSleep): base(firstName, lastName) { _avgHoursSleepPerNight = hoursSleep; } ///Defines the average number of hours of sleep. public int AvgHoursSleepPerNight
{ get { return _avgHoursSleepPerNight; } set { _avgHoursSleepPerNight = value; } } } } Notice how the XML tags are placed after three /// characters - not to be confused with two, as used by comments. The tags we can use are as follows: Tag Description c Text that indicates inline code. code Multiple lines of code, such as a sample. example Description of a code sample. Indicates an exception class. Additionally, the attribute cref can be used to reference another type (such as exception the exception type). This reference is checked against the imported libraries. include Allows XML documentation to be retrieved from another file. Indicates a list of items. The type attribute can be one of:bullet, for bulleted listsnumber, for numbered liststable, for a tableYou can use a listheader element to define headings, and an item element to list define the items in the list. Each of these can contain two elements: item for the item being listed, and description. para Allows paragraph definitions within other tags. param Describes the parameter of a method. The name attribute should match the name of the parameter. Table continued on following page Tag Description paramref Used to indicate references for parameters. Describes the permissions required to access the member. The cref can be used to reference another type permission (such as the security permission type). This reference is checked against the imported libraries. remarks Overview information about the class or type. returns The return value of a method.
The attribute cref is used to reference another type (such as a related member). This reference is checked see against the imported libraries. The attribute cref is used to reference another type (such as a related member), to be documented in the seealso See Also section. This reference is checked against the imported libraries. summary Description of a member or type. value Description of a property. In Visual Studio, these tags can be processed to form HTML pages that become part of the project documentation. Outside Visual Studio, we can produce an XML file for the comments by using the /doc compiler switch (more on these later), which produces the file like so: PeopleCS The programmerclass defines the salient attributes of every fine programmer. Inherits from person
Default constructor Constructor using first and last names The first name of the programmer The last name of the programmer Constructor using first and last names and the hours of sleep The first name of the programmer The last name of the programmer The average number of hours of sleep
Defines the average number of hours of sleep. 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: Prefix Description N Namespace T Type: Class, Interface, Struct, Enum, or Delegate F Field P Property (including indexers) M Method (including constructors) E Event ! Error string if links cannot be resolved 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, we are able to use C# code in an unsafe manner, where we can use 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 us the flexibility to choose, should the need arise. Consult the C# documentation or Wrox's Professional C# Programming, ISBN 1-86007-04-3 for more information on this. Operator Overloading C# is the only one of the supplied languages that supports operator overloading. This works in the same way as method