| |  | 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 |
