C# Cookbook

Larger Cover

C# Cookbook

By Stephen Teilhet, Jay Hilyard

Publisher: O'Reilly Media

Released: January 2004

Pages: 864

Easy to learn and use, the C# language is targeted at developers for Microsoft's .NET platform who've worked with a C-like language before, such as C, C++, or Java. There's no shortage of excellent tutorials and documentation to help new developers get a handle on the language, such as O'Reilly's Learning C# or Programming C#. But when you need practical answers to the day-to-day questions you run up against, a tutorial isn't going to do the trick. The C# Cookbook gets straight to the heart of the problem with code recipes collected especially for developers working on the .NET platform.

The C# Cookbook offers a definitive collection of solutions and examples for this new programming language. Recipes range from simple tasks to the more complex, and are organized with respect to the types of problems you'll need to solve as you progress in your experience as a C# programmer. Nearly every recipe contains a complete, documented code sample showing you how to solve the specific problem, as well as a discussion of how the underlying technology works and a discussion of alternatives, limitations, and other considerations where appropriate.

The recipes in the C# Cookbook are organized into seventeen chapters, each of which focuses on a particular topic in creating C# solutions. Among the topics covered, you'll find:

Numeric data types in C#
Strings and characters
Classes and structures
Exception handling
Delegates and events
Regular expressions
Data structures and algorithms
Networking
Security
Unsafe Code

You don't need to be an experienced C# or .NET developer to use this book. The C# Cookbook is designed for users of all levels with recipes targeted at the real-world developer who needs to solve problems now, not learn lots of theory first. With this guide, all developers will be able to learn and improve their mastery of both the language and the .NET Framework Class Libraries.

Chapter 1 Numbers
1. Determining Approximate Equality Between a Fraction and Floating-Point Value
2. Converting Degrees to Radians
3. Converting Radians to Degrees
4. Using the Bitwise Complement Operator with Various Data Types
5. Test for an Even or Odd Value
6. Obtaining the Most- or Least-Significant Bits of a Number
7. Converting a Number in Another Base to Base10
8. Determining Whether a String Is a Valid Number
9. Rounding a Floating-Point Value
10. Different Rounding Algorithms
11. Converting Celsius to Fahrenheit
12. Converting Fahrenheit to Celsius
13. Safely Performing a Narrowing Numeric Cast
14. Finding the Length of Any Three Sidesof a Right Triangle
15. Finding the Angles of a Right Triangle
Chapter 2 Strings and Characters
1. Determining the Kind of Character
2. Determining Whether a Character Is Within a Specified Range
3. Controlling Case Sensitivity when Comparing Two Characters
4. Finding All Occurrences of a Character Within a String
5. Finding the Location of All Occurrencesof a String Within Another String
6. The Poor Man’s Tokenizer
7. Controlling Case Sensitivity when Comparing Two Strings
8. Comparing a String to the Beginning or End of a Second String
9. Inserting Text into a String
10. Removing or Replacing Characters Within a String
11. Encoding Binary Data as Base64
12. Decoding a Base64-Encoded Binary
13. Converting a String Returned as a Byte[ ] Back into a String
14. Passing a String to a Method that Accepts Only a Byte[ ]
15. Converting Strings to Their Equivalent Value Type
16. Formatting Data in Strings
17. Creating a Delimited String
18. Extracting Items from a Delimited String
19. Setting the Maximum Number of Characters a String Can Contain
20. Iterating Over Each Character in a String
21. Improving String Comparison Performance
22. Improving StringBuilder Performance
23. Pruning Characters from the Headand/or Tail of a String
Chapter 3 Classes and Structures
1. Creating Union-Type Structures
2. Allowing a Type to Represent Itself as a String
3. Converting a String Representation of an Object into an Actual Object
4. Polymorphism via Concrete or Abstract Base Classes
5. Making a Type Sortable
6. Making a Type Searchable
7. Indirectly Overloading the +=, -=, /=, and *= Operators
8. Indirectly Overloading the &&, ||, and ?: Operators
9. Improving the Performance of a Structure’s Equals Method
10. Turning Bits On or Off
11. Making Error-Free Expressions
12. Minimizing (Reducing) Your Boolean Logic
13. Converting Between Simple Types in a Language Agnostic Manner
14. Determining Whether to Use theCast Operator, the as Operator, or theis Operator
15. Casting with the as Operator
16. Determining a Variable’s Type with the is Operator
17. Polymorphism via Interfaces
18. Calling the Same Method on Multiple Object Types
19. Adding a Notification Callback Using an Interface
20. Using Multiple Entry Points toVersion an Application
21. Preventing the Creation of an Only Partially Initialized Object
22. Returning Multiple Items from a Method
23. Parsing Command-Line Parameters
24. Retrofitting a Class to Interoperate with COM
25. Initializing a Constant Field at Runtime
26. Writing Code that Is Compatible with the Widest Range of Managed Languages
27. Implementing Nested foreach Functionality in a Class
28. Building Cloneable Classes
29. Assuring an Object’s Disposal
30. Releasing a COM Object ThroughManaged Code
31. Creating an Object Cache
32. The Single Instance Object
33. Choosing a Serializer
34. Creating Custom Enumerators
35. Rolling Back Object Changes
36. Disposing of Unmanaged Resources
37. Determining Where Boxing and Unboxing Occur
Chapter 4 Enumerations
1. Displaying an Enumeration Value as a String
2. Converting Plain Text to an Equivalent Enumeration Value
3. Testing for a Valid Enumeration Value
4. Testing for a Valid Enumeration of Flags
5. Using Enumerated Members in a Bitmask
6. Determining Whether One or More Enumeration Flags Are Set
Chapter 5 Exception Handling
1. Verifying Critical Parameters
2. Indicating Where Exceptions Originate
3. Choosing when to Throw a Particular Exception
4. Handling Derived Exceptions Individually
5. Assuring Exceptions are Not Lost when Using Finally Blocks
6. Handling Exceptions Thrown from Methods Invoked via Reflection
7. Debugging Problems whenLoading an Assembly
8. HRESULT-Exception Mapping
9. Handling User-Defined HRESULTs
10. Preventing Unhandled Exceptions
11. Displaying Exception Information
12. Getting to the Root of a Problem Quickly
13. Creating a New Exception Type
14. Obtaining a Stack Trace
15. Breaking on a First Chance Exception
16. Preventing the Nefarious TypeInitializationException
17. Handling Exceptions Thrown from an Asynchronous Delegate
Chapter 6 Diagnostics
1. Controlling Tracing Output inProduction Code
2. Providing Fine-Grained Control Over Debugging/Tracing Output
3. Creating Your Own Custom Switch Class
4. A Custom Trace Class that Outputs Information in an XML Format
5. Conditionally Compiling Blocks of Code
6. Determining Whether a Process Has Stopped Responding
7. Using One or More Event Logs in Your Application
8. Changing the Maximum Size of a Custom Event Log
9. Searching Event Log Entries
10. Watching the Event Log for a Specific Entry
11. Finding All Sources Belonging to a Specific Event Log
12. Implementing a Simple Performance Counter
13. Implementing Performance Counters that Require a Base Counter
14. Enable/Disable Complex Tracing Code
Chapter 7 Delegates and Events
1. Controlling when and if a Delegate Fires Within a Multicast Delegate
2. Obtaining Return Values from Each Delegate in a Multicast Delegate
3. Handling Exceptions Individually for Each Delegate in a Multicast Delegate
4. Converting a Synchronous Delegate to an Asynchronous Delegate
5. Adding Events to a Sealed Class
6. Passing Specialized Parameters to and from an Event
7. An Advanced Interface Search Mechanism
8. An Advanced Member Search Mechanism
9. Observing Additions and Modifications to a Hashtable
10. Using the Windows Keyboard Hook
11. Using Windows Hooks to Manipulate the Mouse
Chapter 8 Regular Expressions
1. Enumerating Matches
2. Extracting Groups from a MatchCollection
3. Verifying the Syntax of a Regular Expression
4. Quickly Finding Only the Last Match in a String
5. Replacing Characters or Words in a String
6. Augmenting the Basic String Replacement Function
7. A Better Tokenizer
8. Compiling Regular Expressions
9. Counting Lines of Text
10. Returning the Entire Line in Which a Match Is Found
11. Finding a Particular Occurrence of a Match
12. Using Common Patterns
13. Documenting Your Regular Expressions
Chapter 9 Collections
1. Swapping Two Elements in an Array
2. Quickly Reversing an Array
3. Reversing a Two-Dimensional Array
4. Reversing a Jagged Array
5. A More Flexible StackTrace Class
6. Determining the Number of Times an Item Appears in an ArrayList
7. Retrieving All Instances of a Specific Itemin an ArrayList
8. Inserting and Removing Items from an Array
9. Keeping Your ArrayList Sorted
10. Sorting a Hashtable’s Keys and/or Values
11. Creating a Hashtable with Max and Min Size Boundaries
12. Creating a Hashtable with Max and Min Value Boundaries
13. Displaying an Array’s Data as a Delimited String
14. Storing Snapshots of Lists in an Array
15. Creating a Strongly Typed Collection
16. Persisting a Collection Between Application Sessions
Chapter 10 Data Structures and Algorithms
1. Creating a Hash Code for a Data Type
2. Creating a Priority Queue
3. Creating a More Versatile Queue
4. Determining Where Characters or Strings Do Not Balance
5. Creating a One-to-Many Map (MultiMap)
6. Creating a Binary Tree
7. Creating an n-ary Tree
8. Creating a Set Object
Chapter 11 Filesystem I/O
1. Creating, Copying, Moving, and Deleting a File
2. Manipulating File Attributes
3. Renaming a File
4. Determining Whether a File Exists
5. Choosing a Method of Opening a File or Stream for Reading and/or Writing
6. Randomly Accessing Part of a File
7. Outputting a Platform-Independent EOL Character
8. Create, Write to, and Read from a File
9. Determining Whether a Directory Exists
10. Creating, Moving, and Deleting a Directory
11. Manipulating Directory Attributes
12. Renaming a Directory
13. Searching for Directories or FilesUsing Wildcards
14. Obtaining the Directory Tree
15. Parsing a Path
16. Parsing Paths in Environment Variables
17. Verifying a Path
18. Using a Temporary File in Your Application
19. Opening a File Stream with just aFile Handle
20. Write to Multiple Output Files at One Time
21. Launching and Interacting withConsole Utilities
22. Locking Subsections of a File
23. Watching the Filesystem for Specific Changes to One or More Files or Directories
24. Waiting for an Action to Occurin the Filesystem
25. Comparing Version Information of Two Executable Modules
Chapter 12 Reflection
1. Listing Imported Assemblies
2. Listing Exported Types
3. Finding Overridden Methods
4. Finding Members in an Assembly
5. Finding Members Within an Interface
6. Obtaining Types Nested Within a Type
7. Displaying the Inheritance Hierarchy for a Type
8. Finding the Subclasses of a Type
9. Finding All Serializable Types Within an Assembly
10. Controlling Additions to an ArrayList Through Attributes
11. Filtering Output when Obtaining Members
12. Dynamically Invoking Members
Chapter 13 Networking
1. Converting an IP Address to a Hostname
2. Converting a Hostname to an IP Address
3. Parsing a URI
4. Forming an Absolute URI
5. Handling Web Server Errors
6. Communicating with a Web Server
7. Going Through a Proxy
8. Obtaining the HTML from a URL
9. Writing a TCP Server
10. Writing a TCP Client
11. Simulating Form Execution
12. Downloading Data from a Server
13. Using Named Pipes to Communicate
Chapter 14 Security
1. Controlling Access to Types in aLocal Assembly
2. Encrypting/Decrypting a String
3. Encrypting and Decrypting a File
4. Cleaning Up Cryptography Information
5. Verifying that a String Is Uncorrupted During Transmission
6. Wrapping a String Hash for Ease of Use
7. A Better Random Number Generator
8. Securely Storing Data
9. Making a Security Assert Safe
10. Preventing Malicious Modifications to an Assembly
11. Verifying that an Assembly Has Been Granted Specific Permissions
12. Minimizing the Attack Surface of an Assembly
Chapter 15 Threading
1. Creating Per-Thread Static Fields
2. Providing Thread Safe Access to Class Members
3. Preventing Silent Thread Termination
4. Polling an Asynchronous Delegate
5. Timing Out an Asynchronous Delegate
6. Being Notified of the Completionof an Asynchronous Delegate
7. Waiting for Worker Thread Completion
8. Synchronizing the Reading and Writingof a Resource Efficiently
9. Determining Whether a Requestfor a Pooled Thread Will Be Queued
10. Waiting for All Threads in theThread Pool to Finish
11. Configuring a Timer
12. Storing Thread-Specific Data Privately
Chapter 16 Unsafe Code
1. Controlling Changes to Pointers Passedto Methods
2. Comparing Pointers
3. Navigating Arrays
4. Manipulating a Pointer to a Fixed Array
5. Returning a Pointer to a Particular Element in an Array
6. Creating and Using an Array of Pointers
7. Creating and Using an Array of Pointersto Unknown Types
8. Switching Unknown Pointer Types
9. Breaking Up Larger Numbers into Their Equivalent Byte Array Representation
10. Converting Pointers to a Byte[ ], SByte[ ],or Char[ ] to a String
Chapter 17 XML
1. Reading and Accessing XML Datain Document Order
2. Reading XML on the Web
3. Querying the Contents of an XML Document
4. Validating XML
5. Creating an XML Document Programmatically
6. Detecting Changes to an XML Document
7. Handling Invalid Characters in anXML String
8. Transforming XML to HTML
9. Tearing Apart an XML Document
10. Putting Together an XML Document

Colophon

Title:

C# Cookbook

By:

Stephen Teilhet, Jay Hilyard

Publisher:

O'Reilly Media

Formats:

Print
Safari Books Online

Print:

January 2004

Pages:

864

Print ISBN:

978-0-596-00339-5

| ISBN 10:

0-596-00339-0

Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of C# Cookbook is a garter snake (Thamnophis sirtalis). Named because their longitudinal stripes resemble those on garters once used to hold up men's socks, garter snakes are easily identified by their distinctive stripes: a narrow stripe down the middle of the back with a broad stripe on each side of it. Color and pattern variations enable them to blend into their native environments, helping them evade predators. They are the most common snake in North America and the only species of snake found in Alaska.

Garter snakes have keeled scales--one or more ridges down the central axis of the scales--giving them a rough texture and lackluster appearance. Adult garter snakes generally range in length between 46 and 130 centimeters (one and a half feet to over four feet). Females are usually larger than males, with shorter tails and a bulge where the body and tail meet.

Female garters are ovoviviparous, meaning they deliver "live" young that have gestated in soft eggs. Upon delivery, most of the eggs and mucous membranes have broken, which makes their births appear live. Occasionally, a baby will be born still inside its soft shell. A female will usually deliver 10 to 40 babies: the largest recorded number of live babies birthed by a garter snake is 98. Once emerging from their mothers, baby garters are completely independent and must begin fending for themselves. During this time they are most susceptible to predation, and over half of all baby garters die before they are one year old.

Garter snakes are one of the few animals able to eat toads, newts, and other amphibians with strong chemical defenses. Although diets vary depending on their environments, garter snakes mostly eat earthworms and amphibians; however, they occasionally dine on baby birds, fish, and small rodents. Garter snakes have toxic saliva (harmless to humans), which they use to stun or kill their prey before swallowing them whole. Marlowe Shaeffer was the production editor and proofreader for C# Cookbook. Nancy Kotary was the copyeditor. Reg Aubry and Darren Kelly provided quality control. Jamie Peppard and Mary Agner provided production assistance. Angela Howard wrote the index.

Emma Colby designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

David Futato designed the interior layout. This book was converted by Julie Hawks to FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Marlowe Shaeffer.

Description

Table of Contents

Product Details

About the Author

Colophon

Recommended for You

Chapter 1 Numbers

Determining Approximate Equality Between a Fraction and Floating-Point Value

Converting Degrees to Radians

Converting Radians to Degrees

Using the Bitwise Complement Operator with Various Data Types

Test for an Even or Odd Value

Obtaining the Most- or Least-Significant Bits of a Number

Converting a Number in Another Base to Base10

Determining Whether a String Is a Valid Number

Rounding a Floating-Point Value

Different Rounding Algorithms

Converting Celsius to Fahrenheit

Converting Fahrenheit to Celsius

Safely Performing a Narrowing Numeric Cast

Finding the Length of Any Three Sidesof a Right Triangle

Finding the Angles of a Right Triangle

Chapter 2 Strings and Characters

Determining the Kind of Character

Determining Whether a Character Is Within a Specified Range

Controlling Case Sensitivity when Comparing Two Characters

Finding All Occurrences of a Character Within a String

Finding the Location of All Occurrencesof a String Within Another String

The Poor Man’s Tokenizer

Controlling Case Sensitivity when Comparing Two Strings

Comparing a String to the Beginning or End of a Second String

Inserting Text into a String

Removing or Replacing Characters Within a String

Encoding Binary Data as Base64

Decoding a Base64-Encoded Binary

Converting a String Returned as a Byte[ ] Back into a String

Passing a String to a Method that Accepts Only a Byte[ ]

Converting Strings to Their Equivalent Value Type

Formatting Data in Strings

Creating a Delimited String

Extracting Items from a Delimited String

Setting the Maximum Number of Characters a String Can Contain

Iterating Over Each Character in a String

Improving String Comparison Performance

Improving StringBuilder Performance

Pruning Characters from the Headand/or Tail of a String

Chapter 3 Classes and Structures

Creating Union-Type Structures

Allowing a Type to Represent Itself as a String

Converting a String Representation of an Object into an Actual Object

Polymorphism via Concrete or Abstract Base Classes

Making a Type Sortable

Making a Type Searchable

Indirectly Overloading the +=, -=, /=, and *= Operators

Indirectly Overloading the &&, ||, and ?: Operators

Improving the Performance of a Structure’s Equals Method

Turning Bits On or Off

Making Error-Free Expressions

Minimizing (Reducing) Your Boolean Logic

Converting Between Simple Types in a Language Agnostic Manner

Determining Whether to Use theCast Operator, the as Operator, or theis Operator

Casting with the as Operator

Determining a Variable’s Type with the is Operator

Polymorphism via Interfaces

Calling the Same Method on Multiple Object Types

Adding a Notification Callback Using an Interface

Using Multiple Entry Points toVersion an Application

Preventing the Creation of an Only Partially Initialized Object

Returning Multiple Items from a Method

Parsing Command-Line Parameters

Retrofitting a Class to Interoperate with COM

Initializing a Constant Field at Runtime

Writing Code that Is Compatible with the Widest Range of Managed Languages

Implementing Nested foreach Functionality in a Class

Building Cloneable Classes

Assuring an Object’s Disposal

Releasing a COM Object ThroughManaged Code

Creating an Object Cache

The Single Instance Object

Choosing a Serializer

Creating Custom Enumerators

Rolling Back Object Changes

Disposing of Unmanaged Resources

Determining Where Boxing and Unboxing Occur

Chapter 4 Enumerations

Displaying an Enumeration Value as a String