The Common Language Infrastructure Annotated Standard (Microsoft .NET Development Series)

Hardcover (Print)
Buy New
Buy New from BN.com
$47.43
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 96%)
Other sellers (Hardcover)
  • All (13) from $1.99   
  • New (4) from $35.00   
  • Used (9) from $1.99   

Overview

The Common Language Infrastructure Annotated Standard is the definitive guide to understanding the annotated specification for the Common Language Infrastructure (CLI) standard. With annotations and code samples from both the ECMA standards committee and the Microsoft Common Language Runtime (CLR) team, this book goes beyond the online documentation to clarify and amplify the original standard and describe its implementation.

The core of this book is the international CLI standard. The text describes the CLI and its parts and provides all the information needed to implement a Virtual Execution System (VES) or design a compiler that runs on top of a VES and generates portable code. Author Jim Miller draws upon his experience as editor of the CLI standard and lead of the Microsoft CLR team to guide readers through the CLI blueprint and to a complete understanding of the CLR.

Features of this book include:

  • A heavily annotated architectural overview of the standard
  • A description of the semantics of metadata
  • A complete specification of the Portable Executable (PE) file format
  • Coverage of file format and metadata layout
  • An overview of the CLI libraries
  • A detailed description of the Common Intermediate Language (CIL) instruction set
  • Sample programs and other annexes to the standard
  • An enhanced online index that allows readers to quickly and easily search the entire text for specific topics

The Common Language Infrastructure Annotated Standard is the single source programmers, language and tool designers, and library and VES developers need to render the CLI and the CLR fully comprehensible.

0321154932B09182003

Read More Show Less

Product Details

  • ISBN-13: 9780321154934
  • Publisher: Addison-Wesley
  • Publication date: 10/23/2003
  • Series: Microsoft Windows Development Series
  • Pages: 891
  • Product dimensions: 7.10 (w) x 9.10 (h) x 2.10 (d)

Meet the Author

James S. Miller serves as software architect of the Microsoft team that developed the CLR and as the editor of the ECMA and ISO Common Language Infrastructure (CLI) Standards. Prior to joining Microsoft he was part of the World Wide Web Consortium’s senior management team and served on the research staffs of the Massachusetts Institute of Technology (MIT) Artificial Intelligence Lab, the MIT Lab for Computer Science, Digital Equipment Corporation, and the Open Software Foundation. He earned his Ph.D. in computer science from MIT and has been a member of the Brandeis University faculty.

Susann Ragsdale was the original documentation manager for the CLR team, and currently is a consulting technical writer. Before the CLR, she was a lead writer for COM (Microsoft’s Component Object Model). This followed a long and diverse career in consulting on multiprocessor supercomputers, simulation systems, test systems, and integrated circuits.

0321154932AB09182003

Read More Show Less

Table of Contents

Tables.

Foreword.

Preface.

Acknowledgments.

1. Introduction to the Common Language Infrastructure.

Components of the CLI.

The Common Type System.

The Common Language Specification.

Metadata.

Execution and Deployment Models.

Metadata and the File Format.

The Virtual Execution System.

The Standard Framework.

2. Partition I: Concepts and Architecture.

Standard 1. Scope.

Standard 2. Conformance.

Standard 3. References.

Standard 4. Conventions.

Standard 5. Glossary.

Standard 6. Overview of the Common Language Infrastructure.

Standard 7. Common Language Specification (CLS).

Standard 8. Common Type System.

Standard 9. Metadata.

Standard 10. Name and Type Rules for the Common Language Specification.

Standard 11. Collected CLS Rules.

Standard 12. Virtual Execution System.

3. Partition IIA: Metadata Semantics.

Standard 1. Scope.

Standard 2. Overview.

Standard 3. Validation and Verification.

Standard 4. Introductory Examples.

Standard 5. General Syntax.

Standard 6. Assemblies, Manifests, and Modules.

Standard 7. Types and Signatures.

Standard 8. Visibility, Accessibility, and Hiding.

Standard 9. Defining Types.

Standard 10. Semantics of Classes.

Standard 11. Semantics of Interfaces.

Standard 12. Semantics of Value Types.

Standard 13. Semantics of Special Types.

Standard 14. Defining, Referencing, and Calling Methods.

Standard 15. Defining and Referencing Fields.

Standard 16. Defining Properties.

Standard 17. Defining Events.

Standard 18. Exception Handling.

Standard 19. Declarative Security.

Standard 20. Custom Attributes.

4. Overview of File Format.

What Is in Partition IIB (Chapter 5).

Overview of the PE File Format for CLI Files.

Overview of Metadata Physical Layout in PE Files.

Metadata Logical Layout (Sections 21 and 22).

Annotated Dump of a Tiny PE File.

MS-DOS Header.

PE File Header.

PE Section Headers.

Import Address Table.

CLI Header.

Method Header and CIL.

Metadata Root.

Metadata Stream Headers.

The #~ Stream.

String Heap.

Guid Heap.

Blob Heap.

Import Table.

Relocation Section.

5. Partition IIB: Metadata File Format.

Standard 21. Metadata Logical Format: Tables.

Standard 22. Metadata Logical Format: Other Structures.

Standard 23. Metadata Physical Layout.

Standard 24. File Format Extensions to PE.

6. Partition III: CIL Instruction Set.

Standard 1. Scope.

Standard 2. Prefixes to Instructions.

Standard 3. Base Instructions.

Standard 4. Object Model Instructions.

7. Partition IV: Profiles and Libraries.

Standard 1. Overview.

Standard 2. Libraries and Profiles.

Standard 3. The Standard Profiles.

Standard 4. Kernel Profile Feature Requirements.

Standard 5. The Standard Libraries.

Standard 6. Implementation-Specific Modifications to the System Libraries.

Standard 7. Semantics of the XML Specification.

8. Partition V: Annexes.

Annex A. Scope.

Annex B. Sample Programs.

Annex C. CIL Assembler Implementation.

Annex D. Class Library Design Guidelines.

Annex E. Portability Considerations.

Appendix: Microsoft Portable Executable and Object File Format Specification.

1. General Concepts.

2. Overview.

3. File Headers.

4. Section Table (Section Headers).

5. Other Contents of the File.

6. Special Sections.

7. Archive (Library) File Format.

8. Import Library Format.

Appendix: Example Object File.

Appendix: Calculating Image Message Digests.

Glossary.

References.

Index. 0321154932T10202003

Read More Show Less

Preface

This book, The Common Language Infrastructure Annotated Standard , annotates and amplifies the Common Language Infrastructure (CLI) Standard. It describes the CLI and its parts, and contains all of the information required to understand and implement a Virtual Execution System (VES) or design a compiler that generates portable code and runs on top of a VES.

This book is indispensable for anyone who wants to understand the CLI Standard. By necessity, standards follow a specific set of guidelines, including non-repetition of information. The result is a good standard, but it can be difficult to read and easily understand.

The annotations in this book came directly from the authors of the original specification (primarily Jim Miller) and from the highly talented ECMA technical committee that is responsible for standardizing that specification. The many annotations explain and expand on the original standard, clarifying it, connecting the dots, and supplying many more cross-references to make the system understandable.

This book is intended for four audiences:

  • Language and tool designers
  • Developers of libraries
  • Those interested in developing or understanding a Virtual Execution System
  • Programmers, who will use primarily the Base Class Libraries, published in companion volumes to this one, and entitled the .NET Framework Standard Library Annotated Reference

About This Book

Along with the complete text of the CLI Standard, except for the portion describing the class libraries, this book contains some other information that may be of help.

Chapter 1 is an overview of CLI and describes, in context, where to go in this book to find specific technical areas.

Chapter 2 contains the annotated Partition I of this standard, an architectural overview and recommended to anyone who needs to understand the CLI. It also contains the specifications for the Common Language Specification (CLS), the restrictions on the CLI for anyone writing code that may be used across languages.

Chapter 3 is the part of the standard describing the semantics of metadata, with annotations. It contains the first 20 sections of Partition II, and uses an assembly language, ilasm, to describe these semantics.

Chapter 4 contains information that is not in the standard. It is an overview of the second half of Partition II, and describes how to find different areas of information. It also provides some information on the PE (Portable Executable) file format for managed files and its relation to the layout of metadata.

Chapter 5 contains the annotated second half of Partition II of the standard, sections 21-24, which describes the file format as it relates to managed files, and the physical metadata layout.

Chapter 6 is Partition III of the standard, which consists primarily of a detailed description of the Common Intermediate Language (CIL) instruction set. In addition, this chapter includes an annotated section important to both language designers and developers of Virtual Execution Systems that describes the effect of various numeric operations between types.

Chapter 7 is the annotated Partition IV, which is an overview of the CLI libraries, also describing what is, and is not, required for a conforming CLI implementation. In the International Standard, this Partition contains the Base Class Libraries in XML format. In this series, however, these are published in companion volumes entitled the .NET Framework Standard Library Annotated Reference.

Chapter 8 is the annotated Partition V, which is a set of annexes to the standard. These include sample programs in ilasm with corresponding annotations containing approximate high-level language examples for the same programs, implementation information for a version of ilasm, library design guidelines, and other information of interest to CLI implementers.

The Appendix in this book reprints the Microsoft Portable Executable and Object File Format Specification. This specification includes a good deal of information on the file format that is specific to Microsoft products and hence not standardized. This information allows you to see how the file format for managed code, described in Chapter 5, relates to the existing Microsoft Windows file format. It also helps clarify why the file format for managed code is more complicated than would be necessary if one were designing a portable format strictly for CIL. For those designing a Microsoft Windows-compatible implementation of the VES, it describes how to handle unmanaged code.

Goals of the Standard and of This Book

The goal of any standard is to set out what must be done to comply with the standard, not to tell you how to implement it. The information makes it possible to guarantee that if you write a program and compile it on one implementation of the VES, it will also run on another implementation, unless the program violates the rules. It specifies both what is needed for portability and the limits of portability. It also specifies the rules for creating a Virtual Execution System (VES).

It was not a goal of this standard to describe why decisions were made. However, many of the annotations in this book attempt to provide some of that context, to make the system more coherent.

Another important part of the International Standard is an implementation of a set of libraries that work on all compliant implementations and are language-independent, called the Base Class Libraries. These libraries are described in detail in companion volumes to this one, entitled the .NET Framework Standard Library Annotated Reference.

Where Did the Standard Come From?

This standard started with a band of troublemakers (as most big ideas do), this time at Microsoft. They had a vision of a multi-language standard that would allow programmers to use whichever language best fit the programming task for any module. Furthermore, they believed that these modules should not only work together correctly, but it should be possible to run them on any operating system without rewriting or recompiling.

This idea faced a lot of opposition in a company whose different divisions had invested huge amounts of time and effort in different programming models; no group wanted to give up its special model. Good technology finally prevailed, however, and the .NET concept, with the development of the Common Language Runtime, gained acceptance.

Language groups within Microsoft were involved in early design talks, and by 1999 the talks had expanded to include language developers from outside Microsoft. Many of these discussions were contentious, but they resulted, eventually, in the CTS and the CLS. More significantly, all of Microsoft’s Visual Studio languages did what was necessary to comply with the rules. All of the languages had to make significant changes to their initial designs. The Visual Basic team, in fact, did a complete redesign of the language. Another thing that laid the foundation for creating a standard is that the group at Microsoft started partnerships very early in the process with language and system developers around the world, to ensure that it would really work as a standard, not just an in-house flash in the pan.

Early on, the development team recognized that the concept of the CLI made sense only if it was in wide use, and the best way to do that was to turn it into a standard that was freely available. So, in 2000, long before the release of Microsoft’s Common Language Runtime, Jim Miller, a senior architect of the CLI, went to a meeting of ECMA International, an international industry association for the standardization of information and communications systems, to talk about creating a standard. At that time, it was informally agreed that the CLI should be submitted.

About a year later, after Hewlett-Packard and Intel had joined Microsoft as co-sponsors, a meeting of the ECMA Technical Committee TC39 in Bristol, England, was presented with three documents—(1) what is now Partition I of this book, (2) a document containing information for compiler designers (now the first half of Partition II), and (3) an XML version of the documentation of the Base Class Libraries. Other companies, such as Fujitsu, who was interested in developing a compliant COBOL, had also joined the effort. The copyright was turned over to ECMA, and standardization really began.

At this writing, Microsoft has shipped as product five implementations of the CLI (or a large subset thereof). Of those, three are completely independent implementations, sharing no code at all. These are:

  1. The Common Language Runtime, and derived from that is the Shared Source CLI (commonly known as Rotor).
  2. The .NET Compact Framework, and derived from that code base is a CLI being used for the Microsoft TV platform, called the Microsoft .NET Compact Framework TV Edition.
  3. A minimal CLI, called the Smart Personal Objects Technology (SPOT), being used for very small devices, like watches.

Other CLIs are under development by other companies, such as the Mono project by Ximian, an open-source project called the DotGNU Portable.NET, and one developed as a research project at Intel Corporation.

Where Is the Standard Headed?

This book is based on these ECMA and ISO standards:

  • ECMA: Standard ECMA-335, 2nd Edition, December 2002.
  • ISO: ISO/IEC 23271:2003(E), Information Technology—Common Language Infrastructure (CLI).

But standards are living documents. The ECMA technical committee that is responsible for the technical content of the CLI standard is working to refine and improve the standard. The committee’s plan is to create an ECMA edition 3, and then submit it to ISO. Some of the topics under discussion for possible inclusion in a future standard are the following:

  • Generics
  • Extended threading
  • Exception reordering/runtime check disablement
  • Debugging enhancements
  • Extensible metadata

Generics seem to be the next step in the object-oriented community, and they are likely to be included in a future version of the standard. In the current version, it is not possible to transmit debug information to another debugger, and this change is currently under discussion. Also under discussion are some enhancements that would make it easier to extend the metadata.

Although the CLI standard does not embrace all one might expect in a platform (such as the inclusion of a windowing library or a graphics library), it is felt that these still evolve too rapidly to be standardized. The standard permits anyone to develop these because it lays out the basis for library development.

0321154932P10202003

Read More Show Less

Introduction

The Common Language Infrastructure Standard is the definitive description of the Common Language Infrastructure (CLI). It takes as its basis the international standard Common Language Infrastructure (CLI) Standard, an international standard. It describes what the CLI is, what its parts are, and contains all of the information required to understand and implement a virtual execution system (VES) or design a compiler that generates portable code and runs on top of a VES.

This book, The Common Language Infrastructure Annotated Standard, specifies how the system goes together, and is indispensable for anyone who wants to understand the CLI. The many annotations explain and expand on the original standard, clarifying it and connecting the dots to make the system understandable.

This book, and the international standard, is intended for four audiences:

  • language and tool designers
  • developers of libraries
  • those interested in developing or understanding a Virtual Execution System
  • programmers, who will primarily use the Base Class Libraries, published in companion volumes to this one, and entitled the .NET Framework Class Library Annotated Reference

Reading This Book

It is recommended that for an overview of the basis of the CLI and a roadmap to this book, that you read Chapter 1 of this book.

Goals of the Standard

The goal of any standard is to set out what must be done to comply with the standard, not to tell you how to implement it. To ensure the language interoperability that is at the heart of the CLI, it specifies the rules of the Common Type System (CTS), the Common Language Specification (CLS)--asubset of the CTS that specifies types that can be used in calls to other languages--the Common Intermediate Language (CIL), and the file format. Together, this information makes it possible guarantee that if you write a program and compile it on one implementation of the VES, and then take that program to another, it should run, unless the program violates the rules. It specifies both what is needed for portability, and the limits of portability as well. It also specifies the rules for creating a Virtual Execution System (VES).

Another important part of this standard is an implementation of a set of libraries that work on all compliant implementations and are language independent, called the Base Class Libraries. These libraries are described in detail in the .NET Framework Class Library Annotated Reference.

Where Did The Standard Come From?

This standard started with a band of troublemakers (as most big ideas do), this time at Microsoft. They had a vision of a multi-language standard that would allow programmers to use whichever language best fit the programming task for any module. Then, these modules should not only work together correctly, but it should be possible to run them on any operating system without rewriting or recompiling.

This idea faced a lot of opposition in a company whose different divisions had invested huge time and effort into different programming models, and no group wanted to give up their special models. The win for the programmer and good technology finally prevailed, however, and the .NET concept, with the development of the Common Language Runtime, gained acceptance.

Language groups within Microsoft were involved in early design talks, and by 1999, it expanded to include language developers from outside Microsoft. Many of these discussions were contentious, but they resulted, eventually, in the CTS and the CLS. More significantly, all of Microsoft's Visual Studio languages did what was necessary to comply with the rules. All of the languages had to make significant changes to their initial designs. The Visual Basic team, in fact, did a complete redesign of the language. Another thing that laid the foundation for creating a standard is that the group at Microsoft started partnerships very early in the process with language and system developers around the world, to ensure that it would really work as a standard, not just an in-house flash-in-the-pan.

Early on, the development team recognized that the concept of the CLI only made sense if it was in wide use, and the best way to do that was to turn it into a standard that was freely available. So, in 2000, long before the release of Microsoft's Common Language Runtime, Jim Miller, a senior architect of the CLI, went to a meeting of ECMA International, an international industry association for the standardization of information and communications system, to talk about creating a standard. At that time, it was informally agreed that it should be submitted.

About a year later, after Hewlett-Packard and Intel had joined Microsoft as co-sponsors, a meeting of the ECMA Technical Committee TC39 in Bristol, England was presented with three documents--what is now Partition I of this book, a document containing information for compiler designers, now the first half of Partition II, and an XML version of the documentation of the base class libraries. Other companies, such as Fujitsu, who was interested in developing a compliant COBOL, had also joined the effort. The copyright was turned over to ECMA, and standardization really began.

Microsoft, at the time of writing, has shipped as product 5 implementations of the CLI (or a large subset thereof). Of those, three are completely independent implementations, sharing no code at all. These are:

  • The Common Language Runtime, and derived from that is Rotor the shared source CLI.
  • The .NET Compact Framework, and derived from that code base is a CLI being used for the Microsoft TV platform.
  • A minimal CLI being used for very small devices like watches.
  • Other CLIs are under development by other companies, such as one developed as a research project at Intel Corporation.

Where is the Standard Headed?

This book is based on version 1 of the international CLI standard. But even standards are living documents. The ECMA technical committee that is responsible for the technical content of the standard is working to refine and improve the standard. Some of the topics under discussion for possible inclusion in a future standard are the following:

  • Generics
  • Extended threading
  • Exception reordering/runtime check disablement
  • Serialziation
  • Debugging enhancements
  • Extensible metadata

Generics seem to be the next step in the object-oriented community, and are likely to be included in a future version of the standard. Serialization may be standardized, which would make it easier to support remoting. In the current version, it is not possible to transmit debug information to another debugger, and this change discussion. Also under discussion are some enhancements that would make it easier to extend the metadata.

While this standard does not embrace all one might expect in a platform (such as the inclusion of a windowing library or a graphics library), it is felt that those need not be standardized. The standard permits anyone to develop these, because it lays out the bases for library development.

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Anonymous

    Posted December 25, 2003

    Interesting Commingling of Languages

    When Microsoft released its .NET platform, it attempted, and is attempting, something quite audacious. It is putting forth a programming environment whereby you could combine modules written in different languages, without recompiling, let alone rewriting. Arguably, Microsoft set itself a harder task than did Sun with java. Along this road, as the book describes, a standard arose - the Common Language Infrastructure. It describes a Virtual Execution System and what type of executable code can use it. So a version of Pascal, say, that wanted to run on a VES would need to pass the compilation rules of a Pascal compiler that adhered to CLI. An analogy might help. In some rough way, you might consider CLI + VES to be like a java virtual machine, and the choice of a language to use atop CLI to be like running java under its jvm. Granted, this is crude, but many readers are probably unfamiliar with CLI, whilst having more acquaintance with java. Warning. The book may be heavy sledding for most. The main audience is compiler writers and language developers. Daresay that even experienced developers may not usually deal with a language at this level. A slight irony is that CLI is meant to decouple programmers from any specific platform, which is why Microsoft pushed it over to a standards body. But the most developed instantiation currently appears to be .NET, which is inextricably interwoved with Microsoft's operating systems.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)