|
C# 3.0 Cookbook 3rd Edition
Completely updated for C# 3.0 and the .NET 3.5 platform, the
new edition of this bestseller offers more than 250 code
recipes to common and not-so-common problems that C#
programmers face every day. Every recipe in the book has
been reconsidered with more than a third of them rewritten
to take advantage of new C# 3.0 features.
If you prefer
solutions you can use today to general C# language
instruction, and quick answers to theory, this is your book.
C# 3.0 Cookbook offers a new chapter on LINQ (language
integrated query), plus two expanded chapters for recipes
for extension methods, lambda functions, object
initializers, new synchronization primitives and more. The
new edition is also complemented by a public wiki, which not
only includes all of the C# 2.0 recipes from the previous
edition unchanged by the release of C# 3.0, but invites you
to suggest better ways to solve those tasks.
Here are some of topics covered:
LINQ
Numeric data types and Enumerations
Strings and characters
Classes and structures
Generics
Collections
Exception handling
Delegates, events, and lambda expressions
Filesystem interactions
Web site access
XML usage (including LINQ to XML, XPath and XSLT)
Networking
Threading
Data Structures & Algorithms
Each recipe in the book includes tested code that you can
download from oreilly.com and reuse in your own
applications, and each one includes a detailed discussion of
how and why the underling technology works. You don't have
to be an experienced C# or .NET developer to use C# 3.0
Cookbook. You just have to be someone who wants to solve a
problem now, without having to learn all the related theory
first.
CONTENTS:
Preface
1. Language Integrated Query (LINQ)
1.1 Query a Message Queue
1.2 Using Set Semantics with Data
1.3 Reuse Parameterized Queries with LINQ to SQL
1.4 Sort Results in a Culture-Sensitive Manner
1.5 Adding Functional Extensions for Use with LINQ
1.6 Query and Join Across Data Repositories
1.7 Querying Configuration Files with LINQ
1.8 Creating XML Straight from a Database
1.9 Being Selective About Your Query Results
1.10 Using LINQ with Collections That Don't Support IEnumerable<T>
2. Strings and Characters
2.1 Determining the Kind of Character a Char Contains
2.2 Controlling Case Sensitivity When Comparing Two Characters
2.3
Within Another String
2.4 Controlling Case Sensitivity When Comparing Two Strings
2.5 Comparing a String to the Beginning or End of a Second String
2.6 Inserting Text into a String
2.7 Removing or Replacing Characters Within a String
2.8 Encoding Binary Data As Base64
2.9 Decoding a Base64-Encoded Binary
2.10 Converting a String Returned As a Byte[ ] Back into a String
2.11 Passing a String to a Method That Accepts Only a Byte[ ]
2.12 Converting Strings to Other Types
2.13 Creating a Delimited String
2.14 Extracting Items from a Delimited String
2.15 Iterating over Each Character in a String
2.16 Pruning Characters from the Head and/or Tail of a String
2.17 Testing a String for Null or Empty
2.18 Appending a Line
3. Classes and Structures
3.1 Creating Union-Type Structures
3.2 Making a Type Sortable
3.3 Making a Type Searchable
3.4 Indirectly Overloading the +=, -=, /=, and *= Operators
3.5 Indirectly Overloading the &&, ||, and ?: Operators
3.6 Making Error-Free Expressions
3.7 Reducing Your Boolean Logic
3.8
Language-Agnostic Manner
3.9
or the is Operator
3.10 Casting with the as Operator
3.11 Determining a Variable's Type with the is Operator
3.12 Returning Multiple Items from a Method
3.13 Parsing Command-Line Parameters
3.14 Initializing a Constant Field at Runtime
3.15 Building Cloneable Classes
3.16 Assuring an Object's Disposal
3.17 Disposing of Unmanaged Resources
3.18 Determining Where Boxing and Unboxing Occur
4. Generics
4.1 Deciding When and Where to Use Generics
4.2 Understanding Generic Types
4.3 Replacing the ArrayList with Its Generic Counterpart
4.4 Replacing the Stack and Queue with Their Generic Counterparts
4.5 Using a Linked List
4.6 Creating a Value Type That Can Be Initialized to Null
4.7 Reversing the Contents of a Sorted List
4.8 Making Read-Only Collections the Generic Way
4.9 Replacing the Hashtable with Its Generic Counterpart
4.10 Using foreach with Generic Dictionary Types
4.11 Constraining Type Arguments
4.12 Initializing Generic Variables to Their Default Values
5. Collections
5.1 Swapping Two Elements in an Array
5.2 Reversing an Array Quickly
5.3 Writing a More Flexible StackTrace Class
5.4 Determining the Number of Times an Item Appears in a List<T>
5.5 Retrieving All Instances of a Specific Item in a List<T>
5.6 Inserting and Removing Items from an Array
5.7 Keeping Your List<T> Sorted
5.8 Sorting a Dictionary's Keys and/or Values
5.9 Creating a Dictionary with Max and Min Value Boundaries
5.10 Storing Snapshots of Lists in an Array
5.11 Persisting a Collection Between Application Sessions
5.12 Testing Every Element in an Array or List<T>
5.13 Performing an Action on Each Element in an Array or List<T>
5.14 Creating a Read-Only Array or List<T>
6. Iterators, Partial Types, and Partial Methods
6.1 Creating an Iterator on a Generic Type
6.2 Creating an Iterator on a Nongeneric Type
6.3 Creating Custom Enumerators
6.4 Implementing Iterator Logic
6.5 Forcing an Iterator to Stop Iterating
6.6 Dealing with Finally Blocks and Iterators
6.7 Implementing Nested foreach Functionality in a Class
6.8 Organizing Your Interface Implementations
6.9 Generating Code That Is No Longer in Your Main Code Paths
6.10 Adding Hooks to Generated Entities
7. Exception Handling
7.1 Knowing When to Catch and Rethrow Exceptions
7.2 Assuring Exceptions Are Not Lost When Using Finally Blocks
7.3 Handling Exceptions Thrown from Methods Invoked via Reflection
7.4 Preventing Unhandled Exceptions
7.5 Getting Exception Information
7.6 Getting to the Root of a Problem Quickly
7.7 Creating a New Exception Type
7.8 Obtaining a Stack Trace
7.9 Breaking on a First-Chance Exception
7.10 Handling Exceptions Thrown from an Asynchronous Delegate
7.11 Giving Exceptions the Extra Info They Need with Exception.Data
7.12 Dealing with Unhandled Exceptions in WinForms Applications
7.13
Foundation (WPF) Applications
7.14 Analyzing Exceptions for Common Errors
8. Diagnostics
8.1 Providing Fine-Grained Control over Debugging/Tracing Output
8.2 Determining Whether a Process Has Stopped Responding
8.3 Using Event Logs in Your Application
8.4 Searching Event Log Entries
8.5 Watching the Event Log for a Specific Entry
8.6 Implementing a Simple Performance Counter
8.7 Enabling and Disabling Complex Tracing Code
8.8 Capturing Standard Output for a Process
8.9 Creating Custom Debugging Displays for Your Classes
9. Delegates, Events, and Lambda Expressions
9.1
Multicast Delegate
9.2
Multicast Delegate
9.3
Multicast Delegate
9.4
Asynchronous
9.5 An Advanced Interface Search Mechanism
9.6 Observing Additions and Modifications to Dictionaries
9.7 Using Lambda Expressions
9.8 Set Up Event Handlers Without the Mess
9.9 Using Different Parameter Modifiers in Lambda Expressions
9.10 Using Closures in C#
9.11 Performing Multiple Operations on a List Using Functors
10. Regular Expressions
10.1 Enumerating Matches
10.2 Extracting Groups from a MatchCollection
10.3 Verifying the Syntax of a Regular Expression
10.4 Quickly Finding Only the Last Match in a String
10.5 Augmenting the Basic String Replacement Function
10.6 Implementing a Better Tokenizer
10.7 Counting Lines of Text
10.8 Returning the Entire Line in Which a Match Is Found
10.9 Finding a Particular Occurrence of a Match
10.10 Using Common Patterns
11. Data Structures and Algorithms
11.1 Creating a Hash Code for a Data Type
11.2 Creating a Priority Queue
11.3 Creating a One-to-Many Map (MultiMap)
11.4 Creating a Binary Search Tree
11.5 Creating an n-ary Tree
11.6 Using a HashSet Object
12. Filesystem I/O
12.1 Manipulating File Attributes
12.2 Renaming a File
12.3 Outputting a Platform-Independent EOL Character
12.4 Manipulating Directory Attributes
12.5 Renaming a Directory
12.6 Searching for Directories or Files Using Wildcards
12.7 Obtaining the Directory Tree
12.8 Parsing a Path
12.9 Parsing Paths in Environment Variables
12.10 Launching and Interacting with Console Utilities
12.11 Locking Subsections of a File
12.12 Waiting for an Action to Occur in the Filesystem
12.13 Comparing Version Information of Two Executable Modules
12.14 Querying Information for All Drives on a System
12.15 Compressing and Decompressing Your Files
13. Reflection
13.1 Listing Referenced Assemblies
13.2 Listing Exported Types
13.3 Finding Overridden Methods
13.4 Finding Members in an Assembly
13.5 Determining and Obtaining Nested Types Within an Assembly
13.6 Displaying the Inheritance Hierarchy for a Type
13.7 Finding the Subclasses of a Type
13.8 Finding All Serializable Types Within an Assembly
13.9 Dynamically Invoking Members
13.10 Determining If a Type or Method Is Generic
13.11 Accessing Local Variable Information
13.12 Creating a Generic Type
14. Web
14.1 Converting an IP Address to a Hostname
14.2 Converting a Hostname to an IP Address
14.3 Parsing a URI
14.4 Handling Web Server Errors
14.5 Communicating with a Web Server
14.6 Going Through a Proxy
14.7 Obtaining the HTML from a URL
14.8 Using the Web Browser Control
14.9 Tying Database Tables to the Cache
14.10 Prebuilding an ASP.NET Web Site Programmatically
14.11 Escaping and Unescaping Data for the Web
14.12 Using the UriBuilder Class
14.13 Inspect and Change Your Web Application Configuration
14.14
Faster Performance
14.15 Checking Out a Web Server's Custom Error Pages
15. XML
15.1 Reading and Accessing XML Data in Document Order
15.2 Reading XML on the Web
15.3 Querying the Contents of an XML Document
15.4 Validating XML
15.5 Creating an XML Document Programmatically
15.6 Detecting Changes to an XML Document
15.7 Handling Invalid Characters in an XML String
15.8 Transforming XML
15.9 Tearing Apart an XML Document
15.10 Putting Together an XML Document
15.11 Validating Modified XML Documents Without Reloading
15.12 Extending Transformations
15.13 Getting Your Schemas in Bulk from Existing XML Files
15.14 Passing Parameters to Transformations
16. Networking
16.1 Writing a TCP Server
16.2 Writing a TCP Client
16.3 Simulating Form Execution
16.4 Transferring Data via HTTP
16.5 Using Named Pipes to Communicate
16.6 Pinging Programmatically
16.7 Send SMTP Mail Using the SMTP Service
16.8 Use Sockets to Scan the Ports on a Machine
16.9 Use the Current Internet Connection Settings
16.10 Transferring Files Using FTP
17. Security
17.1 Controlling Access to Types in a Local Assembly
17.2 Encrypting/Decrypting a String
17.3 Encrypting and Decrypting a File
17.4 Cleaning Up Cryptography Information
17.5
Following Transmission
17.6 Storing Data Securely
17.7 Making a Security Assert Safe
17.8 Verifying That an Assembly Has Been Granted Specific Permissions
17.9 Minimizing the Attack Surface of an Assembly
17.10 Obtaining Security/Audit Information
17.11 Granting/Revoking Access to a File or Registry Key
17.12 Protecting String Data with Secure Strings
17.13 Securing Stream Data
17.14 Encrypting web.config Information
17.15 Obtaining the Full Reason a SecurityException Was Thrown
17.16 Achieving Secure Unicode Encoding
17.17 Obtaining a Safer File Handle
18. Threading and Synchronization
18.1 Creating Per-Thread Static Fields
18.2 Providing Thread-Safe Access to Class Members
18.3 Preventing Silent Thread Termination
18.4 Being Notified of the Completion of an Asynchronous Delegate
18.5 Storing Thread-Specific Data Privately
18.6 Granting Multiple Access to Resources with a Semaphore
18.7 Synchronizing Multiple Processes with the Mutex
18.8 Using Events to Make Threads Cooperate
18.9 Get the Naming Rights for Your Events
18.10 Performing Atomic Operations Among Threads
18.11 Optimizing Read-Mostly Access
19. Toolbox
19.1
or User Session Changes
19.2 Controlling a Service
19.3 List What Processes an Assembly Is Loaded In
19.4 Using Message Queues on a Local Workstation
19.5 Finding the Path to the Current Framework Version
19.6
Registered in the Global Assembly Cache (GAC)
19.7 Capturing Output from the Standard Output Stream
19.8 Running Code in Its Own AppDomain
19.9
Version of the Current Operating System
20. Numbers and Enumerations
20.1 Converting Between Degrees and Radians
20.2 Using the Bitwise Complement Operator with Various Data Types
20.3 Converting a Number in Another Base to Base10
20.4 Determining Whether a String Is a Valid Number
20.5 Rounding a Floating-Point Value
20.6 Choosing a Rounding Algorithm
20.7 Converting Between Temperature Scales
20.8 Safely Performing a Narrowing Numeric Cast
20.9 Displaying an Enumeration Value As a String
20.10 Converting Plain Text to an Equivalent Enumeration Value
20.11 Testing for a Valid Enumeration Value
20.12 Testing for a Valid Enumeration of Flags
20.13 Using Enumerated Members in a Bit Mask
20.14 Determining Whether One or More Enumeration Flags Are Set
20.15 Determining the Integral Part of a Decimal or Double
Index
|
