ASP.NET 1.0 and 1.1

Microsoft's .NET framework introduces a whole new way of programming the Microsoft platform. Microsoft developers are primarily concerned with threads and memory (that's basically the API programming model). This model carried over to all areas of development, including Web development, placing a heavy burden upon programmers.

.NET is built upon the notion of managed types. Developers writing classic Windows code (and Web code) wrote classes using C++ or Visual Basic. In many ways, types are similar to the notion of the C++ class in that types are units of state with functionality attached to them. However, the similarity ends there. Whereas it was incumbent upon the developer to manage instances of classes, types are managed completely by the .NET runtime services-the Common Language Runtime (CLR). Because the CLR takes over managing memory and threads, developers are much more at liberty to concentrate on the actual application (rather than chasing down errant pointers, memory leaks, and unexplained crashes).

ASP.NET introduces runtime services and a well-engineered class library for greatly enhancing Web development. In a way, classic ASP was sort of "taped onto" the IIS/ISAPI architecture without any real organic thought as to how early design decisions would affect developers later on. Well, now it's later on and classic ASP.NET's warts have become fairly obvious.

ASP.NET is built from the ground up to be an extensible, feature-rich way to handle HTTP requests. ASP.NET leverages IIS in that requests for ASP.NET services are mapped to an ISAPI DLL. The DLL is named ASPNET_ISAPI.DLL. From there, processing is passed into a worker process provided by ASP.NET (ASPNET_WP.EXE in IIS 5 or W3WP.EXE in IIS 6). The fundamental request processing is handled by managed types within the worker process. Control passes between a number of classes plugged into the pipeline-some provided by Microsoft and/or third parties, and some provided by the developer. What's more, ASP.NET is built from the ground up to be a comprehensive framework for writing Web applications. All the parts of the framework execute together to handle requests. By contrast, classic ASP.NET script code had no structure to it, and code logic within applications tended to be ad hoc.

ASP.NET 1.0 and 1.1 provided a significant number of features, including:

  • An object-oriented framework for defining applications

  • Separation of user interface declarations (HTML) and application logic

  • Compiled code for executing application logic

  • Configurable session state management

  • Built-in data caching

  • Built-in content caching

  • A well-defined UI componentization architecture

  • High-level components for managing data formatting (grids, lists, text boxes)

  • Built-in program tracing and diagnostics

  • Built-in user input validation

  • An easy-to-use custom authentication mechanism

  • Solid integration with ADO.NET (the .NET database story)

  • Excellent support for Web Services

  • Zero reliance on the Component Object Model

  • An extensible pipeline with many places in which a request can be intercepted

ASP.NET 1.0 set the stage for many developers both moving into Web development and moving to the Microsoft Platform.