For your convenience Apress has placed some of the front matter material after the index. Please use the Bookmarks and Contents at a Glance links to access them. Contents at a Glance Preface �����������������������������������������������������������������������������������������������������������������������xxv About the Authors�����������������������������������������������������������������������������������������������������xxvii About the Technical Reviewer �����������������������������������������������������������������������������������xxix Acknowledgments �����������������������������������������������������������������������������������������������������xxxi Introduction �������������������������������������������������������������������������������������������������������������xxxiii ■ Chapter 1: C# and the �NET Runtime and Libraries������������������������������������������������������1 ■ Chapter 2: C# QuickStart and Developing in C# ����������������������������������������������������������3 ■ Chapter 3: Classes 101 ����������������������������������������������������������������������������������������������11 ■ Chapter 4: Base Classes and Inheritance ������������������������������������������������������������������19 ■ Chapter 5: Exception Handling ����������������������������������������������������������������������������������33 ■ Chapter 6: Member Accessibility and Overloading ���������������������������������������������������47 ■ Chapter 7: Other Class Details �����������������������������������������������������������������������������������57 ■ Chapter 8: Structs (Value Types) �������������������������������������������������������������������������������77 ■ Chapter 9: Interfaces �������������������������������������������������������������������������������������������������83 ■ Chapter 10: Versioning and Aliases ���������������������������������������������������������������������������95 ■ Chapter 11: Statements and Flow of Execution �������������������������������������������������������101 ■ Chapter 12: Variable Scoping and Definite Assignment ������������������������������������������109 ■ Chapter 13: Operators and Expressions ������������������������������������������������������������������115 ■ Chapter 14: Conversions �����������������������������������������������������������������������������������������127 ■ Chapter 15: Arrays ��������������������������������������������������������������������������������������������������137 ■ Chapter 16: Properties ��������������������������������������������������������������������������������������������143 v ■ Contents at a GlanCe ■ Chapter 17: Generic Types ���������������������������������������������������������������������������������������153 ■ Chapter 18: Indexers, Enumerators, and Iterators ��������������������������������������������������165 ■ Chapter 19: Strings��������������������������������������������������������������������������������������������������177 ■ Chapter 20: Enumerations ���������������������������������������������������������������������������������������187 ■ Chapter 21: Attributes ���������������������������������������������������������������������������������������������195 ■ Chapter 22: Delegates, Anonymous Methods, and Lambdas �����������������������������������203 ■ Chapter 23: Events ��������������������������������������������������������������������������������������������������215 ■ Chapter 24: Dynamic Typing ������������������������������������������������������������������������������������223 ■ Chapter 25: User-Defined Conversions ��������������������������������������������������������������������227 ■ Chapter 26: Operator Overloading ���������������������������������������������������������������������������241 ■ Chapter 27: Nullable Types ��������������������������������������������������������������������������������������247 ■ Chapter 28: Linq to Objects �������������������������������������������������������������������������������������251 ■ Chapter 29: Linq to XML ������������������������������������������������������������������������������������������269 ■ Chapter 30: Linq to SQL �������������������������������������������������������������������������������������������283 ■ Chapter 31: Other Language Details ������������������������������������������������������������������������293 ■ Chapter 32: Making Friends with the �NET Framework �������������������������������������������305 ■ Chapter 33: System�Array and the Collection Classes ��������������������������������������������311 ■ Chapter 34: Threading ���������������������������������������������������������������������������������������������319 ■ Chapter 35: Asynchronous and Parallel Programming �������������������������������������������335 ■ Chapter 36: Execution-Time Code Generation ���������������������������������������������������������345 ■ Chapter 37: Interop ��������������������������������������������������������������������������������������������������351 ■ Chapter 38: �NET Base Class Library Overview �������������������������������������������������������361 ■ Chapter 39: Deeper into C# ��������������������������������������������������������������������������������������385 ■ Chapter 40: Logging and Debugging Techniques ����������������������������������������������������405 ■ Chapter 41: IDEs and Utilities ����������������������������������������������������������������������������������421 Index ���������������������������������������������������������������������������������������������������������������������������423 vi Introduction When I started on the first edition of this book, I got some very sage advice. “Write the book that you wish existed.” This is not a book to teach you how to write code, nor is it a detailed language specification. It is designed to explain both how C# works and why it works that way—the kind of book that a professional developer who is going to be writing C# code would want. Who This Book Is For This book is for software developers who want to understand why C# is designed the way it is and how to use it effectively. The content assumes familiarity with object-oriented programming concepts. How This Book Is Structured After a couple of introductory chapters, the book progresses from the simpler C# features to the more complex ones. You can read the chapters in order, working your way through the entire language. Or you can choose an individual chapter to understand the details of a specific feature. If you are new to C#, I suggest you start by reading the chapters on properties, generics, delegates and events, as well as the Linq chapters. These are the areas where C# is most different from other languages. If you are more interested in the details of the language syntax, you may find it useful to download the C# Language Reference from MSDN. Downloading the Code The code for the examples shown in this book is available on the Apress web site, www.apress.com. You can find a link on the book’s information page. Scroll down and click on the Source Code/Downloads tab. Contacting the Author One of the humbling parts of being an author is that despite the best efforts of the technical reviewer and copy editor, mistakes and poor explanations will show up in any book. If you have found such a mistake or have a comment, you can contact me at [email protected]. xxxiii Chapter 1 C# and the .NET Runtime and Libraries If you are reading this chapter, my guess is that you are interested in learning more about C#. Welcome. This book is primarily about the C# language, but before diving into the details, it is important to understand the basics of the environment in which C# code is written. The C# compiler will take C# programs and convert them into an intermediate language that can be executed only by the .NET Common Language Runtime (CLR). Languages that target a runtime are sometimes known as managed languages1 and are contrasted with unmanaged languages such as C++ that do not require a runtime2 and therefore run directly on the hardware.3 The .NET Runtime manages memory allocation, security, type safety, exception handling, and many other low-level concerns. There are several different variants of the .NET Runtime, running on everything from multiprocessor servers to smartphones to microcontrollers. To perform useful tasks, your C# code will be using code in the .NET Base Class Library (BCL). The BCL contains classes that are likely to be useful to many programs and includes support for the following: • Performing network operations • Performing I/O operations • Managing security • Globalizing programs4 • Manipulating text • Accessing a database • Manipulating XML • Interacting with event logging, tracing, and other diagnostic operations • Using unmanaged code • Creating and calling code dynamically 1Java is another managed language; it runs using the Java Virtual Machine (JVM), and Visual Basic is of course another language that runs on the CLR. 2Confusingly, C and C++ use the C Runtime, which is a collection of libraries and not a runtime like the .NET Runtime. 3Microsoft Visual C++ can be used as either a managed or unmanaged language (or both). 4Globalization helps developers write applications that can be used in different areas of the world. It helps the application support multiple languages, different date and number formats, and so on. 1 Chapter 1 ■ C# and the .net runtime and Libraries The BCL is big enough that it would be easy to get confused; the various capabilities are organized into namespaces. For example, the System.Globalization namespace is used to help with globalization, the System.XML namespace is used to manipulate XML, and so on. Layered on top of the BCL are specialized libraries that are targeted to creating specific types of applications or services, including the following: • Console applications • Windows GUI applications, using either Windows Forms or the Windows Presentation Foundation (WPF) • ASP.NET (web) applications • Windows Services • Service-oriented applications, using Windows Communication Foundation (WCF) • Workflow-enabled applications, Windows Workflow Foundation (WF) • Windows 8 applications • Windows Phone applications The Base Class Library and all of the other libraries are referred to collectively as the .NET Framework. MaNaGeD VS. UNMaNaGeD CODe if you are used to writing unmanaged code, writing C# code may be a bit unsettling. the runtime manages some things that you previously controlled yourself, which does reduce the flexibility you have. after you have explored the capabilities of the .net Framework, i think you will find that in the vast majority of cases, you can write much more quickly and with higher quality using C#. 2 Chapter 2 C# QuickStart and Developing in C# This chapter presents a quick overview of the C# language. It assumes a certain level of programming knowledge and therefore doesn’t present very much detail. If the explanation here doesn’t make sense, look for a more detailed explanation of the particular topic later in the book. The second part of the chapter discusses how to obtain the C# compiler and the advantages of using Visual Studio to develop C# applications. Hello, Universe As a supporter of SETI,1 I thought that it would be appropriate to do a “Hello, Universe” program rather than the canonical “Hello, World” program. using System; class Hello { public static void Main(string[] args) { Console.WriteLine("Hello, Universe"); // iterate over command-line arguments, // and print them out for (int arg = 0; arg < args.Length; arg++) { Console.WriteLine("Arg {0}: {1}", arg, args[arg]); } } } As discussed earlier, the .NET Runtime has a unified namespace for all program information (or metadata). The using System clause is a way of referencing the classes that are in the System namespace so they can be used without having to put System in front of the type name. The System namespace contains many useful classes, one of which is the Console class, which is used (not surprisingly) to communicate with the console (or DOS box, or command line, for those who have never seen a console). Because there are no global functions in C#, the example declares a class called Hello that contains the static Main() function, which serves as the starting point for execution. Main() can be declared with no parameters or with a string array. Since it’s the starting function, it must be a static function, which means it isn’t associated with an instance of an object. 1 Search for Extraterrestrial Intelligence. See http://www.teamseti.org for more information. 3 Chapter 2 ■ C# QuiCkStart and developing in C# The first line of the function calls the WriteLine() function of the Console class, which will write “Hello, Universe” to the console. The for loop iterates over the parameters that are passed in and then writes out a line for each parameter on the command line. Namespace and Using Statements Namespaces in the .NET Runtime are used to organize classes and other types into a single hierarchical structure. The proper use of namespaces will make classes easy to use and prevent collisions with classes written by other authors. Namespaces can also be thought of as a way to specify long and useful names for classes and other types without having to always type a full name. Namespaces are defined using the namespace statement. For multiple levels of organization, namespaces can be nested: namespace Outer { namespace Inner { class MyClass { public static void Function() {} } } } That’s a fair amount of typing and indenting, so it can be simplified by using the following instead: namespace Outer.Inner { class MyClass { public static void Function() {} } } A source file can define more than one namespace, but in the majority of cases, all the code within one file lives in a single namespace. The fully qualified name of a class—the name of the namespace followed by the name of the class—can become quite long. The following is an example of such a class: System.Xml.Serialization.Advanced.SchemaImporterExtension It would be very tedious to have to write that full class name every time we wanted to use it, so we can add a using statement: using System.Xml.Serialization.Advanced; This statement says, “treat all of the types defined inside this namespace as if they don’t have a namespace in front of them,” which allows us to use SchemaImporterExtension 4 Chapter 2 ■ C# QuiCkStart and developing in C# instead of the full name. The using statement only works for types directly inside the namespace; if we had the following using statement: using System.Xml.Serialization; we would not be able to use the following name: Advanced.SchemaImporterExtension With a limited number of names in the world, there will sometimes be cases where the same name is used in two different namespaces. Collisions between types or namespaces that have the same name can always be resolved by using a type’s fully qualified name. This could be a very long name if the class is deeply nested, so there is a variant of the using clause that allows an alias to be defined to a class: using ThatConsoleClass = System.Console; class Hello { public static void Main() { ThatConsoleClass.WriteLine("Hello"); } } To make the code more readable, the examples in this book rarely use namespaces, but they should be used in most real code. Namespaces and Assemblies An object can be used from within a C# source file only if that object can be located by the C# compiler. By default, the compiler will only open the single assembly known as mscorlib.dll, which contains the core functions for the Common Language Runtime. To reference objects located in other assemblies, the name of the assembly file must be passed to the compiler. This can be done on the command line using the /r:<assembly> option or from within the Visual Studio IDE by adding a reference to the C# project. Typically, there is a correlation between the namespace that an object is in and the name of the assembly in which it resides. For example, the types in the System.Net namespace and child namespaces reside in the System.Net.dll assembly. This may be revised based on the usage patterns of the objects in that assembly; a large or rarely used type in a namespace may reside in a separate assembly. The exact name of the assembly that an object is contained in can be found in the online MSDN documentation for that object. Basic Data Types C# supports the usual set of data types. For each data type that C# supports, there is a corresponding underlying .NET Common Language Runtime type. For example, the int type in C# maps to the System.Int32 type in the runtime. System.Int32 can be used in most of the places where int is used, but that isn’t recommended because it makes the code tougher to read. The basic data types are described in Table 2-1. The runtime types can all be found in the System namespace of the .NET Common Language Runtime. 5