This book is organized into seventeen chapters, each of which focuses on a particular topic in creating C# solutions. The following paragraphs summarize each chapter to give you an overview of this book’s contents:
This chapter focuses on the numeric data types used in C# code. Recipes cover such things as numeric conversions, using bitwise operators on numbers, and testing strings to determine whether they contain a numeric value.
This chapter covers both the
String data type as
well as the
Char data type. Various recipes show
how to compare strings in various ways, encode/decode strings, break
strings apart, and put them back together again, to name a few.
This large chapter contains recipes dealing with both class and structure data types. This chapter covers a wide range of recipes from design patterns to converting a class to interoperating with COM.
This chapter covers the
enum data type. Recipes
display, convert and test enumeration types. In addition, there are
recipes on using enumerations that consist of bit flags.
The recipes in this chapter focus on the best ways to implement exception handling in your application. Preventing unhandled exceptions, reading and displaying stack traces, and throwing/rethrowing exceptions are included recipes. In addition, specific recipes show how to overcome some tricky situations, such as exceptions from late-bound called methods.
This chapter explores recipes that use data types that fall under the
System.Diagnostics namespace. Recipes deal with
Debug classes, event
logs, processes, and performance counters.
This chapter’s recipes show how both delegates and events can be used in your applications. Recipes allow manipulation of delegates that call more than one method, synchronous delegates, asynchronous delegates, and Windows keyboard hooks.
This chapter covers a very useful set of classes that are used to run regular expressions against strings. Recipes enumerate regular expression matches, break up strings into tokens, find/replace characters, and verify the syntax of a regular expression. A recipe is also included that contains many common regular expression patterns.
This chapter examines recipes that make use of collections. The
collection recipes make use of—as well as extend the
functionality of—the array (single, multi, and jagged), the
ArrayList, and the
The various ways to create your own strongly typed collection are
This chapter goes a bit outside of what is provided for you in the .NET Framework Class Library and implements certain data structures and algorithms that are not in the FCL, or possibly are not in existence exactly the way you would like to use them, but ones that you have used to solve problems before. Items such as queues, maps, trees, and hashes are explored.
This chapter deals with filesystem interactions in four distinct ways. The first way is to look at typical file interactions; the second way looks at directory- or folder-based interactions; the third way deals with paths and temporary files; and the fourth way deals with advanced filesystem I/O topics.
This chapter shows ways to use the built-in assembly inspection system provided by the .NET Framework to determine what types, interfaces, and methods are implemented within an assembly and how to access them in a late-bound fashion.
Networking explores the connectivity options provided by the .NET Framework and how to programmatically access network resources. Accessing a web site and its content as well as lower-level TCP/IP tasks are covered. This chapter also includes a recipe for using named pipes via P/Invoke.
There are many ways to write secure code and protect data using the .NET Framework, and in this chapter, we explore areas such as controlling access to types, encryption and decryption, random numbers, securely storing data, and using programmatic and declarative security.
This chapter addresses the subject of using multiple threads of execution in a .NET program and issues like how to implement threading in your application, protecting resources from and allowing safe concurrent access, storing per-thread data, and the use of asynchronous delegates for processing.
This chapter discusses how C# allows you to step outside of the safe environment of managed code and write code that is considered unsafe by the .NET Framework. The possibilities and restrictions of using unsafe code in C# are addressed by illustrating solutions to problems using unsafe code.
If you use .NET, it is likely that you will be dealing with XML to one degree or another; in this chapter, we explore some of the uses for XML, including XPath and XSLT, and topics such as the validation of XML and transformation of XML to HTML.
In some cases, certain recipes are related. In these cases, the See Also section of the recipe as well as some text in the Discussion will note the relation.