Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Książki \ Programowanie \ .NET

.NET Gotchas Język: 2


Cena Brutto: 176.09

Cena netto: 167.70

Wersja: Drukowana
Autor Venkat Subramaniam
Liczba_stron 396
Wydawnictwo OReilly Media
Data_Wydania 2005-05-24
Poziom All Levels

Informacje podstawowe:

  • Wydawnictwo: O'Reilly Media
  • Data wydania: 24 maja 2005
  • Liczba stron: 396
  • Autor/autorzy:
    • Venkat Subramaniam


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.

O autorze/autorach:

Venkat Subramaniam

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.

View Venkat Subramaniam's full profile page.

Zawartość (spis treści):

  1. Chapter 1 CLR/Framework Gotchas

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

    1. GOTCHA #12 Compiler warnings may not be benign
    2. GOTCHA #13 Ordering of catch processing isn't consist across languages
    3. GOTCHA #14 Type.GetType() might fail at run-time
    4. GOTCHA #15 rethrow isn't consistent
    5. GOTCHA #16 Default of Option Strict (off) isn't good
    6. GOTCHA #17 Versioning may lead to Serialization headaches
    7. GOTCHA #18 Creating Web apps can be painful
    8. GOTCHA #19 Naming XML documentation for IntelliSense support isn't intuitive
  3. Chapter 3 Language and API Gotchas

    1. GOTCHA #20 Singleton isn't guaranteed process-wide
    2. GOTCHA #21 Default performance of Data.ReadXMLData.ReadXMLData.ReadXML
    3. GOTCHA #22 enum lacks type-safety
    4. GOTCHA #23 Copy Constructor hampers exensibility
    5. GOTCHA #24 Clone() has limitations
    6. GOTCHA #25 Access to static/SharedC#code examplesShared members isn't enforced consistently
    7. GOTCHA #26 Details of exception may be hidden
    8. GOTCHA #27 Object initialization sequence isn't consistent
    9. GOTCHA #28 Polymorphism kicks in prematurely
    10. GOTCHA #29 Unit testing private methodstesting private methodstesting private methods
  4. Chapter 4 Language Interoperability Gotchas

    1. GOTCHA #30 Common Language Specification Compliance isn't the default
    2. GOTCHA #31 Optional parameters break interoperability
    3. GOTCHA #32 Mixing case between class members breaks interoperability
    4. GOTCHA #33 Name collision with keywords breaks interoperability
    5. GOTCHA #34 Defining an array isn't consistent
  5. Chapter 5 Garbage Collection Gotchas

    1. GOTCHA #35 Writing Finalize() is rarely a good idea
    2. GOTCHA #36 Releasing managed resources in Finalize() can wreak havoc
    3. GOTCHA #37 Rules to invoke base.Finalize() aren't consistent
    4. GOTCHA #38 Depending on Finalize() can tie up critical resources
    5. GOTCHA #39 Using Finalize() on disposed objects is costly
    6. GOTCHA #40 Implementing IDisposable isn't enough
    7. GOTCHA #41 Using the Dispose Design Pattern doesn't guarantee cleanup
  6. Chapter 6 Inheritance and Polymorphism Gotchas

    1. GOTCHA #42 Runtime Type Identification can hurt extensibility
    2. GOTCHA #43 Using new/shadows causes "hideous hiding"
    3. GOTCHA #44 Compilers are lenient toward forgotten override/overrides
    4. GOTCHA #45 Compilers lean toward hiding virtual methods
    5. GOTCHA #46 Exception handling can break polymorphism
    6. GOTCHA #47 Signature mismatches can lead to method hiding
  7. Chapter 7 Multithreading Gotchas

    1. GOTCHA #48 The Thread classThread classThread class
    2. GOTCHA #49 Foreground threads may prevent a program from terminating
    3. GOTCHA #50 Background threads don't terminate gracefully
    4. GOTCHA #51 Interrupt () kicks in only when a thread is blocked
    5. GOTCHA #52 ThreadAbortException—a hot potato
    6. GOTCHA #53 Environment.Exit() brings down the CLR
    7. GOTCHA #54 ResetAbort() may lead to surprises
    8. GOTCHA #55 Abort() takes time to clean up
    9. GOTCHA #56 Calling Type.GetType() may not return what you expect
    10. GOTCHA #57 Locking on globally visible objects is too sweeping
    11. GOTCHA #58 Threads from the thread pool are scarce
    12. GOTCHA #59 Threads invoked using delegates behave like background threads
    13. GOTCHA #60 Passing parametersthreadsparameters to threads is tricky
    14. GOTCHA #61 Exceptions thrown from threads in the pool are lostexceptionslost
    15. GOTCHA #62 Accessing WinForm controls from arbitrary threads is dangerous
    16. GOTCHA #63 Web-service proxy may fail when used for multiple asynchronous calls
    17. GOTCHA #64 Raising events lacks thread-safety
  8. Chapter 8 COM-Interop and Enterprise Services Gotchas

    1. GOTCHA #65 Release of COM object is confusing
    2. GOTCHA #66 Using interface pointers after calling ReleaseComObject() will fail
    3. GOTCHA #67 Cross-apartment calls are expensive
    4. GOTCHA #68 Default apartment of main thread is inconsistent across languages
    5. GOTCHA #69 STAThread attribute may have no effect on your methods
    6. GOTCHA #70 Spattering access to COM components makes code hard to maintain
    7. GOTCHA #71 Auto-generatingGUIDgenerating GUID for your classes leads to versioning woes
    8. GOTCHA #72 All but one of the ClassInterface options are ineffective
    9. GOTCHA #73 Simply tur ning the switch for COM interop is dangerous
    10. GOTCHA #74 ServicedComponents implemented inconsistently on XP and 2003
    11. GOTCHA #75 AutoComplete comes with undesirable side effects
  1. Appendix A Resources

    1. Bibliography
    2. On the Web
  2. Colophon

Produkty Podobne
Programuj z .NET. Praktyka ponad teorią
Zaawansowane zarządzanie pamięcią w .NET: Lepszy kod, wydajność i skalowalność
Tajniki C# i .NET Framework. Wydajne aplikacje dzięki zaawansowanym funkcjom języka C# i architektury .NET
AngularJS for .NET Developers in 24 Hours, Sams Teach Yourself
Microsoft .NET: Architecting Applications for the Enterprise, 2nd Edition
Visual Studio 2012 i .NET 4.5. Poradnik dla zaawansowanych programistów
Język C# 2010 i platforma .NET 4.0
Programming ASP.NET MVC 4
Podstawy Windows Phone 7.5. Projektowanie aplikacji przy użyciu Silverlight
XAML Developer Reference
Więcej produktów