C# Cookbook - Brossura

Teilhet, Steve; Hilyard, Jay

Brossura

ISBN 10: 0596003390 ISBN 13: 9780596003395

Casa editrice: O'Reilly Media, 2004

Riassunto

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.

Su questo libro

L'autore:

Stephen Teilhet earned a degree in electrical engineering but soon afterwards began writing software for the Windows platform. For the last eight years, he has 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 works for Compuware Numega Labs in Nashua, New Hampshire, where he is immersed in the Microsoft .NET technologies.

Jay Hilyard has been developing applications for the Windows platform for over 10 years and is currently a .NET enthusiast. Jay has published an article in MSDN Magazine on Profiling and Garbage Collection and he currently works on the BoundsChecker team at the Compuware NuMega Lab in Nashua, NH. When not immersed in .NET, Jay spends his time with his family and rooting for the Patriots.

Contenuti:

Dedication; Preface; Who This Book Is For; What You Need to Use This Book; How This Book Is Organized; What Was Left Out; Conventions Used in This Book; About the Code; Using Code Examples; Platform Notes; Comments and Questions; Acknowledgments; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Chapter 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; Colophon;

Su questa edizione

• Editore: O'Reilly Media
• Data di pubblicazione: 2004
• ISBN 10: 0596003390
• ISBN 13: 9780596003395
• Rilegatura: Copertina flessibile
• Numero di pagine: 840