Programming in the .NET Environment [Paperback]

Damien Watkins (Author), Mark Hammond (Author), Brad Abrams (Author)

Book Description

ISBN-10: 0201770180 | ISBN-13: 978-0201770186 | Publication Date: November 16, 2002 | Edition: 1

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.

Editorial Reviews

From the Back Cover

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

About the Author

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/.

See all Editorial Reviews

Product Details

• Paperback: 560 pages
• Publisher: Addison-Wesley Professional; 1 edition (November 16, 2002)
• Language: English
• ISBN-10: 0201770180
• ISBN-13: 978-0201770186
• Product Dimensions: 9.3 x 7.4 x 1.2 inches
• Shipping Weight: 2 pounds (View shipping rates and policies)
• Average Customer Review: 4.1 out of 5 stars  See all reviews (8 customer reviews)
• Amazon Best Sellers Rank: #1,975,874 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

10 of 13 people found the following review helpful:

3.0 out of 5 stars Excellent book if you're already a .NET expert, April 6, 2003

By A Customer

This review is from: Programming in the .NET Environment (Paperback)

A better title for this book would be `An Insider's Guide to Why the .NET Framework Was Designed the Way It Was'. The authors are Microsoft developers who have been working on .NET for most of its existence. Because of their first hand knowledge of the Framework's evolution, they offer a perspective that is uniquely different than all the other .NET books out there. Covered are topics such as the design goals of C# (including an alarming story of how Microsoft considered modifying C++ rather than creating a new language), the internal discussions of the Visual Basic team regarding how that language would evolve, and the advantages/disadvantages of garbage collection versus deterministic finalization, and why garbage collection finally won out. There are even little known nuggets, such as why every .NET Framework executable contains the string "BSJB" (they are the initials of four of the original developers).

This book is filled with numerous examples of how .NET solves problems differently than other architectures such as CORBA, COM, and Java. It freely admits advantages others might have in certain areas but the authors clearly evangelize .NET as the best overall solution. It follows a consistent pattern when discussing concepts such as type systems, metadata, versioning, and security. First, it describes the core problem or challenge. Second, implementations by other languages/architectures are briefly discussed. Finally, a detailed explanation is given of how .NET offers the best solution, complete with clear examples.

Several topics are discussed that are skipped in other .NET books. Whether this is a good thing depends on your skill level and your interest in these topics. Experienced developers who are already proficient in .NET will appreciate the excellent discussion of the boxing of value types into reference types, how events and properties are implemented behind the scenes, and the line-by-line analysis of the Intermediate Language (IL) of a simple application.

While most examples are presented in C#, this book does not help one become proficient in it. The examples are given only to illustrate how the .NET Framework works, not any particular language.

What are clearly missing are chapters on creating web applications, web services, windows forms, and windows services. In other words, this book by itself only provides a small piece of the knowledge a developer must gain when learning .NET.

As a former Visual Basic developer, I am task-oriented. This is in contrast to being theory-oriented, which is how I think of C++ developers who spend an extra ten hours tweaking pointers (and tracking down memory leaks) to gain a ten percent speed increase in a procedure. Though I have converted to C#, I am still more interested in getting the job done quickly than understanding the internal details of the .NET engine.

I bring this up because this book is theory-based, and as such I found it lacking in information I could immediately apply to my programming projects. We are all stretched for time, and I would rather spend mine reading about techniques to solve business problems through real-world examples of forms and services, not learning why C# produces slightly different IL than VB.

That being said, this book has a place among developers who come from a Computer Science background, or who know C++ or Java inside and out, or who already know .NET very well and want to learn the core underpinnings. In this regard it does an excellent job and is well written and concise.

However, I only gave it three stars because I believe most developers could better spend their time with other books that offered more practical and applicable advice. Those books, such as Wrox's `Professional C#' or Sams' `ASP.NET Unleashed', teach just enough of the core underpinnings to keep a developer from shooting himself in the foot, yet focus most of the time on real world examples that are far more useful.

3 of 3 people found the following review helpful:

4.0 out of 5 stars Solid intro to .NET, December 20, 2002

By 

"richardtgrimes" (Kenilworth, Warks United Kingdom) - See all my reviews

This review is from: Programming in the .NET Environment (Paperback)

You have to approach this book as two halves: the main text and the appendices, and indeed, the appendices take up some 40% of the book. The main text is a good introduction to the framework and leads you through the basic features of types, assemblies, configuration, localization etc. The language used in the main text is (understandably) C# and one of the appendices is an introduction to this language by the acclaimed writer on C#, Eric Gunnerson. The other appendices cover a diverse collection of languages from VB.NET, through Python, Perl, Component Pascal and Oberon. If you are interested in the languages that can be used with .NET then the appendices are useful but incomplete (bizarrely, IL and Managed C++ are not covered). Instead, I recommend that developers new to .NET should ignore the appendices and read the main text, which is a good grounding before reading Richter's book.

7 of 9 people found the following review helpful:

5.0 out of 5 stars Straight From The Source, February 18, 2003

By 

J. Plamondon (Texas) - See all my reviews
(REAL NAME)   

This review is from: Programming in the .NET Environment (Paperback)

Do you want to know how .NET actually WORKS? If you weren't comfortable using C++ until you understood v-tables, then this is the book for you.

The co-authors are exactly the right people for this purpose. Brad Abrams was a .NET development lead; Mark Hammond implemented Python.NET; and Damien Watkins helped Monash University learn about .NET before starting his own .NET consulting company.

When I was one of Microsoft's Technical Evangelists for .NET, I invited Mark and Damien to participate with Brad in the design of the .NET Runtime back in 1999 -- along with the designers of other commerical and academic languages such as Smalltalk, Scheme, Eiffel, Haskell, Oberon, etc. -- to make sure that the .NET Runtime and CLR really could support different languages well. Their feedback made .NET more flexible, powerful, and useable. In this book, they explain not only HOW .NET works, but WHY. After all, these guys helped MAKE those decisions.

Some have said that only compiler writers targeting .NET would be interested in reading this book. I could not disagree more. At each level of abstraction above the silicon, more and more trade-offs must be made by those implementing the abstractions. If you don't understand the feature and performance trade-offs they made, then you're not going to be able to make good trade-offs yourself, when writing code that uses their abstractions. In an ideal world, all abstractions would be pure, involving no trade-offs; but .NET was designed for the real world, in which performance still matters. Do you write code for the real world, too? Then you NEED to read this book.

If you'd rather read the Kama Sutra than "Sex for Dummies," then order this book RIGHT NOW.