Buy Used
CDN$ 15.95
+ CDN$ 6.49 shipping
Used: Good | Details
Sold by Daily-Deal-
Condition: Used: Good
Comment: This Book is in Good Condition. Used Copy With Light Amount of Wear. 100% Guaranteed.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

.NET Framework Standard Library Annotated Reference, Volume 2: Networking Library, Reflection Library, and XML Library Hardcover – Aug 23 2005

See all formats and editions Hide other formats and editions
Amazon Price
New from Used from
Hardcover, Aug 23 2005
"Please retry"
CDN$ 85.85 CDN$ 15.95

Harry Potter and the Cursed Child
click to open popover

No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
Getting the download link through email is temporarily not available. Please check back later.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your mobile phone number.

Product Details

  • Hardcover: 512 pages
  • Publisher: Addison-Wesley Professional; 1 edition (Aug. 23 2005)
  • Language: English
  • ISBN-10: 0321194454
  • ISBN-13: 978-0321194459
  • Product Dimensions: 19.2 x 3.2 x 24.3 cm
  • Shipping Weight: 1 Kg
  • Average Customer Review: Be the first to review this item
  • Amazon Bestsellers Rank: #2,911,377 in Books (See Top 100 in Books)
  •  Would you like to update product info, give feedback on images, or tell us about a lower price?

  • See Complete Table of Contents

Product Description

From the Inside Flap

This book is intended for anyone building applications using the .NET Framework. It is meant to be a dictionary-style reference to the core types in the Framework.

The .NET Framework is huge. The amount of time that would be required limits our ability to cover the entire .NET Framework in the depth it deserves. As a result, we have focused the scope of this book on the most important, widely used types in the Framework. Luckily, such a subset was already created in the standardization process of the Common Language Runtime and the C# Programming Language. This book covers the second half of that subset (Volume 1 covered the first half). In the printed portion of this volume you will find all the type-level information for these types. Both the type-level information and member-level information are available in electronic form on the CD.

To make the standard more accessible, this book includes the following features:

  • Annotations from key folks involved in the design of the .NET Framework
  • Namespace overviews
  • Type descriptions
  • Sample code to illustrate type uses
  • A fully searchable CD that includes all source code, descriptions, annotations, and examples

These features not only bring the standard to life, but more importantly, they serve as a convenient, informative reference to the most used types in the .NET Framework.

The Standard

At the Professional Developer’s Conference in October 2001, Microsoft, in partnership with HP and Intel, began the ECMA standardization process of three core parts of its new developer platform: the Common Language Infrastructure (CLI), the C# programming language, and a subset of the .NET Framework that is included in the CLI and referenced in the C# specification.

The CLI and the C# programming language are covered in other books in this series. Jim Miller and Susann Ragsdale’s The Common Language Infrastructure Annotated Standard (Addison-Wesley, 2004) covers the CLI, which includes the metadata file format, IL Instruction set, and the type system. The C# Programming Language (Addison-Wesley, 2004) by Anders Hejlsberg, Scott Wiltamuth, and Peter Golde covers the C# programming language specification.

This book covers the second half of the .NET Framework as standardized in ECMA 335 and ISO 23271. The standards break the .NET Framework into seven different libraries to allow conformant implementations in resource-constrained environments. Those libraries are as follows:

Base Class Library—A simple runtime library for modern programming languages. It serves as the standard for the runtime library for the language C#, as well as one of the CLI standard libraries. It provides types to represent the built-in data types of the CLI, simple file access, custom attributes, security attributes, string manipulation, formatting, streams, collections, and so forth.

Extended Numerics Library—Provides the support for floating-point (System.Single, System.Double) and extended-precision (System.Decimal) data types. Like the Base Class Library, this library is directly referenced by the C# standard.

Network Library—Provides simple networking services, including direct access to network ports and HTTP support.

Reflection Library—Provides the ability to examine the structure of types, create instances of types, and invoke methods on types, all based on a description of the type.

XML Library—Provides a simple “pull-style” parser for XML. It is designed for resource-constrained devices, yet provides a simple user model.

Runtime Infrastructure Library—Provides the services needed by a compiler to target the CLI and the facilities needed to dynamically load types from a stream in the file format specified. For example, it provides System.BadImageFormatException, which is thrown when a stream that does not have the correct format is loaded.

Extended Array Library—Provides support for non-vector arrays, that is, arrays that have more than one dimension and arrays that have non-zero lower bounds.

The first volume of the .NET Framework Standard Library Reference covered the Base Class Library, the Extended Numerics Library and the Extended Array Library. This volume will contain the remaining libraries, as well as Microsoft-specific members on those types.

Namespace Overviews

To facilitate reader understanding, for each namespace we cover we provide an overview that describes the functionality and the inheritance hierarchy of types defined in that namespace. At the end of the namespace overview section we include a complete inheritance hierarchy for all the types covered in this volume. In the diagrams we differentiate the various kinds of types that make up the framework.

Type Chapters

Types are described in their own chapters, which are organized alphabetically by type name.

The header contains the namespace name, the type name, and the library name from the ECMA\ISO Standard.

Type Hierarchy
Under the header we include a diagram representing the full inheritance hierarchy for this type, subclasses of this type found in this volume, and any interfaces they implement. The type being described is shown with a gray background .

Type Summary
This section contains the C# declaration syntax for all members defined on this type. It is meant to provide a quick reference in a very familiar format to what is in the type. In this summary we highlight certain attributes of these members.

CF Indicates the member is not available in the .NET Compact Framework. If not included the member is available.
MS Indicates that the member is not included in the ECMA\ISO standard.
1.1 Indicates that the member is new in V1.1 of the .NET Framework.

Type Description
This section contains a detailed description of how this type is to be used. For the most part this text is taken directly from the standard.

Throughout this section we provide annotations from key members of the design team at Microsoft and members of the ECMA standardization committee. The comments in this section vary widely, and include notes on everything from common issues to the history of the class design or standardization process to areas where, in retrospect, the designers feel they could have done better.

Here’s an example of an annotation from Brad Abrams on the AppDomain class. Each annotation is attributed to individuals by their initials.

We introduced Application Domains as a lightweight process mechanism. Because managed code can be verifiably type safe (memory safe) we did not need the heavyweight address space barrier that processes provide. This savings works out well most of the time. However, when using interop with unmanaged code it does cause some problems when type safety is violated. One notable example of this is the loader-lock and AppDomain marshaling problem that C++ was succeptible to. We fixed this problem in a service pack of v1.1.

Type Examples
In this section we provide sample code illustrating use of the type. Some samples are from the standard, but we added many more to facilitate a deeper and quicker understanding of the use of the type. All the samples we provide are fully compilable programs and include selected output .

All of these samples have been tested with V1.0 and V1.1 of the .NET Framework and the appropriate ones have been tested on the .NET Compact Framework.

Complete source code for the samples is available on the CD that is included in the back of the book.

Type Members
The detailed descriptions of the members are included in the electronic version of the book on the CD. To facilitate easy look-ups, the member descriptions appear in the same order as the type summary sections. Each member contains some or all of the following fields:

Syntax—C# declaration syntax is provided for familiar reference. ILASM syntax is provided for completeness.
Summary—Short description of the member’s purpose.
Parameters—Table of parameters accepted by this member and their meaning.
Description—A complete description of this member.
Return Value—The value and range returned by this method.
Property Value—The value of this property.
Exceptions—Table of the common exceptions thrown by this member.
Permissions—Table of the code access permissions demanded by this method.
Example—An example using this member following the same pattern as the type samples.

Conventions Used in This Book

Courier is used for all source code blocks, including syntax declarations, class names, and member names.

In order to aid readability, the namespace portion of the fully qualified type names were removed when the result was unambigous. The following guidelines were used:

  • When referring to a member of the type being addressed, only the member names were used.
  • When referring to a type, other than the one being addressed, but in the same namespace, only the type name is used.
Additional Features

In addition to including the content from the ISO CLI standard, this book includes a number of other features:

  • For every type covered in the book we include all the members as defined in V1.1 of the .NET Framework. Many members were left out of the ECMA standard to streamline platform work because types in the signature were not in the standard or because of scheduling reasons. As this book is primarily targeted at developers using the .NET Framework, we elected to include all the members of the types we cover, not just those that are standardized.
  • Nearly every type contains annotations from key members of the design team at Microsoft and members of the ECMA standards group. These annotations bring rationale, history, and other interesting notes about the types covered.
  • We added more than 1,000 samples to the book. Nearly every member has a working sample with output included. All of the samples can be found on the CD.

Many people contributed to making this book possible. We would like to thank:

  • Martin Heller, series editor, for his technical guidance as well as coordinating a myriad of details involved in creating the book.
  • Joan Murray from Addison-Wesley for her patience and guidance.
  • David Platt for producing the excellent namespace overviews provided here.
  • Joel Marcey for providing technical support in working with the Xml doc format used in the ECMA standard and for providing thoughtful and lighthearted annotations.
  • The contributing members of ECMA TC-39 TG1 and TG2 for formalizing the CLI and C# Standards on which this book is based.
  • Mike Koenig, my manager here at Microsoft, for allowing me the time to contribute this work.
  • Alex Homer, Kevin Westhead, and Joel Marcey for sharing their coding expertise through the large set of samples shown in this book.
  • The many .NET developers who reviewed early versions of the manuscript and provided valuable feedback, including William Bartholomew, Alfred Gary Myers, Jr., Jordan Matthiesen, Kevin Westhead, and Bill Wagner.

Brad Abrams
Lead Program Manager, .NET Framework Team
Microsoft Corporation
March 2005


From the Back Cover

“This is a complete, authoritative, and truly useful reference for every .NET developer. It covers every aspect of .NET Framework library by providing concise descriptions with just the right number of examples. I would not start development of any significant .NET project without having this book on my bookshelf.”
—Max Loukianov, Vice President of Research and Development, Netpise Inc.
“The .NET Framework Standard Library Annotated Reference is the one reference you really need when you use the .NET Framework library. The annotations provide clear insight into the design choices that the library development team made when building the library. Those explanations will guide you to the best design choices for your own application code.”
—Bill Wagner, Founder/Consultant, SRT Solutions, and author of Effective C#
“More than just a reference, this book provides great insight into the massive amount of thought that went into designing the Microsoft .NET Framework. It is both entertaining and educational, combining interesting and sometimes amusing annotations along with the reference material.”
—Jordan Matthiesen, Software Engineer
“Brad Abrams, Tamara Abrams, and the CLR team take readers on a journey through the backstreets of the .NET Framework, pointing out invaluable design decisions and performance best practices along the way. Not to be missed by any developer who has ever wondered why the Framework is designed the way it is.”
—William D. Bartholomew, Senior Software Architect, Orli-TECH Pty Ltd
“This volume provides an in-depth review for every class method listed, including a CD with many examples of usage. The most valuable aspect of this book is the annotations provided; the annotators’ thoughts about the design of the .NET Framework lets the reader develop a crystal-clear understanding of what can be accomplished with this fantastic technology.”
—Bradley Snobar, Software Engineer
“The utility of a reference book is often a function of how easily you can find a desired subject and, once there, how clearly is it explained. On both counts, you should find that this book stands well.”
—Dr. Wes Boudville, Inventor

The .NET Framework Standard Library Annotated Reference, Volume 2, completes the definitive reference to the .NET Framework base class library. This book-and-CD set offers programmers unparalleled insight into the ECMA and ISO specifications for the classes and members, while also explaining why they were designed as they were and demonstrating how to use them. This volume covers the Networking, Reflection, and XML libraries, complementing Volume 1’s coverage of the Base Class and Extended Numerics libraries.

The printed book contains high-level descriptions of each namespace, plus detailed descriptions and samples of each type, including annotations, inheritance diagrams, and a listing of members.

The accompanying CD contains a vastly expanded version of the book’s text that includes detailed descriptions of each member and samples for most members—almost two thousand searchable pages of immediately useful reference material, plus a full source-code archive.

With the ECMA and ISO standards as its core, the combined book and CD include

  • A clear and complete overview of each namespace, describing its purpose and functionality and the inheritance hierarchy of types it defines.
  • Type descriptions. Each type is covered in its own chapter, with a quick reference to the C# declaration syntax for all members defined in the type, and a detailed description of how the type is used.
  • Annotations from key insiders: members of the Microsoft design team and the ECMA Standards Committee. These comments cover everything from design rationale and history to common problems and shortcomings, with exceptional clarity and candor.
  • Reference tabs and an exhaustive index, which allow readers to quickly and easily navigate the text.
  • Code samples. Types are illustrated by working code samples, with output included.
  • Reusable source code for the more than one thousand samples is supplied as an archive on the CD. All code has been tested with versions 1.0, 1.1, and 2.0 of the .NET Framework and, where appropriate, with the .NET Compact Framework.

See all Product Description

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) HASH(0xa3fd8990) out of 5 stars 6 reviews
13 of 15 people found the following review helpful
HASH(0xa33de408) out of 5 stars Worthwhile Reference, but could use more annotations. Sept. 14 2005
By Phillip Haack - Published on
Having read both volume 1 and volume 2 of .NET Framework Standard Library Annotated Reference (SLAR as it is affectionately known), I can easily recommend it as a very worthwhile reference for the serious .NET developer.

Volume 2 takes the reader deeper into the framework than Vol 1, spending more time in the XML, Reflection and Network libraries among other areas.

Although Volume 2 was informative, it wasn't as insightful as Volume 1, partly due to the fact that it covered classes less used than Vol 1. Also because of the absence of Jeffrey Richter as a commenter.

The annotations on the Socket related classes were quite skimpy, which was a disappointment for me personally, but might not matter to most developers.

Thought I would prefer even more annotations, the existing annotations are very insightful and provide a lot of valuable information.

Every type is clearly presented alongside working source code that demonstrates the given type. That, and the fact that all the code and types are searchable on the accompanying CD makes this a must have for your .NET bookshelf.
7 of 9 people found the following review helpful
HASH(0xa33de810) out of 5 stars WinFX, WCF, WPF, WWF. Everything runs on top of this. Sept. 17 2005
By Alfred Gary Myers Jr. - Published on
Being a reader of Brad Abram's blog, I had found very interesting the posts, taken from SLAR vol. 1, dedicated on commenting a subset of the Framework Class Libraries (FCL).
So when he asked for volunteers on reviewing the second volume, I didn't think twice in being one of them.
In the weeks that followed I shared my time between working, studying for 70-320 and reviewing annotations and code samples.
I have to tell you: I really believe in the idea of telling us mere mortals the stories behind the scenes on developing the FCL.
Only on this two part series, you get to know why the things were done the way they are.
Since much of the book's value is in its annotations, the Annotation Index is extremely useful in finding comments made by a particular contributor.
I missed the poster that volume one had and the contributions of Jeffrey Richter, Kit George and Anders Hejlsberg. Maybe they didn't have much to comment on the libraries covered by this volume.
On the other hand, in this volume we have great contributions from Adam Nathan (COM Interop), Suzanne Cook (Fusion), Joel Pobar (Reflection, Rotor).
WinFx is coming with all those new shinny APIs such as WCF (Indigo), WPF (Avalon), WWF (Workflow), etc. But don't you forget that they are all developed on top of the libraries contained in these two books.
If you want to be a reference within your team for the years to come, these two books are among the ones to read to pursue this goal.
4 of 5 people found the following review helpful
HASH(0xa33d481c) out of 5 stars take a look at the internationalisation classes Sept. 15 2005
By W Boudville - Published on
The authors continue the exposition of Volume 1, into these classes of .NET. Here, the topics include networking, XML and reflection. The number of XML classes is less than for the others. But they give solid ability to read and write XML data. The XML functionality seems on a par with what is currently offered in Java 1.4 and 1.5.

The importance of the networking classes is because so much of our efforts revolve around the Internet these days. So you can find out how to make a request to a web server using http. Plus classes for credentialling and security. There is even a neat little IWebProxy interface, for getting to hosts using proxy servers.

Under the rubric of reflection, .NET also includes internationalisation [i18n] issues. They call it globalisation, which I think is basically the same thing. There are classes that encode culture-specific data, like calendars and languages. Microsoft has built out .NET with scads of this information. It's a global marketplace for your efforts, right? .NET lets you take advantage of this.

Like the first edition, the book goes beyond being a mere printing of man pages. Each class gets example code that may often be the simplest way to get a quick understanding of a common usage of that class. Plus the informal remarks help this understanding along.
2 of 4 people found the following review helpful
HASH(0xa33de888) out of 5 stars cyberkid June 29 2006
By Ralph Veras - Published on
Very well organized, excellent archives, and good source code. Thesee libraries make an excellent reference for coding your application
2 of 5 people found the following review helpful
HASH(0xa33dec0c) out of 5 stars an authoritative and essential reference for all .NET developers June 24 2006
By C# Online.NET, Editor - Published on
Excerpt from C# Online.NET Review (wiki.CSharp-Online.NET):
"This book is the authoritative reference to the .NET Framework libraries: Networking Library, Reflection Library, and XML Library. Each type has its own chapter with the following features:

- Header - namespace name, type name, library name.
- Type summary - C# declaration syntax for all members.
- Type description - detailed usage description.
- Annotations - annotations by key Microsoft design team members including Anders Hejlsberg.
- Example - C# source code and program output."