Customer Reviews

.NET Gotchas

5 star:		(9)
4 star:		(4)
3 star:		(1)
2 star:		(1)
1 star:		(3)

 

 

If I had just two words to describe this book they would be "Experience Talking". Read this only if you have played with .net for a year or more. You will recount how you were stuck in an issue and spent anything from hours to days figuring out whats the right way to do it. And now it is out there for you in this book.

The Highs:
--> The author gets to the point from the word go instead of talking about whats .net etc.... Hence for the advanced reader, its a delight.
--> The gotchas are explained keeping in mind how Design Principles might get violated by the programmer and what can be done to avoid.
--> The examples are both in C# and VB.NET which makes it appealing for programmers from both the communities.
--> The author has gone to low level details like MSIL generated code to explain the reason behind a gotcha which clarifies things very well.

The Lows:
--> A few typos in the code (I found two glithces) but the errors will be evident to the observant reader.

Strongly recommended for anyone who believes in learning from other peoples mistakes :)

The real question about this book is, "What is the point?" I purchased this book based on early reviews. I encourage you not not make my mistake; you should take a look at the contents first. I believe you will quickly decide you have several better book choices from Amazon. The book is a collection of essentially unrelated code snippets in C# and VB.NET, which describe how not to write code. Everything in the book is well-known and available in the C# / VB.NET online documentation. If you are specifically interested in programming mistakes then this book may be of interest to you. But if you are looking for practical coding techniques you should look somewhere else.

Most C# and VB.Net programmers know there are many quirks and unforseen results that hide within the .NET Framework. Sometimes we think we know how something should behave, and will spend hours trying to make it work -- all the while, the actual behavior was working correctly, it was our assumptions that were incorrect.

In this book, the author takes you through 75 of the most common quirks, gotchas and pitfalls that even the most experienced .NET programmer sometimes will get stuck up on. This is not a book about errors within .NET, rather one that shows you the more common differences between perceived and expected results.

The book is organized into sections covering different areas of the framework -- from the CLR itself, to garbage collection, to the Visual Studio environment, and beyond. One of the more helpful parts about the book is the author in many places will illustrate code snippets with "gotcha" or incorrect code, and then have a sample of the correct way to code a given item to get back the intended results. In addition, a wrap-up at the end of each gotcha puts the entire thing into a nutshell-quote to make it (hopefully) easy to remember and apply.

To wrap it all up, the author also includes a pretty comprehensive appendix to direct to you to web sites, online discussion groups and FAQ's to find out more information about the particular quirk or gotcha.

All in all, one of those books you won't just purchase and sit down and read for the heck of it. Rather, one of the books you purchase and yank off the shelf when you find yourself doing some .NET programming and find yourself scratching your head trying to avoid a pitfall.

I love O'Reilly books in general but this book has me asking what has happened there. This gotchas book is a weak entry in the O'Reilly lineup. Not so much from a technical point of view; overall the book is competent, but from a "why do I want this book"? On the positive side the book is interesting because it presents some real arcane features of the CLR, but on the negative side there is very little practical value. Like any book, check it out first to see if you will find it useful --- I did not.

.NET Gotchas
By Venkat Subramaniam
O'Reilly Press
ISBN 0596009097

Reviewed by Steven Mullins-HuNTUG member

75 ways to improve your C# and VB.Net programs
Thank you for letting me know I was not just going crazy thinking things were not working properly for me.
This whole book is for those of us that find things that we can never get to work and now the truth is out. They really don't work. I started this by reading the compiler gotchas and that made me feel a lot better. Being new to the visual studio environment I was very unsure of my code writing since the last time I had to write code we were using simple VB ver.4 scripting so I was not very sure of what I was doing.
This book is full of code and talks through the issues and covers things very well. This book stays next to my Visual Studio Developers Notebook.

I would give The .NET Gotchas a 5 star rating that book was a god send.

There are very few programming books that gives you a sense of "Oh Really ?" after reading them and this is definitely one of those. First of all, be aware that the intended audience for this book is definitely VB.net or C# programmers with experience. If you're a newbie to .Net, then you need to know some stuff before opening this book and therfore it would not be a good value addition for newbies.

Okay, I read only Chapter-5 (Garbage Collection Gotchas) in this book so far but from just reading that chapter alone, I got the sense of "Oh Really !". Rarely do you see Garbage Collection discussed in such detail in .Net books, but it is a class act in this book. The concept or Gotcha is explained very clearly without any typos and the code is presented in the book in both VB & C#. Therefore, it is highly useful for both the audience (VB & C#) and also it gives you a sense of what is possible or not-possible in the other language. For example, C# uses ~ for destructor whereas in VB you have to explicitly code the Finalize method. Also, there is no equivalent of "using" in VB although .Net 2.0 introduces it in VB. As far as Chapter-5 is concerned, I had to read the gotchas in order since they kind of build up on the previous one. But, Iam really hoping that I can just read the other Gotchas in no particular order.

To Summarize

PRO'S :
* Code presented in both VB & C#
* No typos or obvious errors (atleast in Chapter-5)
* Great value addition even if you are just curious and have only a limited time
* Gives you a sense of what the other language has or lacks
* .Net 2.0 enhancements mentioned alongside so that you know what's coming in the new version

CONS :
* Really can't think of any unless there is some major conceptual error (I don't think there would be !)

BOTTOMLINE : A great value addition to the book collection of VB & C# programmers and an absolute MUST-HAVE !

This book assumes some knowledge with the .NET framework but I think it's approachable to the beginner. Venkat discusses the material in a clear concise manner and even manages to throw in a few jokes for good measure. I have read most of "Effective C#" but prefer this one because of the immediate usefulness of his examples. (or maybe it's the 25 more examples? :)) Having any "effective" type book on .NET REQUIRES part of it devoted to Threading. I would have liked to see more on this topic. It's an easy thing to do but a very hard thing to get right (not to mention debug).

One of my favorite parts is where Venkat tied in some of his agile experience into the examples. Maybe his new book is going to have a chapter on agile gotchas!? More Agile Development pitfalls would have been nice too!


This book belongs on the reference shelf within easy reach. It's a book from an experience expert that manages to reach beginners and experts alike.

I like the format of this book. A short title is given, then some explanation and some code examples, then a nutshell summary of the problem. In this case the vignettes are always stated as problems, which gives the book a negative feel. But that's ok, since it's 'gotchas', right?

But enough about form. It's about the content. And the content here is up to snuff. An awful lot of time is spent on interop, which is appropriate. And some strategies are provided that will help you build classes that work well across COM. This implies, at least to me, that the book is well researched and I think it is.

The writing is good, if just a little dry. The code is hilighted to make it easier to read. And code samples are provided both in VB and C#. Definitely worth a look if you job involves writing components that need to work across languages.

At my work, we have a pretty rigorous application process. Once of the most difficult aspects of our application process is the series of very difficult .NET questions, which determine the applicant's understanding of C# and the .NET CLR. If you read this book before taking our .NET test, not only will you pass, but you'll probably be able to put some of the testers to shame. This is one of the best books I've read on the "under the hood" aspects of the CLR.

This book is filled with tips (e.g. gotcha #12 - compiler warnings may not be benign), which are then followed by an explanation of what the problem is, and how it can be resolved. In the example above, the author describes how .NET will allow you to do things that you probably shouldn't be allowed to do. In this particular example, the programmer used "=" instead of "==", and failed to mark a method in a derived class with the "override" keyword. This book also does an excellent job describing some of the differences between C# and VB.NET. For example, the author illustrates that the sequence of initialization is not the same between the two languages.

In terms of organization, when the author identifies a "gotcha", there is a clear code example provided that exploits the problem. The author even displays a large "X" next to the code, so you know not to use it. After discussing how to resolve the problem, the author usually provides code that is safe to use (which is identified with a large check mark next to it).

Without a doubt, this is the best book I have read on the subject of things to look out for in the .NET framework. The issues discussed in this book should be known by every .NET developer. At least read the book before your next job interview.

.NET Gotchas is one of those books that points out the subtle details of the .NET framework that you may have missed when reading the product documentation. Not only are pitfalls and best practices exposed, but the author's treatment of the framework "gotchas" proves to be, at times, a pragmatic look at object oriented programming.

To get the most value out of this book, you should be knowledgeable of .NET terminology and C# or Visual Basic.NET. All of the sample code and examples are presented in these two languages. Even though this book is a reference format, the author's writing style is conversational, which I appreciated.

I have not had a lot of experience with .NET development, and I therefore found a majority of the topics very useful. There are some "gotchas" for the completely uninitiated, such as "String concatenation is expensive" and "Typeless ArrayList isn't type-safe". Experienced framework developers will likely get more value from this text as a memory mnemonic.

Overall, there is content in here for a wide variety of developer types, however, the majority of the content will be of use to those, like myself, that are relatively new to the framework. I believe that having this reference on hand will save most developers a lot of grief and trips to the message boards.