среда, 29 сентября 2010, Александр Краковецкий

По сложившейся хорошей традиции продолжаем публикацию обзоров интересных и полезных книг. Сегодня поговорим о книге издательства O'Reilly - ".NET Gotchas", автор - Venkat Subramaniam.

"Gotcha" пошло от выражения "I got cha", что может быть переведено как "подловил!" или "попался!". 

Как уже понятно из названия, в книге описаны "скользкие" места, с которыми может столкнуться разработчик в процессе разработки программного обеспечения на платформе .NET с использованием языков C# и VB.NET.

Отдельно необходимо обратить внимание на тот факт, что в книге детально описаны отличия между C# и VB.NET. Эти отличия могут приводить к тому, что один и тот же код, написанный с использованием разных языков, может выдавать различный MSIL код и, соответственно, различные результаты при выполнении.

Некоторые советы достаточно известны, другие заставляют лишний раз пересмотреть написанный код. Например, в этой книге описано:

• различия в поведении классов и структур
• почему структуры не могут иметь непараметрические конструкторы
• почем нужно использовать StringBuilder при конкатенации строк
• когда деление на нуль не выдает исключение
• почему Type.GetType() может причинить вам много головной боли
• почему важно читать warnings компилятора
• что singleton уникальный лишь в рамках одного AppDomain
• как и зачем можно (нужно) использовать имена переменных вида @name
• зачем нужен Finalize() и когда его лучше не применять
• и др.

Книга содержит несколько разделов. Ниже приведу оглавление:

Chapter 1. CLR/Framework Gotchas

• Section 1.1. GOTCHA #1 Type alias size doesn't match what you're familiar with
• Section 1.2. GOTCHA #2 struct and class differ in behavior
• Section 1.3. GOTCHA #3 Returning value types from a method/property is risky
• Section 1.4. GOTCHA #4 You can't force calls to your value-type constructors
• Section 1.5. GOTCHA #5 String concatenation is expensive
• Section 1.6. GOTCHA #6 Exceptions may go unhandled
• Section 1.7. GOTCHA #7 Uninitialized event handlers aren't treated gracefully
• Section 1.8. GOTCHA #8 Division operation isn't consistent between types
• Section 1.9. GOTCHA #9 Typeless ArrayList isn't type-safe
• Section 1.10. GOTCHA #10 Type.GetType() may not locate all types
• Section 1.11. GOTCHA #11 Public key reported by sn.exe is inconsistent

• Section 2.1. GOTCHA #12 Compiler warnings may not be benign
• Section 2.2. GOTCHA #13 Ordering of catch processing isn't consist across languages
• Section 2.3. GOTCHA #14 Type.GetType() might fail at run-time
• Section 2.4. GOTCHA #15 rethrow isn't consistent
• Section 2.5. GOTCHA #16 Default of Option Strict (off) isn't good
• Section 2.6. GOTCHA #17 Versioning may lead to Serialization headaches
• Section 2.7. GOTCHA #18 Creating Web apps can be painful
• Section 2.8. GOTCHA #19 Naming XML documentation for IntelliSense support isn't intuitive

• Section 3.1. GOTCHA #20 Singleton isn't guaranteed process-wide
• Section 3.2. GOTCHA #21 Default performance of Data.ReadXMLData.ReadXML
• Section 3.3. GOTCHA #22 enum lacks type-safety
• Section 3.4. GOTCHA #23 Copy Constructor hampers exensibility
• Section 3.5. GOTCHA #24 Clone() has limitations
• Section 3.6. GOTCHA #25 Access to static/Shared members isn't enforced consistently
• Section 3.7. GOTCHA #26 Details of exception may be hidden
• Section 3.8. GOTCHA #27 Object initialization sequence isn't consistent
• Section 3.9. GOTCHA #28 Polymorphism kicks in prematurely
• Section 3.10. GOTCHA #29 Unit testing private methodstesting private methods

Chapter 4. Language Interoperability Gotchas

• Section 4.1. GOTCHA #30 Common Language Specification Compliance isn't the default
• Section 4.2. GOTCHA #31 Optional parameters break interoperability
• Section 4.3. GOTCHA #32 Mixing case between class members breaks interoperability
• Section 4.4. GOTCHA #33 Name collision with keywords breaks interoperability
• Section 4.5. GOTCHA #34 Defining an array isn't consistent

• Section 5.1. GOTCHA #35 Writing Finalize() is rarely a good idea
• Section 5.2. GOTCHA #36 Releasing managed resources in Finalize( ) can wreak havoc
• Section 5.3. GOTCHA #37 Rules to invoke base.Finalize() aren't consistent
• Section 5.4. GOTCHA #38 Depending on Finalize() can tie up critical resources
• Section 5.5. GOTCHA #39 Using Finalize() on disposed objects is costly
• Section 5.6. GOTCHA #40 Implementing IDisposable isn't enough
• Section 5.7. GOTCHA #41 Using the Dispose Design Pattern doesn't guarantee cleanup

• Section 6.1. GOTCHA #42 Runtime Type Identification can hurt extensibility
• Section 6.2. GOTCHA #43 Using new/shadows causes "hideous hiding"
• Section 6.3. GOTCHA #44 Compilers are lenient toward forgotten override/overrides
• Section 6.4. GOTCHA #45 Compilers lean toward hiding virtual methods
• Section 6.5. GOTCHA #46 Exception handling can break polymorphism
• Section 6.6. GOTCHA #47 Signature mismatches can lead to method hiding

• Section 7.1. GOTCHA #48 The Thread classThread class
• Section 7.2. GOTCHA #49 Foreground threads may prevent a program from terminating
• Section 7.3. GOTCHA #50 Background threads don't terminate gracefully
• Section 7.4. GOTCHA #51 Interrupt () kicks in only when a thread is blocked
• Section 7.5. GOTCHA #52 ThreadAbortException—a hot potato
• Section 7.6. GOTCHA #53 Environment.Exit() brings down the CLR
• Section 7.7. GOTCHA #54 ResetAbort() may lead to surprises
• Section 7.8. GOTCHA #55 Abort() takes time to clean up
• Section 7.9. GOTCHA #56 Calling Type.GetType() may not return what you expect
• Section 7.10. GOTCHA #57 Locking on globally visible objects is too sweeping
• Section 7.11. GOTCHA #58 Threads from the thread pool are scarce
• Section 7.12. GOTCHA #59 Threads invoked using delegates behave like background threads
• Section 7.13. GOTCHA #60 Passing parameters to threads is tricky
• Section 7.14. GOTCHA #61 Exceptions thrown from threads in the pool are lost
• Section 7.15. GOTCHA #62 Accessing WinForm controls from arbitrary threads is dangerous
• Section 7.16. GOTCHA #63 Web-service proxy may fail when used for multiple asynchronous calls
• Section 7.17. GOTCHA #64 Raising events lacks thread-safety

• Section 8.1. GOTCHA #65 Release of COM object is confusing
• Section 8.2. GOTCHA #66 Using interface pointers after calling ReleaseComObject() will fail
• Section 8.3. GOTCHA #67 Cross-apartment calls are expensive
• Section 8.4. GOTCHA #68 Default apartment of main thread is inconsistent across languages
• Section 8.5. GOTCHA #69 STAThread attribute may have no effect on your methods
• Section 8.6. GOTCHA #70 Spattering access to COM components makes code hard to maintain
• Section 8.7. GOTCHA #71 Auto-generating GUID for your classes leads to versioning woes
• Section 8.8. GOTCHA #72 All but one of the ClassInterface options are ineffective
• Section 8.9. GOTCHA #73 Simply tur ning the switch for COM interop is dangerous
• Section 8.10. GOTCHA #74 ServicedComponents implemented inconsistently on XP and 2003
• Section 8.11. GOTCHA #75 AutoComplete comes with undesirable side effects

В целом, нельзя сказать, что книгу должен прочитать каждый, но для расширения кругозора очень даже полезно. Я думаю, что по возможности буду переводить интересные готчи и публиковать их в блоге.

Скачать исходный код можно внизу страницы. Купить книгу можно на сайте издательства.

---