See more Amazon Details

Contents Listing

Preface

1. Numbers
1.1 Determining Approximate Equality Between a Fraction and Floating-Point Value
1.2 Converting Degrees to Radians
1.3 Converting Radians to Degrees
1.4 Using the Bitwise Complement Operator with Various Data Types
1.5 Test for an Even or Odd Value
1.6 Obtaining the Most- or Least-Significant Bits of a Number
1.7 Converting a Number in Another Base to Base10
1.8 Determining Whether a String Is a Valid Number
1.9 Rounding a Floating-Point Value
1.10 Different Rounding Algorithms
1.11 Converting Celsius to Fahrenheit
1.12 Converting Fahrenheit to Celsius
1.13 Safely Performing a Narrowing Numeric Cast
1.14 Finding the Length of Any Three Sides of a Right Triangle
1.15 Finding the Angles of a Right Triangle

2. Strings and Characters
2.1 Determining the Kind of Character
2.2 Determining Whether a Character Is Within a Specified Range
2.3 Controlling Case Sensitivity when Comparing Two Characters
2.4 Finding All Occurrences of a Character Within a String
2.5 Finding the Location of All Occurrences of a String WithinAnother String
2.6 The Poor Man's Tokenizer
2.7 Controlling Case Sensitivity when Comparing Two Strings
2.8 Comparing a String to the Beginning or End of a Second String
2.9 Inserting Text into a String
2.10 Removing or Replacing Characters Within a String
2.11 Encoding Binary Data as Base64
2.12 Decoding a Base64-Encoded Binary
2.13 Converting a String Returned as a Byte[ ] Back into a String
2.14 Passing a String to a Method that Accepts Only a Byte[ ]
2.15 Converting Strings to Their Equivalent Value Type
2.16 Formatting Data in Strings
2.17 Creating a Delimited String
2.18 Extracting Items from a Delimited String
2.19 Setting the Maximum Number of Characters a String Can Contain
2.20 Iterating Over Each Character in a String
2.21 Improving String Comparison Performance
2.22 Improving StringBuilder Performance
2.23 Pruning Characters from the Head and/or Tail of a String

3. Classes and Structures
3.1 Creating Union-Type Structures
3.2 Allowing a Type to Represent Itself as a String
3.3 Converting a String Representation of an Object into an Actual Object
3.4 Polymorphism via Concrete or Abstract Base Classes
3.5 Making a Type Sortable
3.6 Making a Type Searchable
3.7 Indirectly Overloading the +=, -=, /=, and *= Operators
3.8 Indirectly Overloading the &&, ||, and ?: Operators
3.9 Improving the Performance of a Structure's Equals Method
3.10 Turning Bits On or Off
3.11 Making Error-Free Expressions
3.12 Minimizing (Reducing) Your Boolean Logic
3.13 Converting Between Simple Types in a Language Agnostic Manner
3.14 Determining Whether to Use the Cast Operator, the as Operator, or the is Operator
3.15 Casting with the as Operator
3.16 Determining a Variable's Type with the is Operator
3.17 Polymorphism via Interfaces
      3.18 Calling the Same Method on Multiple Object Types
      3.19 Adding a Notification Callback Using an Interface
      3.20 Using Multiple Entry Points to Version an Application
      3.21 Preventing the Creation of an Only Partially Initialized Object
      3.22 Returning Multiple Items from a Method
      3.23 Parsing Command-Line Parameters
      3.24 Retrofitting a Class to Interoperate with COM
      3.25 Initializing a Constant Field at Runtime
      3.26 Writing Code that Is Compatible with the Widest Rangeof Managed Languages
      3.27 Implementing Nested foreach Functionality in a Class
      3.28 Building Cloneable Classes
      3.29 Assuring an Object's Disposal
      3.30 Releasing a COM Object Through Managed Code
      3.31 Creating an Object Cache
      3.32 The Single Instance Object
      3.33 Choosing a Serializer
      3.34 Creating Custom Enumerators
      3.35 Rolling Back Object Changes
      3.36 Disposing of Unmanaged Resources
      3.37 Determining Where Boxing and Unboxing Occur

4. Enumerations
4.1 Displaying an Enumeration Value as a String
4.2 Converting Plain Text to an Equivalent Enumeration Value
4.3 Testing for a Valid Enumeration Value
4.4 Testing for a Valid Enumeration of Flags
4.5 Using Enumerated Members in a Bitmask
4.6 Determining Whether One or More Enumeration Flags Are Set

5. Exception Handling
5.1 Verifying Critical Parameters
5.2 Indicating Where Exceptions Originate
5.3 Choosing when to Throw a Particular Exception
5.4 Handling Derived Exceptions Individually
5.5 Assuring Exceptions are Not Lost when Using Finally Blocks
5.6 Handling Exceptions Thrown from Methods Invoked via Reflection
5.7 Debugging Problems when Loading an Assembly
5.8 HRESULT-Exception Mapping
5.9 Handling User-Defined HRESULTs
5.10 Preventing Unhandled Exceptions
5.11 Displaying Exception Information
5.12 Getting to the Root of a Problem Quickly
5.13 Creating a New Exception Type
5.14 Obtaining a Stack Trace
5.15 Breaking on a First Chance Exception
5.16 Preventing the Nefarious TypeInitializationException
5.17 Handling Exceptions Thrown from an Asynchronous Delegate

6. Diagnostics
      6.1 Controlling Tracing Output in Production Code
      6.2 Providing Fine-Grained Control Over Debugging/Tracing Output
      6.3 Creating Your Own Custom Switch Class
      6.4 A Custom Trace Class that Outputs Information in an XML Format
      6.5 Conditionally Compiling Blocks of Code
      6.6 Determining Whether a Process Has Stopped Responding
      6.7 Using One or More Event Logs in Your Application
      6.8 Changing the Maximum Size of a Custom Event Log
      6.9 Searching Event Log Entries
      6.10 Watching the Event Log for a Specific Entry
      6.11 Finding All Sources Belonging to a Specific Event Log
      6.12 Implementing a Simple Performance Counter
      6.13 Implementing Performance Counters that Require a Base Counter
      6.14 Enable/Disable Complex Tracing Code

7. Delegates and Events
      7.1 Controlling when and if a Delegate Fires Within a Multicast Delegate
      7.2 Obtaining Return Values from Each Delegate in a Multicast Delegate
      7.3 Handling Exceptions Individually for Each Delegate in a Multicast Delegate
      7.4 Converting a Synchronous Delegate to an Asynchronous Delegate
      7.5 Adding Events to a Sealed Class
      7.6 Passing Specialized Parameters to and from an Event
      7.7 An Advanced Interface Search Mechanism
      7.8 An Advanced Member Search Mechanism
      7.9 Observing Additions and Modifications to a Hashtable
      7.10 Using the Windows Keyboard Hook
      7.11 Using Windows Hooks to Manipulate the Mouse

8. Regular Expressions
8.1 Enumerating Matches
8.2 Extracting Groups from a MatchCollection
8.3 Verifying the Syntax of a Regular Expression
8.4 Quickly Finding Only the Last Match in a String
8.5 Replacing Characters or Words in a String
8.6 Augmenting the Basic String Replacement Function
8.7 A Better Tokenizer
8.8 Compiling Regular Expressions
8.9 Counting Lines of Text
8.10 Returning the Entire Line in Which a Match Is Found
8.11 Finding a Particular Occurrence of a Match
8.12 Using Common Patterns
8.13 Documenting Your Regular Expressions

9. Collections
9.1 Swapping Two Elements in an Array
9.2 Quickly Reversing an Array
9.3 Reversing a Two-Dimensional Array
9.4 Reversing a Jagged Array
9.5 A More Flexible StackTrace Class
9.6 Determining the Number of Times an Item Appears in an ArrayList
9.7 Retrieving All Instances of a Specific Item in an ArrayList
9.8 Inserting and Removing Items from an Array
9.9 Keeping Your ArrayList Sorted
9.10 Sorting a Hashtable's Keys and/or Values
9.11 Creating a Hashtable with Max and Min Size Boundaries
9.12 Creating a Hashtable with Max and Min Value Boundaries
9.13 Displaying an Array's Data as a Delimited String
9.14 Storing Snapshots of Lists in an Array
9.15 Creating a Strongly Typed Collection
9.16 Persisting a Collection Between Application Sessions

10. Data Structures and Algorithms
10.1 Creating a Hash Code for a Data Type
10.2 Creating a Priority Queue
10.3 Creating a More Versatile Queue
10.4 Determining Where Characters or Strings Do Not Balance
10.5 Creating a One-to-Many Map (MultiMap)
10.6 Creating a Binary Tree
10.7 Creating an n-ary Tree
10.8 Creating a Set Object

11. Filesystem I/O
11.1 Creating, Copying, Moving, and Deleting a File
11.2 Manipulating File Attributes
11.3 Renaming a File
11.4 Determining Whether a File Exists
11.5 Choosing a Method of Opening a File or Stream for Reading and/or Writing
11.6 Randomly Accessing Part of a File
11.7 Outputting a Platform-Independent EOL Character
11.8 Create, Write to, and Read from a File
11.9 Determining Whether a Directory Exists
11.10 Creating, Moving, and Deleting a Directory
11.11 Manipulating Directory Attributes
11.12 Renaming a Directory
11.13 Searching for Directories or Files Using Wildcards
11.14 Obtaining the Directory Tree
11.15 Parsing a Path
11.16 Parsing Paths in Environment Variables
11.17 Verifying a Path
11.18 Using a Temporary File in Your Application
11.19 Opening a File Stream with just a File Handle
11.20 Write to Multiple Output Files at One Time
11.21 Launching and Interacting with Console Utilities
11.22 Locking Subsections of a File
11.23 Watching the Filesystem for Specific Changes to One or MoreFiles or Directories
11.24 Waiting for an Action to Occur in the Filesystem
11.25 Comparing Version Information of Two Executable Modules

12. Reflection
      12.1 Listing Imported Assemblies
      12.2 Listing Exported Types
      12.3 Finding Overridden Methods
      12.4 Finding Members in an Assembly
      12.5 Finding Members Within an Interface
      12.6 Obtaining Types Nested Within a Type
      12.7 Displaying the Inheritance Hierarchy for a Type
      12.8 Finding the Subclasses of a Type
      12.9 Finding All Serializable Types Within an Assembly
      12.10 Controlling Additions to an ArrayList Through Attributes
      12.11 Filtering Output when Obtaining Members
      12.12 Dynamically Invoking Members

13. Networking
      13.1 Converting an IP Address to a Hostname
      13.2 Converting a Hostname to an IP Address
      13.3 Parsing a URI
      13.4 Forming an Absolute URI
      13.5 Handling Web Server Errors
      13.6 Communicating with a Web Server
      13.7 Going Through a Proxy
      13.8 Obtaining the HTML from a URL
      13.9 Writing a TCP Server
      13.10 Writing a TCP Client
      13.11 Simulating Form Execution
      13.12 Downloading Data from a Server
      13.13 Using Named Pipes to Communicate

14. Security
      14.1 Controlling Access to Types in a Local Assembly
      14.2 Encrypting/Decrypting a String
      14.3 Encrypting and Decrypting a File
      14.4 Cleaning Up Cryptography Information
      14.5 Verifying that a String Is Uncorrupted During Transmission
      14.6 Wrapping a String Hash for Ease of Use
      14.7 A Better Random Number Generator
      14.8 Securely Storing Data
      14.9 Making a Security Assert Safe
      14.10 Preventing Malicious Modifications to an Assembly
      14.11 Verifying that an Assembly Has Been Granted Specific Permissions
      14.12 Minimizing the Attack Surface of an Assembly

15. Threading
      15.1 Creating Per-Thread Static Fields
      15.2 Providing Thread Safe Access to Class Members
      15.3 Preventing Silent Thread Termination
      15.4 Polling an Asynchronous Delegate
      15.5 Timing Out an Asynchronous Delegate
      15.6 Being Notified of the Completion of an Asynchronous Delegate
      15.7 Waiting for Worker Thread Completion
      15.8 Synchronizing the Reading and Writing of a Resource Efficiently
      15.9 Determining Whether a Request for a Pooled ThreadWill Be Queued
      15.10 Waiting for All Threads in the Thread Pool to Finish
      15.11 Configuring a Timer
      15.12 Storing Thread-Specific Data Privately

16. Unsafe Code
      16.1 Controlling Changes to Pointers Passed to Methods
      16.2 Comparing Pointers
      16.3 Navigating Arrays
      16.4 Manipulating a Pointer to a Fixed Array
      16.5 Returning a Pointer to a Particular Element in an Array
      16.6 Creating and Using an Array of Pointers
      16.7 Creating and Using an Array of Pointers to Unknown Types
      16.8 Switching Unknown Pointer Types
      16.9 Breaking Up Larger Numbers into Their Equivalent Byte Array Representation
      16.10 Converting Pointers to a Byte[], SByte[], or Char[] to a String

17. XML
17.1 Reading and Accessing XML Data in Document Order
17.2 Reading XML on the Web
17.3 Querying the Contents of an XML Document
17.4 Validating XML
17.5 Creating an XML Document Programmatically
17.6 Detecting Changes to an XML Document
17.7 Handling Invalid Characters in an XML String
17.8 Transforming XML to HTML
17.9 Tearing Apart an XML Document
17.10 Putting Together an XML Document

Index