.NET Gotchas: 75 Ways to Improve Your C# and VB.NET Programs 1st Edition, Kindle Edition

by Venkat Subramaniam (Author) Format: Kindle Edition

16 ratings

Flip to back Flip to front

Audible Sample Playing... Paused You are listening to a sample of the Audible narration for this Kindle book.
Learn more

ISBN-13: 978-0596009090

ISBN-10: 0596009097

Why is ISBN important?

Share <Embed>

Other Sellers

from

Other Sellers

See all 2 versions

Buy

$31.99

eBook features:

Highlight, take notes, and search in the book
Length: 396 pages
Enhanced Typesetting: Enabled
Page Flip: Enabled

Read with the free Kindle apps (available on iOS, Android, PC & Mac), Kindle E-readers and on Fire Tablet devices. See all supported devices

Sold by: Amazon.com Services LLC

Print List Price: $39.95 Save $7.96 (20%)‎

Enter a promotion code or Gift Card

Like most complex tasks, .NET programming is fraught with potential costly, and time-consuming hazards. The millions of Microsoft developers worldwide who create applications for the .NET platform can attest to that. Thankfully there's now a book that shows you how to avoid such costly and time-consuming mistakes. It's called .NET Gotchas.The ultimate guide for efficient, pain-free coding, .NET Gotchas from O'Reilly contains 75 common .NET programming pitfalls--and advice on how to work around them. It will help you steer away from those mistakes that cause application performance problems, or so taint code that it just doesn't work right.The book is organized into nine chapters, each focusing on those features and constructs of the .NET platform that consistently baffle developers. Within each chapter are several "gotchas," with detailed examples, discussions, and guidelines for avoiding them. No doubt about it, when applied, these concise presentations of best practices will help you lead a more productive, stress-free existence.What's more, because code examples are written in both VB.NET and C#, .NET Gotchas is of interest to more than 75 percent of the growing numbers of .NET programmers. So if you're a .NET developer who's mired in the trenches and yearning for a better way, this book is most definitely for you.

Create your FREE Amazon Business account to save up to 10% with Business-only prices and free shipping. Register today

Editorial Reviews

About the Author

Dr. Venkat Subramaniam (venkats@agiledeveloper.com) is the founder of Agile Developer, Inc. (a software training, mentoring and development firm), and a co-founder of DuraSoft. Working with .NET since its Beta 2 pre-release, he's used the platform extensively on commercial projects for his clients. Venkat offers several courses on developing applications using .NET, and has trained and mentored more than 3,000 software developers in the US and Europe. A frequent speaker at software development conferences, he is also an adjunct professor for the practice of computer science at University of Houston, and teaches at Rice University's School for Continuing Studies. Venkat holds a BS in Computer Engineering, an MS in Electrical Engineering, and PhD in Computer Science. He is recipient of the 2004 UH Computer Science Department Teaching Excellence award.

--This text refers to an alternate kindle_edition edition.

Product details

ASIN ‏ : ‎ B00AHNRVEI
Publisher ‏ : ‎ O'Reilly Media; 1st edition (May 24, 2005)
Publication date ‏ : ‎ May 24, 2005
Language ‏ : ‎ English
File size ‏ : ‎ 5605 KB
Simultaneous device usage ‏ : ‎ Unlimited
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 396 pages
Lending ‏ : ‎ Not Enabled

Customer Reviews:
16 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.

Venkat Subramaniam

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Dr. Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects. He is a frequent invited speaker at international software conferences and user groups. He's author of .NET Gotchas (O'Reilly), coauthor of the 2007 Jolt Productivity award-winning book Practices of an Agile Developer (Pragmatic Bookshelf),

and author of Programming Groovy (Pragmatic Bookshelf).

Customer reviews

5 star		28%
4 star		18%
3 star		18%
2 star		18%
1 star		18%

How customer reviews and ratings work

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Raja K

Absolute MUST-HAVE for BOTH VB & C# Programmers !

Reviewed in the United States on July 7, 2005

Verified Purchase

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 !

4 people found this helpful

Helpful

Want to really understand .NET?

Reviewed in the United States on August 14, 2005

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.

5 people found this helpful

Helpful

Robert Stinnett

Watch out for that pitfall!

Reviewed in the United States on June 5, 2005

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.