ASP.Net Bible

Elements of the .NET Framework

2009-03-18T05:13:00.000-07:00

The Main Elements of the .NET Framework

The .NET Framework consists of three key elements
1. Common Language Runtime
2. NET Class Library
3. Unifying components

Common Language Runtime
The Common Language Runtime (CLR) is a layer between an application and the operating system it executes on. The CLR simplifies an application's design and reduces the amount of code developers need to write because it provides a variety of execution services that include memory management, thread management, component lifetime management, and default error handling. The key benefit of the CLR is that it transparently provides these execution services to all applications, regardless of what programming language they're written in and without any additional effort on the part of the developer.
The CLR is also responsible for compiling code just before it executes. Instead of producing a binary representation of your code, as traditional compilers do, .NET compilers produce a representation of your code in a language common to the .NET Framework: Microsoft Intermediate Language (MSIL), often referred to as IL. When your code executes for the first time, the CLR invokes a special compiler called a Just In Time (JIT) compiler, which transforms the IL into executable instructions that are specific to the type and model of your system's processor. Because all .NET languages have the same compiled representation, they all have similar performance characteristics. This means that a program written in Visual Basic .NET can perform as well as the same program written in Visual C++ .NET. (C++ is the language of choice for developers who need the best possible performance a system can deliver.)

Easy application deployment and maintenance

2009-03-18T05:07:00.000-07:00

Applications are often made up of several components:

1. Web Pages
2. Windows forms-based components
3. Web services
4. Components housed in DLLs
The .NET Framework makes it possible to install applications that use some or all of these components without having to register DLLs (using regsvr32.exe) or to create Registration Database (also known as the system Registry) entries. The .NET Framework makes it easy to deploy applications using zero-impact installation often all that's required to install an application is to copy it into a directory along with the components it requires. This is possible because the .NET Framework handles the details of locating and loading components an application needs, even if you have several versions of the same component available on a single system. All of this is possible because the .NET Framework records extra information about an application's components — the extra information is called metadata. A component of the .NET, Framework, the Class Loader, inspects an application's metadata and ensures that all of the components the application depends on are available on the system before the application begins to execute. This feature of the .NET Framework works to isolate applications from each other despite changes in system configuration, making it easier to install and upgrade applications.
Once an application is running on a system, it is sometimes necessary to change certain traits of the application, such as its security requirements, optional parameters, and even database connections. .NET Framework applications use a configuration model based on application-configuration files. A configuration file is a text file that contains XML elements that affect the behavior of an application. For example, an administrator can configure an application to use only a certain version of a component the application relies on, thereby ensuring consistent behavior regardless of how often the component is upgraded.
The following code shows an ASP.NET's basic configuration file; the file is called web.config:

This code shows that the ASP.NET application will have page buffering on (pages will be sent to clients only when the page is completely rendered), and that ASP.NET will track ndividual clients' session information (as shown in the pages tag). This code also demonstrates how to define a custom configuration key, called dsn — within the appSettings section, which applications have access to through the TraceSwitch class.

Three types of Runtime diagnostics:Event logging,Performance counters,Tracing

2009-02-10T10:09:00.000-08:00

Framework provides three types of Runtime diagnostics:
1. Event logging
2. Performance counters
3. Tracing

1. Event logging
Windows 2000 and Windows XP have a feature called an Event Log _ a database containing information about important hardware or software events. The Event Log is useful for recording information about the status of your applications and provides systems administrators a means of diagnosing problems, since they can review Event Log entries using the Event Viewer (supplied with Windows and available in theAdministrative Tools group in the Control Panel). There are three types of Event Log events:
1. Informational events: Usually contain basic information, such as an application starting or shutting down
2. Warning events: Usually provide information about unusual conditions that have the potential to become errors
3. Error events: Represent critical errors in an application that prevent it from executing normally .
Events are stored in Event Logs — Windows supports three types of Event Logs:
1. Application: Contains messages that applications such as Microsoft SQL Server log
2. System: Contains messages that device drivers and system services log.
3. Security: Contains system-generated messages about events that occur when security auditing is enabled
The .NET Framework makes it easy to work with the Event Log as shown in the following
code:

Imports System
Imports System.Diagnostics
Module eventLogDemo
Sub Main()
If Not EventLog.SourceExists("ASPnetBible") Then
EventLog.CreateEventSource( _
"ASPnetBible", "Application")
Console.WriteLine( _
"Created new EventSource 'ASPnetBible'")
End If
Dim evLog As New EventLog()
evLog.Source = "ASPnetBible"
' Note: this listing does not show the
' complete message for brevity
evLog.WriteEntry( "...starting")
Console.WriteLine("Wrote 'starting'...")
evLog.WriteEntry("... exiting")
Console.WriteLine("Wrote 'exit'...")
End Sub
End Module

This code is a Visual Basic .NET console application that creates an Event Source called ASPnetBible and logs the application's starting and exiting events to the system's Application event log — although the listing doesn't show it, both messages are informational.

2. Performance counters
Performance counters are useful for monitoring the health and performance of an application. You can chart the value of using the Performance applet in the Administrative Tools folder of the systems Control Panel. The .NET Framework makes it easy for you to read the value of existing performance counters, such as the system's percent CPU Utilization, as well as create your own applicationspecific performance counters. The following code demonstrates how to work with performance counters in a simple Windows Forms application:

' Create a new performace counter

Dim counterCollection As New CounterCreationDataCollection()
Dim couterItem As New CounterCreationData()
counterName = "demoCounter"
perfCatName = "ASPnetBible"
couterItem.CounterName = counterName
couterItem.CounterType =
PerformanceCounterType.NumberOfItems32
counterCollection.Add(couterItem)
PerformanceCounterCategory.Create(perfCatName, _
"sample counter", counterCollection)
' ...elsewhere in the application - Increment the counter
Dim perfCounter As PerformanceCounter
perfCounter = New PerformanceCounter()
perfCounter.CategoryName = perfCatName
perfCounter.CounterName = counterName
perfCounter.ReadOnly = False
perfCounter.IncrementBy(50)
System.Threading.Thread.Sleep(2000)
perfCounter.IncrementBy(-50)
'...elsewhere in the application - Delete the sample counter
PerformanceCounterCategory.Delete(perfCatName)

This code demonstrates how to create a new performance counter category and counter using the CouterCreationDataCollection and CouterCreationData classes — the fragment shown is from the sample application's Load event handler. In the next section of the code, from a button's Click event handler, the code creates an instance of the sample performance counter, increments it, and waits two seconds before decrementing the counter. The last part of the code shows how to delete the performance counter when the form closes.

3. Tracing
Debugging an application by using the Visual Studio .NET debugger is a great way to track down problems; however, there are many scenarios in which things happen too quickly to follow interactively or in which you simply need to know the sequence of events that lead to a problem before the problem occurs. Tracing is an alternative to using a debugger to step through each line of code as your application executes. You can configure ASP.NET tracing by using two methods: pagelevel tracing and application-level tracing. Both types of tracing provide similar results; however, the difference is in how you access the results for each approach. Page-level tracing provides trace details on the ASPX page when it completes executing, and application-level tracing stores the details of the trace in a file called (by default) trace.acx, which is located in the same directory as the ASP.NET application — you can view the file by using your browser. When you enable tracing, which is disabled by default, ASP.NET records detailed information about the page request, trace messages, control information, cookies, header information, the contents of any form fields, and a raw output of the contents of server variables (like CONTENT_TYPE and HTTP_REFERRER). Table 1-1 shows a fragment of a trace output from a simple ASP.NET page.
Table 1-1: Fragment of an ASP.NET Page Trace
Category Message From
First(s)
From
Last(s)
aspx.page Begin Init
aspx.page End Init 0.000096 0.000096
aspx.page Begin
LoadViewStat
e
0.000189 0.000092
aspx.page End
LoadViewStat
e
0.000308 0.000119
aspx.page Begin
ProcessPostD
ata
0.000393 0.000085

Benefits of the .NET Framework

2009-01-31T02:42:00.000-08:00

The .NET Framework offers a number of benefits to developers:
1. A consistent programming model
2. Direct support for security
3. Simplified development efforts
4. Easy application deployment and maintenance

1. Programming model
Different programming languages offer different models for doing the same thing. For example, the following code demonstrates how to open a file and write a one-line message to it using Visual Basic 6.0:

Public Sub testFileAccess()
On Error GoTo handle_Error
' Use native method of opening an writing to a file...
Dim outputFile As Long
outputFile = FreeFile
Open "c:\temp\test.txt" For Output As #outputFile
Print #outputFile, "Hello World!"
Close #outputFile

' Use the Microsoft Scripting Runtime to
' open and write to the file...

Dim fso As Object
Set fso = CreateObject("Scripting.FileSystemObject")
Dim outputText As TextStream
Set outputText = fso.CreateTextFile("c:\temp\test2.txt")
outputText.WriteLine "Hello World!"
outputText.Close
Set fso = Nothing
Exit Sub
handle_Error:
' Handle or report error here
End Sub

This code demonstrates that more than one technique is available to create and write to a new file. The first method uses Visual Basic's built-in support; the second method uses the Microsoft Scripting Runtime. C++ also offers more than one way of performing the same task, as shown in the following code:

#include
#include
#include
#include
using namespace std;
int main(int argc, char* argv[])
{
// Use the C Runtime Library (CRT)...
FILE *testFile;
if( (testFile = fopen( "c:\\temp\\test3.txt",
"wt" )) == NULL ) {
cout << "Could not open first test file!" << style="font-weight: bold;">

Visual Basic .NET:

Imports System.IO
Imports System.Text
Module Demo
Sub Main()
Dim outputFile As StreamWriter = _ New StreamWriter("c:\temp\test5.txt")
outputFile.WriteLine("Hello World!")
outputFile.Close()
End Sub

End Module

Visual C# .NET:

using System.IO;
using System.Text;
class Demo
{
static void Main()
{
StreamWriter outputFile = new StreamWriter("c:\\temp\\test6.txt");
outputFile.WriteLine("Hello World!");
outputFile.Close();
}

The preceding code demonstrates, apart from slight syntactical differences, that the technique for writing to a file in either language is identical — both listings use the StreamWriter class to write the "Hello World!" message out to the text files. In fact, unlike the Visual Basic and Visual C++ listings, which demonstrate that there's more than one way to do something within the same language, the preceding listings show that there's a unified means of accomplishing the same task by using the .NET Class Library.

The .NET Class Library is a key component of the .NET Framework — it is sometimes referred to as the Base Class Library (BCL). The .NET Class Library contains hundreds of classes you can use for tasks such as the following:
1. Processing XML
2. Working with data from multiple data sources
3. Debugging your code and working with event logs
4. Working with data streams and files
5. Managing the run-time environment
6. Developing Web services, components, and standard Windows applications
7. Working with application security
8. Working with directory services

The functionality that the .NET Class Library provides is available to all .NET languages, resulting in a consistent object model regardless of the programming language developers use.

2. Direct support for security
Developing an application that resides on a user's desktop system and uses local resources is easy, from a security point of view, because security simply isn't a consideration in this scenario. Security becomes much more important when you create applications that access data on remote systems or applications that perform privileged tasks on behalf of non privileged users, because systems may have to authenticate users, and encryption (scrambling to avoid eavesdropping) may be necessary to secure data communications.

Windows NT, Windows 2000, and Windows XP have a number of security features based on Access Control Lists (ACLs). An ACL contains a number of entries that specify which users may access, or are explicitly denied access, to resources such as files and printers. ACLs are a great way of protecting executable files (applications) from unauthorized access, but they do not secure all parts of the file. The .NET Framework enables both developers and system administrators to specify method-level security. Developers (through easy-to-use programming language constructs called attributes) and systems administrators (by using administrative tools and byediting an application's configuration file) can configure an application's security so that only authorized users can invoke a component's methods.

The .NET Framework uses industry-standard protocols such as TCP/IP and means of communications such as the Extensible Markup Language (XML), Simple Object Access Protocol (SOAP, a standard application messaging protocol), and HTTP to facilitate distributed application communications. This makes distributed computing more secure, because .NET developers cooperate with network connectivity devices as opposed to attempting to work around their security restrictions.

3. Simplified development efforts
Two aspects of creating Web-based applications present unique challenges to Web developers: visual page design and debugging applications. Visual page design is straightforward when creating static content; however, when you need to present the result of executing a query in a tabular format using an ASP page, page design can get rather involved. This is because developers need to mix traditional ASP code, which represents the application's logic, and HTML, which represents the resentation of the data. ASP.NET and the .NET Framework simplify development by allowing developers to separate an application's logic from its presentation, resulting in an easier-to-maintain code base. ASP.NET can also handle the details of maintaining the state of controls, such as the contents of text boxes, between calls to the same ASP.NET page, thereby reducing the amount of code you need to write. Visual Studio .NET, which is tightly integrated with the .NET Framework, assists developers as they create ASP.NET and other applications by providing visual designers that facilitate visual drag and drop editing, making page layout and form layout a breeze.

Another aspect of creating applications is debugging. Developers sometimes make mistakes; systems don't behave as you expect them to, and unexpected conditions arise — all of these issues are collectively referred to as, using the affectionate term, "bugs." Tracking down bugs — known as "debugging" — quickly and effectively requires developers to be familiar with a variety of tools, sometimes available from a third party, and techniques — a combination of programming techniques and techniques for using a particular tool. The .NET Framework simplifies debugging with support for Runtime diagnostics.

Runtime diagnostics not only help you track down bugs but also help you determine how well your applications perform and assess the condition of your application. The .NET Framework provides three types of Runtime diagnostics:
1. Event logging
2. Performance counters
3. Tracing

Understanding the .NET Framework

2009-01-31T02:34:00.000-08:00

The Internet revolution of the late 1990s represented a dramatic shift in the way individuals and organizations communicate with each other. Traditional applications, such as word processors and accounting packages, are modeled as stand-alone applications: they offer users the capability to perform tasks using data stored on the system the application resides and executes on. Most new software, in contrast, is modeled based on a distributed computing model where applications collaborate to provide services and expose functionality to each other. As a result, the primary role of most new software is changing into supporting information exchange (through Web servers and browsers), collaboration (through e-mail and instant messaging), and individual expression (through Web logs, also known as Blogs, and e-zines — Web based magazines). Essentially, the basic role of software is changing from providing discrete functionality to providing services.

The .NET Framework represents a unified, object-oriented set of services and libraries that embrace the changing role of new network-centric and network-aware software. In fact, the .NET Framework is the first platform designed from the ground up with the Internet in mind.

This chapter introduces the .NET Framework in terms of the benefits it provides. I
present some sample code in Visual C# .NET, Visual Basic .NET, Visual Basic 6.0, and Visual C++; don't worry if you're not familiar with these languages, since I describe in the discussion what each sample does.