Professional ASP.NET 1.0 Special Edition- P5

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

Thêm vào BST

Báo xấu

52
lượt xem 10
download

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

Professional ASP.NET 1.0 Special Edition- P5: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- P5

Let's have a look at the practicalities of the CLR and CLS. Common API In the previous version of Visual Studio, common functionality was always far harder to implement than it should have been. For C++ programmers, the Windows API is a natural home, but Visual Basic programmers had to use custom controls and libraries, or delve into the API itself. This isn't complex, and can yield great benefits, but there is no consistency. With .NET we now have a common API and a great set of class libraries. For example, consider the case of TCP/IP network applications. C++ programmers generally write directly to Winsock, whereas Visual Basic programmers prefer to use custom controls on their forms. The .NET framework provides a System.Net.Sockets namespace encompassing all of the networking functionality, and its usage is the same for each language. For example, consider the case of writing to a UDP port - you can see the only differences in the code are the syntax of the language: Visual Basic .NET Dim Client As UdpClient Dim HostName As String Dim HostIP As IPHostEntry Dim GroupAddress As IPAddress Dim Remote As IPEndPoint HostName = DNS.GetHostName() HostIP = DNS.GetHostByName(HostName) Client = New UdpClient(8080) GroupAddress = IpAddress.Parse("224.0.0.1") Client.JoinMultiCastGroup(GroupAddress, 500)
Remote = New IPEndPoint(GroupAddress, 8080) Client.Send(".NET is great", 13, Remote) C# UdpClient Client; String HostName; IPHostEntry HostIP; IPAddress GroupAddress; IPEndPoint Remote; HostName = DNS.GetHostName(); HostIP = DNS.GetHostByName(HostName); Client = new UdpClient(8080); GroupAddress = IpAddress.Parse("224.0.0.1"); Client.JoinMultiCastGroup(GroupAddress, 500); Remote = new IPEndPoint(GroupAddress, 8080); Client.Send(".NET is great", 13, Remote); JScript .NET var Client : UdpClient;
var HostName : String; var HostIP : IPHostEntry; var GroupAddress : IPAddress; var Remote : IPEndPoint; HostName = DNS.GetHostName(); HostIP = DNS.GetHostByName(HostName); Client = new UdpClient(8080); GroupAddress = IpAddress.Parse("224.0.0.1"); Client.JoinMultiCastGroup(GroupAddress, 500); Remote = new IPEndPoint(GroupAddress, 8080); Client.Send(".NET is great", 13, Remote); Common Types One of the ways in which cross language functionality is made available is by use of common types. Those Visual Basic programmers (and I was one) who delved into the Windows API, always had the problem about converting types. Strings were the worst, because the API is C/C++ based, which uses Null terminated strings, so you always had to do conversion and fixed string handling stuff. It was ugly. With the CLS there is a common set of types, so no conversion is required. The previous chapter detailed these, showing their range and size, and explained that the various compilers will convert native types into CLS ones. The conversion works like this: Visual Type C# JScript .NET Basic .NET System.Boolean Boolean Bool Boolean System.Byte Byte Byte Byte
System.Char Char Char Char No direct equivalent. Use the CLS No direct equivalent. JScript .NET has its own System.DateTime Date type. Date type. System.Decimal Decimal Decimal Decimal System.Double Double Double DoubleNumber System.Int16 Short Short Short Type Visual Basic .NET C# JScript .NET System.Int32 Integer Int Int System.Int64 Long Long Long System.UInt16 No direct equivalent. Ushort Ushort System.UInt32 No direct equivalent. Uint Uint System.UInt64 No direct equivalent. Ulong Ulong System.SByte No direct equivalent. Sbyte Sbyte System.Single Single Float Float System.String String String String Note that not all languages have equivalents of the CLS types. For example, JScript .NET implements dates using the standard JScript Date object. However, you can convert between various type formats, as well as declaring the CLS types directly. Cross-Language Inheritance Another area where the CLS has helped is the area of inheritance. Assuming that you use the common types in your class interfaces, then inheriting classes written in other languages is no different to that of inheriting from the same language. We showed a brief example in the previous chapter, when discussing the CLR and common functionality, but a fuller example makes this clear. For example, suppose that you had the following Visual Basic class: Public Class Person Private _firstName As String Private _lastName As String Sub New() End Sub
Sub New(firstName As String, lastName As String) _firstName = firstName _lastName = lastName End Sub Public Property FirstName() As String ' property code here End Property Public Property LastName() As String ' property code here End Property End Class You could write another program, perhaps in C#, that inherits from it: 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; } } ~programmer() { } }
This brings great flexibility to development, especially where team development is concerned. Another great point about this is that many of the base classes and web controls are inheritable. Therefore, in any language, you can extend them as you wish. A good example of this is the ASP.NET DataGrid control. Say you didn't want to use paging, but wanted to provide a scrollable grid, so browsers that supported inline frames would allow the entire content of the grid to be rendered within a scrollable frame. You can create your own control (say, in Visual Basic), inheriting everything from the base control (perhaps written in C#), and then just output the normal content within an IFRAME. This sort of thing is extremely easy to do with the new framework. Cross-Language Debugging and Profiling The cross language debugging features are really cool, and provide a huge leap forward over any debugging features we've ever had before. Both the framework and Visual Studio .NET come with visual debuggers, the only difference being that the Visual Studio .NET debugger allows remote debugging as well as edit and continue. The debuggers work through the CLR, and allow us to step through ASP.NET pages and into components, whatever the language. Along with debugging comes tracing and profiling, with the ability to use common techniques to track code. Both of these topics are covered in more detail in Chapter 22. Performance Issues Performance is always a question in people's minds, and often gets raised during beta testing when there's lots of debugging code hanging around in the product. Even in the early betas it was clear that ASP.NET was faster than ASP, with figures showing that it was 2-3 times as fast. One of the reasons for this performance improvement is the full compilation of code. Many people confuse Intermediate Language (IL) and the CLR with byte-code and interpreters (notably Java), and assume that performance will drop. Their belief in this deepens when they first access an aspx page, because that first hit can sometimes be slow. That's because pages are compiled on their first hit, and then served from the cache thereafter (unless explicit caching has been disabled). Appendix B has a list of tips and tricks to help with performance. Languages Although all languages compile to IL and then to native code, there may be some slight performance differences, due to the nature of the compiler and the language. In some languages, the IL produced may not be as efficient as with others (some people have said that the C# compiler is better than the Visual Basic one), but the effects should be imperceptible. It's only under the highest possible stress situation that you may find differences, and to be honest, I wouldn't even consider it a problem.
Late Bound Code One of the greatest advantages of the CLR is fully typed languages. However, you can still use JScript without datatypes, allowing legacy code to continue working. The disadvantage of this is that types then have to be inferred, and this will have a performance impact. In Visual Basic, if strict semantics are not being used (either by the Option Strict Off page directive or by the /optionstrict- compiler switch), then late-bound calls on object types are handled at run-time rather than compile time. Common Examples Experienced developers probably won't have much trouble using the new features of the languages, or even converting from one language to another. However, there are plenty of people who use ASP and VBScript daily to build great sites, but who have little experience of advanced development features, such as the object oriented features in .NET. That's actually a testament to how simple ASP is, but now that ASP.NET is moving up a gear, it's important that you make the most of these features. To that end, this section will give a few samples in Visual Basic .NET, C# and JScript .NET, covering a few common areas. This will help should you want to convert existing code, write new code in a language that you aren't an expert in, or perhaps just examine someone else's code. We won't cover the definition of classes and class members again in this section, as they've had a good examination earlier in the chapter. Variable Declaration The first point to look at is that of variable declaration. Visual Basic .NET Visual Basic .NET has the same variable declaration syntax as the previous version, but now has the ability to set initial values at variable declaration time. For example: Dim Name As String = "Rob Smith" Dim Age As Integer = 28
Dim coolDude As New Person("Vince", "Patel") C# C# follows the C/C++ style of variable declaration: string Name = "Rob Smith"; int Age = 28; coolDude = new Person("Vince", "Patel"); JScript .NET JScript .NET uses the standard JScript declaration method, with the addition of optional types: var Name : String = "Rob Smith"; var Age = 28; var coolDude : Person = new Person("Vince", "Patel") Functions and Procedures Declaring procedures is similar in all languages. Visual Basic .NET Procedures and functions follow similar syntax to previous versions: Private Function GetDiscounts(Company As String) As DataSet Public Sub UpdateDiscounts(Company As String, Discount As Double)
The major difference is that by default all parameters are now passed by value, and not by reference. And remember that Optional parameters also now require a default value: ' incorrect Function GetDiscounts(Optional Comp As String) As DataSet ' correct Function GetDiscounts(Optional Comp As String = "Wrox") As DataSet Returning values from functions now uses the Return statement, rather than setting the function name to the desired value. For example: Function IsActive() As Boolean ' some code here Return True End Function The way you call procedures has also changed. The rule is that arguments to all procedure calls must be enclosed in parentheses. For example: UpdateDiscounts "Wrox", 5 ' no longer works UpdateDiscounts("Wrox", 5) ' new syntax C# C# doesn't have any notion of procedures - there are only functions that either return or don't return values (in which case the type is void). For example: bool IsActive()
{ // some code here return true; } void UpdateDiscounts(string Company, double Discount) { return; } To call procedures, C# requires that parentheses are used. JScript .NET For JScript .NET the declaration of functions is changed by the addition of types. function IsActive() : Boolean { // some code here return true; } function UpdateDiscounts(Company : String, Discount : Double) : void
{ return; } To call procedures, JScript .NET requires that parentheses are used. Syntax Differences There are a few syntactical differences that confuse many people when switching languages for the first time. The first is that Visual Basic isn't case sensitive, but the other languages are - it still catches me out. Other things are the use of line terminators in C# and JScript, which use a semi-colon. Many people switching to these languages complain about them, but the reason they are so great is that it makes the language free form - the end of the line doesn't end the current statement. This is unlike Visual Basic, where the end of the line is the end of the statement, and a line continuation character is required for long lines. Listed below are some of the major syntactical differences between the languages. Loops Visual Basic .NET There are four loop constructs in Visual Basic, and the syntax of one has changed in Visual Basic .NET. The first is the For…Next loop: For counter = start To end [Step step] Next [counter] For example: For count = 1 To 10 ...
Next The second is the While loop, for which the syntax has changed - the new syntax is: While condition End While For example: While count < 10 ... End While In previous versions of Visual Basic the loop was terminated with a Wend statement. The third is the Do…Loop, which has two forms: Do [(While | Until) condition] Loop or: Do Loop [(While | Until) condition] The difference between these two is the placement of the test condition. In the first instance the test is executed before any loop content, and therefore the content may not get executed. In the second case the test is at the end of the loop, so the content is always executed at least once. For example:
Do While count < 10 Loop Do Loop While count < 10 The For Each loop construct is for iterating through collections: For Each element In collection Next [element] For example: Dim ctl As Control For Each ctl In Page.Controls . Next C# C# has the same number of loop constructs as Visual Basic. The first is the for loop: for ([initializers] ; [expression] ; [iterators]) For example: for (count = 0 ; count < 10 ; count++)
Each of these parts is optional. For example: for ( ; count < 10; count++) for ( ; ; count++) for (count = 0 ; ; count++) for ( ; ; ) The last of these produces an infinite loop. The second is the while loop: while (expression) For example: while (count < 10) The third is the do…while loop: do statement while (expression); For example: do while (count < 10); The foreach loop construct is for iterating through collections: foreach (type identifier in expression)
For example: foreach (Control ctl in Page.Controls) You can also use this for looping through arrays: String[] Authors = new String[] {"Alex", "Brian", "Dave", "Karli", "Rich", "Rob"}; foreach (String Author in Authors) Console.WriteLine("{0}", Author); One point to note about loops in C# is that the loop affects the code block after the loop. This can be a single line or a bracketed block. For example: for (count = 0 ; count < 10 ; count++) Console.WriteLine("{0}", count); or, if more than one line is required as part of the loop: for (count = 0 ; count < 10 ; count++) { Console.Write("The value is now: "); Console.WriteLine("{0}", count); } JScript .NET
JScript .NET has the same number of loop constructs as C# and Visual Basic .NET, with the syntax being more C# like. The first is the for loop, where, unlike C#, all parts of the loop are required: for (initializers ; expression ; iterators) For example: for (count = 0 ; count < 10 ; count++) The second is the while loop: while (expression) For example: while (count < 10) The third is the do…while loop: do statement while (expression); For example: do while (count < 10); The fourth loop construct is for iterating through objects and arrays: for (identifier in [object | array]) For example: for (ctl in Page.Controls)
or, for looping through arrays: var Authors :String= new String[] {"Alex", "Brian", "Dave", "Karli", "Rich", "Rob"}; foreach (String Author in Authors) Console.WriteLine("{0}", Author); One point to note about loops in JScript .NET is that the loop affects the code block after the loop. This can be a single line or a bracketed block. For example: for (count = 0 ; count < 10 ; count++) Console.WriteLine("{0}", count); or, if more than one line is required as part of the loop: for (count = 0 ; count < 10 ; count++) { Console.Write("The value is now: "); Console.WriteLine("{0}", count); } Type Conversion Type conversion of one data type to another is an area that causes a great deal of confusion, especially for those programmers who are used to a type-less language such as VBScript. When dealing with strongly typed languages you either have to let the compiler, or runtime, convert between types (if it can) or explicitly perform the conversion yourself. The method of conversion depends upon the language:
Visual Basic .NET In Visual Basic .NET there are two ways to do this. The first uses CType: Dim AgeString As String Dim Age As Integer AgeString = "25" Age = CType(AgeString, Integer) The CType function takes an object and a data type, and returns the object converted to the data type. The other way is to use the data type as a cast function: Age = CInt(AgeString) C# In C# we just place the type in parentheses before the expression we wish to convert. For example: Age = (int)AgeString; JScript .NET To cast in JScript .NET we use a cast function. For example: Age = int(AgeString) Summary
In this chapter we've examined the languages supplied with .NET, and discovered that the underlying framework provides a rich development environment. The whole issue, and arguments that go along with it, of which language is better, or more suitable, has simply disappeared. The language that's best is the one you are most familiar with. Apart from a few small areas, the major difference between the .NET languages is the syntax. We've also looked at the enhancements to the existing languages that bring them into line with the CLR and CLS, how these features are compatible across all languages, and the benefits they bring. Features such as cross-language development, debugging, and tracing may not seem that great if you only use one language, but the flexibility it brings is immeasurable, especially when combined with the extensive class libraries. Now that we've examined the languages, it's time to start to use them and look in detail at the process of writing ASP.NET pages.