Developing Applications with Visual Studio .Net

by Richard Grimes

This is the.NET book C++ developers have been waiting for: a meaty, practical guide to Visual Studio.NET programming from one of the world's leading authorities on Microsoft development. Best-selling COM/ATL author Richard Grimes begins by reviewing the fundamental concepts that underlie the .NET Runtime, including managed vs. unmanaged code, garbage collection, the Microsoft Intermediate Language, type information, and metadata. Next, Grimes introduces...

• Format: Paperback
• Language: English
• ISBN: 0201708523
• ISBN13: 9780201708523
• Release Date: January 2002
• Publisher: Addison-Wesley Professional
• Length: 832 Pages
• Weight: 0.90 lbs.
• Dimensions: 1.5" x 7.4" x 9.2"

Customer Reviews

Gem of a book - pays for itself in days

This is a gem of a book that is packed with insights not readily found elsewhere. Chapter 3 ('Context & Remoting') perfectly distills the subject in about 90 pages with clear code snippets. Chapter 2 on the FCL was well done (over 120 pages) with good code examples. The chapters on VS (IDE) was not extraordinary but acceptable. The frosting of the book was Chapter 7 on Managed C++, quote "It is time to return to my true love, C++". Ditto.

Quality book that offers a lot of insight into .NET

The book really comes from the perspective of a Win32/C++ developer. I would not recommend this book, unless you have come from this background, or really want to understand some of the internals of .Net (and are really willing to spend some time in it). It also only really covers Visual C# and Visual C++.Net (managed and unmanaged). Overall it is a quality book that offers a lot of insight into the world of .Net. It requires one to read it a few times through to really get the details as Grimes has a tendency to dig deep into details that may not make sense at the time. The organization is fair but could use a lot of work as the chapter layout seems a little disjointed. There could also be many more examples in the book. The book provides an adequate number of examples, but could use more. The first few chapters really spend a lot of time digging into the framework. Many times Grimes leads one deep down a path (such as boxing and unboxing) and others he refers to another chapter later (such as exception handling etc). It's a decent overview of .Net but requires one to read it over a few times. Many times it delves into the inner workings of .Net that might not be easy to grasp the first time through. The second chapter starts looking at the framework classes, and gives a healthy overview of .Net's offering. Chapter 3 gets into .Net remoting and context. Overall I think chapter 2 and 3 are probably the best of the book. Chapter four concerns itself with COM interop and COM+. This chapter is a good overview of what was done before and how it works in .Net. It is a necessary chapter, but I for one kinda glossed over it. The price of interop tends to be fairly high and to be avoided wherever possible. I think this is a great chapter, though, as I am sure I will need to do this at some point and this will be a good reference. Chapters 5 and 6 concern themselves with Visual Studio .Net and how to build applications. Pretty good chapters, especially if you have not become familiar with the IDE yet. The section on tools and external tools are very important. Chapter 7 is all about Visual C++.Net (managed and unmanaged). I think this is really a highlight as there are not many good books on Visual C++.Net. Grimes does an excellent job of describing the enhancements to Visual C++ and some features that have been widely ignored (ATL Server and Visual C++ unmanaged). Chapter 8 provides an excellent overview of application development. Unfortunately the book does not cover ADO.Net or ASP.Net, but it makes up for it by covering many tricky areas of development like localization, and logging mechanisms. Chapter 9 covers debugging. I wish this chapter was actually longer, but It does a good job of showing debugging techniques for .Net. This chapter is an absolute must read for any developer, as debugging techniques can not be over stressed. Overall I think the book is very detailed and it sho

Good book if you can choke down "Managed C++"

Updated Review:After a year of programming real world projects with .NET, I had to change my opinion on this book. As the author acknowledges, there is ALOT of existing C++ code and libraries. Trying to port existing code or using Interop techniques is not always the best solution. I'm glad to have a reference to Managed C++ that helps me compile C++ solutions to .NET(I would like to see a tiny bit more on mixed mode, c runtime linking, and C++ idioms that Just Don't Work). I still believe this is not the simplest book for learning C#, but those books have become a dime a dozen. This book is one you'll be glad if you need to using existing software.Original Review:Ok, I'm a C++ developer that has a hard time stomaching what MS has done to my beloved language. However, I am very interested in the .NET initiative( and C# ) and wanted to get the perspective of a C++ expert, especially one with a COM background. I read this book and found it quite good, except for the examples in "Managed C++"( in which there were many ). Granted, I was warned, but seeing C++ twisted like that reminded me of Bilbo's line ...butter scraped over too much bread... . The "Managed C++" examples were truly distracting. The author had to explain why the plumbing overhead, we learned to detest in COM, now exists in every line of code in "Managed C++"( my words, not his ).

A tour that goes deep

If you've done some C++ and COM programming in the past and want to gain a subsential knownledge of the .NET Framework, this book is the one you should choose. Of course this is not an absolute requirement! You can start right away with this book but it will be difficult!Richard Grimes is giving us very good information about how things work, and how to leverage the quality of your code to its maximun by giving good examples and trics. It is not a easy book, but if you're ready to work hard during one one week or two you can go throughout this book and you'll gain everything you need to start with .NET and even more. I really liked the chapter on .NET remoting, which was clear and full of good insights that help me understand what was going on when calling a method remotly with the .NET framework. This is not an How To book, but a Why book :) Why things work like as they do, so you can use things very efficiently. The book also explains some part of the IDE of VS.NET to help you exploit the power of this new and very exciting IDE.The book use C++ and C#, no VB.NET which is I think a good decision because to much isn't better than to less and there's plenty of good VB.NET books out there. So, if you've read and appreciate the deep coverage and quality information given in Beginning ATL 3 COM or Professional ATL COM programming from WROX, which were writing by Richard Grimes, you'll definitly like this book. He has a good writing style and has the ability to focus on important things.

Best book so far on Managed C++, VS.NET and how it all works

Richard is a long time respected author in the Microsoft world and he does not disapoint with this very well written, consise and well targeted book. I have been working with .NET for over 2 years now but there are a lot of mysterious areas still. Richard sets the tone right away "I have diliberately decided to C++ Win32 developers. This book has no VB.NET code and the barest minimum of ASP.NET. I also make no excuses about the fact that this book is packed full of details, and in places it touches on tough concepts." Yes! Finally! Not another book on what C# and VB.NET is and a rehash of the existing documentation, this book is a detailed dig and exploration in the vital areas of the runtime, interop, managed C++, and VS.NET among others. The book starts with a drilling down into the .NET Runtime. There is a lengthy investigation of the Framework Class Library in Chapter 2. The next chapters on Contexts and Remoting, and Interoperation and COM+ are utterly brilliant with detailed information that you need to know to use these technologies. The next two chapters focus on VS.NET. There is some run-thru of the environment and the menus, but Richard covers the atomation model that has been exposed and add-ins and even VSIP. This is stuff that I have not seen in any other book. Chapter 7 is the heart and soul for me on Visual C++.NET. The discussion of the changes in ATL 7 are perfect and something I have next to my desk every day as I develop. The best part is the rationale and clear explanation on Atrributes. Then, the sections on Managed C++ are very clear and detailed. This book has spent the whole week open next to my work computer as I have used the VS.NET and Chapetr 7 chapters. This book is a must have if you are a hard-core .NET developer in C# and MC++.