C# Cookbook

Larger Cover

C# Cookbook, 2nd Edition

350 Solutions for C# Programmers

By Jay Hilyard, Stephen Teilhet

Publisher: O'Reilly Media

Released: January 2006

Pages: 1192

With C# Cookbook, 2nd Edition, you'll be able to learn and improve your mastery of both the C# language and the .NET platform. This updated bestseller has been completely revised to account for C# 2.0, the latest version of this popular object-oriented programming language. It also includes more than 100 new code solutions (over 300 overall) to common problems and tasks that you're sure to face as a C# programmer.

Nearly every solution, or "recipe," contains a complete, documented code sample showing you how to solve the specific problem, as well as a detailed discussion of how and why the underling technology works. This question-solution-discussion format is a proven teaching method, as any fan of O'Reilly's "Cookbook" series can attest to. In fact, no other source offers a learn-as-you-go format quite like this.

C# Cookbook, 2nd Edition is organized into 20 chapters, each of which focuses on a particular topic in creating C# solutions. Here are just some of what's covered:

Numeric data types
Strings and characters
Classes and structures
Generics
Exception handling
Delegates, events, and anonymous methods
Filesystem interactions
Web site access
XML usage (including XPath and XSLT)
Networking
Threading
Unsafe code

Best of all, you don't have to be an experienced C# or .NET developer to use C# Cookbook, 2nd Edition. You just have to be someone who wants to solve a problem now, without having to learn all the related theory first.

Chapter 1 Numbers and Enumerations
1. Introduction
2. Determining Approximate Equality Between a Fraction and Floating-Point Value
3. Converting Degrees to Radians
4. Converting Radians to Degrees
5. Using the Bitwise Complement Operator with Various Data Types
6. Testing for an Even or Odd Value
7. Obtaining the High Word or Low Word of a Number
8. Converting a Number in Another Base to Base10
9. Determining Whether a String Is a Valid Number
10. Rounding a Floating-Point Value
11. Choosing a Rounding Algorithm
12. Converting Celsius to Fahrenheit
13. Converting Fahrenheit to Celsius
14. Safely Performing a Narrowing Numeric Cast
15. Finding the Length of Any Three Sides of a Right Triangle
16. Finding the Angles of a Right Triangle
17. Displaying an Enumeration Value as a String
18. Converting Plain Text to an Equivalent Enumeration Value
19. Testing for a Valid Enumeration Value
20. Testing for a Valid Enumeration of Flags
21. Using Enumerated Members in a Bit Mask
22. Determining if One or More Enumeration Flags Are Set
23. Determining the Integral Part of a Decimal or Double
Chapter 2 Strings and Characters
1. Introduction
2. Determining the Kind of Character a char Contains
3. Determining Whether a Character Is Within a Specified Range
4. Controlling Case Sensitivity When Comparing Two Characters
5. Finding All Occurrences of a Character Within a String
6. Finding the Location of All Occurrences of a String Within Another String
7. Implementing a Poor Man's Tokenizer to Deconstruct a String
8. Controlling Case Sensitivity When Comparing Two Strings
9. Comparing a String to the Beginning or End of a Second String
10. Inserting Text into a String
11. Removing or Replacing Characters Within a String
12. Encoding Binary Data as Base64
13. Decoding a Base64-Encoded Binary
14. Converting a String Returned as a Byte[ ] Back into a String
15. Passing a String to a Method That Accepts only a Byte[ ]
16. Converting Strings to Other Types
17. Formatting Data in Strings
18. Creating a Delimited String
19. Extracting Items from a Delimited String
20. Setting the Maximum Number of Characters a StringBuilder Can Contain
21. Iterating over Each Character in a String
22. Improving String Comparison Performance
23. Improving StringBuilder Performance
24. Pruning Characters from the Head and/or Tail of a String
25. Testing a String for Null or Empty
26. Appending a Line
27. Encoding Chunks of Data
Chapter 3 Classes and Structures
1. Introduction
2. Creating Union-Type Structures
3. Allowing a Type to Represent Itself as a String
4. Converting a String Representation of an Object into an Actual Object
5. Implementing Polymorphism with Abstract Base Classes
6. Making a Type Sortable
7. Making a Type Searchable
8. Indirectly Overloading the +=, -=, /=, and *= Operators
9. Indirectly Overloading the &&, ||, and ?: Operators
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 When to Use the Cast Operator, the as Operator, or the is Operator
15. Casting with the as Operator
16. Determining a Variable's Type with the is Operator
17. Implementing Polymorphism with Interfaces
18. Calling the Same Method on Multiple Object Types
19. Adding a Notification Callback Using an Interface
20. Using Multiple Entry Points to Version 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. Building Cloneable Classes
28. Assuring an Object's Disposal
29. Releasing a COM Object Through Managed Code
30. Creating an Object Cache
31. Rolling Back Object Changes
32. Disposing of Unmanaged Resources
33. Determining Where Boxing and Unboxing Occur
Chapter 4 Generics
1. Introduction
2. Deciding When and Where to Use Generics
3. Understanding Generic Types
4. Getting the Type of a Generic Type
5. Replacing the ArrayList with Its Generic Counterpart
6. Replacing the Stack and Queue with Their Generic Counterparts
7. Implementing a Linked List
8. Creating a Value Type That Can Be Initialized to Null
9. Reversing the Contents of a Sorted List
10. Making Read-Only Collections the Generic Way
11. Replacing the Hashtable with Its Generic Counterpart
12. Using foreach with Generic Dictionary Types
13. Constraining Type Arguments
14. Initializing Generic Variables to Their Default Values
Chapter 5 Collections
1. Introduction
2. Swapping Two Elements in an Array
3. Reversing an Array Quickly
4. Reversing a Two-Dimensional Array
5. Reversing a Jagged Array
6. Writing a More Flexible StackTrace Class
7. Determining the Number of Times an Item Appears in a List<T>
8. Retrieving All Instances of a Specific Item in a List<T>
9. Inserting and Removing Items from an Array
10. Keeping Your List<T> Sorted
11. Sorting a Dictionary's Keys and/or Values
12. Creating a Dictionary 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. Persisting a Collection Between Application Sessions
16. Testing Every Element in an Array or List<T>
17. Performing an Action on Each Element in an Array or List<T>
18. Creating a Read-Only Array or List<T>
Chapter 6 Iterators and Partial Types
1. Introduction
2. Implementing Nested foreach Functionality in a Class
3. Creating Custom Enumerators
4. Creating an Iterator on a Generic Type
5. Creating an Iterator on a Non-generic Type
6. Creating Iterators That Accept Parameters
7. Adding Multiple Iterators on a Single Type
8. Implementing Iterators as Overloaded Operators
9. Forcing an Iterator to Stop Iterating
10. Dealing with Finally Blocks and Iterators
11. Organizing Your Interface Implementations
12. Generating Code That Is No Longer in Your Main Code Paths
Chapter 7 Exception Handling
1. Introduction
2. Verifying Critical Parameters
3. Knowing When to Catch and Rethrow Exceptions
4. Identifying Exceptions and Their Usage
5. Handling Derived Exceptions Individually
6. Assuring Exceptions Are Not Lost When Using Finally Blocks
7. Handling Exceptions Thrown from Methods Invoked via Reflection
8. Debugging Problems When Loading an Assembly
9. Mapping Back and Forth Between Managed Exceptions and HRESULTs
10. Handling User-Defined HRESULTs
11. Preventing Unhandled Exceptions
12. Getting Exception Information
13. Getting to the Root of a Problem Quickly
14. Creating a New Exception Type
15. Obtaining a Stack Trace
16. Breaking on a First-Chance Exception
17. Preventing the Nefarious TypeInitializationException
18. Handling Exceptions Thrown from an Asynchronous Delegate
19. Giving Exceptions the Extra Info They Need with Exception.Data
20. Looking at Exceptions in a New Way Using Visualizers
21. Dealing with Unhandled Exceptions in WinForms Applications
Chapter 8 Diagnostics
1. Introduction
2. Controlling Tracing Output in Production Code
3. Providing Fine-Grained Control over Debugging/Tracing Output
4. Creating Your Own Custom Switch Class
5. Compiling Blocks of Code Conditionally
6. Determining Whether a Process Has Stopped Responding
7. Using 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. Enabling and Disabling Complex Tracing Code
15. Capturing Standard Output for a Process
16. Creating Custom Debugging Displays for Your Classes
17. Determining Current appdomain Settings Information
18. Boosting the Priority of a Process Programmatically
19. Looking at Your Runtime Environment and Seeing What You Can Do About It
Chapter 9 Delegates, Events, and Anonymous Methods
1. Introduction
2. Controlling When and If a Delegate Fires Within a Multicast Delegate
3. Obtaining Return Values from Each Delegate in a Multicast Delegate
4. Handling Exceptions Individually for Each Delegate in a Multicast Delegate
5. Converting Delegate Invocation from Synchronous to Asynchronous
6. Wrapping Sealed Classes to Add Events
7. Passing Specialized Parameters to and from an Event
8. An Advanced Interface Search Mechanism
9. An Advanced Member Search Mechanism
10. Observing Additions and Modifications to a Hashtable
11. Using the Windows Keyboard Hook
12. Tracking and Responding to the Mouse
13. Using Anonymous Methods
14. Set up Event Handlers Without the Mess
15. Using Different Parameter Modifiers in Anonymous Methods
16. Using Closures in C#
17. Performing Multiple Operations on a List Using Functors
Chapter 10 Regular Expressions
1. Introduction
2. Enumerating Matches
3. Extracting Groups from a MatchCollection
4. Verifying the Syntax of a Regular Expression
5. Quickly Finding Only the Last Match in a String
6. Replacing Characters or Words in a String
7. Augmenting the Basic String Replacement Function
8. Implementing a Better Tokenizer
9. Compiling Regular Expressions
10. Counting Lines of Text
11. Returning the Entire Line in Which a Match Is Found
12. Finding a Particular Occurrence of a Match
13. Using Common Patterns
14. Documenting Your Regular Expressions
15. Using Built-in Regular Expressions to Parse ASP. NET Pages
Chapter 11 Data Structures and Algorithms
1. Introduction
2. Creating a Hash Code for a Data Type
3. Creating a Priority Queue
4. Creating a Double Queue
5. Determining Where Characters or Strings Do Not Balance
6. Creating a One-to-Many Map (MultiMap)
7. Creating a Binary Tree
8. Creating an n-ary Tree
9. Creating a Set Object
Chapter 12 Filesystem I/O
1. Introduction
2. Creating, Copying, Moving, or Deleting a File
3. Manipulating File Attributes
4. Renaming a File
5. Determining Whether a File Exists
6. Choosing a Method of Opening a File or Stream for Reading and/or Writing
7. Accessing Part of a File Randomly
8. Outputting a Platform-Independent EOL Character
9. Creating, Writing to, and Reading from a File
10. Determining Whether a Directory Exists
11. Creating, Copying, Moving, or Deleting a Directory
12. Manipulating Directory Attributes
13. Renaming a Directory
14. Searching for Directories or Files Using Wildcards
15. Obtaining the Directory Tree
16. Parsing a Path
17. Parsing Paths in Environment Variables
18. Verifying a Path
19. Using a Temporary File in Your Application
20. Opening a File Stream with Just a File Handle
21. Writing to Multiple Output Files at One Time
22. Launching and Interacting with Console Utilities
23. Locking Subsections of a File
24. Watching the Filesystem for Specific Changes to One or More Files or Directories
25. Waiting for an Action to Occur in the Filesystem
26. Comparing Version Information of Two Executable Modules
27. Querying Information for All Drives on a System
28. Encrypting/Decrypting an Existing File
29. Compressing and Decompressing Your Files
Chapter 13 Reflection
1. Introduction
2. Listing Referenced Assemblies
3. Listing Exported Types
4. Finding Overridden Methods
5. Finding Members in an Assembly
6. Finding Members Within an Interface
7. Determining and Obtaining Nested Types Within an Assembly
8. Displaying the Inheritance Hierarchy for a Type
9. Finding the Subclasses of a Type
10. Finding All Serializable Types Within an Assembly
11. Filtering Output When Obtaining Members
12. Dynamically Invoking Members
13. Providing Guidance to Obfuscators
14. Determining if a Type or Method Is Generic
15. Reading Manifest Resources Programmatically
16. Accessing Local Variable Information
17. Creating a Generic Type
Chapter 14 Web
1. Introduction
2. Converting an IP Address to a Hostname
3. Converting a Hostname to an IP Address
4. Parsing a URI
5. Forming and Validating an Absolute Uri
6. Handling Web Server Errors
7. Communicating with a Web Server
8. Going Through a Proxy
9. Obtaining the HTML from a URL
10. Using the New Web Browser Control
11. Tying Database Tables to the Cache
12. Caching Data with Multiple Dependencies
13. Prebuilding an ASP.NET Web Site Programmatically
14. Escaping and Unescaping Data for the Web
15. Using the UriBuilder Class
16. Inspect and Change Your Web Application Configuration
17. Working with HTML
18. Using Cached Results When Working with HTTP for Faster Performance
19. Checking out a Web Server's Custom Error Pages
20. Determining the Application Mappings for ASP.NET Set Up on IIS
Chapter 15 XML
1. Introduction
2. Reading and Accessing XML Data in Document Order
3. Reading XML on the Web
4. Querying the Contents of an XML Document
5. Validating XML
6. Creating an XML Document Programmatically
7. Detecting Changes to an XML Document
8. Handling Invalid Characters in an XML String
9. Transforming XML
10. Tearing Apart an XML Document
11. Putting Together an XML Document
12. Validating Modified XML Documents Without Reloading
13. Extending XSLT Transformations
14. Getting Your Schema in Bulk from Existing XML Files
15. Passing Parameters to XSLT Transformations
Chapter 16 Networking
1. Introduction
2. Writing a TCP Server
3. Writing a TCP Client
4. Simulating Form Execution
5. Downloading Data from a Server
6. Using Named Pipes to Communicate
7. Pinging Programmatically
8. Send SMTP Mail Using the SMTP Service
9. Check out Your Network Connectivity
10. Use Sockets to Scan the Ports on a Machine
11. Use the Current Internet Connection Settings
12. Download a File Using FTP
Chapter 17 Security
1. Introduction
2. Controlling Access to Types in a Local Assembly
3. Encrypting/Decrypting a String
4. Encrypting and Decrypting a File
5. Cleaning up Cryptography Information
6. Verifying that a String Remains Uncorrupted Following Transmission
7. Wrapping a String Hash for Ease of Use
8. A Better Random Number Generator
9. Storing Data Securely
10. Making a Security Assert Safe
11. Preventing Malicious Modifications to an Assembly
12. Verifying That an Assembly Has Been Granted Specific Permissions
13. Minimizing the Attack Surface of an Assembly
14. Obtaining Security/Audit Information
15. Granting/Revoking Access to a File or Registry Key
16. Protecting String Data with Secure Strings
17. Securing Stream Data
18. Encrypting web.config Information
19. Obtaining the Full Reason a SecurityException Was Thrown
20. Achieving Secure Unicode Encoding
21. Obtaining a Safer File Handle
Chapter 18 Threading and Synchronization
1. Introduction
2. Creating Per-Thread Static Fields
3. Providing Thread-Safe Access to Class Members
4. Preventing Silent Thread Termination
5. Polling an Asynchronous Delegate
6. Timing out an Asynchronous Delegate
7. Being Notified of the Completion of an Asynchronous Delegate
8. Determining Whether a Request for a Pooled Thread Will Be Queued
9. Configuring a Timer
10. Storing Thread-Specific Data Privately
11. Granting Multiple Access to Resources with a Semaphore
12. Synchronizing Multiple Processes with the Mutex
13. Using Events to Make Threads Cooperate
14. Get the Naming Rights for Your Events
15. Performing Atomic Operations Among Threads
Chapter 19 Unsafe Code
1. Introduction
2. Controlling Changes to Pointers Passed to Methods
3. Comparing Pointers
4. Navigating Arrays
5. Manipulating a Pointer to a Fixed Array
6. Returning a Pointer to a Particular Element in an Array
7. Creating and Using an Array of Pointers
8. Switching Unknown Pointer Types
9. Converting a String to a char*
10. Declaring a Fixed-Size Structure with an Embedded Array
Chapter 20 Toolbox
1. Introduction
2. Dealing with Operating System Shutdown, Power Management, or User Session Changes
3. Controlling a Service
4. List What Processes an Assembly Is Loaded In
5. Using Message Queues on a Local Workstation
6. Finding the Path to the Current Framework Version
7. Determining the Versions of an Assembly That Are Registered in the Global Assembly Cache (GAC)
8. Getting the Windows Directory
9. Capturing Output from the Standard Output Stream
10. Running Code in Its Own appdomain
11. Determining the Operating System and Service Pack Version of the Current Operating System

Colophon

Title:

C# Cookbook, 2nd Edition

By:

Jay Hilyard, Stephen Teilhet

Publisher:

O'Reilly Media

Formats:

Print
Ebook
Safari Books Online

Print:

January 2006

Ebook:

June 2009

Pages:

1192

Print ISBN:

978-0-596-10063-6

| ISBN 10:

0-596-10063-9

Ebook ISBN:

978-0-596-55708-9

| ISBN 10:

0-596-55708-6

Jay Hilyard

Jay Hilyard has been developing applications for the Windows platform for over 15 years and for .NET for more than 7 of those. Jay has published multiple articles in MSDN Magazine and he currently works on the New Product Team at Newmarket International in Portsmouth, NH. When not immersed in .NET, Jay spends his time with his family and rooting for the Patriots.

View Jay Hilyard's full profile page.
Stephen Teilhet

Stephen Teilhet earned a degree in electrical engineering, but soon afterwards began to write software for the Windows platform. For the last 11 years, he's worked for several consulting firms on a wide range of projects, specializing in Visual Basic, Visual C++, MTS, COM, MSMQ, and SQL Server. He has been working with the .NET technologies since the pre-alpha version of the 1.0 .NET framework was being developed by Microsoft. Currently he works for Ounce Labs where he is working on enhancing their static security code analysis tool to find vulnerabilities in several languages including the .NET languages.

View Stephen Teilhet's full profile page.

Colophon

About the AuthorsJay Hilyard has been developing applications for the Windows platform for over 12 years and for .NET for more than 4 years. Jay has published multiple articles in MSDN Magazine and he currently works on the New Product Development team at Newmarket International in Portsmouth, NH. When not immersed in .NET, Jay spends his time with his family and rooting for the Patriots.Stephen Teilhet earned a degree in electrical engineering, but soon afterward began to write software for the Windows platform. For the last 11 years, he's worked for several consulting firms on a wide range of projects, specializing in Visual Basic, Visual C++, MTS, COM, MSMQ, and SQL Server. Stephen currently is employed at Compuware Numega Labs in Nashua, NH, where he has worked on several award-winning products, including DevPartner CodeReview and, most recently, DevPartner SecurityChecker.ColophonThe 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.The cover image is from a 19th-century engraving from the Dover Pictorial Archive. The cover font is Adobe ITC Garamond. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed.

Description

Table of Contents

Product Details

About the Author

Colophon

Recommended for You

Chapter 1 Numbers and Enumerations

Introduction

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

Testing for an Even or Odd Value

Obtaining the High Word or Low Word of a Number

Converting a Number in Another Base to Base10

Determining Whether a String Is a Valid Number

Rounding a Floating-Point Value

Choosing a Rounding Algorithm

Converting Celsius to Fahrenheit

Converting Fahrenheit to Celsius

Safely Performing a Narrowing Numeric Cast

Finding the Length of Any Three Sides of a Right Triangle

Finding the Angles of a Right Triangle

Displaying an Enumeration Value as a String

Converting Plain Text to an Equivalent Enumeration Value

Testing for a Valid Enumeration Value

Testing for a Valid Enumeration of Flags

Using Enumerated Members in a Bit Mask

Determining if One or More Enumeration Flags Are Set

Determining the Integral Part of a Decimal or Double

Chapter 2 Strings and Characters

Introduction

Determining the Kind of Character a char Contains

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 Occurrences of a String Within Another String

Implementing a Poor Man's Tokenizer to Deconstruct a String

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

Formatting Data in Strings

Creating a Delimited String

Extracting Items from a Delimited String

Setting the Maximum Number of Characters a StringBuilder Can Contain

Iterating over Each Character in a String

Improving String Comparison Performance

Improving StringBuilder Performance

Pruning Characters from the Head and/or Tail of a String

Testing a String for Null or Empty

Appending a Line

Encoding Chunks of Data

Chapter 3 Classes and Structures

Introduction

Creating Union-Type Structures

Allowing a Type to Represent Itself as a String

Converting a String Representation of an Object into an Actual Object

Implementing Polymorphism with Abstract Base Classes

Making a Type Sortable

Making a Type Searchable

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

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

Turning Bits On or Off

Making Error-Free Expressions

Minimizing (Reducing) Your Boolean Logic

Converting Between Simple Types in a Language-Agnostic Manner

Determining When to Use the Cast Operator, the as Operator, or the is Operator

Casting with the as Operator

Determining a Variable's Type with the is Operator

Implementing Polymorphism with Interfaces

Calling the Same Method on Multiple Object Types

Adding a Notification Callback Using an Interface

Using Multiple Entry Points to Version 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

Building Cloneable Classes