- Shopping Bag ( 0 items )
Posted November 14, 2005
Are you among the many programmers who have come to appreciate how powerful Microsoft's .NET Framework can be as a platform for development? If you do, this book is for you! Author Venkat Subramaniam, has done an outstanding job of writing a great book that shares his .NET experiences with developers, to help them avoid the gotchas! Subramaniam begins by discussing the features in the CLR and the Framework that can impact the behavior and performance of your application. Next, the author focuses on Visual Studio- and compiler-related gotchas. Then, he delves into gotchas at the language and API level of the .NET platform. The author continues by discussing the issues of language operability gotchas. In addition, the author next focuses on concerns related to garbage collection, and how to write code that handles it effectively. He also discusses, the things you need to be aware of in the areas of inheritance and polymorphism so you can make the best use of these important concepts. Next, the author addresses the general problems with threading, the thread pool, asynchronous calls using delegates, and threading problems related to Windows Forms and Web Services. Finally, he focuses on details you should be aware of to make interoperability work for you. With the preceding in mind, the author has also done an excellent job of writing a book that focuses on the .NET Framework and language features that have consistently exhibited behavior that is not obvious to the programmer. So, why should you be interested in learning about these unexpected features? Because, knowning these little gotchas will help you avoid mistakes!Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.
Posted August 14, 2005
Want to really understand .NET?
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.Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.
Posted June 6, 2005
A nice, random access book on C# and VB.NET programming. You are expected to know the rudiments of at least one of these languages. It might be worthwhile to have this book around, as a possible quick time saver, if you're debugging. Looking over the gotchas, one sees how the ambitious scope of .NET has sometimes caused problems. In any given language, you know that certain names cannot be used for variables or classes, because they are reserved keywords. But .NET lets you mix source code from different languages. If you do this, the reserved keywords in C#, say, effectively expand to include keywords in those other languages. Something you never had to worry about before. Another gotch arises due to arrays. In C#, the array size is one more than the maximum allowed index. In VB, the array is made with that maximum value. Inconsistent. The book has other items that are more intricate. Some of these might be new to you.Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.