Applied Microsofta .Net Framework Programming

by Jeffrey Richter

Aimed at experienced developers and designers, explains the structure, functions, and operational components of Microsoft's .NET framework. This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0735614229
• ISBN13: 9780735614222
• Release Date: January 2002
• Publisher: Microsoft Press
• Length: 640 Pages
• Weight: 2.80 lbs.
• Dimensions: 1.3" x 7.6" x 9.4"

Customer Reviews

Good Inside look to .Net Framework

This book is an excellent inside look to programming with the .Net Framework. It is a good start to anyone who wishes to familiarize himself with it . This book is all about the small stuff that many .Net programming books tend to ignore . What I particularly liked in this book are the following:- How the Compiler assembles C# code into IL code . In many chapters this is done to show performance impact on doing thing one way not the other way- Working with CLR Types : comparison between types, and how to perform casting, boxing, and unboxing - Events and Delegates and how to use them - Exception was covered in more details than the typical ( try - catch) explanations that I found in most other .Net books. I particularly liked the talk about unhandled exception and non CLS compliant exceptions.I read the book from cover to cover and used some techniques in terms of delegates and exception handling in my application. I just found the chapter on "Garbage Collection" little confusing. Also it doesn't have a lot of programming examples, and all the programming examples are in C#. ONE FINAL THING to add is that this book is mainly about programming with Common Language Runtime. It is not a reference book that covers the different class libraries that .Net framework offers and how to use them, for that you probably need to buy other books to cover topics such as : ASP .Net, ADO.NET, Web Services, Remoting, etc.. .

Picks up where the others leave off

This book is an absolute necessity for anyone serious about writing programs targeting the .NET Framework. The author delves far deeper into the inner workings of this new platform then any I've encountered so far. It is not intended to be a tutorial, especially for a particular programming language. Instead, it's an in depth discussion on how the basic framework classes operate internally and how best to manipulate them efficiently and expertly. Virtually all the examples are in the C# language, but this does not prevent VB.NET and Managed C++ users from following the material. In fact, he does point out when the different languages utilize the framework differently and/or how these languages map into the framework. Chapters 2 & 3 did require my reading them more than once. The material is complicated and dense, but he covers it with great clarity and expertise. Just expect to return to it several times. He covers a lot of ground in great detail in these chapters on assemblies and the various strategies available for deploying programs and components. Also, the chapters on manipulating text and the garbage collection facilities are the best and the most detailed I've encountered. Many lights will go off in your mind as you're reading this book. I highly recommend this book to anyone AFTER learning the syntax of their chosen .NET language.

Required reading written by a longtime Windows expert

As a C++ programmer moving into the C#/.NET world, I found this book essential to good .NET program design. With VS 7, Intellisense and MSDN samples it's possible to just "jump in" and start writing Windows apps in C#, but I wouldn't recommend it if you have the time to read this book first. Richter describes in detail the intricacies of compilation, IL, value types, boxing, interfaces, the garbage collector, and other things that work slightly different from how they did in the C++ world. It WILL help you know where to expect those subtle bugs and how to avoid them.In addition, Richter covers a lot of the new features built in the language that will save you development time. He doesn't tackle most of the specialized classes in the .NET Framework like other books (e.g. the Wrox one) does, but he does go in depth into the ones that will be used by most programmers - for example, the new things you can do with strings (all Unicode, with built in text conversion routines and methods for locale-sensitive comparisons), the new type objects that all objects expose (not just strong typing, you can query the inheritance model and all sorts of good stuff), and some delightful tricks you can do with enums that will make you fall in love with them all over again.If you tried to read Advanced Windows and were scared off or bored, I want to reassure you that Applied Microsoft .NET Framework Programming is more readable than Advanced Windows was - you can actually hole up in a little cafe and read it from end to end if you want to, in about a day and a half. It's also a little more accessible to people without a theoretical background or college degree in computer science. But rest assured, Richter goes into quite enough detail for the compiler geeks among us.Understanding of COM, object-oriented programming, interfaces, stack vs. heap memory, etc. is required. I thought I would be dragged into .NET kicking and screaming, but I've become quite the evangelist - partially due to this book.

Essential .NET Book

As a highly experienced VB/COM developer, I have been making the move over the C# and .NET. I have spent hours at the book stores looking over nearly every book available. I have bought a bunch of books as well, but none have come close to this book as far as insight, depth of knowledge, and .NET fundamentals. Mind you, this book is by no means for programming or object oriented beginners. It is meant for programmers who really know their stuff, but now want to know their stuff on .NET. Expecting to create a .NET solution without thorough knowledge of the material in this book would be seriously shortchanging your app.Each chapter of this book covers a different fundamental piece of .NET -- Methods, Events, Shared Assemblies, Exceptions, etc. Without getting too language specific, he writes thoroughly about how these fundamentals were meant to be used. It is clear that he spent a lot of time with the Microsoft .NET team, as much of the material in this book is unavailable elsewhere, to my knowledge. But this book is far from a Microsoft infomercial, as so many are. For example, he talks about C# primitive types and actually disagrees with Microsoft's C# language spec with regard to their usage.In summary, I would highly recommend this book to any experienced programmer who is serious about getting up to speed with .NET.

The *definitive* book on CLR and .NET internals!!

I have been working with .NET for almost two years now and had extremely high expectations for this book. Not only have they been met but far surpassed! This book is absolutely amazing and full of detailed information unavailable anywehere else. Even people that have worked with .NET for 2 years struggle over how JIT of methods really works: Does it JIT each method and then cache or JIT each time? Richter shows you on page 15 in detail. By page 9, he is already on a detailed explanation of how the CLR loads and the JMP _CorExeMain mechaism. I read the first 70 pages last night and I can say with confidence that I learned something new every page! How rare that is for a technical book and how rare especially for a .NET book. Assemblies and how they are made up internally are covered in Chapter 2, Shared Assemblies in 3, then types. But the crown jewel, IMHO, of this book, is Chapter 19, on Garbage Collection, which is the best darn detailed explanation of GC in .NET anywhere and finalization. This book is a *must* have for any serious .NET programmer.