Synopses & Reviews
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.
.NET programming pitfalls, and how to avoid them
About the Author
Dr. Venkat Subramaniam (firstname.lastname@example.org) 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.
Table of Contents
Dedication; Preface; Who This Book Is For; What You Need to Use This Book; Measure of Performance; Conventions Used in This Book; Using Code Examples; Comments and Questions; Safari® Enabled; Acknowledgments; Chapter 1: CLR/Framework Gotchas; 1.1 GOTCHA #1 Type alias size doesn't match what you're familiar with; 1.2 GOTCHA #2 struct and class differ in behavior; 1.3 GOTCHA #3 Returning value types from a method/property is risky; 1.4 GOTCHA #4 You can't force calls to your value-type constructors; 1.5 GOTCHA #5 String concatenation is expensive; 1.6 GOTCHA #6 Exceptions may go unhandled; 1.7 GOTCHA #7 Uninitialized event handlers aren't treated gracefully; 1.8 GOTCHA #8 Division operation isn't consistent between types; 1.9 GOTCHA #9 Typeless ArrayList isn't type-safe; 1.10 GOTCHA #10 Type.GetType() may not locate all types; 1.11 GOTCHA #11 Public key reported by sn.exe is inconsistent; Chapter 2: Visual Studio and Compiler Gotchas; 2.1 GOTCHA #12 Compiler warnings may not be benign; 2.2 GOTCHA #13 Ordering of catch processing isn't consist across languages; 2.3 GOTCHA #14 Type.GetType() might fail at run-time; 2.4 GOTCHA #15 rethrow isn't consistent; 2.5 GOTCHA #16 Default of Option Strict (off) isn't good; 2.6 GOTCHA #17 Versioning may lead to Serialization headaches; 2.7 GOTCHA #18 Creating Web apps can be painful; 2.8 GOTCHA #19 Naming XML documentation for IntelliSense support isn't intuitive; Chapter 3: Language and API Gotchas; 3.1 GOTCHA #20 Singleton isn't guaranteed process-wide; 3.2 GOTCHA #21 Default performance of Data.ReadXMLData.ReadXMLData.ReadXML; 3.3 GOTCHA #22 enum lacks type-safety; 3.4 GOTCHA #23 Copy Constructor hampers exensibility; 3.5 GOTCHA #24 Clone() has limitations; 3.6 GOTCHA #25 Access to static/SharedC#code examplesShared members isn't enforced consistently; 3.7 GOTCHA #26 Details of exception may be hidden; 3.8 GOTCHA #27 Object initialization sequence isn't consistent; 3.9 GOTCHA #28 Polymorphism kicks in prematurely; 3.10 GOTCHA #29 Unit testing private methodstesting private methodstesting private methods; Chapter 4: Language Interoperability Gotchas; 4.1 GOTCHA #30 Common Language Specification Compliance isn't the default; 4.2 GOTCHA #31 Optional parameters break interoperability; 4.3 GOTCHA #32 Mixing case between class members breaks interoperability; 4.4 GOTCHA #33 Name collision with keywords breaks interoperability; 4.5 GOTCHA #34 Defining an array isn't consistent; Chapter 5: Garbage Collection Gotchas; 5.1 GOTCHA #35 Writing Finalize() is rarely a good idea; 5.2 GOTCHA #36 Releasing managed resources in Finalize() can wreak havoc; 5.3 GOTCHA #37 Rules to invoke base.Finalize() aren't consistent; 5.4 GOTCHA #38 Depending on Finalize() can tie up critical resources; 5.5 GOTCHA #39 Using Finalize() on disposed objects is costly; 5.6 GOTCHA #40 Implementing IDisposable isn't enough; 5.7 GOTCHA #41 Using the Dispose Design Pattern doesn't guarantee cleanup; Chapter 6: Inheritance and Polymorphism Gotchas; 6.1 GOTCHA #42 Runtime Type Identification can hurt extensibility; 6.2 GOTCHA #43 Using new/shadows causes "hideous hiding"; 6.3 GOTCHA #44 Compilers are lenient toward forgotten override/overrides; 6.4 GOTCHA #45 Compilers lean toward hiding virtual methods; 6.5 GOTCHA #46 Exception handling can break polymorphism; 6.6 GOTCHA #47 Signature mismatches can lead to method hiding; Chapter 7: Multithreading Gotchas; 7.1 GOTCHA #48 The Thread classThread classThread class; 7.2 GOTCHA #49 Foreground threads may prevent a program from terminating; 7.3 GOTCHA #50 Background threads don't terminate gracefully; 7.4 GOTCHA #51 Interrupt () kicks in only when a thread is blocked; 7.5 GOTCHA #52 ThreadAbortException--a hot potato; 7.6 GOTCHA #53 Environment.Exit() brings down the CLR; 7.7 GOTCHA #54 ResetAbort() may lead to surprises; 7.8 GOTCHA #55 Abort() takes time to clean up; 7.9 GOTCHA #56 Calling Type.GetType() may not return what you expect; 7.10 GOTCHA #57 Locking on globally visible objects is too sweeping; 7.11 GOTCHA #58 Threads from the thread pool are scarce; 7.12 GOTCHA #59 Threads invoked using delegates behave like background threads; 7.13 GOTCHA #60 Passing parametersthreadsparameters to threads is tricky; 7.14 GOTCHA #61 Exceptions thrown from threads in the pool are lostexceptionslost; 7.15 GOTCHA #62 Accessing WinForm controls from arbitrary threads is dangerous; 7.16 GOTCHA #63 Web-service proxy may fail when used for multiple asynchronous calls; 7.17 GOTCHA #64 Raising events lacks thread-safety; Chapter 8: COM-Interop and Enterprise Services Gotchas; 8.1 GOTCHA #65 Release of COM object is confusing; 8.2 GOTCHA #66 Using interface pointers after calling ReleaseComObject() will fail; 8.3 GOTCHA #67 Cross-apartment calls are expensive; 8.4 GOTCHA #68 Default apartment of main thread is inconsistent across languages; 8.5 GOTCHA #69 STAThread attribute may have no effect on your methods; 8.6 GOTCHA #70 Spattering access to COM components makes code hard to maintain; 8.7 GOTCHA #71 Auto-generatingGUIDgenerating GUID for your classes leads to versioning woes; 8.8 GOTCHA #72 All but one of the ClassInterface options are ineffective; 8.9 GOTCHA #73 Simply tur ning the switch for COM interop is dangerous; 8.10 GOTCHA #74 ServicedComponents implemented inconsistently on XP and 2003; 8.11 GOTCHA #75 AutoComplete comes with undesirable side effects; Resources; Bibliography; On the Web; Colophon;