Other Sellers on Amazon
+ Free Shipping
Advanced .NET Debugging 1st Edition
|New from||Used from|
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Frequently bought together
Customers who viewed this item also viewed
Praise for Advanced .NET Debugging
“While the .NET environment provides a developer with a powerful toolbox to accomplish their goals, it can often be a daunting task to debug some of the issues that inevitably crop up during software development. This book provides the crucial details about how the CLR works internally, which you need to know to diagnose many classes of bugs in your .NET programs, and it provides clear examples of how to solve the same types of issues we see our customers struggle with on a daily basis. This book is required reading for all serious .NET developers.”
—Lee Culver, CLR Quick Response Team, Microsoft Corporation
“Have you ever wondered why your .NET application is not responding? Or why it’s intermittently consuming high CPU? Or crashing? When things go wrong you need to think low level, using the proper knowledge and tools to investigate the internals of your application. Advanced .NET Debugging delivers the knowledge necessary to quickly isolate nasty software problems. Welcome to the debugging world!”
—Roberto A. Farah, Senior Premier Field Engineer, Microsoft Corporation
“Mario Hewardt’s Advanced .NET Debugging is an excellent resource for both beginner and experienced developers working with .NET. The book is also packed with many debugging tips and discussions of CLR internals that will benefit developers architecting software. I highly recommend Mario’s book.”
—Jeffrey Richter, consultant, trainer, and author at Wintellect
“This book talks about tools such as SOS in the kind of depth that I have not seen elsewhere. It’s a definite aid in understanding and debugging managed application behavior.”
—Maoni Stephens, GC Developer, Microsoft Corporation
“Advanced .NET Debugging is essential reading for someone who wants to get under the covers and obtain an intimate understanding of how the .NET Common Language Runtime works. It clearly identifies the layout of the system and how the assemblies are loaded and organized. I recommend it to anyone who wants to debug more complex issues brought on by synchronization problems and corruption. It also effectively addresses the difficult task of postmortem debugging.”
—Pat Styles, Microsoft Corporation
From the Back Cover
“Mario Hewardt’s Advanced .NET Debugging is an excellent resource for both beginner and experienced developers working with .NET. The book is also packed with many debugging tips and discussions of CLR internals, which will benefit developers architecting software.”
–Jeffrey Richter, consultant, trainer, and author at Wintellect
“Mario has done it again. His Advanced Windows Debugging (coauthored with Daniel Pravat) is an invaluable resource for native code debugging, and Advanced .NET Debugging achieves the same quality, clarity, and breadth to make it just as invaluable for .NET debugging.”
–Mark Russinovich, Technical Fellow, Microsoft Corporation
The Only Complete, Practical Guide to Fixing the Toughest .NET Bugs
Advanced .NET Debugging is the first focused, pragmatic guide to tracking down today’s most complex and challenging .NET application bugs. It is the only book to focus entirely on using powerful native debugging tools, including WinDBG, NTSD, and CDB, to debug .NET applications. Using these tools, author Mario Hewardt explains how to identify the real root causes of problems―far more quickly than you ever could with other debuggers.
Hewardt first introduces the key concepts needed to successfully use .NET’s native debuggers. Next, he turns to sophisticated debugging techniques, using real-world examples that demonstrate many common C# programming errors.
This book enables you to
- Make practical use of postmortem debugging, including PowerDBG and other “power tools”
- Understand the debugging details and implications of the new .NET CLR 4.0
- Master and successfully use Debugging Tools for Windows, as well as SOS, SOSEX, CLR Profiler, and other powerful tools
- Gain a deeper, more practical understanding of CLR internals, such as examining thread-specific data, managed heap and garbage collector, interoperability layer, and .NET exceptions
- Solve difficult synchronization problems, managed heap problems, interoperability problems, and much more
- Generate and successfully analyze crash dumps
A companion web site (advanceddotnetdebugging.com) contains all sample code, examples, and bonus content.
- Item Weight : 1.87 pounds
- Paperback : 542 pages
- ISBN-10 : 0321578899
- ISBN-13 : 978-0321578891
- Dimensions : 7.6 x 1.23 x 10 inches
- Publisher : Addison-Wesley Professional; 1st edition (November 9, 2009)
- Language: : English
- Best Sellers Rank: #1,976,762 in Books (See Top 100 in Books)
- Customer Reviews:
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
Then you stumble across a book like this and you think "where were you 12 months ago when I first started this journey?"
It's hard to say if there is any good beginner guide to WinDbg, as experience is the true teacher with that tool. But this is the best thing I've read on the topic and would highly recommend it if you are at the beginning or intermediate level with WinDbg.
Software Defect Researcher
Founder of Crash Dump Analysis Portal
Editor-in-Chief of Debugged! MZ/PE magazine
The author of Windows Debugging: Practical Foundations and x64 Windows Debugging: Practical Foundations
Although written around 2009 and the release of .Net 4.0, I still highly recommend this book as a starting point because the fundamentals and strategies outlined are still valid in 2018 and it is not uncommon to also have to troubleshoot legacy code.
Mario does an amazing job in all of his books and courses. He also quickly and politely responded to all my emails on his old Microsoft email no matter how stupid the question was. I selfishly wish he would write another/current book using the same techniques and outlines he used in the past.
If you already have Advanced Windows Debugging by the same author and have read it, then you should be in good shape to tackle this one. But if you haven't, fear not, you can still make it.
The book is soft-bound, neatly printed in about 500 pages and contains 10 chapters divided into 3 parts. It doesn't weight much and can be easily carried around.
Part 1 consists of 3 chapters. In the first chapter the reader is an introduction to the tools. The 2nd chapter - CLR fundamentals - contrary to its name, is not a high level overview for the newbie. Instead it is a wealth of information for all .NET programmers. No matter how senior a programmer you are, I will bet that you will still learn something (probably a lot) from this chapter. The 3rd chapter - Basic Debugging Tasks - is a bit lengthy (I don't mean that in a bad way) at about 100 pages, helps you get acquainted with the tools and commands.
Part 2 consists of 4 chapters - Assembly Loader, Managed Heap and Garbage Collection, Synchronization and Interoperability. As you might guess from the names, it is pretty advanced. It is hard, but you will emerge with a much better and clearer understanding of the platform. The chapter on interoperability might not be useful for everybody, but for those who have felt the pain of COM interop or PInvoke this chapter pays for the price of the book many times over.
Part 3 consists of the advanced-advanced topics. There is a chapter named Postmortem debugging which includes debugging problems when you have no access to the live machine and you cannot reproduce the problem locally. It consists of taking a dump file and analyzing it offsite. Not an everyday topic for most programmers, but you will surely be thankful for this chapter if you ever come across it. It also explains how the Windows error reporting works. The second last chapter is called PowerTools which includes discussion of PowerDbg which allows you to control native debuggers using powershell (how cool is that !). There is also information on Visual Studio integration with SOS and on CLR Profiler. The last chapter, a small one at about 15 pages, is on .NET 4.0 (based on Beta 1 release though).
The writing style is very clear and precise. There are plenty of samples and some good diagrams to help your understand the concepts better (i loved them, a picture is worth a thousand words). In short, this is book worth purchasing and worth reading and worth reading again (which is what I am going to do).
There is a support website for the book at advanceddotnetdebugging dot com.
Top reviews from other countries
There isnt enough overview/diagrams to let you orientate yourself to a maze of structures - i.e. It's basically a linear walkthrough thats easy to get lost in
It's dominated by listings of 'raw' memory dumps whose structures are often not made clear enough (there are diagrams - but not enough). A lot of the time your just following a trail of pointers and memory dumps of numbers. I didnt feel I was being helped to build a map /overview of what was going on.
A major problem I had was that its all 32 bit addressing - most windows users are 64. This makes following the examples a bit more difficult - you have to relate your addresses to the authors e.g. the author in the sync section uses a memory address for an object not referenced since GC section over 70 pages earlier, I gave up at that point - as there would have been a lot of work to go back though the steps in GC to get that address to follow the Sync section example
Id still recomend it though - as there's nothing else out there that goes into detail about the CLR/.NET that I'm aware of. If youve got the time and patience to fill in the gaps - its contains a lot of useful information
Once I'm past the initial stubling blocks of working with 64 bit and not having the souces files for the examples I'm getting on with it much better. There is a ton of knowledge in here, but you're gonna have to work around the holes yourself; on the plus side, that might mean you get a deeper understanding that you would have otherwise.
Basically, this book is just a well formatted summary of articles about WinDbg for .NET with a few extras.
Most of the information from this book you won't ever need, other pieces are easy to google. That's why I wouldn't recommend it to anyone who has already an experience with WinDbg.
Three stars rating is because
1) book's title is totally misleading
2) a lot of advanced topics are not described
3) price is too high for something like this book