XML مؤثر: 50 روش خاص برای بهبود XML شما

Learning the fundamentals of XML might take a programmer a week. Learning how to use XML effectively might take a lifetime. While many books have been written that teach developers how to use the basic syntax of XML, this is the first one that really focuses on how to use XML well. This book is not a tutorial. It is not going to teach you what a tag is or how to write a DTD (Document Type Definition). Instead it's going to tell you when, why, where, and how to use such tools effectively (and equally important when not to use them).Since XML has become a fundamental underpinning of new software systems, it becomes important to ask new questions, not just what XML is, but how does one use it effectively? Which techniques work and which don't? Perhaps most importantly, which techniques appear to work at first but fail to scale as systems are further developed? This book answers these questions. It is not enough to write programs that compile and produce the expected results. It is important to write code that is extensible, legible, and maintainable. XML can be used to produce robust, extensible, maintainable systems. Contents......Page 10 List of Tables......Page 16 List of Figures......Page 18 Foreword......Page 24 Preface......Page 26 1.1 Software Quality......Page 32 1.1.1 Quality Through the Eyes of the User, the Builder, and the Manager......Page 33 1.1.2 Quality Attributes......Page 35 1.1.3 A World of Tensions......Page 38 1.2 How to Read This Book......Page 40 1.2.1 Typographical Conventions......Page 41 1.2.2 Diagrams......Page 42 1.2.4 Assembly Code......Page 44 1.2.7 Tools......Page 45 2.1 Input Problems......Page 48 2.2.1 Incomplete or Missing Output......Page 52 2.2.2 Correct Results at the Wrong Time......Page 54 2.2.3 Wrong Format......Page 55 2.3.1 Off-by-One Errors and Loop Iterations......Page 57 2.3.2 Neglected Extreme Conditions......Page 58 2.3.3 Forgotten Cases, Condition Tests, or Steps......Page 60 2.3.4 Missing Methods......Page 65 2.3.5 Unnecessary Functionality......Page 68 2.3.6 Misinterpretation......Page 71 2.4.1 Incorrect Algorithm or Computation......Page 73 2.4.2 Incorrect Operand in an Expression......Page 74 2.4.3 Incorrect Operator in an Expression......Page 78 2.4.4 Operator Precedence Problems......Page 79 2.4.5 Overflow, Underflow, and Sign Conversion-Errors......Page 80 2.5 Concurrency and Timing Problems......Page 82 2.6 Interface Problems......Page 87 2.6.1 Incorrect Routine or Arguments......Page 88 2.6.2 Failure to Test a Return Value......Page 90 2.6.3 Missing Error Detection or Recovery......Page 93 2.6.4 Resource Leaks......Page 96 2.6.5 Misuse of Object-Oriented Facilities......Page 99 2.7.1 Incorrect Data Initialization......Page 100 2.7.2 Referencing the Wrong Data Variable......Page 102 2.7.3 Out-of-Bounds References......Page 106 2.7.4 Incorrect Subscripting......Page 108 2.7.5 Incorrect Scaling or Data Units......Page 110 2.7.6 Incorrect Data Packing or Unpacking......Page 111 2.7.7 Inconsistent Data......Page 113 2.8.1 Management Strategy......Page 116 2.8.2 Redundancy in Space......Page 118 2.8.3 Redundancy in Time......Page 120 2.8.4 Recoverability......Page 121 3 Security......Page 132 3.1 Vulnerable Code......Page 133 3.2 The Buffer Overflow......Page 137 3.3 Race Conditions......Page 143 3.4.1 Functions Susceptible to Buffer Overflows......Page 146 3.4.2 Format String Vulnerabilities......Page 149 3.4.3 Path and Shell Metacharacter Vulnerabilities......Page 150 3.4.4 Temporary Files......Page 152 3.4.5 Functions Unsuitable for Cryptographic Use......Page 153 3.4.6 Forgeable Data......Page 155 3.5 Untrusted Input......Page 156 3.6 Result Verification......Page 162 3.7 Data and Privilege Leakage......Page 165 3.7.1 Data Leakage......Page 166 3.7.2 Privilege Leakage......Page 169 3.7.3 The Java Approach......Page 171 3.7.4 Isolating Privileged Code......Page 172 3.8 Trojan Horse......Page 174 3.9 Tools......Page 177 4 Time Performance......Page 182 4.1 Measurement Techniques......Page 187 4.1.1 Workload Characterization......Page 188 4.1.2 I/O-Bound Tasks......Page 189 4.1.3 Kernel-Bound Tasks......Page 192 4.1.4 CPU-Bound Tasks and Profiling Tools......Page 194 4.2 Algorithm Complexity......Page 204 4.3 Stand-Alone Code......Page 210 4.4 Interacting with the Operating System......Page 213 4.5 Interacting with Peripherals......Page 221 4.6 Involuntary Interactions......Page 222 4.7 Caching......Page 225 4.7.1 A Simple System Call Cache......Page 226 4.7.2 Replacement Strategies......Page 228 4.7.3 Precomputing Results......Page 230 5 Space Performance......Page 238 5.1.1 Basic Data Types......Page 240 5.1.2 Aggregate Data Types......Page 244 5.1.3 Alignment......Page 246 5.1.4 Objects......Page 253 5.2 Memory Organization......Page 258 5.3 Memory Hierarchies......Page 262 5.3.1 Main Memory and Its Caches......Page 263 5.3.2 Disk Cache and Banked Memory......Page 266 5.3.3 Swap Area and File-Based Disk Storage......Page 269 5.4.1 Memory Allocation......Page 270 5.4.3 Data Mapping......Page 272 5.4.4 Code Mapping......Page 273 5.4.6 Interprocess Communication......Page 275 5.5 Heap Memory Management......Page 277 5.5.1 Heap Fragmentation......Page 278 5.5.2 Heap Profiling......Page 285 5.5.3 Memory Leaks......Page 287 5.5.4 Garbage Collection......Page 293 5.6.1 The Stack Frame......Page 295 5.6.2 Stack Space......Page 300 5.7 Code......Page 305 5.7.1 Design Time......Page 307 5.7.2 Coding Time......Page 310 5.7.3 Build Time......Page 311 6 Portability......Page 320 6.1 Operating Systems......Page 321 6.2.1 Data Type Properties......Page 327 6.2.2 Data Storage......Page 329 6.2.3 Machine-Specific Code......Page 331 6.3.1 Compiler Bugs......Page 333 6.4 Graphical User Interfaces......Page 338 6.5.1 Character Sets......Page 340 6.5.2 Locale......Page 344 6.5.3 Messages......Page 347 7 Maintainability......Page 356 7.1 Measuring Maintainability......Page 357 7.1.1 The Maintainability Index......Page 358 7.1.2 Metrics for Object-Oriented Programs......Page 364 7.1.3 Dependency Metrics on Packages......Page 374 7.2 Analyzability......Page 382 7.2.1 Consistency......Page 384 7.2.2 Expression Formatting......Page 385 7.2.3 Statement Formatting......Page 387 7.2.4 Naming Conventions......Page 388 7.2.5 Statement-Level Comments......Page 391 7.2.6 Versioning Comments......Page 393 7.2.7 Visual Structure: Blocks and Indentation......Page 394 7.2.8 Length of Expressions, Functions, and Methods......Page 395 7.2.9 Control Structures......Page 399 7.2.10 Boolean Expressions......Page 403 7.2.11 Recognizability and Cohesion......Page 405 7.2.12 Dependencies and Coupling......Page 408 7.2.13 Code Block Comments......Page 420 7.2.14 Data Declaration Comments......Page 424 7.2.16 Locality of Dependencies......Page 425 7.2.17 Ambiguity......Page 427 7.2.18 Reviewability......Page 428 7.3.1 Identification......Page 434 7.3.2 Separation......Page 439 7.4 Stability......Page 449 7.4.1 Encapsulation and Data Hiding......Page 450 7.4.2 Data Abstraction......Page 454 7.4.3 Type Checking......Page 456 7.4.4 Compile-Time Assertions......Page 459 7.4.5 Runtime Checks and Inspection-Time Assertions......Page 462 7.5 Testability......Page 463 7.5.1 Unit Testing......Page 464 7.5.2 Integration Testing......Page 468 7.5.3 System Testing......Page 470 7.5.4 Test Coverage Analysis......Page 472 7.5.5 Incidental Testing......Page 475 7.6 Effects of the Development Environment......Page 482 7.6.1 Incremental Builds......Page 483 7.6.2 Tuning Build Performance......Page 485 8 Floating-Point Arithmetic......Page 496 8.1 Floating-Point Representation......Page 497 8.1.1 Measuring Error......Page 500 8.1.2 Rounding......Page 501 8.1.3 Memory Format......Page 503 8.1.5 Exponent Biasing......Page 505 8.1.7 Denormal Numbers......Page 506 8.1.8 Special Values......Page 507 8.2 Rounding......Page 509 8.3 Overflow......Page 512 8.4 Underflow......Page 514 8.5 Cancellation......Page 518 8.6 Absorption......Page 522 8.7 Invalid Operations......Page 526 A Source Code Credits......Page 534 Bibliography......Page 536 A......Page 554 C......Page 556 D......Page 560 E......Page 562 F......Page 564 G......Page 565 H......Page 566 I......Page 567 J......Page 569 L......Page 571 M......Page 573 O......Page 575 P......Page 576 Q......Page 578 R......Page 579 S......Page 580 T......Page 583 U......Page 585 W......Page 589 X......Page 591 Z......Page 592 C......Page 594 G......Page 595 L......Page 596 R......Page 597 W......Page 598 Z......Page 599 Annotation Learning the fundamentals of XML might take a programmer a week. Learning how to use XML effectively might take a lifetime. While many books have been written that teach developers how to use the basic syntax of XML, this is the first one that really focuses on how to use XML well. This book is not a tutorial. It is not going to teach you what a tag is or how to write a DTD. I assume you know these things. Instead it's going to tell you when, why, where, and how to use such tools effectively (and perhaps equally importantly when not to use them). This book derives directly from my own experiences teaching and writing about XML. Over the last five years. I've written several books and taught numerous introductory courses about XML syntax, APIs, and tools. Increasingly I'm finding that audiences are already familiar with the basics of XML. They know what a tag is, how to validate a document against a DTD, and how to transform a document with an XSLT style sheet. The question of what XML is and why to use it has been sufficiently well evangelized. The essential syntax and rules are reasonably well understood. However, although most developers know what a CDATA section is, they are not sure what to use one for. Although programmers know how to add attribute and child nodes to elements, they are not certain which one to use when. Since XML has become a fundamental underpinning of new software systems, it becomes important to begin asking new questions, not just what XML is, but how does one use it effectively? Which techniques work and which don't? Perhaps most importantly, which techniques appear to work at first but fail to scale as systems are further developed? When I teach programming at my university, one of the first things I tell my students is that it is not enough to write programs that compile and produce the expected results. It is as important (perhaps more important) to write code that is extensible, legible, and maintainable. XML can be used to produce robust, extensible, maintainable, comprehensible systems or it can be used to create masses of unmaintainable, illegible, fragile, closed code. In the immortal words of Eric Clapton, "It's in the way that you use it." XML is not a programming language. It is a markup language; but it is being successfully used by many programmers. There have been markup languages before, but in the developer community XML is far and away the most successful. However, the newness and unfamiliarity of markup languages have meant that many developers are using it less effectively than they could. Many programmers are hacking together systems that work, but are not as robust, extensible, or portable as XML promises. This is to be expected. Programmers working with XML are pioneers exploring new territory, opening up new vistas in software, and accomplishing things that could not easily be accomplished just a few years ago. However one definition of a pioneer is someone with an arrow in their back, and more than a few XML pioneers have returned from the frontier with arrows in their backs. Five years after the initial release of XML into the world, certain patterns and antipatterns for the proper design of XML applications are becoming apparent. All of us in the XML community have made mistakes while exploring this new territory, the author of this book prominently among them. However, we've learned from those mistakes, and we're beginning to develop some principles that may help those who follow in our footsteps to avoid making the same mistakes we did. It is time to put up some caution signs in the road. We may not exactly say "Here there be dragons", but we can at least say, "That road is a lot rockier than it looks at first glance, and you might really want to take this slightly less obvious but much smoother path off to the left." This book is divided into four parts beginning with the lowest layer of XML and gradually working up to the highest: Part I covers XML syntax, those aspects of XML that don't really affect the information content of an XML document, but may have large impacts on how easy or hard those documents are to edit and process. Part II looks at XML structures, the general organization and annotation of information in an XML document. Part III discusses the various techniques and APIs that are available for processing XML with languages such as C++, C#, Java, Python, and Perl and thus local semantics to the labeled structures of XML. Part IV explores effective techniques for systems built around XML documents, rather than looking at individual documents in isolation. Although, this is how I've organized the book, you should be able to begin reading at essentially any chapter. This book makes an excellent bathroom reader. :- ) You may wish to read the introduction first, which defines a number of key terms that are used throughout the book, and which are frequently misused or confused. However, after that feel free to pick and choose from the topics as your interest and needs dictate. I've made liberal use of cross-references to throughout to direct you along other paths through the book that may be of interest. I hope that this book is a beginning, not an end. It's still early in the life of XML, and much remains to be discovered and invented. You may well develop best practices of your own that are not mentioned here. If you do I'd love to hear about them. You may also take issue with some of the principles stated here. I'd like to hear about that too. Discussion of many of the guidelines identified here has taken place on the xml-dev mailing list, and seems likely to continue in the future. If you're interested in further discussion of the issues raised in this book, I recommend you subscribe and participate there. Complete details can be found at(http://lists.xml.org/) http://lists.xml.org/ . On the other hand, if you find out and out mistakes in this book (The ID attribute value on p. 87 is missing a closing quote. The word "Cat" is misspelled on p. 46.) you can write me directly at(mailto:elharo@metalab.unc.edu) elharo@metalab.unc.edu . I maintain a web page listing known errata for this book, as well as any updates at(http://www.cafeconleche.org/books/effectivexml/) http://www.cafeconleche.org/books/effectivexml/ . I hope this book makes your use of XML both more effective and more enjoyable. --Elliotte Rusty Harold (mailto:elharo@metalab.unc.edu) elharo@metalab.unc.edu Brooklyn NY April 22, 2003 0321150406P06062003

“shining A Bright Light Into Many Of The Dark Corners Of C# 3.0, This Book Not Only Covers The ‘how,’ But Also The ‘why,’ Arming The Reader With Many Field-tested Methods For Wringing The Most From The New Language Features, Such As Linq, Generics, And Multithreading. If You Are Serious About Developing With The C# Language, You Need This Book.”

–bill Craun, Principal Consultant, Ambassador Solutions, Inc.

“more Effective C# Is An Opportunity To Work Beside Bill Wagner. Bill Leverages His Knowledge Of C# And Distills His Expertise Down To Some Very Real Advice About Programming And Designing Applications That Every Serious Visual C# User Should Know. More Effective C# Is One Of Those Rare Books That Doesn’t Just Regurgitate Syntax, But Teaches You How To Use The C# Language.”

–peter Ritchie, Microsoft Mvp: Visual C#

“more Effective C# Is A Great Follow-up To Bill Wagner’s Previous Book. The Extensive

c# 3.0 And Linq Coverage Is Extremely Timely!”

–tomas Restrepo, Microsoft Mvp: Visual C++, .net, And Biztalk Server

“as One Of The Current Designers Of C#, It Is Rare That I Learn Something New About The Language By Reading A Book. More Effective C# Is A Notable Exception. Gently Blending Concrete Code And Deep Insights, Bill Wagner Frequently Makes Me Look At C# In A Fresh Light–one That Really Makes It Shine. More Effective C# Is At The Surface A Collection Of Very Useful Guidelines. Look Again. As You Read Through It, You’ll Find That You Acquire More Than Just The Individual Pieces Of Advice; Gradually You’ll Pick Up On An Approach Toprogramming In C# That Is Thoughtful, Beautiful, And Deeply Pleasant. While You Can Make Your Way Willy-nilly Through The Individual Guidelines, I Do Recommend Reading The Whole Book–or At Least Not Skipping Over The Chapter Introductions Before You Dive Into Specific Nuggets Of Advice. There’s Perspective And Insight To Be Found There That In Itself Can Be An Important Guide And Inspiration For Your Future Adventures In C#.”

–mads Torgersen, Program Manager, Visual C#, Microsoft

“bill Wagner Has Written An Excellent Book Outlining The Best Practices For Developers Who Work With The C# Language. By Authoring More Effective C#, He Has Again Established Himself As One Of The Most Important Voices In The C# Community. Many Of Us Already Know How To Use C#. What We Need Is Advice On How To Hone Our Skills So That We Can Become Wiser Programmers. There Is No More Sophisticated Source Of Information On How To Become A First-class C# Developer Than Bill Wagner’s Book. Bill Is Intelligent, Thoughtful, Experienced, And Skillful. By Applying The Lessons From This Book To Your Own Code, You Will Find Many Ways To Polish And Improve The Work That You Produce.”

–charlie Calvert, Community Program Manager, Visual C#, Microsoft

in More Effective C#, Microsoft C# Mvp And Regional Director Bill Wagner Introduces Fifty Brand-new Ways To Write More Efficient And More Robust Software. This All-new Book Follows The Same Format As Wagner’s Best-selling Effective C# (addison-wesley, 2005), Providing Clear, Practical Explanations, Expert Tips, And Plenty Of Realistic Code Examples.

wagner Shows How To Make The Most Of Powerful Innovations Built Into Microsoft’s New C# 3.0 And .net Framework 3.5, As Well As Advanced C# Language Capabilities Not Covered In His Previous Book. Drawing On His Unsurpassed C# Experience, The Author Reveals New Best Practices For Working With Linq, Generics, Metaprogramming, And Many Other Features. He Also Uncovers Practices That Compromise Performance Or Reliability And Shows Exactly How To Avoid Them.

more Effective C# Shows How To

• use Generics To Express Your Design Intent More Effectively

• master Advanced Generics Techniques, Such As Constraints, Method Constraints, And Generic Specialization

• use The Multithreaded Techniques You’ll Need To Work With The .net Framework Every Day

• express Modern Design Idioms Using The Rich Palette Of C# Language Features

• successfully Mix Object Oriented And Functional Programming Constructs

• create Composable Interfaces And Avoid Confusion In Public Interfaces

• use Extension Methods To Separate Contracts From Implementation

• program Successfully With C# Closures And Anonymous Types

• write More Effective Linq Queries

• make The Most Of Linq Lazy Evaluation Queries And Lambda Expressions

• distinguish And Convert Between Delegates And Expression Trees

• efficiently Utilize Nullable Types And Partial Classes

• use Implicit Properties For Mutable, Nonserializable Data

you’re Already A Successful C# Programmer–this Book Can Help You Become An Outstanding One.

Praise for Effective XML

“This is an excellent collection of XML best practices: essential reading for any developer using XML. This book will help you avoid common pitfalls and ensure your XML applications remain practical and interoperable for as long as possible.”

     —Edd Dumbill, Managing Editor, XML.com and Program Chair, XML Europe

“A collection of useful advice about XML and related technologies. Well worth reading both before, during, and after XML application development.”

     —Sean McGrath, CTO, Propylon

“A book on many best practices for XML that we have been eagerly waiting for.”

     —Akmal B. Chaudhri, Editor, IBM developerWorks

“The fifty easy-to-read items cover many aspects of XML, ranging from how to use markup effectively to what schema language is best for what task. Sometimes controversial, but always relevant, Elliotte Rusty Harold’s book provides best practices for working with XML that every user and implementer of XML should be aware of.”

     —Michael Rys, Ph.D., Program Manager, SQL Server XML Technologies, Microsoft Corporation

“Effective XML is an excellent book with perfect timing. Finally, an XML book everyone needs to read! Effective XML is a fount of XML best practices and solid advice. Whether you read Effective XML cover to cover or randomly one section at a time, its clear writing and insightful recommendations enlighten, entertain, educate, and ultimately improve the effectiveness of even the most expert XML developer. I’ll tell you what I tell all my coworkers and customers: You need this book.”

     —Michael Brundage, Technical Lead, XML Query Processing, Microsoft WebData XML Team

“This book provides great insight for all developers who write XML software, regardless of whether the software is a trivial application-specific XML processor or a fullblown W3C XML Schema Language validator. Mr. Harold covers everything from a very important high-level terminology discussion to details about parsed XML nodes. The well-researched comparisons of currently available XML-related software products, as well as the key criteria for selecting between XML technologies, exemplify the thoroughness of this book.”

     —Cliff Binstock, Author, The XML Schema Complete Reference

If you want to become a more effective XML developer, you need this book. You will learn which tools to use when in order to write legible, extensible, maintainable and robust XML code.

Page 36: How do you write DTDs that are independent of namespace prefixes? Page 82: What do parsers reliably report and what don't they? Page 130: Which schema language is the right one for your job? Page 178: Which API should you choose for maximum speed and minimum size? Page 257: What can you do to ensure fast, reliable access to DTDs and schemas without making your document less portable? Page 283: Is XML too verbose for your application?

Elliotte Rusty Harold provides you with 50 practical rules of thumb based on real-world examples and best practices. His engaging writing style is easy to understand and illustrates how you can save development time while improving your XML code. Learn to write XML that is easy to edit, simple to process, and is fully interoperable with other applications and code. Understand how to design and document XML vocabularies so they are both descriptive and extensible. After reading this book, you'll be ready to choose the best tools and APIs for both large-scale and small-scale processing jobs. Elliotte provides you with essential information on building services such as verification, compression, authentication, caching, and content management.

If you want to design, deploy, or build better systems that utilize XML—then buy this book and get going!

'This book really demonstrates Bill's strengths as a writer and programmer. In a very short amount of time, he is able to present an issue, fix it and conclude it; each chapter is tight, succinct, and to the point.'—Josh Holmes, Independent Contractor'The book provides a good introduction to the C# language elements from a pragmatic point of view, identifying best practices along the way, and following a clear and logical progression from the basic syntax to creating components to improving your code writing skills. Since each topic is covered in short entries, it is very easy to read and you'll quickly realize the benefits of the book.'—Tomas Restrepo, Microsoft MVP'The book covers the basics well, especially with respect to the decisions needed when deriving classes from System.Object. It is easy to read with examples that are clear, concise and solid. I think it will bring good value to most readers.'—Rob Steel, Central Region Integration COE & Lead Architect, Microsoft'Effective C# provides the C# developer with the tools they need to rapidly grow their experience in Visual C# 2003 while also providing insight into the many improvements to the language that will be hitting a desktop near you in the form of Visual C# 2005.'—Doug Holland, Precision Objects'Part of the point of the.NET Framework—and the C# Language, in particular—is to let the developer focus solving customer problems and deliver product, rather than spending hours (or even weeks) writing plumbing code. Bill Wagner's Effective C#, not only shows you what's going on behind the scenes, but shows you how to take advantage of particular C# code constructs. Written in a dispassionate style that focuses on the facts—and just the facts—of writing effective C# code, Wagner's book drills down into practices that will let you write C# applications and components that are easier to maintain as well as faster to run. I'm recommending Effective C# to all students of my.NET BootCamp and other C#-related courses.'—Richard Hale Shaw, www.RichardHaleShawGroup.com C#'s resemblances to C++, Java, and C make it easier to learn, but there's a downside: C# programmers often continue to use older techniques when far better alternatives are available. In Effective C#, respected.NET expert Bill Wagner identifies fifty ways you can start leveraging the full power of C# in order to write faster, more efficient, and more reliable software. Effective C# follows the format that made Effective C++ (Addison-Wesley, 1998) and Effective Java (Addison-Wesley, 2001) indispensable to hundreds of thousands of developers: clear, practical explanations, expert tips, and plenty of realistic code examples. Drawing on his unsurpassed C# experience, Wagner addresses everything from value types to assemblies, exceptions to reflection. Along the way, he shows exactly how to avoid dozens of common C# performance and reliability pitfalls. You'll learn how to: Use both types of C# constants for efficiency and maintainability, see item 2 Use immutable data types to eliminate unnecessary error checking, see item 7 Avoid the C# function that'll practically always get you in trouble, see item 10 Minimize garbage collection, boxing, and unboxing, see items 16 and 17 Take full advantage of interfaces and delegates, see items 19 though 2 "This book really demonstrates Bill's strengths as a writer and programmer. In a very short amount of time, he is able to present an issue, fix it and conclude it; each chapter is tight, succinct, and to the point."--Josh Holmes, Independent Contractor "The book provides a good introduction to the C# language elements from a pragmatic point of view, identifying best practices along the way, and following a clear and logical progression from the basic syntax to creating components to improving your code writing skills. Since each topic is covered in short entries, it is very easy to read and you'll quickly realize the benefits of the book." -Tomas Restrepo, Microsoft MVP "The book covers the basics well, especially with respect to the decisions needed when deriving classes from System. Object. It is easy to read with examples that are clear, concise and solid. I think it will bring good value to most readers." -Rob Steel, Central Region Integration COE & Lead Architect, Microsoft " Effective C# provides the C# developer with the tools they need to rapidly grow their experience in Visual C# 2003 while also providing insight into the many improvements to the language that will be hitting a desktop near you in the form of Visual C# 2005." -Doug Holland, Precision Objects "Part of the point of the .NET Framework-and the C# Language, in particular-is to let the developer focus solving customer problems and deliver product, rather than spending hours (or even weeks) writing plumbing code. Bill Wagner's Effective C#, not only shows you what's going on behind the scenes, but shows you how to take advantage of particular C# code constructs. Written in a dispassionate style that focuses on the facts-and just the facts-of writing effective C# code, Wagner's book drills down into practices that will let you write C# applications and components that are easier to maintain as well as faster to run. I'm recommending Effective C# to all students of my .NET BootCamp and other C#-related courses." -Richard Hale Shaw, www.RichardHaleShawGroup.com C#'s resemblances to C++, Java, and C make it easier to learn, but there's a downside: C# programmers often continue to use older techniques when far better alternatives are available. In Effective C#, respected .NET expert Bill Wagner identifies fifty ways you can start leveraging the full power of C# in order to write faster, more efficient, and more reliable software. Effective C# follows the format that made Effectiv .. "Shining a bright light into many of the dark corners of C# 3.0, this book not only covers the 'how, ' but also the 'why, ' arming the reader with many field-tested methods for wringing the most from the new language features, such as LINQ, generics, and multithreading. If you are serious about developing with the C# language, you need this book."--Bill Craun, Principal Consultant, Ambassador Solutions, Inc." More Effective C# is an opportunity to work beside Bill Wagner. Bill leverages his knowledge of C# and distills his expertise down to some very real advice about programming and designing applications that every serious Visual C# user should know. More Effective C# is one of those rare books that doesn't just regurgitate syntax, but teaches you how to use the C# language." -Peter Ritchie, Microsoft MVP: Visual C# " More Effective C# is a great follow-up to Bill Wagner's previous book. The extensive C# 3.0 and LINQ coverage is extremely timely!" -Tomas Restrepo, Microsoft MVP: Visual C++, .NET, and Biztalk Server "As one of the current designers of C#, it is rare that I learn something new about the language by reading a book. More Effective C# is a notable exception. Gently blending concrete code and deep insights, Bill Wagner frequently makes me look at C# in a fresh light-one that really makes it shine. More Effective C# is at the surface a collection of very useful guidelines. Look again. As you read through it, you'll find that you acquire more than just the individual pieces of advice; gradually you'll pick up on an approach to programming in C# that is thoughtful, beautiful, and deeply pleasant. While you can make your way willy-nilly through the individual guidelines, I do recommend reading the whole book-or at least not skipping over the chapter introductions before you dive into specific nuggets of advice. There's perspective and insight to be found there that in itself can be an important guide and inspiration for your future adventures in C#." -Mads Torgersen, Program Manager, Visual C#, Microsoft "Bill Wagner has written an excellent book outlining the best practices for developers who work with the C# language. By authoring More Effective C#, he has again established himself as one of the most important voices in the C# community. Many of us already know how to use C#. What we need is advice on how to hone our skills so that we can become wiser programmers. There is no more sophisticated source of information on how to become ..

C#'s resemblances to C++, Java, and C make it easier to learn, but there's a downside: C# programmers often continue to use older techniques when far better alternatives are available. In Effective C#, respected .NET expert Bill Wagner identifies fifty ways you can start leveraging the full power of C# in order to write faster, more efficient, and more reliable software.

Effective C# follows the format that made Effective C++ (Addison-Wesley, 1998) and Effective Java (Addison-Wesley, 2001) indispensable to hundreds of thousands of developers: clear, practical explanations, expert tips, and plenty of realistic code examples. Drawing on his unsurpassed C# experience, Wagner addresses everything from value types to assemblies, exceptions to reflection. Along the way, he shows exactly how to avoid dozens of common C# performance and reliability pitfalls. You'll learn how to:

• Use both types of C# constants for efficiency and maintainability, see item 2

• Use immutable data types to eliminate unnecessary error checking, see item 7

• Avoid the C# function that'll practically always get you in trouble, see item 10

• Minimize garbage collection, boxing, and unboxing, see items 16 and 17

• Take full advantage of interfaces and delegates, see items 19 though 22

• Create CLS compliant assemblies that use noncompliant C# language features, see item 30

• Improve reliability and maintainability by creating small, cohesive assemblies, see item 32

• Leverage the full power of .NET's runtime diagnostics, see item 36

• Know when—and when not—to use reflection, see items 42 and 43

• Preview the major enhancements in C# 2.0, see item 49

• You're already a successful C# programmer—this book can help you become an outstanding one.

Slashdot.org

If you're interested in, or currently working with, .NET and are tempted to skip past this book as Just Another C# Reference Book, think again. Wagner's book is a great resource because it covers concepts which run across the entire .NET Framework regardless of which language you're working with. ...The bottom line: this book really is a critical addition to a serious C# or .NET developer's bookshelf.

"With this book, Ted Neward helps you make the leap from being a good Java enterprise developer to a great developer!"
—John Crupi, Sun Distinguished Engineer coauthor, Core J2EE Patterns

If you want to build better Java enterprise applications and work more efficiently, look no further. Inside, you will find an accessible guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE) development. Learn how to:

• Use in-process or local storage to avoid the network, see item 44
• Set lower isolation levels for better transactional throughput, see item 35
• Use Web services for open integration, see item 22
• Consider your lookup carefully, see item 16
• Pre-generate content to minimize processing, see item 55
• Utilize role-based authorization, see item 63
• Be robust in the face of failure, see item 7
• Employ independent JREs for side-by-side versioning, see item 69

Ted Neward provides you with 75 easily digestible tips that will help you master J2EE development on a systemic and architectural level. His panoramic look at the good, the bad, and the ugly aspects of J2EE development will address your most pressing concerns. Learn how to design your enterprise systems so they adapt to future demands. Improve the efficiency of your code without compromising its correctness. Discover how to implement sophisticated functionality that is not directly supported by the language or platform. After reading Effective Enterprise Java, you will know how to design and implement better, more scalable enterprise-scope Java software systems.

Page 26: How can I avoid off-by-one errors? Page 143: Are Trojan Horse attacks for real? Page 158: Where should I look when my application can't handle its workload? Page 256: How can I detect memory leaks? Page 309: How do I target my application to international markets? Page 394: How should I name my code's identifiers? Page 441: How can I find and improve the code coverage of my tests? Diomidis Spinellis' first book, "Code Reading," showed programmers how to understand and modify key functional properties of software. " Code Quality " focuses on non-functional properties, demonstrating how to meet such critical requirements as reliability, security, portability, and maintainability, as well as efficiency in time and space. Spinellis draws on hundreds of examples from open source projects--such as the Apache web and application servers, the BSD Unix systems, and the HSQLDB Java database--to illustrate concepts and techniques that every professional software developer will be able to appreciate and apply immediately. Complete files for the open source code illustrated in this book are available online at: http: //(http://www.spinellis.gr/codequality/) www.spinellis.gr/codequality/ If you are a programmer, you need this book. You've got a day to add a new feature in a 34,000-line program: Where do you start? Page 333 How can you understand and simplify an inscrutable piece of code? Page 39 Where do you start when disentangling a complicated build process? Page 167 How do you comprehend code that appears to be doing five things in parallel? Page 132 You may read code because you have to--to fix it, inspect it, or improve it. You may read code the way an engineer examines a machine--to discover what makes it tick. Or you may read code because you are scavenging--looking for material to reuse. Code-reading requires its own set of skills, and the ability to determine which technique you use when is crucial. In this indispensable book, Diomidis Spinellis uses more than 600 real-world examples to show you how to identify good (and bad) code: how to read it, what to look for, and how to use this knowledge to improve your own code. Fact: If you make a habit of reading good code, you will write better code yourself. 0201799405B02032003 C# is the premier language for .NET development, and is currently the fastestgrowing programming language. It is already being used by 29% of professionalprogrammers, with that percentage expected to continue increasing rapidly. It isstill a relatively new language, however, and developers are still looking forresources to enable them to use it better. Effective C# covers C# from apractical perspective, and provides insight into using the language moreefficiently. The reader will get information based on years of practical C#experience in real world settings. The format of the book is the same that hasproven immensely popular in other books in Scott Meyers' series. The authorhas a devoted following from his regular C# columns in Visual StudioMagazine. Every serious C# developer will keep this book close at hand, toreturn to again and again for advice. Cd-rom Contains Cross-referenced Code. 1. Introduction -- 2. Basic Programming Elements -- 3. Advanced C Data Types -- 4. C Data Structures -- 5. Advanced Control Flow -- 6. Tackling Large Projects -- 7. Coding Standards And Conventions -- 8. Documentation -- 9. Architecture -- 10. Code-reading Tools -- 11. A Complete Example -- A. Outline Of The Code Provided -- B. Source Code Credits -- C. Referenced Source Files -- D. Source Code Licenses -- E. Maxims For Reading Code. Diomidis Spinellis. Includes Bibliographical References (p. 445-457) And Indexes. System Requirements For Accompanying Cd-rom: Operating System That Supports Cds With File Names Longer Than 8+3 Characters, Such As Windows 95 And Later Versions, Unix Systems Supporting The Rock Ridge Extensions, And Macintosh Systems Running Joliet Volume Access. This book is a unique and essential reference that focuses upon the reading and comprehension of existing software code. While code reading is an important task faced by the vast majority of students, it has been virtually ignored as a discipline by existing references. The book fills this need with a practical presentation of all important code concepts, form, structure, and syntax that a student is likely to encounter. The concepts are supported by examples taken from real-world open source software projects. The focus upon reading code (rather than developing and implementing programs from scratch) provides for a vastly increased breadth of coverage. "If you want to build better Java enterprise applications and work more efficiently, look no further. Inside, you will find an accessible guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE) development. Learn how to: use in-process or local storage to avoid the network; set lower isolation levels for better transactional throughput; use Web services for open integration; consider your lookup carefully; pre-generate content to minimize processing; utilize role-based authorization; be robust in the face of failure; and employ independent JREs for side-by-side versioning."--Jacket An authority on C# presents fifty specific, practical ways for developers to improve their C# programming skills, focusing on the features, tools, and applications of C# 3.0--including LINQ, generics, and multi-threading--and includes helpful suggestions on how to avoid common pitfalls and problems with the programming language. Original. (Intermediate) Learning the basic syntax of XML is easy enough, but learning how to use XML is more difficult." Effective XML" makes it possible to become a more effective programmer sooner. It crystallizes the hard-won expertise of XML pioneers into 50 rules of thumb for the optimal design of XML documents and applications The author teaches programmers how to use XML effectively and produce better code. Harold explains the critical rules of thumb employed by the experts to get the most out of XML and provides 50 ways to use XML to produce code that is extensible, legible and maintainable. Code-reading requires its own set of skills. This book uses more than 600 real-world examples to show you how to identify good and bad code: how to read it, what to look for, and how to use this knowledge to improve your own code. It is useful for programmers.