Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Debugging Applications for Microsoft® .NET and Microsoft Windows® (Pro-Developer)
You get huge development advantages with Microsoft Visual Studio® .NET 2003but you need a new bag of debugging tricks to take full advantage of them in today’s .NET and Win32® development worlds. Learn lethally effective, real-world application debugging techniques for .NET Framework 1.1 and Windows with this fully updated programming guide. Debugging expert John Robbins expands the first edition of his classic debugging book with all-new scenarios and bug-killing tools, tips, and techniques. You’ll see every .NET and Windows debugging scenario herefrom XML Web services and Microsoft ASP.NET to Windows services and exceptions. Along with John’s expert guidance, you get more than 6 MB of his battle-tested source codefor the tools and tactics you need to ship better software faster!
Topics covered include:
- Where bugs come from and how to think about solving them
- Debugging during coding
- Operating system debugging support and how Win32 debuggers work
- Advanced debugger usage and .NET debugging with Visual Studio .NET
- Advanced native code techniques with Visual Studio .NET and WinDBG
- Extending the Visual Studio .NET integrated development environment
- Managed exception monitoring
- Flow tracing and performance
- Finding source and line information with just a crash address
- Crash handlers
- Debugging Windows services and DLLs that load into services
- Multithreaded deadlocks
- Automated testing
- The Debug C run-time library
- A high-performance tracing tool for server applications
- Smoothing the working set
- Appendixes: Reading Dr. Watson log files, plus resources for .NET and Windows developers
CD-ROM features:
- 6+ MB of professional-level source code samples written in Microsoft Visual C++®, Visual C#®, and Visual Basic® .NET
- Debugging Tools for Windows
- Microsoft .NET Framework 1.1 SDK
- Windows Application Compatibility Toolkit (ACT)
A Note Regarding the CD or DVD
The print version of this book ships with a CD or DVD. For those customers purchasing one of the digital formats in which this book is available, we are pleased to offer the CD/DVD content as a free download via O'Reilly Media's Digital Distribution services. To download this content, please visit O'Reilly's web site, search for the title of this book to find its catalog page, and click on the link below the cover image (Examples, Companion Content, or Practice Files). Note that while we provide as much of the media content as we are able via free download, we are sometimes limited by licensing restrictions. Please direct any questions or concerns to booktech@oreilly.com.
- ISBN-100735615365
- ISBN-13978-0735615366
- PublisherMicrosoft Press
- Publication dateApril 2, 2003
- LanguageEnglish
- Dimensions7.63 x 2.34 x 9.42 inches
- Print length801 pages
Similar items that may deliver to you quickly
Editorial Reviews
Amazon.com Review
The greatest value of Robbins' work is in his treatment of bugs' origins in flawed software design and their later manifestation in faulty coding practice. He explains in great detail, for example, how to use assertions (in concert with error handling) to keep bad data from getting into software modules and causing trouble. This coverage is why your development team should read this book before getting too far down the development path.
If you're already done with your software system and just can't make it work right (and, naturally, the Deadline of Death is looming), this book offers hope as well. Want to write a method that you invoke manually only when the program is at a breakpoint in the debugger? This book shows how. Need lots of details on how to add assembly-language code to your Visual C++ .NET software? You'll find them here. There's a lot of information about how debuggers do their work in general, too. To put it concisely, this book contains a career's worth of information on how to keep bugs to a minimum and track them down when they occur. --David Wall
Topics covered: How to design Microsoft Windows software to minimize design flaws, implement designs with as few software errors as possible, and use diagnostic tools and techniques to squash bugs that make it into your systems. All the latest Visual Studio .NET tools get attention, as do techniques for getting the most out of those tools. Specific coverage goes to strategies for fixing thread deadlock problems, resolving memory troubles, and reading Dr. Watson dumps.
About the Author
John Robbins is a co-founder of Wintellect, a .NET and Windows consulting and education firm. Wintellect's mission is to help companies ship better software faster using any Microsoft platform. He concentrates on the emergency debugging and consulting aspects of the business. John also teaches other developers how to better debug so they can solve their development problems faster with his course "Debugging Applications." John has worked on debugging or tuning a wide range of applications from companies such as eBay, Microsoft, and AutoDesk, as well as many corporate development shops. In addition to writing both editions of Debugging Applications, John is a contributing editor to MSDN Magazine where he writes the popular Bugslayer column. Before founding Wintellect, John was one of the first engineers at NuMega Technologies (now Compuware Corporation) where he was a key player in designing, developing and managing many of the most-used and award-winning developer tools in the C/C++, Microsoft Visual Basic, and Java marketplace. Prior to stumbling into software development in his late 20s, John was a paratrooper and Green Beret in the United States Army. Since he no longer gets the same adrenaline high that he used to jumping out of airplanes in the middle of the night onto an unlit, postage-stamp-size drop zone with a full combat load, he rides motorcycles at high rates of speed--much to his wife's chagrin.
Product details
- Publisher : Microsoft Press (April 2, 2003)
- Language : English
- Paperback : 801 pages
- ISBN-10 : 0735615365
- ISBN-13 : 978-0735615366
- Item Weight : 3.85 pounds
- Dimensions : 7.63 x 2.34 x 9.42 inches
- Best Sellers Rank: #4,385,333 in Books (See Top 100 in Books)
- #137 in Computer Programming Debugging
- #500 in PC Hardware
- #803 in Microsoft .NET
- Customer Reviews:
About the author

Discover more of the author’s books, see similar authors, read book recommendations and more.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
This book covers real-world debugging issues that plague programmers and are difficult to solve, such as multi-threading and memory issues amongst others. Also this book has several entertaining real-world scenarios that can help give you perspective on debugging.
However this book is not for the beginner, a solid grasp of programming is essential for this book. However those with a good grasp of what programming is about with at least a basic knowledge of .NET will be right at home with this book.
Although this is exceptionally good book, I wish it had more content for the specifics of .NET debugging. I think another missing topic is `debugging mixed managed and unmanaged code'.
After reading most of the book, I disliked only one thing, which is author's strong opinion about using exceptions in the applications.
It discusses mainly C/C++ debugging in a typical MFC style (ASSERT/VERIFY etc).
Here is the content at a glance:
1. Bugs: Where they come From and How you Solve Them
2. Getting Started Debugging
3. Debugging During Coding
4. Operating System Debugging Support and How Win32 Debuggers Work
5. Advanced Debugger Usage with Visual Studio .NET
6. Advanced .NET Debugging with Visual Studio .NET
7. Advanced Native Code Techniques with Visual Studio .NET
8. Advanced Native Code Techniques with WinDGB
9. Extending the Visual Studio .NET IDE
10. Managed Exception Monitoring
11. Flow Tracing
12. Finding Source and Line Information with Just a Crash Address
13. Crash Handlers
14. Debugging Windows Services and DLLs That Load into Services
15. Multithreaded Deadlocks
16. Automated Testing
17. The Debug C Run-Time Library and Memory Management
18. FastTrace: A High-Performance Tracing Tool for Server Applications
19. Smoothing the Working Set
Appendixes.
As you can tell, there is hardly a .NET stuff to pay for, so for those of us owing the author's previous debugging book, this is just a second edition with .NET appended to confuse buyers!
Most useful to me were the symbol-server tips, the SuperAssert macro and seeing how it does it what it does, crash handling in general, and the author's insight into why certain things are so slow (like OutputDebugString).
This book does have a not-so-subtle anti-C++ bias, there are little digs at C++ coding techniques throughout the book, which seem a little antiquated and inappropriate in 2005.
In the chapter on the debug C-runtime, I'm really surprised the author does not suggest writing a leak-detection system that captures the callstack at the time of allocation, I've found the C-runtime's file-and-line-oriented leak report fairly useless since the allocation is often deep inside some container class, you really need to know what code caused the allocation, not what code actually did the allocation. And the recommended feature that walks the entire heap every N allocations is unusable (it's too slow) in a large C++ program which might have many thousands of allocations. Also, redefining C++ keywords as suggested seems so evil, there are better ways of doing this.
I believe Windows XP Service Pack 2 changed some Windows internals that affect crash handling/debugging/stack walking, I wouldn't mind seeing an updated volume that covers these changes in detail.
Overall though, an excellent book, the most useful debugging book I've found so far.
John walks the reader through debugging without tears. This edition of the book does contain a lot more information and is very current (a little too current cos all the binaries were built with VS .NET 2003 which is not in the market at this time.
However, this didn't hinder me since I have a copy of the RC. The first part of the book covers coding practices that will reduce the need to debug in the first place. The other parts of the book go into the dirty details of going after bugs with full confidence. From native win32 to managed code to multithreading; its all here.
If you're tired of scratching your head even when you have a debugger in front of you, stop reading my review and get yourself a copy of this book right away.






