|
|
|
Copyright
|
|
|
|
Dedication
|
|
|
|
Preface
|
|
|
|
|
Who This Book Is For
|
|
|
|
|
What You Need to Use This Book
|
|
|
|
|
Platform Notes
|
|
|
|
|
How This Book Is Organized
|
|
|
|
|
What Was Left Out
|
|
|
|
|
Conventions Used in This Book
|
|
|
|
|
About the Code
|
|
|
|
|
Using Code Examples
|
|
|
|
|
Comments and Questions
|
|
|
|
|
Safari Enabled
|
|
|
|
|
Acknowledgments
|
|
|
|
Chapter 1. Numbers and Enumerations
|
|
|
|
|
Introduction
|
|
|
|
|
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. Testing for an Even or Odd Value
|
|
|
|
|
Recipe 1.6. Obtaining the High Word or Low Word 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. Choosing a Rounding Algorithm
|
|
|
|
|
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 Sides of a Right Triangle
|
|
|
|
|
Recipe 1.15. Finding the Angles of a Right Triangle
|
|
|
|
|
Recipe 1.16. Displaying an Enumeration Value as a String
|
|
|
|
|
Recipe 1.17. Converting Plain Text to an Equivalent Enumeration Value
|
|
|
|
|
Recipe 1.18. Testing for a Valid Enumeration Value
|
|
|
|
|
Recipe 1.19. Testing for a Valid Enumeration of Flags
|
|
|
|
|
Recipe 1.20. Using Enumerated Members in a Bit Mask
|
|
|
|
|
Recipe 1.21. Determining if One or More Enumeration Flags Are Set
|
|
|
|
|
Recipe 1.22. Determining the Integral Part of a Decimal or Double
|
|
|
|
Chapter 2. Strings and Characters
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 2.1. Determining the Kind of Character a char Contains
|
|
|
|
|
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 Occurrences of a String Within Another String
|
|
|
|
|
Recipe 2.6. Implementing a Poor Man's Tokenizer to Deconstruct a String
|
|
|
|
|
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 Other Types
|
|
|
|
|
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 StringBuilder 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 Head and/or Tail of a String
|
|
|
|
|
Recipe 2.24. Testing a String for Null or Empty
|
|
|
|
|
Recipe 2.25. Appending a Line
|
|
|
|
|
Recipe 2.26. Encoding Chunks of Data
|
|
|
|
Chapter 3. Classes and Structures
|
|
|
|
|
Introduction
|
|
|
|
|
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. Implementing Polymorphism with 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. Turning Bits On or Off
|
|
|
|
|
Recipe 3.10. Making Error-Free Expressions
|
|
|
|
|
Recipe 3.11. Minimizing (Reducing) Your Boolean Logic
|
|
|
|
|
Recipe 3.12. Converting Between Simple Types in a Language-
Agnostic
Manner
|
|
|
|
|
Recipe 3.13. Determining When to Use the Cast Operator, the as Operator, or the is Operator
|
|
|
|
|
Recipe 3.14. Casting with the as Operator
|
|
|
|
|
Recipe 3.15. Determining a Variable's Type with the is Operator
|
|
|
|
|
Recipe 3.16. Implementing Polymorphism with Interfaces
|
|
|
|
|
Recipe 3.17. Calling the Same Method on Multiple Object Types
|
|
|
|
|
Recipe 3.18. Adding a Notification Callback Using an Interface
|
|
|
|
|
Recipe 3.19. Using Multiple Entry Points to Version an Application
|
|
|
|
|
Recipe 3.20. Preventing the Creation of an Only Partially Initialized Object
|
|
|
|
|
Recipe 3.21. Returning Multiple Items from a Method
|
|
|
|
|
Recipe 3.22. Parsing Command-Line Parameters
|
|
|
|
|
Recipe 3.23. Retrofitting a Class to Interoperate with COM
|
|
|
|
|
Recipe 3.24. Initializing a Constant Field at Runtime
|
|
|
|
|
Recipe 3.25. Writing Code That Is Compatible with the Widest Range of Managed Languages
|
|
|
|
|
Recipe 3.26. Building Cloneable Classes
|
|
|
|
|
Recipe 3.27. Assuring an Object's Disposal
|
|
|
|
|
Recipe 3.28. Releasing a COM Object Through Managed Code
|
|
|
|
|
Recipe 3.29. Creating an Object Cache
|
|
|
|
|
Recipe 3.30. Rolling Back Object Changes
|
|
|
|
|
Recipe 3.31. Disposing of Unmanaged Resources
|
|
|
|
|
Recipe 3.32. Determining Where Boxing and Unboxing Occur
|
|
|
|
Chapter 4. Generics
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 4.1. Deciding When and Where to Use Generics
|
|
|
|
|
Recipe 4.2. Understanding Generic Types
|
|
|
|
|
Recipe 4.3. Getting the Type of a Generic Type
|
|
|
|
|
Recipe 4.4. Replacing the ArrayList with Its Generic Counterpart
|
|
|
|
|
Recipe 4.5. Replacing the Stack and Queue with Their Generic Counterparts
|
|
|
|
|
Recipe 4.6. Implementing a Linked List
|
|
|
|
|
Recipe 4.7. Creating a Value Type That Can Be Initialized to Null
|
|
|
|
|
Recipe 4.8. Reversing the Contents of a Sorted List
|
|
|
|
|
Recipe 4.9. Making Read-Only Collections the Generic Way
|
|
|
|
|
Recipe 4.10. Replacing the Hashtable with Its Generic Counterpart
|
|
|
|
|
Recipe 4.11. Using foreach with Generic Dictionary Types
|
|
|
|
|
Recipe 4.12. Constraining Type Arguments
|
|
|
|
|
Recipe 4.13. Initializing Generic Variables to Their Default Values
|
|
|
|
Chapter 5. Collections
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 5.1. Swapping Two Elements in an Array
|
|
|
|
|
Recipe 5.2. Reversing an Array Quickly
|
|
|
|
|
Recipe 5.3. Reversing a Two-Dimensional Array
|
|
|
|
|
Recipe 5.4. Reversing a Jagged Array
|
|
|
|
|
Recipe 5.5. Writing a More Flexible StackTrace Class
|
|
|
|
|
Recipe 5.6. Determining the Number of Times an Item Appears in a List<T>
|
|
|
|
|
Recipe 5.7. Retrieving All Instances of a Specific Item in a List<T>
|
|
|
|
|
Recipe 5.8. Inserting and Removing Items from an Array
|
|
|
|
|
Recipe 5.9. Keeping Your List<T> Sorted
|
|
|
|
|
Recipe 5.10. Sorting a Dictionary's Keys and/or Values
|
|
|
|
|
Recipe 5.11. Creating a Dictionary with Max and Min Value Boundaries
|
|
|
|
|
Recipe 5.12. Displaying an Array's Data as a Delimited String
|
|
|
|
|
Recipe 5.13. Storing Snapshots of Lists in an Array
|
|
|
|
|
Recipe 5.14. Persisting a Collection Between Application Sessions
|
|
|
|
|
Recipe 5.15. Testing Every Element in an Array or List<T>
|
|
|
|
|
Recipe 5.16. Performing an Action on Each Element in an Array or List<T>
|
|
|
|
|
Recipe 5.17. Creating a Read-Only Array or List<T>
|
|
|
|
Chapter 6. Iterators and Partial Types
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 6.1. Implementing Nested foreach Functionality in a Class
|
|
|
|
|
Recipe 6.2. Creating Custom Enumerators
|
|
|
|
|
Recipe 6.3. Creating an Iterator on a Generic Type
|
|
|
|
|
Recipe 6.4. Creating an Iterator on a Non-generic Type
|
|
|
|
|
Recipe 6.5. Creating Iterators That Accept Parameters
|
|
|
|
|
Recipe 6.6. Adding Multiple Iterators on a Single Type
|
|
|
|
|
Recipe 6.7. Implementing Iterators as Overloaded Operators
|
|
|
|
|
Recipe 6.8. Forcing an Iterator to Stop Iterating
|
|
|
|
|
Recipe 6.9. Dealing with Finally Blocks and Iterators
|
|
|
|
|
Recipe 6.10. Organizing Your Interface Implementations
|
|
|
|
|
Recipe 6.11. Generating Code That Is No Longer in Your Main Code Paths
|
|
|
|
Chapter 7. Exception Handling
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 7.1. Verifying Critical Parameters
|
|
|
|
|
Recipe 7.2. Knowing When to Catch and Rethrow Exceptions
|
|
|
|
|
Recipe 7.3. Identifying Exceptions and Their Usage
|
|
|
|
|
Recipe 7.4. Handling Derived Exceptions Individually
|
|
|
|
|
Recipe 7.5. Assuring Exceptions Are Not Lost When Using Finally Blocks
|
|
|
|
|
Recipe 7.6. Handling Exceptions Thrown from Methods Invoked via Reflection
|
|
|
|
|
Recipe 7.7. Debugging Problems When Loading an Assembly
|
|
|
|
|
Recipe 7.8. Mapping Back and Forth Between Managed Exceptions and HRESULTs
|
|
|
|
|
Recipe 7.9. Handling User-Defined HRESULTs
|
|
|
|
|
Recipe 7.10. Preventing Unhandled Exceptions
|
|
|
|
|
Recipe 7.11. Getting Exception Information
|
|
|
|
|
Recipe 7.12. Getting to the Root of a Problem Quickly
|
|
|
|
|
Recipe 7.13. Creating a New Exception Type
|
|
|
|
|
Recipe 7.14. Obtaining a Stack Trace
|
|
|
|
|
Recipe 7.15. Breaking on a First-Chance Exception
|
|
|
|
|
Recipe 7.16. Preventing the Nefarious TypeInitializationException
|
|
|
|
|
Recipe 7.17. Handling Exceptions Thrown from an Asynchronous Delegate
|
|
|
|
|
Recipe 7.18. Giving Exceptions the Extra Info They Need with Exception.Data
|
|
|
|
|
Recipe 7.19. Looking at Exceptions in a New Way Using Visualizers
|
|
|
|
|
Recipe 7.20. Dealing with Unhandled Exceptions in WinForms Applications
|
|
|
|
Chapter 8. Diagnostics
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 8.1. Controlling Tracing Output in Production Code
|
|
|
|
|
Recipe 8.2. Providing Fine-Grained Control over Debugging/Tracing Output
|
|
|
|
|
Recipe 8.3. Creating Your Own Custom Switch Class
|
|
|
|
|
Recipe 8.4. Compiling Blocks of Code Conditionally
|
|
|
|
|
Recipe 8.5. Determining Whether a Process Has Stopped Responding
|
|
|
|
|
Recipe 8.6. Using Event Logs in Your Application
|
|
|
|
|
Recipe 8.7. Changing the Maximum Size of a Custom Event Log
|
|
|
|
|
Recipe 8.8. Searching Event Log Entries
|
|
|
|
|
Recipe 8.9. Watching the Event Log for a Specific Entry
|
|
|
|
|
Recipe 8.10. Finding All Sources Belonging to a Specific Event Log
|
|
|
|
|
Recipe 8.11. Implementing a Simple Performance Counter
|
|
|
|
|
Recipe 8.12. Implementing Performance Counters That Require a Base Counter
|
|
|
|
|
Recipe 8.13. Enabling and Disabling Complex Tracing Code
|
|
|
|
|
Recipe 8.14. Capturing Standard Output for a Process
|
|
|
|
|
Recipe 8.15. Creating Custom Debugging Displays for Your Classes
|
|
|
|
|
Recipe 8.16. Determining Current appdomain Settings Information
|
|
|
|
|
Recipe 8.17. Boosting the Priority of a Process Programmatically
|
|
|
|
|
Recipe 8.18. Looking at Your Runtime Environment and Seeing What You Can Do About It
|
|
|
|
Chapter 9. Delegates, Events, and Anonymous Methods
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 9.1. Controlling When and If a Delegate Fires Within a Multicast Delegate
|
|
|
|
|
Recipe 9.2. Obtaining Return Values from Each Delegate in a Multicast Delegate
|
|
|
|
|
Recipe 9.3. Handling Exceptions Individually for Each Delegate in a Multicast Delegate
|
|
|
|
|
Recipe 9.4. Converting Delegate Invocation from Synchronous to Asynchronous
|
|
|
|
|
Recipe 9.5. Wrapping Sealed Classes to Add Events
|
|
|
|
|
Recipe 9.6. Passing Specialized Parameters to and from an Event
|
|
|
|
|
Recipe 9.7. An Advanced Interface Search Mechanism
|
|
|
|
|
Recipe 9.8. An Advanced Member Search Mechanism
|
|
|
|
|
Recipe 9.9. Observing Additions and Modifications to a Hashtable
|
|
|
|
|
Recipe 9.10. Using the Windows Keyboard Hook
|
|
|
|
|
Recipe 9.11. Tracking and Responding to the Mouse
|
|
|
|
|
Recipe 9.12. Using Anonymous Methods
|
|
|
|
|
Recipe 9.13. Set up Event Handlers Without the Mess
|
|
|
|
|
Recipe 9.14. Using Different Parameter Modifiers in Anonymous Methods
|
|
|
|
|
Recipe 9.15. Using Closures in C#
|
|
|
|
|
Recipe 9.16. Performing Multiple Operations on a List Using Functors
|
|
|
|
Chapter 10. Regular Expressions
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 10.1. Enumerating Matches
|
|
|
|
|
Recipe 10.2. Extracting Groups from a MatchCollection
|
|
|
|
|
Recipe 10.3. Verifying the Syntax of a Regular Expression
|
|
|
|
|
Recipe 10.4. Quickly Finding Only the Last Match in a String
|
|
|
|
|
Recipe 10.5. Replacing Characters or Words in a String
|
|
|
|
|
Recipe 10.6. Augmenting the Basic String Replacement Function
|
|
|
|
|
Recipe 10.7. Implementing a Better Tokenizer
|
|
|
|
|
Recipe 10.8. Compiling Regular Expressions
|
|
|
|
|
Recipe 10.9. Counting Lines of Text
|
|
|
|
|
Recipe 10.10. Returning the Entire Line in Which a Match Is Found
|
|
|
|
|
Recipe 10.11. Finding a Particular Occurrence of a Match
|
|
|
|
|
Recipe 10.12. Using Common Patterns
|
|
|
|
|
Recipe 10.13. Documenting Your Regular Expressions
|
|
|
|
|
Recipe 10.14. Using Built-in Regular Expressions to Parse ASP. NET Pages
|
|
|
|
Chapter 11. Data Structures and Algorithms
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 11.1. Creating a Hash Code for a Data Type
|
|
|
|
|
Recipe 11.2. Creating a Priority Queue
|
|
|
|
|
Recipe 11.3. Creating a Double Queue
|
|
|
|
|
Recipe 11.4. Determining Where Characters or Strings Do Not Balance
|
|
|
|
|
Recipe 11.5. Creating a One-to-Many Map (MultiMap)
|
|
|
|
|
Recipe 11.6. Creating a Binary Tree
|
|
|
|
|
Recipe 11.7. Creating an n-ary Tree
|
|
|
|
|
Recipe 11.8. Creating a Set Object
|
|
|
|
Chapter 12. Filesystem I/O
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 12.1. Creating, Copying, Moving, or Deleting a File
|
|
|
|
|
Recipe 12.2. Manipulating File Attributes
|
|
|
|
|
Recipe 12.3. Renaming a File
|
|
|
|
|
Recipe 12.4. Determining Whether a File Exists
|
|
|
|
|
Recipe 12.5. Choosing a Method of Opening a File or Stream for Reading and/or Writing
|
|
|
|
|
Recipe 12.6. Accessing Part of a File Randomly
|
|
|
|
|
Recipe 12.7. Outputting a Platform-Independent EOL Character
|
|
|
|
|
Recipe 12.8. Creating, Writing to, and Reading from a File
|
|
|
|
|
Recipe 12.9. Determining Whether a Directory Exists
|
|
|
|
|
Recipe 12.10. Creating, Copying, Moving, or Deleting a Directory
|
|
|
|
|
Recipe 12.11. Manipulating Directory Attributes
|
|
|
|
|
Recipe 12.12. Renaming a Directory
|
|
|
|
|
Recipe 12.13. Searching for Directories or Files Using Wildcards
|
|
|
|
|
Recipe 12.14. Obtaining the Directory Tree
|
|
|
|
|
Recipe 12.15. Parsing a Path
|
|
|
|
|
Recipe 12.16. Parsing Paths in Environment Variables
|
|
|
|
|
Recipe 12.17. Verifying a Path
|
|
|
|
|
Recipe 12.18. Using a Temporary File in Your Application
|
|
|
|
|
Recipe 12.19. Opening a File Stream with Just a File Handle
|
|
|
|
|
Recipe 12.20. Writing to Multiple Output Files at One Time
|
|
|
|
|
Recipe 12.21. Launching and Interacting with Console Utilities
|
|
|
|
|
Recipe 12.22. Locking Subsections of a File
|
|
|
|
|
Recipe 12.23. Watching the Filesystem for Specific Changes to One or More Files or Directories
|
|
|
|
|
Recipe 12.24. Waiting for an Action to Occur in the Filesystem
|
|
|
|
|
Recipe 12.25. Comparing Version Information of Two Executable Modules
|
|
|
|
|
Recipe 12.26. Querying Information for All Drives on a System
|
|
|
|
|
Recipe 12.27. Encrypting/Decrypting an Existing File
|
|
|
|
|
Recipe 12.28. Compressing and Decompressing Your Files
|
|
|
|
Chapter 13. Reflection
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 13.1. Listing Referenced Assemblies
|
|
|
|
|
Recipe 13.2. Listing Exported Types
|
|
|
|
|
Recipe 13.3. Finding Overridden Methods
|
|
|
|
|
Recipe 13.4. Finding Members in an Assembly
|
|
|
|
|
Recipe 13.5. Finding Members Within an Interface
|
|
|
|
|
Recipe 13.6. Determining and Obtaining Nested Types Within an Assembly
|
|
|
|
|
Recipe 13.7. Displaying the Inheritance Hierarchy for a Type
|
|
|
|
|
Recipe 13.8. Finding the Subclasses of a Type
|
|
|
|
|
Recipe 13.9. Finding All Serializable Types Within an Assembly
|
|
|
|
|
Recipe 13.10. Filtering Output When Obtaining Members
|
|
|
|
|
Recipe 13.11. Dynamically Invoking Members
|
|
|
|
|
Recipe 13.12. Providing Guidance to Obfuscators
|
|
|
|
|
Recipe 13.13. Determining if a Type or Method Is Generic
|
|
|
|
|
Recipe 13.14. Reading Manifest Resources Programmatically
|
|
|
|
|
Recipe 13.15. Accessing Local Variable Information
|
|
|
|
|
Recipe 13.16. Creating a Generic Type
|
|
|
|
Chapter 14. Web
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 14.1. Converting an IP Address to a Hostname
|
|
|
|
|
Recipe 14.2. Converting a Hostname to an IP Address
|
|
|
|
|
Recipe 14.3. Parsing a URI
|
|
|
|
|
Recipe 14.4. Forming and Validating an Absolute Uri
|
|
|
|
|
Recipe 14.5. Handling Web Server Errors
|
|
|
|
|
Recipe 14.6. Communicating with a Web Server
|
|
|
|
|
Recipe 14.7. Going Through a Proxy
|
|
|
|
|
Recipe 14.8. Obtaining the HTML from a URL
|
|
|
|
|
Recipe 14.9. Using the New Web Browser Control
|
|
|
|
|
Recipe 14.10. Tying Database Tables to the Cache
|
|
|
|
|
Recipe 14.11. Caching Data with Multiple Dependencies
|
|
|
|
|
Recipe 14.12. Prebuilding an ASP.NET Web Site Programmatically
|
|
|
|
|
Recipe 14.13. Escaping and Unescaping Data for the Web
|
|
|
|
|
Recipe 14.14. Using the UriBuilder Class
|
|
|
|
|
Recipe 14.15. Inspect and Change Your Web Application Configuration
|
|
|
|
|
Recipe 14.16. Working with HTML
|
|
|
|
|
Recipe 14.17. Using Cached Results When Working with HTTP for Faster Performance
|
|
|
|
|
Recipe 14.18. Checking out a Web Server's Custom Error Pages
|
|
|
|
|
Recipe 14.19. Determining the Application Mappings for ASP.NET Set Up on IIS
|
|
|
|
Chapter 15. XML
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 15.1. Reading and Accessing XML Data in Document Order
|
|
|
|
|
Recipe 15.2. Reading XML on the Web
|
|
|
|
|
Recipe 15.3. Querying the Contents of an XML Document
|
|
|
|
|
Recipe 15.4. Validating XML
|
|
|
|
|
Recipe 15.5. Creating an XML Document Programmatically
|
|
|
|
|
Recipe 15.6. Detecting Changes to an XML Document
|
|
|
|
|
Recipe 15.7. Handling Invalid Characters in an XML String
|
|
|
|
|
Recipe 15.8. Transforming XML
|
|
|
|
|
Recipe 15.9. Tearing Apart an XML Document
|
|
|
|
|
Recipe 15.10.
Putting
Together an XML Document
|
|
|
|
|
Recipe 15.11. Validating Modified XML Documents Without Reloading
|
|
|
|
|
Recipe 15.12. Extending XSLT Transformations
|
|
|
|
|
Recipe 15.13. Getting Your Schema in Bulk from Existing XML Files
|
|
|
|
|
Recipe 15.14. Passing Parameters to XSLT Transformations
|
|
|
|
Chapter 16. Networking
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 16.1. Writing a TCP Server
|
|
|
|
|
Recipe 16.2. Writing a TCP Client
|
|
|
|
|
Recipe 16.3. Simulating Form Execution
|
|
|
|
|
Recipe 16.4. Downloading Data from a Server
|
|
|
|
|
Recipe 16.5. Using Named Pipes to Communicate
|
|
|
|
|
Recipe 16.6. Pinging Programmatically
|
|
|
|
|
Recipe 16.7. Send SMTP Mail Using the SMTP Service
|
|
|
|
|
Recipe 16.8. Check out Your Network Connectivity
|
|
|
|
|
Recipe 16.9. Use Sockets to Scan the Ports on a Machine
|
|
|
|
|
Recipe 16.10. Use the Current Internet Connection Settings
|
|
|
|
|
Recipe 16.11. Download a File Using FTP
|
|
|
|
Chapter 17. Security
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 17.1. Controlling Access to Types in a Local Assembly
|
|
|
|
|
Recipe 17.2. Encrypting/Decrypting a String
|
|
|
|
|
Recipe 17.3. Encrypting and Decrypting a File
|
|
|
|
|
Recipe 17.4. Cleaning up Cryptography Information
|
|
|
|
|
Recipe 17.5. Verifying that a String Remains Uncorrupted Following Transmission
|
|
|
|
|
Recipe 17.6. Wrapping a String Hash for Ease of Use
|
|
|
|
|
Recipe 17.7. A Better Random Number Generator
|
|
|
|
|
Recipe 17.8. Storing Data Securely
|
|
|
|
|
Recipe 17.9. Making a Security Assert Safe
|
|
|
|
|
Recipe 17.10. Preventing Malicious Modifications to an Assembly
|
|
|
|
|
Recipe 17.11. Verifying That an Assembly Has Been Granted Specific Permissions
|
|
|
|
|
Recipe 17.12. Minimizing the Attack Surface of an Assembly
|
|
|
|
|
Recipe 17.13. Obtaining Security/Audit Information
|
|
|
|
|
Recipe 17.14. Granting/Revoking Access to a File or Registry Key
|
|
|
|
|
Recipe 17.15. Protecting String Data with Secure Strings
|
|
|
|
|
Recipe 17.16. Securing Stream Data
|
|
|
|
|
Recipe 17.17. Encrypting web.config Information
|
|
|
|
|
Recipe 17.18. Obtaining the Full Reason a SecurityException Was Thrown
|
|
|
|
|
Recipe 17.19. Achieving Secure Unicode Encoding
|
|
|
|
|
Recipe 17.20. Obtaining a Safer File Handle
|
|
|
|
Chapter 18. Threading and Synchronization
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 18.1. Creating Per-Thread Static Fields
|
|
|
|
|
Recipe 18.2. Providing Thread-Safe Access to Class Members
|
|
|
|
|
Recipe 18.3. Preventing Silent Thread Termination
|
|
|
|
|
Recipe 18.4. Polling an Asynchronous Delegate
|
|
|
|
|
Recipe 18.5. Timing out an Asynchronous Delegate
|
|
|
|
|
Recipe 18.6. Being Notified of the Completion of an Asynchronous Delegate
|
|
|
|
|
Recipe 18.7. Determining Whether a Request for a Pooled Thread Will Be Queued
|
|
|
|
|
Recipe 18.8. Configuring a Timer
|
|
|
|
|
Recipe 18.9. Storing Thread-Specific Data Privately
|
|
|
|
|
Recipe 18.10. Granting Multiple Access to Resources with a Semaphore
|
|
|
|
|
Recipe 18.11. Synchronizing Multiple Processes with the Mutex
|
|
|
|
|
Recipe 18.12. Using Events to Make Threads Cooperate
|
|
|
|
|
Recipe 18.13. Get the Naming Rights for Your Events
|
|
|
|
|
Recipe 18.14. Performing Atomic Operations Among Threads
|
|
|
|
Chapter 19. Unsafe Code
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 19.1. Controlling Changes to Pointers Passed to Methods
|
|
|
|
|
Recipe 19.2. Comparing Pointers
|
|
|
|
|
Recipe 19.3. Navigating Arrays
|
|
|
|
|
Recipe 19.4. Manipulating a Pointer to a Fixed Array
|
|
|
|
|
Recipe 19.5. Returning a Pointer to a Particular Element in an Array
|
|
|
|
|
Recipe 19.6. Creating and Using an Array of Pointers
|
|
|
|
|
Recipe 19.7. Switching Unknown Pointer Types
|
|
|
|
|
Recipe 19.8. Converting a String to a char*
|
|
|
|
|
Recipe 19.9. Declaring a Fixed-Size Structure with an Embedded Array
|
|
|
|
Chapter 20. Toolbox
|
|
|
|
|
Introduction
|
|
|
|
|
Recipe 20.1. Dealing with Operating System Shutdown, Power Management, or User Session Changes
|
|
|
|
|
Recipe 20.2. Controlling a Service
|
|
|
|
|
Recipe 20.3. List What Processes an Assembly Is Loaded In
|
|
|
|
|
Recipe 20.4. Using Message Queues on a Local Workstation
|
|
|
|
|
Recipe 20.5. Finding the Path to the Current Framework Version
|
|
|
|
|
Recipe 20.6. Determining the Versions of an Assembly That Are Registered in the Global Assembly Cache (GAC)
|
|
|
|
|
Recipe 20.7. Getting the Windows Directory
|
|
|
|
|
Recipe 20.8. Capturing Output from the Standard Output Stream
|
|
|
|
|
Recipe 20.9. Running Code in Its Own appdomain
|
|
|
|
|
Recipe 20.10. Determining the Operating System and Service Pack Version of the Current Operating System
|
|
|
|
About the Authors
|
|
|
|
Colophon
|
|
|
|
Index
|
