Programming in the .NET Environment

Understanding the philosophy and architecture of .NET is important for any Microsoft developer. The .NET Framework is not an abstract programming model. It is a full-featured system that allows developers to implement their solutions and then make them available to other developers in a robust and secure environment. This book shows developers how to produce generic frameworks, libraries, classes, and tools to be used in the .NET Framework. It also shows how to use the right language to develop parts of a system and then incorporate these parts together at runtime regardless of language differences. The book will conclude with a series of appendices from contributors who are very active in the .NET community.

Auteur

Damien Watkins is the founder of Project 42, a consulting company specializing in the development of Component Based Systems for the Internet. Until 2002 he was a lecturer at Monash University in Melbourne, Australia. Damien became involved with the development of the .NET Framework in 1998 when Microsoft invited Monash University to join Project 7, an early access program for .NET.

Mark Hammond has been an independent software consultant since 1995. He has produced many of the Windows extensions for Python, including PythonWin, Active Scripting and Active Debugging support, and coauthored the Python/COM framework and extensions. In 2000 he published his first book, Python Programming on Win32, and from 1999 through 2001 developed the first .NET implementation of the Python language.

Brad Abrams was a founding member of both the Common Language Runtime and .NET Framework teams at Microsoft, where he is currently a Lead Program Manager. Brad has been involved with WinFX and Windows Vista efforts from the beginning. His primary role is to ensure consistency and developer productivity of the .NET Framework through Vista and beyond. His popular blog can be found at http://blogs.msdn.com/BradA/.

Texte du rabat

Programming in the .NET Environment is the software developer's guide to the .NET Framework. The authors describe Microsoft's vision for distributed component-based systems development and then show programmers how to develop software that takes full advantage of the features of the .NET Framework. Readers learn how to author components, libraries, and frameworks that not only exploit the capabilities of the .NET Framework but also integrate seamlessly into that environment.

This book begins with an introduction to the goals and architecture of the .NET Framework. Readers will then gain a thorough understanding of the type, metadata, and execution systems; learn how to build and deploy their components within .NET assemblies; and gain an understanding of the facilities of the Framework Class Libraries.

Topic coverage includes:

• The Common Language Runtime (CLR) and the Framework Class Libraries
• The CLR's Type, Metadata, and Execution Systems
• Creating and deploying .NET Assemblies
• Internationalization and localization facilities
• .NET Languages, including C# and Visual Basic .NET The book concludes with appendixes written by other specialists in the field: Paul Vick (writing about VB .NET), Eric Gunnerson (on C#), Mark Hammond (on Python for .NET), Jan Dubois (on Perl for .NET), John Gough (on Component Pascal for .NET), Pankaj Surana (on Scheme for .NET), Nigel Perry (on Mondrian), and Juerg Gutknecht (on Active Oberon for .NET).

Written by a team of experienced authors using a practical, authoritative approach, Programming in the .NET Environment is an indispensable guide to developing components that fulfill the promise of Microsoft's .NET Framework.

Books in the Microsoft .NET Development Series are written and reviewed by the principal authorities and pioneering developers of the Microsoft .NET technologies, including the Microsoft .NET development team and DevelopMentor. Books in the Microsoft .NET Development Series focus on the design, architecture, and implementation of the Microsoft .NET initiative to empower developers and students everywhere with the knowledge they need to thrive in the Microsoft .NET revolution.

0201770180B10312002

Résumé
An authoritative guide for developers who want to develop software that fully takes advantage of the .NET Framework.

Contenu
(NOTE: Each chapter concludes with a Summary.)

Foreword.

Preface.

1. Introducing the .NET Framework.

Programming Issues.

Programming in the Small.

Programming in the Large.

Solutions.

Comparing the .NET Framework and IDL-Based Systems.

Elements of the .NET Framework.

Common Language Runtime.

Base Framework.

Exposing the .NET Framework.

Windows Clients.

ASP.NET: Web Forms.

ASP.NET: Web Services.

Terminology.

The Type System.

The Metadata System.

The Execution System.

Example: Hello World.

2. The Type System.

The Relationship Between Programming Languages and Type Systems.

The Evolution of Type Systems.

Programming Language-Specific Type Systems.

The Design Challenge: Development of a Single Type System for Multiple Languages.

CLR-Programming Language Interaction: An Overview.

Elements of the CLR Type System.

Value Types.

Built-in Value Types.

User-Defined Value Types.

Reference Types.

Object Types.

Interface Types.

Pointer Types.

Example: User-Defined Object Type.

Example: Use of Interfaces on Value Types.

Assignment Compatibility.

Nested Types.

Visibility.

Accessibility.

3. The Metadata System.

Medata Issues.

Saving Metadata About Types: IDL Files.

Reflection: Inspection of a Type's Metadata.

Reflection Classes.

Example: Using Reflection.

Example: Use of Type as an Abstract Type.

Metadata Tools and Extensions.

A Tool for Reading Metadata.

Metadata Extensibility.

Dynamic Discovery of Types.

Assemblies and Manifests.

Meta-Programming.

Metadata File Format.

COM Interop.

4. The Execution System.

The Execution System Versus Other-Component Models.

Intermediate Language.

Example: Generating Intermediate Language.

Verification of Intermediate Language.

Starting a CLR Program.

COR Debugger.

Application Domains.

Memory Management.

Value Types Versus Reference Types.

Garbage Collection.

Security.

Role-Based Security.

Evidence-Based Security.

Policy Manager.

Code Groups.

Named Permission Sets.

Policy Assemblies.

Examining Policy Levels and Permission Sets.

Stack Walks.

Declarative and Imperative Style.

5. Building Applications.

Existing Technologies to Solve Application-Related Problems.

Well-Known Locations.

Search Paths.

Symbolic Names.

Versioning-Related Technologies.

Windows Registry.

Assemblies.

Example: A Simple Assembly.

Version 1 of AboutBox.

Building the Assembly with nmake and makefile.

Functioning of the makefile.

Embedded and Linked Resources.

Example: A .NET Assembly with Embedded Resources.

Example: A .NET Assembly with Linked Resources.

The Assembly Linker.

Public and Private Assemblies.

Strong Names.

Assembly Caches.

Example: Creating and Using Public Assemblies.

Assembly Versioning.

Example: Building a Second Version of an Assembly.

Example: Binding to a Different Version of an Assembly.

Internalization and Localization.

Definitions.

Existing Technologies: Separation of Code and User Interfaces.

.NET Localization Concepts.

Example: A Localized Application.

Application Domains.

Application Domains Versus Processes.

Use of Application Domains.

Example: Retrieving Current Application Domain Information.

Example: Creating and Manipulating Application Domains.

Example: Loading Assemblies into Application Domains.

6. Deploying Applications.

Configuration F…