| |
 |
Preface |
| |
|
|
Who This Book Is For |
| |
|
|
What You Need to Use This Book |
| |
|
|
How This Book Is Organized |
| |
|
|
What Was Left Out |
| |
|
|
Conventions Used in This Book |
| |
|
|
About the Code |
| |
|
|
Platform Notes |
|
| |
|
Chapter 1. Numbers |
| |
|
|
Recipe 1.1. Determining Approximate Equality Between a Fraction and Floating-Point Value |
| |
|
|
Recipe 1.2. Converting Degrees to Radians |
| |
|
|
Recipe 1.3. Converting Radians to Degrees |
| |
|
|
Recipe 1.4. Using the Bitwise Complement Operator with Various Data Types |
| |
|
|
Recipe 1.5. Test for an Even or Odd Value |
| |
|
|
Recipe 1.6. Obtaining the Most- or Least-Significant Bits of a Number |
| |
|
|
Recipe 1.7. Converting a Number in Another Base to Base10 |
| |
|
|
Recipe 1.8. Determining Whether a String Is a Valid Number |
| |
|
|
Recipe 1.9. Rounding a Floating-Point Value |
| |
|
|
Recipe 1.10. Different Rounding Algorithms |
| |
|
|
Recipe 1.11. Converting Celsius to Fahrenheit |
| |
|
|
Recipe 1.12. Converting Fahrenheit to Celsius |
| |
|
|
Recipe 1.13. Safely Performing a Narrowing Numeric Cast |
| |
|
|
Recipe 1.14. Finding the Length of Any Three Sidesof a Right Triangle |
| |
|
|
Recipe 1.15. Finding the Angles of a Right Triangle |
|
| |
|
Chapter 2. Strings and Characters |
| |
|
|
Recipe 2.1. Determining the Kind of Character |
| |
|
|
Recipe 2.2. Determining Whether a Character Is Within a Specified Range |
| |
|
|
Recipe 2.3. Controlling Case Sensitivity when Comparing Two Characters |
| |
|
|
Recipe 2.4. Finding All Occurrences of a Character Within a String |
| |
|
|
Recipe 2.5. Finding the Location of All Occurrencesof a String Within Another String |
| |
|
|
Recipe 2.6. The Poor Man's Tokenizer |
| |
|
|
Recipe 2.7. Controlling Case Sensitivity when Comparing Two Strings |
| |
|
|
Recipe 2.8. Comparing a String to the Beginning or End of a Second String |
| |
|
|
Recipe 2.9. Inserting Text into a String |
| |
|
|
Recipe 2.10. Removing or Replacing Characters Within a String |
| |
|
|
Recipe 2.11. Encoding Binary Data as Base64 |
| |
|
|
Recipe 2.12. Decoding a Base64-Encoded Binary |
| |
|
|
Recipe 2.13. Converting a String Returned as a Byte[ ] Back into a String |
| |
|
|
Recipe 2.14. Passing a String to a Method that Accepts Only a Byte[ ] |
| |
|
|
Recipe 2.15. Converting Strings to Their Equivalent Value Type |
| |
|
|
Recipe 2.16. Formatting Data in Strings |
| |
|
|
Recipe 2.17. Creating a Delimited String |
| |
|
|
Recipe 2.18. Extracting Items from a Delimited String |
| |
|
|
Recipe 2.19. Setting the Maximum Number of Characters a String Can Contain |
| |
|
|
Recipe 2.20. Iterating Over Each Character in a String |
| |
|
|
Recipe 2.21. Improving String Comparison Performance |
| |
|
|
Recipe 2.22. Improving StringBuilder Performance |
| |
|
|
Recipe 2.23. Pruning Characters from the Headand/or Tail of a String |
|
| |
|
Chapter 3. Classes and Structures |
| |
|
|
Recipe 3.1. Creating Union-Type Structures |
| |
|
|
Recipe 3.2. Allowing a Type to Represent Itself as a String |
| |
|
|
Recipe 3.3. Converting a String Representation of an Object into an Actual Object |
| |
|
|
Recipe 3.4. Polymorphism via Concrete or Abstract Base Classes |
| |
|
|
Recipe 3.5. Making a Type Sortable |
| |
|
|
Recipe 3.6. Making a Type Searchable |
| |
|
|
Recipe 3.7. Indirectly Overloading the +=, -=, /=, and *= Operators |
| |
|
|
Recipe 3.8. Indirectly Overloading the &&, ||, and ?: Operators |
| |
|
|
Recipe 3.9. Improving the Performance of a Structure's Equals Method |
| |
|
|
Recipe 3.10. Turning Bits On or Off |
| |
|
|
Recipe 3.11. Making Error-Free Expressions |
| |
|
|
Recipe 3.12. Minimizing (Reducing) Your Boolean Logic |
| |
|
|
Recipe 3.13. Converting Between Simple Types in a Language Agnostic Manner |
| |
|
|
Recipe 3.14. Determining Whether to Use theCast Operator, the as Operator, or theis Operator |
| |
|
|
Recipe 3.15. Casting with the as Operator |
| |
|
|
Recipe 3.16. Determining a Variable's Type with the is Operator |
| |
|
|
Recipe 3.17. Polymorphism via Interfaces |
| |
|
|
Recipe 3.18. Calling the Same Method on Multiple Object Types |
| |
|
|
Recipe 3.19. Adding a Notification Callback Using an Interface |
| |
|
|
Recipe 3.20. Using Multiple Entry Points toVersion an Application |
| |
|
|
Recipe 3.21. Preventing the Creation of an Only Partially Initialized Object |
| |
|
|
Recipe 3.22. Returning Multiple Items from a Method |
| |
|
|
Recipe 3.23. Parsing Command-Line Parameters |
| |
|
|
Recipe 3.24. Retrofitting a Class to Interoperate with COM |
| |
|
|
Recipe 3.25. Initializing a Constant Field at Runtime |
| |
|
|
Recipe 3.26. Writing Code that Is Compatible with the Widest Range of Managed Languages |
| |
|
|
Recipe 3.27. Implementing Nested foreach Functionality in a Class |
| |
|
|
Recipe 3.28. Building Cloneable Classes |
| |
|
|
Recipe 3.29. Assuring an Object's Disposal |
| |
|
|
Recipe 3.30. Releasing a COM Object ThroughManaged Code |
| |
|
|
Recipe 3.31. Creating an Object Cache |
| |
|
|
Recipe 3.32. The Single Instance Object |
| |
|
|
Recipe 3.33. Choosing a Serializer |
| |
|
|
Recipe 3.34. Creating Custom Enumerators |
| |
|
|
Recipe 3.35. Rolling Back Object Changes |
| |
|
|
Recipe 3.36. Disposing of Unmanaged Resources |
| |
|
|
Recipe 3.37. Determining Where Boxing and Unboxing Occur |
|
| |
|
Chapter 4. Enumerations |
| |
|
|
Recipe 4.1. Displaying an Enumeration Value as a String |
| |
|
|
Recipe 4.2. Converting Plain Text to an Equivalent Enumeration Value |
| |
|
|
Recipe 4.3. Testing for a Valid Enumeration Value |
| |
|
|
Recipe 4.4. Testing for a Valid Enumeration of Flags |
| |
|
|
Recipe 4.5. Using Enumerated Members in a Bitmask |
| |
|
|
Recipe 4.6. Determining Whether One or More Enumeration Flags Are Set |
|
| |
|
Chapter 5. Exception Handling |
| |
|
|
Recipe 5.1. Verifying Critical Parameters |
| |
|
|
Recipe 5.2. Indicating Where Exceptions Originate |
| |
|
|
Recipe 5.3. Choosing when to Throw a Particular Exception |
| |
|
|
Recipe 5.4. Handling Derived Exceptions Individually |
| |
|
|
Recipe 5.5. Assuring Exceptions are Not Lost when Using Finally Blocks |
| |
|
|
Recipe 5.6. Handling Exceptions Thrown from Methods Invoked via Reflection |
| |
|
|
Recipe 5.7. Debugging Problems whenLoading an Assembly |
| |
|
|
Recipe 5.8. HRESULT-Exception Mapping |
| |
|
|
Recipe 5.9. Handling User-Defined HRESULTs |
| |
|
|
Recipe 5.10. Preventing Unhandled Exceptions |
| |
|
|
Recipe 5.11. Displaying Exception Information |
| |
|
|
Recipe 5.12. Getting to the Root of a Problem Quickly |
| |
|
|
Recipe 5.13. Creating a New Exception Type |
| |
|
|
Recipe 5.14. Obtaining a Stack Trace |
| |
|
|
Recipe 5.15. Breaking on a First Chance Exception |
| |
|
|
Recipe 5.16. Preventing the Nefarious TypeInitializationException |
| |
|
|
Recipe 5.17. Handling Exceptions Thrown from an Asynchronous Delegate |
|
| |
|
Chapter 6. Diagnostics |
| |
|
|
Recipe 6.1. Controlling Tracing Output inProduction Code |
| |
|
|
Recipe 6.2. Providing Fine-Grained Control Over Debugging/Tracing Output |
| |
|
|
Recipe 6.3. Creating Your Own Custom Switch Class |
| |
|
|
Recipe 6.4. A Custom Trace Class that Outputs Information in an XML Format |
| |
|
|
Recipe 6.5. Conditionally Compiling Blocks of Code |
| |
|
|
Recipe 6.6. Determining Whether a Process Has Stopped Responding |
| |
|
|
Recipe 6.7. Using One or More Event Logs in Your Application |
| |
|
|
Recipe 6.8. Changing the Maximum Size of a Custom Event Log |
| |
|
|
Recipe 6.9. Searching Event Log Entries |
| |
|
|
Recipe 6.10. Watching the Event Log for a Specific Entry |
| |
|
|
Recipe 6.11. Finding All Sources Belonging to a Specific Event Log |
| |
|
|
Recipe 6.12. Implementing a Simple Performance Counter |
| |
|
|
Recipe 6.13. Implementing Performance Counters that Require a Base Counter |
| |
|
|
Recipe 6.14. Enable/Disable Complex Tracing Code |
|
| |
|
Chapter 7. Delegates and Events |
| |
|
|
Recipe 7.1. Controlling when and if a Delegate Fires Within a Multicast Delegate |
| |
|
|
Recipe 7.2. Obtaining Return Values from Each Delegate in a Multicast Delegate |
| |
|
|
Recipe 7.3. Handling Exceptions Individually for Each Delegate in a Multicast Delegate |
| |
|
|
Recipe 7.4. Converting a Synchronous Delegate to an Asynchronous Delegate |
| |
|
|
Recipe 7.5. Adding Events to a Sealed Class |
| |
|
|
Recipe 7.6. Passing Specialized Parameters to and from an Event |
| |
|
|
Recipe 7.7. An Advanced Interface Search Mechanism |
| |
|
|
Recipe 7.8. An Advanced Member Search Mechanism |
| |
|
|
Recipe 7.9. Observing Additions and Modifications to a Hashtable |
| |
|
|
Recipe 7.10. Using the Windows Keyboard Hook |
| |
|
|
Recipe 7.11. Using Windows Hooks to Manipulate the Mouse |
|
| |
|
Chapter 8. Regular Expressions |
| |
|
|
Recipe 8.1. Enumerating Matches |
| |
|
|
Recipe 8.2. Extracting Groups from a MatchCollection |
| |
|
|
Recipe 8.3. Verifying the Syntax of a Regular Expression |
| |
|
|
Recipe 8.4. Quickly Finding Only the Last Match in a String |
| |
|
|
Recipe 8.5. Replacing Characters or Words in a String |
| |
|
|
Recipe 8.6. Augmenting the Basic String Replacement Function |
| |
|
|
Recipe 8.7. A Better Tokenizer |
| |
|
|
Recipe 8.8. Compiling Regular Expressions |
| |
|
|
Recipe 8.9. Counting Lines of Text |
| |
|
|
Recipe 8.10. Returning the Entire Line in Which a Match Is Found |
| |
|
|
Recipe 8.11. Finding a Particular Occurrence of a Match |
| |
|
|
Recipe 8.12. Using Common Patterns |
| |
|
|
Recipe 8.13. Documenting Your Regular Expressions |
|
| |
|
Chapter 9. Collections |
| |
|
|
Recipe 9.1. Swapping Two Elements in an Array |
| |
|
|
Recipe 9.2. Quickly Reversing an Array |
| |
|
|
Recipe 9.3. Reversing a Two-Dimensional Array |
| |
|
|
Recipe 9.4. Reversing a Jagged Array |
| |
|
|
Recipe 9.5. A More Flexible StackTrace Class |
| |
|
|
Recipe 9.6. Determining the Number of Times an Item Appears in an ArrayList |
| |
|
|
Recipe 9.7. Retrieving All Instances of a Specific Itemin an ArrayList |
| |
|
|
Recipe 9.8. Inserting and Removing Items from an Array |
| |
|
|
Recipe 9.9. Keeping Your ArrayList Sorted |
| |
|
|
Recipe 9.10. Sorting a Hashtable's Keys and/or Values |
| |
|
|
Recipe 9.11. Creating a Hashtable with Max and Min Size Boundaries |
| |
|
|
Recipe 9.12. Creating a Hashtable with Max and Min Value Boundaries |
| |
|
|
Recipe 9.13. Displaying an Array's Data as a Delimited String |
| |
|
|
Recipe 9.14. Storing Snapshots of Lists in an Array |
| |
|
|
Recipe 9.15. Creating a Strongly Typed Collection |
| |
|
|
Recipe 9.16. Persisting a Collection Between Application Sessions |
|
| |
|
Chapter 10. Data Structures and Algorithms |
| |
|
|
Recipe 10.1. Creating a Hash Code for a Data Type |
| |
|
|
Recipe 10.2. Creating a Priority Queue |
| |
|
|
Recipe 10.3. Creating a More Versatile Queue |
| |
|
|
Recipe 10.4. Determining Where Characters or Strings Do Not Balance |
| |
|
|
Recipe 10.5. Creating a One-to-Many Map (MultiMap) |
| |
|
|
Recipe 10.6. Creating a Binary Tree |
| |
|
|
Recipe 10.7. Creating an n-ary Tree |
| |
|
|
Recipe 10.8. Creating a Set Object |
|
| |
|
Chapter 11. Filesystem I/O |
| |
|
|
Recipe 11.1. Creating, Copying, Moving, and Deleting a File |
| |
|
|
Recipe 11.2. Manipulating File Attributes |
| |
|
|
Recipe 11.3. Renaming a File |
| |
|
|
Recipe 11.4. Determining Whether a File Exists |
| |
|
|
Recipe 11.5. Choosing a Method of Opening a File or Stream for Reading and/or Writing |
| |
|
|
Recipe 11.6. Randomly Accessing Part of a File |
| |
|
|
Recipe 11.7. Outputting a Platform-Independent EOL Character |
| |
|
|
Recipe 11.8. Create, Write to, and Read from a File |
| |
|
|
Recipe 11.9. Determining Whether a Directory Exists |
| |
|
|
Recipe 11.10. Creating, Moving, and Deleting a Directory |
| |
|
|
Recipe 11.11. Manipulating Directory Attributes |
| |
|
|
Recipe 11.12. Renaming a Directory |
| |
|
|
Recipe 11.13. Searching for Directories or FilesUsing Wildcards |
| |
|
|
Recipe 11.14. Obtaining the Directory Tree |
| |
|
|
Recipe 11.15. Parsing a Path |
| |
|
|
Recipe 11.16. Parsing Paths in Environment Variables |
| |
|
|
Recipe 11.17. Verifying a Path |
| |
|
|
Recipe 11.18. Using a Temporary File in Your Application |
| |
|
|
Recipe 11.19. Opening a File Stream with just aFile Handle |
| |
|
|
Recipe 11.20. Write to Multiple Output Files at One Time |
| |
|
|
Recipe 11.21. Launching and Interacting withConsole Utilities |
| |
|
|
Recipe 11.22. Locking Subsections of a File |
| |
|
|
Recipe 11.23. Watching the Filesystem for Specific Changes to One or More Files or Directories |
| |
|
|
Recipe 11.24. Waiting for an Action to Occurin the Filesystem |
| |
|
|
Recipe 11.25. Comparing Version Information of Two Executable Modules |
|
| |
|
Chapter 12. Reflection |
| |
|
|
Recipe 12.1. Listing Imported Assemblies |
| |
|
|
Recipe 12.2. Listing Exported Types |
| |
|
|
Recipe 12.3. Finding Overridden Methods |
| |
|
|
Recipe 12.4. Finding Members in an Assembly |
| |
|
|
Recipe 12.5. Finding Members Within an Interface |
| |
|
|
Recipe 12.6. Obtaining Types Nested Within a Type |
| |
|
|
Recipe 12.7. Displaying the Inheritance Hierarchy for a Type |
| |
|
|
Recipe 12.8. Finding the Subclasses of a Type |
| |
|
|
Recipe 12.9. Finding All Serializable Types Within an Assembly |
| |
|
|
Recipe 12.10. Controlling Additions to an ArrayList Through Attributes |
| |
|
|
Recipe 12.11. Filtering Output when Obtaining Members |
| |
|
|
Recipe 12.12. Dynamically Invoking Members |
|
| |
|
Chapter 13. Networking |
| |
|
|
Recipe 13.1. Converting an IP Address to a Hostname |
| |
|
|
Recipe 13.2. Converting a Hostname to an IP Address |
| |
|
|
Recipe 13.3. Parsing a URI |
| |
|
|
Recipe 13.4. Forming an Absolute URI |
| |
|
|
Recipe 13.5. Handling Web Server Errors |
| |
|
|
Recipe 13.6. Communicating with a Web Server |
| |
|
|
Recipe 13.7. Going Through a Proxy |
| |
|
|
Recipe 13.8. Obtaining the HTML from a URL |
| |
|
|
Recipe 13.9. Writing a TCP Server |
| |
|
|
Recipe 13.10. Writing a TCP Client |
| |
|
|
Recipe 13.11. Simulating Form Execution |
| |
|
|
Recipe 13.12. Downloading Data from a Server |
| |
|
|
Recipe 13.13. Using Named Pipes to Communicate |
|
| |
|
Chapter 14. Security |
| |
|
|
Recipe 14.1. Controlling Access to Types in aLocal Assembly |
| |
|
|
Recipe 14.2. Encrypting/Decrypting a String |
| |
|
|
Recipe 14.3. Encrypting and Decrypting a File |
| |
|
|
Recipe 14.4. Cleaning Up Cryptography Information |
| |
|
|
Recipe 14.5. Verifying that a String Is Uncorrupted During Transmission |
| |
|
|
Recipe 14.6. Wrapping a String Hash for Ease of Use |
| |
|
|
Recipe 14.7. A Better Random Number Generator |
| |
|
|
Recipe 14.8. Securely Storing Data |
| |
|
|
Recipe 14.9. Making a Security Assert Safe |
| |
|
|
Recipe 14.10. Preventing Malicious Modifications to an Assembly |
| |
|
|
Recipe 14.11. Verifying that an Assembly Has Been Granted Specific Permissions |
| |
|
|
Recipe 14.12. Minimizing the Attack Surface of an Assembly |
|
| |
|
Chapter 15. Threading |
| |
|
|
Recipe 15.1. Creating Per-Thread Static Fields |
| |
|
|
Recipe 15.2. Providing Thread Safe Access to Class Members |
| |
|
|
Recipe 15.3. Preventing Silent Thread Termination |
| |
|
|
Recipe 15.4. Polling an Asynchronous Delegate |
| |
|
|
Recipe 15.5. Timing Out an Asynchronous Delegate |
| |
|
|
Recipe 15.6. Being Notified of the Completionof an Asynchronous Delegate |
| |
|
|
Recipe 15.7. Waiting for Worker Thread Completion |
| |
|
|
Recipe 15.8. Synchronizing the Reading and Writingof a Resource Efficiently |
| |
|
|
Recipe 15.9. Determining Whether a Requestfor a Pooled Thread Will Be Queued |
| |
|
|
Recipe 15.10. Waiting for All Threads in theThread Pool to Finish |
| |
|
|
Recipe 15.11. Configuring a Timer |
| |
|
|
Recipe 15.12. Storing Thread-Specific Data Privately |
|
| |
|
Chapter 16. Unsafe Code |
| |
|
|
Recipe 16.1. Controlling Changes to Pointers Passedto Methods |
| |
|
|
Recipe 16.2. Comparing Pointers |
| |
|
|
Recipe 16.3. Navigating Arrays |
| |
|
|
Recipe 16.4. Manipulating a Pointer to a Fixed Array |
| |
|
|
Recipe 16.5. Returning a Pointer to a Particular Element in an Array |
| |
|
|
Recipe 16.6. Creating and Using an Array of Pointers |
| |
|
|
Recipe 16.7. Creating and Using an Array of Pointersto Unknown Types |
| |
|
|
Recipe 16.8. Switching Unknown Pointer Types |
| |
|
|
Recipe 16.9. Breaking Up Larger Numbers into Their Equivalent Byte Array Representation |
| |
|
|
Recipe 16.10. Converting Pointers to a Byte[ ], SByte[ ],or Char[ ] to a String |
|
| |
|
Chapter 17. XML |
| |
|
|
Recipe 17.1. Reading and Accessing XML Datain Document Order |
| |
|
|
Recipe 17.2. Reading XML on the Web |
| |
|
|
Recipe 17.3. Querying the Contents of an XML Document |
| |
|
|
Recipe 17.4. Validating XML |
| |
|
|
Recipe 17.5. Creating an XML Document Programmatically |
| |
|
|
Recipe 17.6. Detecting Changes to an XML Document |
| |
|
|
Recipe 17.7. Handling Invalid Characters in anXML String |
| |
|
|
Recipe 17.8. Transforming XML to HTML |
| |
|
|
Recipe 17.9. Tearing Apart an XML Document |
| |
|
|
Recipe 17.10. Putting Together an XML Document |
|
| |
|
Colophon |
| |
|
Index |
