Overview of .NET Framework 3.5 Architecture
This article provides conceptual Overview of .NET Framework 3.5 Architecture, including the common language runtime, the .NET Framework class library, compilation, execution, native code and much more.
.Net Framework 3.5 Architecture
- 1.1 Introduction
- 1.2 Principal Design Features
- 1.3 Dot net Architecture
- 1.3.1 Framework Base Class Library
- 1.3.2 Common Language Runtime (CLR)
- 1.3.3 Assemblies
- 1.3.4 Metadata
- 1.3.5 Security
- 1.3.6 Memory Management
- 1.4 Challenges in Building Modern Application with earlier versions of .net
- 1.5 Addressing the Challenges with .net 3.5
- 1.5.1 Windows Presentation Foundation
- 1.5.2 Windows Communication Foundation
- 1.5.3 Windows Workflow Foundation
- 1.5.4 Windows CardSpace
- 1.5.5 ASP.NET AJAX
- 1.5.6 Language-Integrated Query
- 1.6 Conclusion
- 1.7 Summary
What will you learn from this chapter?
- The basic idea of including this chapter is to get acquainted with .net architecture. One should be aware of the architecture as to how it is operating in prior to development.
- This chapter will also help in learning the basic principles behind the metamorphosis of .net architecture.
1.1 Introduction of .net framework
Microsoft is a software framework that can be installed on computers running Microsoft Windows operating systems. It is the first Microsoft development environment designed from the ground up for Internet development. Although .NET is not meant to be used exclusively for Internet development, its innovations were driven by the limitations of current Internet development tools and technology.
Base for Topic
A software framework, in computer programming, is an abstraction in which common code providing generic functionality can be overridden or specialized by user code providing specific functionality. Frameworks are similar to software libraries in that they are reusable abstractions of code wrapped in a well-defined API.
.NET Framework 1.0
This is the first release of the .NET Framework, released on 13 February 2002 and available for Windows 98, Me, NT 4.0, 2000, and XP.
.NET Framework 1.1
This is the first major .NET Framework upgrade. It is available on its own as a redistributable package or in a software development kit, and was published on 3 April 2003. It is also part of the second release of Microsoft Visual Studio .NET (released as Visual Studio .NET 2003). This is the first version of the .NET Framework to be included as part of the Windows operating system (Windows Server 2003).
.Net Framework 2.0
- Numerous API changes.
- Full 64-bit support for both the x64 and the IA64 hardware platforms.
- Language support for generics built directly into the .NET CLR.
- Many additional and improved ASP.NET web controls.
- New data controls with declarative data binding.
- New personalization features for ASP.NET, such as support for themes, skins and web parts.
- .NET Micro Framework – a version of the .NET Framework related to the Smart Personal Objects Technology initiative.
- Partial classes
- Anonymous methods
- Data Tables
.Net Framework 3.0
- Windows Presentation Foundation (WPF)
- Windows Communication Foundation (WCF)
- Windows Workflow Foundation (WF)
- Windows CardSpace
.Net Framework 3.5
Version 3.5 of the .NET Framework was released on 19 November 2007, but it is not included with Windows Server 2008. As with .NET Framework 3.0, version 3.5 uses the CLR of version 2.0. In addition, it installs .NET Framework 2.0 SP1, installs .NET Framework 2.0 SP2 with 3.5 SP1) and .NET Framework 3.0 SP1 installs .NET Framework 3.0 SP2 with 3.5 SP1), which adds some methods and properties to the BCL classes in version 2.0 which are required for version 3.5 features such as Language Integrated Query (LINQ). These changes do not affect applications written for version 2.0, however.
The source code of the Base Class Library in this version has been partially released (for debugging reference only) under the Microsoft Reference Source License.
Changes since version 3.0
- New language features in C# 3.0 and VB.NET 9.0 compiler
- Adds support for expression trees and lambda methods
- Extension methods
- Expression trees to represent high-level source code at runtime
- Anonymous types with static type inference
- Language Integrated Query (LINQ) along with its various providers
- LINQ to Objects
- LINQ to XML
- LINQ to SQL
- Paging support for ADO.NET
- ADO.NET synchronization API to synchronize local caches and server side data stores
- Asynchronous network I/O API
- Peer-to-peer networking stack, including a managed PNRP resolver
- Managed wrappers for Windows Management Instrumentation and Active Directory APIs
- Support for HTTP pipelining and syndication feeds.
- ASP.NET AJAX is included
Any tool cannot do well unless it is driven by knowledge and intelligence. The .net Framework is one of its kinds which is meant for developing innovative and attractive websites and building and running next generation webservices. The basic idea is to make applications which are visually stunning and run very fast including security. This framework provides the best in class components running on comprehensive and consistent programming model which is event-driven.It is the most appreciated and admired dynamic object oriented framework to support multi lingual programming languages. The framework where you can build application which works the way you want it with diverse API’s, implementing service oriented model-view-controller architecture which is necessary for today’s applications and of course user friendly interface.
.NET framework includes a large library of coded solutions to common programming problems and a virtual machine that manages the execution of programs written specifically for the framework. The .NET Framework is a key Microsoft offering and is intended to be used by most new applications created for the Windows platform. Programs written for the .NET Framework execute in a software environment that manages the program’s runtime requirements. Also part of the .NET Framework, this runtime environment is known as the Common Language Runtime (CLR). The CLR provides the appearance of an application virtual machine so that programmers need not consider the capabilities of the specific CPU that will execute the program. The CLR also provides other important services such as security, memory management, and exception handling. The class library and the CLR together constitute the .NET Framework.
In this chapter I am going to discuss about the principal design features of .net framework such as interoperability, security, base class library etc. I will be explaining the microsoft’s way of implementing common language infrastructure which is called common language runtime. I will also discuss the challenges faced by the earlier version to meet the people’s requirement and also the advancement in the framework to meet those requirements.
1.2 Principal design features
Because interaction between new and older applications is commonly required, the .NET Framework provides means to access functionality that is implemented in programs that execute outside the .NET environment. Access to COM components is provided in the System.Runtime.InteropServices and System.EnterpriseServices namespaces of the framework; access to other functionality is provided using the P/Invoke feature.
Common Runtime Engine
The Common Language Runtime (CLR) is the virtual machine component of the .NET framework. All .NET programs execute under the supervision of the CLR, guaranteeing certain properties and behaviors in the areas of memory management, security, and exception handling.
The .NET Framework introduces a Common Type System, or CTS. The CTS specification defines all possible datatypes and programming constructs supported by the CLR and how they may or may not interact with each other. Because of this feature, the .NET Framework supports the exchange of instances of types between programs written in any of the .NET languages. This is discussed in more detail in Microsoft .NET Languages.
Base Class Library
The Base Class Library (BCL), part of the Framework Class Library (FCL), is a library of functionality available to all languages using the .NET Framework. The BCL provides classes which encapsulate a number of common functions, including file reading and writing, graphic rendering, database interaction and XML document manipulation.
The .NET framework includes design features and tools that help manage the installation of computer software to ensure that it does not interfere with previously installed software, and that it conforms to security requirements.
The design of the .NET Framework allows it to be platform independent, and thus cross-platform compatible. That is, a program written to use the framework should run without change on any type of system for which the framework is implemented. Microsoft’s commercial implementations of the framework cover Windows, Windows CE, and the Xbox 360. In addition, Microsoft submits the specifications for the Common Language Infrastructure (which includes the core class libraries, Common Type System, and the Common Intermediate Language), the C# language, and the C++/CLI language to both ECMA and the ISO, making them available as open standards. This makes it possible for third parties to create compatible implementations of the framework and its languages on other platforms.
The basis of this new development platform consists of three primary components or layers: the Common Language Runtime (CLR), the .NET Framework Base Classes, and the user and program interfaces, as demonstrated in Figure 1.1.
1.3.1 Framework Base Class Library
The framework’s Base Class Library provides a large range of features including user interface, data and data access, database connectivity, cryptography, web application development, numeric algorithms, and network communications. The class library is used by programmers, who combine it with their own code to produce applications.
1.3.2 Common Language Runtime (CLR)
Programs written for the .NET Framework execute in a software environment that manages the program’s runtime requirements. Also part of the .NET Framework, this runtime environment is known as the Common Language Runtime (CLR). CLR is the foundation of the .NET Framework. Its principal purpose is to load, execute, and manage code that has been compiled to Microsoft’s new intermediate byte-code format called Intermediate Language (IL). Several languages, notably Microsoft’s Visual Basic .NET and C# .NET (pronounced “C sharp”), have compilers supporting this format, and many more are currently in development.
The CLR provides the appearance of an application virtual machine so that programmers need not consider
The capabilities of the specific CPU that will execute the program. The CLR also provides other important services such as security, memory management, and exception handling. The table below shows functions of different components of CLR.
|Class loader||Manages metadata, as well as the loading and layout of classes.|
|MSIL to native compiler||Converts MSIL to native code (Just-in-Time).|
|Code manager||Manages code execution.|
|Garbage collector||Provides automatic lifetime management of all of your objects. This is a multiprocessor, scalable garbage collector.|
|Security engine||Provides evidence-based security, based on the origin of the code in addition to the user.|
|Debug engine||Allows you to debug your application and trace the execution of code.|
|Type checker||Will not allow unsafe casts or uninitialized variables. MSIL can be verified to guarantee type safety.|
|Exception manager||Provides structured exception handling, which is integrated with Windows Structured Exception Handling (SEH). Error reporting has been improved.|
|Thread support||Provides classes and interfaces that enable multithreaded programming.|
|COM marshaller||Provides marshalling to and from COM.|
|Base Class Library (BCL) support||Integrates code with the runtime that supports the BCL.|
Code running under the control of the CLR is often termed managed code. However, before it can be executed by the CLR, any source code that we develop (in C# or some other language) needs to be compiled. Compilation occurs in two steps in .NET:
1) Compilation of source code to IL
2) Compilation of IL to system-specific code by the CLR
This two-stage compilation process is very important, because the existence of the IL (managed code) is the key to providing many of the benefits of .NET. It is important to note that the IL code is not interpreted. The common language runtime uses just-in-time (JIT) compilers to compile the IL code to native binary code before execution.
Lets say there is a C# file named SomeSource.cs. When this file is compiled using C# compiler then the compiler will generate SomSource.exe file which will consist of IL and metadata. At this point this .exe is called a managed application.
The JIT compiler, which is part of the CLR, uses both the metadata and the IL from a managed executable to create machine language instructions at runtime. Then, these machine language instructions are executed natively. However, in the process of JIT compiling the code some very important things happen. First, type-safety and security are verified. Second, code correctness is verified (no dangling memory references, or referencing unassigned data). Third, code executes at native speed. And fourth, processor independence i.e. platform independence.
If a managed executable was ill-designed to break a security rule, the CLR will catch this at verification or JIT compilation time, and will refuse to execute the code. If a managed executable references unassigned data, or attempts to coerce a data-type into an incompatible type (through typecasting), the CLR will catch this and refuse to execute the code. And your code runs full speed on your hardware.
The CLR, through code management, will increase the functionality and robustness of your traditional console or GUI applications.
Following image shows you that how native code is generated by mscoree.dll in .NET framework.
- It contains code that the common language runtime executes. Microsoft intermediate language (MSIL) code in a portable executable (PE) file will not be executed if it does not have an associated assembly manifest.
- It forms a type boundary. Every type’s identity includes the name of the assembly in which it resides. A type called MyType loaded in the scope of one assembly is not the same as type called MyType loaded in the scope of another assembly.
- It forms a deployment unit. When an application starts, only the assemblies that the application initially calls must be present. Other assemblies, such as localization resources or assemblies containing utility classes, can be retrieved on demand. This allows applications to be kept simple and thin when first downloaded.
- It forms a version boundary. The assembly is the smallest versionable unit in the common language runtime; all types and resources in the same assembly are versioned as a unit. The assembly’s manifest describes the version dependencies you specify for any dependent assemblies.
All CIL is self-describing through .NET metadata. The CLR checks the metadata to ensure that the correct method is called. Metadata is usually generated by language compilers but developers can create their own metadata through custom attributes. Metadata contains information about the assembly, and is also used to implement the reflective programming capabilities of .NET Framework.
.NET has its own security mechanism with two general features: Code Access Security (CAS), and validation and verification. Code Access Security is based on evidence that is associated with a specific assembly. Typically the evidence is the source of the assembly (whether it is installed on the local machine or has been downloaded from the intranet or Internet). Code Access Security uses evidence to determine the permissions granted to the code. Other code can demand that calling code is granted a specified permission. The demand causes the CLR to perform a call stack walk: every assembly of each method in the call stack is checked for the required permission; if any assembly is not granted the permission a security exception is thrown.
When an assembly is loaded the CLR performs various tests. Two such tests are validation and verification. During validation the CLR checks that the assembly contains valid metadata and CIL, and whether the internal tables are correct. Verification is not so exact. The verification mechanism checks to see if the code does anything that is ‘unsafe’. The algorithm used is quite conservative; hence occasionally code that is ‘safe’ does not pass. Unsafe code will only be executed if the assembly has the ‘skip verification’ permission, which generally means code that is installed on the local machine.
1.3.6 Memory Management
The .NET Framework CLR frees the developer from the burden of managing memory (allocating and freeing up when done); instead it does the memory management itself. To this end, the memory allocated to instantiations of .NET types (objects) is done contiguously from the managed heap, a pool of memory managed by the CLR. As long as there exists a reference to an object, which might be either a direct reference to an object or via a graph of objects, the object is considered to be in use by the CLR. When there is no reference to an object, and it cannot be reached or used, it becomes garbage. However, it still holds on to the memory allocated to it. .NET Framework includes a garbage collector which runs periodically, on a separate thread from the application’s thread, that enumerates all the unusable objects and reclaims the memory allocated to them.
The .NET Garbage Collector (GC) is a non-deterministic, compacting, mark-and-sweep garbage collector. The GC runs only when a certain amount of memory has been used or there is enough pressure for memory on the system. Since it is not guaranteed when the conditions to reclaim memory are reached, the GC runs are non-deterministic.The GC used by .NET Framework is actually generational. Objects are assigned a generation; newly created objects belong to Generation 0. The objects that survive a garbage collection are tagged as Generation 1, and the Generation 1 objects that survive another collection are Generation 2 objects. The .NET Framework uses up to Generation 2 objects. Higher generation objects are garbage collected less frequently than lower generation objects. This helps increase the efficiency of garbage collection, as older objects tend to have a larger lifetime than newer objects. Thus, by removing older (and thus more likely to survive a collection) objects from the scope of a collection run, fewer objects need to be checked and compacted.
1.4 The Challenges of Building Modern Applications
Creating a modern application is not a simple task—the requirements are substantial. Traditional concerns such as creating effective business logic and allowing access via a Web browser are still important, but they’re no longer enough. Modern applications present a range of new challenges, including the following:
- Users increasingly expect Web browser interfaces to act like installed Windows applications. Loading a new page whenever something has changed is no longer sufficient—it’s just too slow. What’s needed is better support for responsive browser applications.
- Data remains central to most applications. How that data can be represented has expanded considerably. Relational data is still important, as is mapping between objects and relations. Yet the amount of data represented using XML continues to increase. A running program’s objects also contain data. A technology that allowed consistent access to diverse data would help developers create applications in less time and with fewer errors.
- Applications commonly communicate with other applications, both inside and outside the organization. Modern applications also must often fit into a service-oriented architecture (SOA), exposing some of their functionality as interoperable services accessible by other software. Achieving these goals requires support for service-oriented applications.
- Organizations are increasingly taking a process-oriented view of what they do. Since most applications automate some part of a business process, it can be useful to make the steps in this process explicit in the code. An effective way to do this is by using workflow technology, an approach that requires support for workflow-based applications.
- Organizations are increasingly taking a The requirements for a modern user interface have grown significantly. Providing real business value can commonly require working with various kinds of documents, using two- and three-dimensional graphics, displaying video, and more. Meeting these needs requires a unified approach to diverse user interfaces.
- Organizations are increasingly taking a The people who use an application commonly need a way to convey information about who they are. Many different technologies for defining and using a digital identity are in use, and problems such as phishing are common. Given this, a modern application and the people who use it can benefit from consistent user control of digital identities.
Given that today’s applications commonly need to tackle some or all of these challenges, the platform those applications are built on should also address all of them. The goal of the .NET Framework 3.5 is to do this for Windows software.
1.5 Addressing the Challenges: Spotlighting the .NET Framework
The .NET Framework 3.5 contains a number of technologies that can help developers solve the problems just described. Some were part of the .NET Framework 3.0, while others are new with the 3.5 release. This section introduces the most important of these technologies.
1.5.1 Windows Presentation Foundation: A Unified Approach to Diverse User Interfaces
The user interface is an important part of nearly every application. Yet what users expect from those interfaces has advanced significantly. Traditional menu-driven GUIs are still required, of course, but applications may also need to display video, run animations, use two- and three-dimensional graphics, and work with various kinds of documents. And all of this must be possible whether the application is accessed from a standalone desktop client or via a Web browser.
A primary goal of Windows Presentation Foundation (WPF), originally released with the .NET Framework 3.0, is to address this challenge. By offering a consistent technical underpinning for all of these user interface aspects, WPF makes life simpler for developers. By taking a more modern approach, including support for video, animation, two- and three-dimensional graphics, and various kinds of documents, WPF can let users work with information in new ways. And by providing a common foundation for desktop clients and browser clients, WPF makes it easier to build applications that address the problems.
User interfaces are a complex and important part of modern applications. Through WPF, the .NET Framework 3.5 presents a more complete and consistent solution to the challenges these interfaces present. The goal is to let people who create user interfaces—both developers and designers—do their jobs more effectively.
1.5.2 Windows Communication Foundation: Support for Service-Oriented Applications
From the beginning, the .NET Framework has provided plenty of approaches to communication. Those choices include the following:
- ASP.NET Web Services (commonly known as ASMX), providing interoperable SOAP-based communication.
- .NET Remoting, focusing on communication between .NET applications.
- Enterprise Services, offering support for scalable, transactional applications.
- System.Messaging, supporting queued messaging via Microsoft Message Queuing (MSMQ).
- Web Services Enhancements (WSE), an extension to ASP.NET Web Services that provides support for more recent specifications such as WS-Security.
All of these technologies have had a role to play. Yet why have several different solutions to address what is essentially the same problem? Why not instead create a single foundation for application communication?
This is exactly what’s done by Windows Communication Foundation (WCF). Rather than requiring developers to use a different technology with a different application programming interface for each kind of communication, WCF provides a common approach using a common API. Originally released as part of the .NET Framework 3.0, WCF is now Microsoft’s recommended approach for communication. Most applications that might have used one of the technologies just listed should instead use WCF for communication.
Communication between applications, whether within an organization or across organizations, is a fundamental part of modern software. The .NET Framework 3.5 addresses this challenge via the service-oriented approach of WCF.
1.5.3 Windows Workflow Foundation: Support for Workflow-Based Applications
A workflow is a simple idea: it’s just a series of steps performed in some order. One might even argue that every application implements a workflow, since every application executes some process. Yet the traditional approach to creating an application using C# or Visual Basic or some other programming language is to make the steps in this process implicit in the code. This certainly works, but it also embeds the process itself deeply into a program’s logic, making that process more difficult to create and to change.
Using workflow technology to implement process logic can be an effective way to address this problem. Rather than embedding the logic in ordinary code, each step in the process is explicitly defined, then executed by a workflow engine. The result is a clean implementation of the process itself. With Windows Workflow Foundation (WF), Microsoft provides a common workflow technology for Windows, giving any workflow-based application a common foundation to build on. Since its release in the .NET Framework 3.0, WF has been used both in software provided by Microsoft, such as Windows SharePoint Services, and in applications created by other organizations.
By providing a common workflow technology for Windows, WF makes this useful paradigm for building software generally available to developers. As a process-oriented view of software continues to gain in popularity, the use of workflow will likely grow as well.
1.5.4 Windows CardSpace: Consistent User Control of Digital Identities
Today everyone is frustrated and tired of memorizing the usernames and passwords. These identities are used to access mail accounts, bank accounts and other financial institutions. This loathsome traditional approach has several drawbacks and some of them are shown below:
- People have an extra burden of remembering these identities and can put them in serious trouble if, by chance, they forget the usernames and passwords as the usual tendancy is to have different usernames and passwords for different sites.
- Usernames, passwords, and other personal information can be stolen by phishers. By sending deceptive emails, phishers attract their victim to log into a Web site that looks just like, say, the site of the victim’s bank. The site is actually controlled by the phisher, however, and so once the victim enters his username and password, the phisher can use this information to masquerade as the user at the real site.
Reducing the severity of these problems requires a new approach to managing digital identities. Windows CardSpace, originally released with the .NET Framework 3.0, is an important part of that approach. To help people keep track of their digital identities, CardSpace represents each identity as a distinct information card. Consider a website which accepts CardSpace logins. In this case user will be shown the cardspace selection screen and will be allowed to select a card. As soon as user selects a card and clicks on login the requested site will make a new request to the issuer of the card asking for the information required to l og into the site. The identity provider will give all the information requested by the site and if it is valid then user will be redirected to the main page.
The identities represented by these cards are created by one or more identity providers. Any organization can offer an identity provider, and CardSpace itself also includes a self-issued identity provider that runs on client machines. With this provider, users can create their own identities that don’t rely on passwords for authentication. Web sites can accept these self-issued CardSpace identities rather than relying on the usual password-based approach, reducing the problems that passwords bring.
1.5.5 ASP.NET AJAX Support for Responsive Browser Applications
Web browsers are the most popular user interface for new applications. Still, they’ve traditionally suffered from a significant limitation: Each new request from a user requires a round-trip to the Web server, commonly resulting in loading a new page. A more intelligent—and faster—approach would be to access data in the background whenever possible, then update only those parts of the page that change. Users would see much more responsive applications, since they would spend less time waiting for new pages to be loaded.
Even though the core technologies that underlie AJAX first appeared in the 1999 release of Internet Explorer 5, this approach took several years to become popular. Today, however, is becoming the dominant style for new Web browser applications. Accordingly, the .NET Framework 3.5 now incorporates a technology called ASP.NET AJAX. An extension to the original ASP.NET, the goal is to make it easier for developers to create AJAX applications.
1.5.6 Language-Integrated Query: Consistent Access to Diverse Data
Most applications work with data in some way. That data can be represented in a variety of ways, including as tables in a relational database, in XML documents, and in objects held in memory. Accessing each of these kinds of data has traditionally required using a different approach. It’s common to use SQL to work with relational data, for example, XQuery for XML data, and custom code for in-memory data. Yet since the intent is the same—accessing information—why not provide a common approach for all of these cases?
This is the goal of Language-Integrated Query (LINQ), a technology that’s new with the .NET Framework 3.5. Rather than requiring specialized languages and a separate approach for each kind of data, LINQ adds a set of extensions to C# and VB that allow common access to diverse information. This technology covers a large area, including object/relational mapping and more. The idea is to lessen the burden on developer and make dealing with data much more easier and faster.
So far, you’ve just scratched the surface of the features and frills that are provided in ASP.NET and the .net framework. You’ve taken a quick look at the high-level concepts you need to understand in order to be a competent ASP.NET programmer. You’ve also previewed the new features that ASP.NET 3.5 offers. As you continue through other chapters, you’ll learn much more about the innovations and revolutions of asp.net 3.5 and the .net framework.
- .NET Framework is a software framework that can be installed on computers running Microsoft Windows operating systems.
- The Principal Design Features .net framework are Interoperability, Language Independence, Security, Common Language Runtime, Base Class Library, simplified deployment & Portability.
- Basic components of .net architecture. are Common Language Runtime (CLR) & Base Class Library (BCL)
- How CLR works?
- Components of CLR
- Memory management
Q: How do you differentiate managed code and unmanaged code?
Managed Code is what Visual Basic .NET and C# compilers create. It compiles to Intermediate Language (IL) not to machine code that could run directly on your computer. Managed code runs in the Common Language Runtime.
Unmanaged code is what you use to make before Visual Studio .NET 2002 was released. It compiled directly to machine code that ran on the machine where you compiled it—and on other machines as long as they had the same chip or nearly the same.
Q: What is CTS and CLS?
CLS stands for common language specification where as CTS stands for common type system.
- CLS: cls is a standard for .net . cls is small set of specification to make all languages as a .net compliant languages. cls make a use of cts and clr. if my languages (c#,vb.net,j#,vc++) wants to be compliant language it has to follow cls standard.
- CTS : Common Type System is also a standard like cls. If two languages (c# or vb.net or j# or vc++) wants to communicate with eachother, they have to convert into some common type (i.e in clr common language runtime). In c# we use int which is converted to Int32 of CLR to communicate with vb.net which uses Integer or vice versa.
CLR: Common Language Runtime
CLI: Common Language Infrastructure
CTS: Common Type System
XML: Extensible Markup Language
LINQ: Language Integrated Query
WCF: Windows Communication Foundation
WPF: Windows Presentation Foundation
WF: Windows Workflow Foundation
1.9.2 List of Images and Tables
Figure 1.2 Components of .net Framework
Figure 1.3 .Net Framework Base Classes
Figure 1.3 Common Language Runtime
Figure 1.4 Compilation and Execution
Figure 1.5 Native Code and MSCorEE.dll
Table 1.1 Components of CLR
- Pro ASP.NET 3.5 in C# 2008 by Matthew Macdonald and Mario Szpuszta- Chapter 1 Introduction to the framework
- ASP.NET 2.0 Unleashed by Stephen Walther- Chapter 1 Overview of Framework/Class Library
- ASP.NET 2.0 Unleashed by Stephen Walther- Chapter 1 Overview of Framework/Common Language Runtime