Programming in the .NET Environment

Programming in the .NET Environment

by Damien Watkins, Mark Hammond, Brad Abrams
Released November 2002
Publisher(s): Addison-Wesley Professional
ISBN: 0201770180

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

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

Table of contents

  1. Copyright
  2. Microsoft .NET Development Series
  3. Titles in the Series
  4. Foreword
  5. Preface
  6. Introducing the .NET Framework
    1. Programming Issues
    2. Solutions
    3. Comparing the .NET Framework and IDL-Based Systems
    4. Elements of the .NET Framework
    5. Exposing the .NET Framework
    6. Applications and the .NET Framework
    7. Terminology
    8. Example: Hello World
    9. Summary
  7. The Type System
    1. The Relationship Between Programming Languages and Type Systems
    2. Elements of the CLR Type System
    3. Value Types
    4. Reference Types
    5. Example: User-Defined Object Type
    6. Example: Use of Interfaces on Value Types
    7. Assignment Compatibility
    8. Nested Types
    9. Visibility
    10. Accessibility
    11. Summary
  8. The Metadata System
    1. Metadata Issues
    2. Saving Metadata About Types: IDL Files
    3. Reflection: Inspection of a Type's Metadata
    4. Metadata Tools and Extensions
    5. Dynamic Discovery of Types
    6. Assemblies and Manifests
    7. Meta-Programming
    8. Metadata File Format
    9. COM Interop
    10. Summary
  9. The Execution System
    1. The Execution System Versus Other Component Models
    2. Intermediate Language
    3. Starting a CLR Program
    4. COR Debugger
    5. Application Domains
    6. Memory Management
    7. Security
    8. Policy Manager
    9. Stack Walks
    10. Declarative and Imperative Style
    11. Summary
  10. Building Applications
    1. Existing Technologies to Solve Application-Related Problems
    2. Assemblies
    3. Example: A Simple Assembly
    4. Embedded and Linked Resources
    5. The Assembly Linker
    6. Public and Private Assemblies
    7. Assembly Versioning
    8. Internationalization and Localization
    9. Application Domains
    10. Summary
  11. Deploying Applications
    1. Configuration Files
    2. Downloading Web Content
    3. Installing Applications
    4. Using the CLI on Non-Windows Platforms
    5. Summary
  12. The Framework Class Library
    1. A Historical Perspective
    2. Goals of the .NET Framework
    3. Design Guidelines
    4. Namespaces
    5. Looking Back and Looking Ahead
    6. Summary
  13. Visual Basic .NET
    1. Type System Additions
    2. Type System Modifications
    3. Platform Changes
    4. Language Cleanup
    5. New Features
    6. Future Directions
    7. Conclusions
  14. C#
    1. History and Design Goals
    2. The C# Type System
    3. Component-Oriented Development
    4. Unsafe Code
    5. Neat Things
    6. A Stack Component Example
    7. Future Directions
    8. C# and Standardization
    9. Conclusions
  15. Python for .NET
    1. A Brief Overview of Python
    2. Python for .NET
    3. Using Python for .NET
    4. Limitations of Python for .NET
    5. Possible .NET and Python Enhancements
    6. Alternative Implementation Strategies
    7. Conclusions
  16. Perl and the .NET Runtime
    1. Perl for .NET Research Compiler
    2. PerlNET Component Builder
    3. Supported .NET Features
    4. PerlNET Status
    5. Example: A Windows Forms Application
    6. Conclusions
  17. Component Pascal on the CLR
    1. About Component Pascal
    2. Mapping to the CLR
    3. Semantic Challenges
    4. Conclusions
  18. Hotdog: Compiling Scheme to Object-Oriented Virtual Machines
    1. Introduction to the Hotdog Scheme Compiler
    2. Scheme, Briefly
    3. Object-Oriented Virtual Machines
    4. Implementations
    5. Limitations
    6. Performance Improvements
    7. Conclusions
    8. References
  19. Functional Languages for the .NET Framework
    1. A Brief Introduction to Mondrian
    2. Types in Mondrian
    3. Functions in Mondrian
    4. Calling Other CLR-Hosted Languages
    5. The Power of .NET: A Multilanguage Example
    6. Conclusions
    7. References
  20. Active Oberon for .NET: A Case Study in Language Model Mapping
    1. History of the ETH Programming Languages
    2. The Active Object System
    3. The Mapping to the Common Type System
    4. Summary and Conclusions
    5. Acknowledgments
    6. References
  21. Glossary
  22. Suggested Reading List

Product information

  • Title: Programming in the .NET Environment
  • Author(s): Damien Watkins, Mark Hammond, Brad Abrams
  • Release date: November 2002
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 0201770180