- C# Cookbook
- 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 Sidesof 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 Occurrencesof a String Within Another 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 Headand/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 theCast Operator, the as Operator, or theis 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 toVersion 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 Range of 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 ThroughManaged 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 whenLoading 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 inProduction 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 Itemin 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 FilesUsing 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 aFile Handle
- 11.20. Write to Multiple Output Files at One Time
- 11.21. Launching and Interacting withConsole Utilities
- 11.22. Locking Subsections of a File
- 11.23. Watching the Filesystem for Specific Changes to One or More Files or Directories
- 11.24. Waiting for an Action to Occurin 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 aLocal 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 Completionof an Asynchronous Delegate
- 15.7. Waiting for Worker Thread Completion
- 15.8. Synchronizing the Reading and Writingof a Resource Efficiently
- 15.9. Determining Whether a Requestfor a Pooled Thread Will Be Queued
- 15.10. Waiting for All Threads in theThread Pool to Finish
- 15.11. Configuring a Timer
- 15.12. Storing Thread-Specific Data Privately
- 16. Unsafe Code
- 16.1. Controlling Changes to Pointers Passedto 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 Pointersto 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 Datain 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 anXML String
- 17.8. Transforming XML to HTML
- 17.9. Tearing Apart an XML Document
- 17.10. Putting Together an XML Document
- Index
- Colophon
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.