| |  | Dedication |
| | | Copyright |
| | | 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 |
| |
| | Using Code Examples |
| |
| | Platform Notes |
| |
| | Comments and Questions |
| |
| | Acknowledgments |
|
| | |
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 |
