The .NET Framework has two components:
   □ Common Language Runtime
   □ .NET Framework class library
   The Common Language Runtime (CLR) is the agent that manages your .NET applications at execution time. It provides core services such as memory, thread, and resource management. Applications that run on top of the CLR are known as managed code; all others are known as unmanaged code.
   The .NET Framework class library is a comprehensive set of reusable classes that provides all the functionalities your application needs. This library enables you to develop applications ranging from desktop Windows applications to ASP.NET web applications, and Windows Mobile applications that run on Pocket PCs.

   The Common Language Runtime (CLR) is the virtual machine in the .NET Framework. It sits on top of the Windows operating system (Windows XP, Windows Vista, Windows Server 2008, and so on). A .NET application is compiled into a bytecode format known as MSIL (Microsoft Intermediate Language). During execution, the CLR JIT ( just-in-time) compiles the bytecode into the processor's native code and executes the application. Alternatively, MSIL code can be precompiled into native code so that JIT compiling is no longer needed; that speeds up the execution time of your application.
   The CLR also provides the following services:
   □ Memory management/garbage collection
   □ Thread management
   □ Exception handling
   □ Security
   .NET developers write applications using a .NET language such as C#, VB.NET, or C++. The MSIL bytecode allows .NET applications to be portable (at least theoretically) to other platforms because the application is compiled to native code only during runtime.

   At the time of writing, Microsoft's implementation of the .NET Framework runs only on Windows operating systems. However, there is an open-source implementation of the .NET Framework, called "Mono," that runs on Mac and Linux.

   Figure 1-1 shows the relationships between the CLR, unmanaged and managed code.
   Figure 1-1

   The .NET Framework class library contains classes that allow you to develop the following types of applications:
   □ Console applications
   □ Windows applications
   □ Windows services 
   □ ASP.NET Web applications
   □ Web Services
   □ Windows Communication Foundation (WCF) applications
   □ Windows Presentation Foundation (WPF) applications
   □ Windows Workflow Foundation (WF) applications
   The library's classes are organized using a hierarchy of namespaces. For example, all the classes for performing I/O operations are located in the System.IO namespace, and classes that manipulate regular expressions are located in the System.Text.RegularExpressions namespace.
   The .NET Framework class library is divided into two parts:
   □ Framework Class Library (FCL)
   □ Base Class Library (BCL)
   The BCL is a subset of the entire class library and contains the set of classes that provide core functionalities for your applications. Some of the classes in the BCL are contained in the mscorlib.dll, System.dll, and System.core.dll assemblies. The BCL is available to all the languages using the .NET Framework. It encapsulates all the common functions such as file handling, database access, graphics manipulation, and XML document manipulation.
   The FCL is the entire class library and it provides the classes for you to develop all the different types of applications listed previously.
   Figure 1-2 shows the key components that make up the .NET Framework.
   Figure 1-2 

   In early 2008, Microsoft released the latest version of Visual Studio — Visual Studio 2008. With it comes a plethora of editions designed for the different types of developers in mind:
   □ Visual Web Developer 2008 Express Edition
   □ Visual Basic 2008 Express Edition
   □ Visual C# 2008 Express Edition
   □ Visual C++ 2008 Express Edition
   □ Visual Studio 2008 Standard Edition 
   □ Visual Studio 2008 Professional Edition
   □ Visual Studio 2008 Team System 2008 Architecture Edition
   □ Visual Studio 2008 Team System 2008 Database Edition
   □ Visual Studio 2008 Team System 2008 Development Edition
   □ Visual Studio 2008 Team System 2008 Test Edition
   □ Visual Studio 2008 Team System 2008 Team Suite

   For a detailed discussion of the features available in each edition, check out the following URL: http://msdn.microsoft.com/en-us/vs2008/products/cc149003.aspx.

   The Express editions are designed for hobbyists and are available for download at no charge. This is a great way to get started with Visual Studio 2008 and is ideal for students and beginning programmers. However, if you are a professional developer, you should purchase either the Standard or Professional Edition. Note that if you are developing Windows Mobile applications, you need the Professional Edition (or higher). If you are working in a large development environment and need to develop collaboratively with other developers on large projects, check out the Team System editions.

   If you are not ready to purchase Visual Studio 2008, you can always download a 90-day trial edition of Visual Studio 2008 Professional from http://msdn.microsoft.com/en-us/vs2008/products/cc268305.aspx.

   The first time you launch Visual Studio 2008, you choose the default environment settings. If you are going to use the C# language most of the time, choose the Visual C# Development Settings (see Figure 2-1). Choosing this option does not mean that you cannot use other languages (such as Visual Basic); it just means that C# will be listed as the default project type when you create a new project.
   Figure 2-1
   If the Visual C# Development Settings is chosen, Visual C# appears at the top of the Project Types list (see the left screenshot in Figure 2-2). In contrast, choosing the General Development Settings puts the Visual Basic language at the top (see the right screenshot in Figure 2-2).
   Figure 2-2 

   If for some reason you want to change the development settings after you have set them, you can always select Tools→Import and Export Settings to reset the settings. In the Import and Export Settings Wizard dialog that appears (see Figure 2-3), you can:
   Figure 2-3 
   □ Export the settings to a file so that they can be exported to another machine
   □ Import a saved setting
   □ Reset all the settings
   To reset to another setting, check the Reset All Settings option and click Next. In the next step, you can choose either to save your current settings or to just reset the settings without saving. Once you have selected the option, click Next, and you can select another setting (see Figure 2-4).
   Figure 2-4

   After you select a default setting, Visual Studio 2008 takes a couple of minutes to initialize. Once that's done, you will see something as shown in Figure 2-5.
   Figure 2-5 
   To create a new project, select File→New→Project (see Figure 2-6).
   Figure 2-6
   In the Visual C# development setting, you see the New Project dialog shown in Figure 2-7.
   Figure 2-7
   The default project name (WindowsFormApplication1 in this example) is provided, along with the following:
   □ The default location for saving the project.
   □ The solution name. The solution name by default is the same as your project name and is changed automatically to be the same as the project name. However, you can modify the solution name if you want it to have a different name than the project name.
   □ A separate directory to store the solution; if you uncheck the Create Directory For Solution checkbox, a solution is not be created for your project.
   You can target a different version of the .NET Framework by selecting it from the dropdown list at the top right corner of the New Project dialog (see Figure 2-8).
   Figure 2-8

   Remember: A solution contains one or more projects.

   Figure 2-9 shows the various parts of the Visual Studio 2008 development environment.
   Figure 2-9
   These parts are described in the following sections.

Menu Bar

   The Menu bar contains standard Visual Studio commands. For example, Figure 2-10 shows that the File menu (see Figure 2-10) contains commands that enable you to create new projects, open existing projects, save the current form, and so on.
   Figure 2-10 
   To customize the items displayed in the Menu bar, select Tools→Customize to display the Customize dialog (see Figure 2-11). Click on the Commands tab; the list of main menu items (Action, Addins, Analyze, and so forth) is on the left. Selecting a main menu item displays the list of available submenu items on the right. You can rearrange the submenu items by dragging them and dropping them onto the desired main menu item.
   Figure 2-11 
   To add a new submenu item to a main menu item, click the Rearrange Commands button. In the Rearrange Commands dialog (see Figure 2-12), select the menu you want to customize, and click the Add button. You can then select the various submenu items from the different categories to add to the menu.
   Figure 2-12 

Toolbar

   The Toolbar (see Figure 2-13) contains shortcuts to many of the often used commands contained in the Menu bar.
   Figure 2-13
   As with the Menu bar, the Toolbar is also customizable. To add additional toolbars, simply right-click on any existing toolbar and check the toolbar(s) you want to add to Visual Studio from the list of toolbars available (see Figure 2-14).
   Figure 2-14
   To customize the Toolbar, select Tools→Customize. On the Toolbars tab of the Customize dialog (see Figure 2-15), check the toolbar(s) you want to add to Visual Studio. You can create your own custom toolbar by clicking the New button.
   Figure 2-15
   As with the Menu bar, you can also rearrange the items displayed in each toolbar. To customize the items displayed in the Toolbar, select Tools→Customize to open the Customize dialog and then click the Rearrange Commands button. The Rearrange Commands dialog allows you to add/delete items from each toolbar (see Figure 2-16).
   Figure 2-16
   Each toolbar in the Toolbar can also be physically rearranged in Visual Studio by dragging the four-dot line on the left edge of the toolbar (see Figure 2-17) and relocating it to the new desired position.
   Figure 2-17

Toolbox

   The Toolbox (see Figure 2-18) contains all the controls that you can use in your applications. You can drag controls from the Toolbox and drop them onto the design surface of your application.
   Figure 2-18
   Each tab in the Toolbox contains controls that are related to a specific purpose. You can create your own tab to house your own controls. To do so, right-click on the Toolbox and select Add Tab. Name the newly created tab (see Figure 2-19).
   Figure 2-19
   To add controls to the Toolbox, right-click on the tab to which you want the controls added and select Choose Items. The Choose Toolbox Items dialog (see Figure 2-20) opens.
   Figure 2-20
   You can add the following types of controls to the Toolbox:
   □ .NET Framework components
   □ COM components
   □ WPF components
   □ Workflow activities
   You can also click the Browse button to locate the .dll file that contains your own custom controls.
   Another way to add controls to the Toolbox is to simply drag the DLL containing the controls and drop it directly onto the Toolbox.
   You can relocate the Toolbox by dragging it and repositioning it on the various anchor points on the screen. Figure 2-21 shows the anchor points displayed by Visual Studio 2008 when you drag the Toolbox.
   Figure 2-21
   If you have limited screen real estate, you might want to auto-hide the Toolbox by clicking the Auto Hide button (see Figure 2-22).
   Figure 2-22

Missing Controls in Toolbox

   Sometimes, for some unknown reasons, the controls in the Toolbox may suddenly go missing. The usual remedy is to right-click the Toolbox and select Reset Toolbox. This works most of the time. However, if that fails to work, you may need to do the following:
   Navigate to C:\Documents and Settings\<user_name>\Local Settings\Application Data\Microsoft\VisualStudio\9.0.
   Within this folder are some hidden files. Simply delete the following files: toolbox.tbd, toolboxIndex.tbd, toolbox_reset.tbd, and toolboxIndex_reset.tbd.
   Then restart Visual Studio 2008. Your controls should now come back up!

Solution Explorer

   The Solution Explorer window contains all the files and resources used in your project. A solution contains one or more projects. Figure 2-23 shows the various buttons available in the Solution Explorer.
   Figure 2-23

   The buttons in the Solution Explorer window are context sensitive, which means that some buttons will not be visible when certain items are selected. For instance, if you select the project name, the View Code and View Designer buttons will not be shown.

   To add additional items such as a Windows Form or a Class to your current project, right-click the project name in Solution Explorer, select Add (see Figure 2-24), and then choose the item you want to add from the list.
   Figure 2-24
   You can also add new (or existing) projects to the current solution. To do so, right-click on the solution name in Solution Explorer, select Add (see Figure 2-25), and then select what you want to add.
   Figure 2-25
   When you have multiple projects in a solution, one of the projects will be set as the startup project (the project name that is displayed in bold in Solution Explorer is the startup project). That is, when you press F5 to debug the application, the project set as the startup project will be debugged. To change the startup project, right-click the project that you want to set as the startup and select Set as Startup Project (see Figure 2-26).
   Figure 2-26
   To debug multiple projects at the same time when you press the F5 key, set multiple projects as the startup projects. To do so, right-click on the solution name in Solution Explorer and select Properties.
   Select the Multiple Startup Projects option (see Figure 2-27), and set the appropriate action for each project (None, Start, or Start Without Debugging).
   Figure 2-27
   Then when you press F5, the projects configured to start launch at the same time.

Properties

   The Properties window shows the list of properties associated with the various items in your projects (Windows Forms, controls, projects, solutions, etc).
   Figure 2-28 shows the Properties window displaying the list of properties of a Windows Form (Form1, in this example). By default, the properties are displayed in Categorized view, but you can change it to Alphabetical view, which lists all the properties in alphabetical order.
   Figure 2-28
   All default property values are displayed in normal font, while nondefault values are displayed in bold. This feature is very useful for debugging because it enables you to quickly trace the property values that you have changed.
   Besides displaying properties of items, the Properties window also displays events. When the Properties window is displaying an item (such as a Windows Form or a control) that supports events, you can click the Events icon (see left side of Figure 2-29) to view the list of events supported by that item. To create an event handler stub for an event, simply double-click the event name and Visual Studio 2008 automatically creates an event handler for you (see right side of Figure 2-29).
   Figure 2-29

Error List

   The Error List window (see Figure 2-30) is used to display:
   □ Errors, warnings, and messages produced as you edit and compile code.
   □ Syntax errors noted by IntelliSense.
   Figure 2-30
   To display the Error List window, select View→Error List.
   You can double-click on an error message to open the source file and locate the position of the error. Once the error is located, press F1 for help.

Output Window

   The Output window (View→Output) displays status messages for your application when you are debugging in Visual Studio 2008. The Output window is useful for displaying debugging messages in your application. For example, you can use the Console.WriteLine() statement to display a message to the Output window:
   Console.WriteLine(DateTime.Now.ToString());
   Figure 2-31 shows the message displayed in the Output window.
   Figure 2-31

Designer Window

   The Designer window enables you to visually design the UI of your application. Depending on the type of projects you are creating, the Designer displays a different design surface where you can drag and drop controls onto it. Figure 2-32 shows the Designer for creating different types of projects — Windows Forms (left), Windows Mobile (right), and Web (bottom left).
   Figure 2-32
   To switch to the code-behind of the application, you can either double-click on the surface of the designer, or right-click the item in Solution Explorer and select View Code. For example, if you are developing a Windows Forms application, you can right-click on a form, say Form1.cs, in Solution Explorer and select View Code. The code-behind for Form1 then displays (see Figure 2-33).
   Figure 2-33

Code View

   Code view is where you write the code for your application. You can switch between design view and code view by clicking on the relevant tabs (see Figure 2-34).
   Figure 2-34
   In Visual Studio, you can right-click on the tabs (see Figure 2-35) to arrange the code view either horizontally or vertically, to maximize the use of your monitor(s).
   Figure 2-35
   Figure 2-36 shows the code view and design view displaying horizontally.
   Figure 2-36
   Figure 2-37 shows the code view and design view displaying vertically.
   Figure 2-37

   Having multiple views at the same time is useful if you have a big monitor (or multiple monitors).

   Within the code view of Visual Studio 2008 is the Code and Text Editor, which provides several rich features that make editing your code easy and efficient, including:
   □ Code Snippets
   □ IntelliSense statement completion
   □ IntelliSense support for object properties, methods and events
   □ Refactoring support 

   The Code Snippet feature in Visual Studio 2008 enables you to insert commonly used code blocks into your project, thereby improving the efficiency of your development process. To insert a code snippet, right-click on the location where you want to insert the code snippet in the Code Editor, and select Insert Snippet (see Figure 2-38).
   Figure 2-38
   Select the snippet category by clicking on the category name (see the top of Figure 2-39) and then selecting the code snippet you want to insert (see bottom of Figure 2-39).
   Figure 2-39 
   For example, suppose that you select the try code snippet. The following block of code will be inserted automatically:
   private void Form1_Load(object sender, EventArgs e) {
    try {
    } catch (Exception) {
     throw;
    }
   }
   You can also use the Surround With code snippets feature. Suppose that you have the following statements:
   private void Form1_Load(object sender, EventArgs e) {
    int num1 = 5;
    int num2 = 0;
    int result = num1 / num2;
   }
   The third statement is dangerous because it could result in a division-by-zero runtime error, so it would be good to wrap the code in a try-сatch block. To do so, you can highlight the block of code you want to put within a try-сatch block and right-click it. Select Surround With (see Figure 2-40), and then select the try code snippet.
   Figure 2-40 
   Your code now looks like this:
   private void Form1_Load(object sender, EventArgs e) {
    try {
     int num1 = 5;
     int num2 = 0;
     int result = num1 / num2;
    } catch (Exception) {
     throw;
    }
   }

   IntelliSense is one of the most useful tools in Visual Studio 2008. IntelliSense automatically detects the properties, methods, events, and so forth of an object as you type in the code editor. You do not need to remember the exact member names of an object because IntelliSense helps you by dynamically providing you with a list of relevant members as you enter your code.
   For example, when you type the word Console in the code editor followed by the ., IntelliSense displays a list of relevant members pertaining to the Console class (see Figure 2-41).
   Figure 2-41
   When you have selected the member you want to use, press the Tab key and IntelliSense will insert the member into your code. 
   IntelliSense in Visual Studio 2008 has some great enhancements. For example, the IntelliSense dropdown list often obscures the code that is behind when it pops up. You can now make the dropdown list disappear momentarily by pressing the Control key. Figure 2-42 shows the IntelliSense dropdown list blocking the code behind it (top) and having it be translucent by pressing the Control key (bottom).
   Figure 2-42
   You can also use IntelliSense to tidy up the namespaces at the top of your code. For example, you often import a lot of namespaces at the beginning of your code and some of them might not ever be used by your application. In Visual Studio 2008, you can select the namespaces, right-click, and select Organize Usings (see Figure 2-43).
   Figure 2-43
   Then you can choose to:
   □ Remove all unused using statements
   □ Sort the using statements alphabetically
   □ Remove all unused using statements and sort the remaining namespace alphabetically

   Another useful feature available in Visual Studio 2008 is code refactoring. Even though the term may sound unfamiliar, many of you have actually used it. In a nutshell, code refactoring means restructuring your code so that the original intention of the code is preserved. For example, you may rename a variable so that it better reflects its usage. In that case, the entire application that uses the variable needs to be updated with the new name. Another example of code refactoring is extracting a block of code and placing it into a function for more efficient code reuse. In either case, you would need to put in significant amount of effort to ensure that you do not inadvertently inject errors into the modified code. In Visual Studio 2008, you can perform code refactoring easily. The following sections explain how to use this feature.

Rename

   Renaming variables is a common programming task. However, if you are not careful, you may inadvertently rename the wrong variable (most people use the find-and-replace feature available in the IDE, which is susceptible to wrongly renaming variables). In C# refactoring, you can rename a variable by selecting it, right-clicking, and choosing Refactoring→Rename (see Figure 2-44).
   Figure 2-44 
   You are prompted for a new name (see Figure 2-45). Enter a new name, and click OK.
   Figure 2-45
   You can preview the change (see Figure 2-46) before it is applied to your code.
   Figure 2-46 
   Click the Apply button to change the variable name.

Extract Method

   Very often, you write repetitive code within your application. Consider the following example:
   private void Form1_Load(object sender, EventArgs e) {
    int num = 10, sum = 0;
    for (int i = 1; i <= num; i++) {
     sum += i;
    }
   }
   Here, you are summing up all the numbers from 1 to num, a common operation. It would be better for you to package this block of code into a function. So, highlight the code (see Figure 2-47), right-click it, and select Refactor→Extract Method.
   Figure 2-47
   Supply a new name for your method (see Figure 2-48). You can also preview the default method signature that the refactoring engine has created for you. Click OK.
   Figure 2-48 
   The block of statements is now encapsulated within a function and the original block of code is replaced by a call to that function:
   private void Form1_Load(object sender, EventArgs e) {
    Summation();
   }
 
   private static void Summation() {
    int num = 10, sum = 0;
    for (int i = 1; i <= num; i++) {
     sum += i;
    }
   }
   However, you still need to do some tweaking because the variable sum should be returned from the function. The code you highlight will affect how the refactoring engine works. For example, if you include the variables declaration in the highlighting, a void function is created.
   While the method extraction feature is useful, you must pay close attention to the new method signature and the return type. Often, some minor changes are needed to get what you want. Here's another example:
   Single radius = 3.5f;
   Single height = 5;
   double volume = Math.PI * Math.Pow(radius, 2) * height; 
   If you exclude the variables declaration in the refactoring (instead of selecting all the three lines; see Figure 2-49) and name the new method VolumeofCylinder, a method with two parameters is created:
   private void Form1_Load(object sender, EventArgs e) {
    Single radius = 3.5f;
    Single height = 5;
    double volume = VolumeofCylinder(radius, height);
   }
 
   private static double VolumeofCylinder(Single radius, Single height) {
    return Math.PI * Math.Pow(radius, 2) * height;
   }
   Figure 2-49
   Here are some observations:
   □ Variables that are defined outside of the highlighted block for refactoring are used as an input parameter in the new method.
   □ If variables are declared within the block selected for refactoring, the new method will have no signature.
   □ Values that are changed within the block of highlighted code will be passed into the new method by reference.

Reorder and Remove Parameters

   You can use code refactoring to reorder the parameters in a function. Consider the following function from the previous example:
   private static double VolumeofCylinder(Single radius, Single height) {
   return Math.PI * Math.Pow(radius, 2) * height;
   }
   Highlight the function signature, right-click it, and select Refactor→Reorder Parameters (see Figure 2-50).
   Figure 2-50 
   You can then rearrange the order of the parameter list (see Figure 2-51).
   Figure 2-51 
   Click OK. You can preview the changes before they are made (see Figure 2-52).
   Figure 2-52
   Once you click the Apply button, your code is changed automatically:
   private void Form1_Load(object sender, EventArgs e) {
    Single radius = 3.5f;
    Single height = 5;
    double volume = VolumeofCylinder(height, radius);
   }
 
   private static double VolumeofCylinder(Single height, Single radius) {
    return Math.PI * Math.Pow(radius, 2) * height;
   }
   All statements that call the modified function will have their arguments order changed automatically.
   You can also remove parameters from a function by highlighting the function signature, right-clicking, and selecting Refactor→Remove Parameters. Then remove the parameter(s) you want to delete (see Figure 2-53). All statements that call the modified function will have their calls changed automatically.
   Figure 2-53 

Encapsulate Field

   Consider the following string declaration:
   namespace WindowsFormsApplication1 {
    public partial class Form1 : Form {
     public string caption;
     private void Form1_Load(object sender, EventArgs e) {
      //...
     }
    }
   } 
   Instead of exposing the caption variable as public, it is a better idea to encapsulate it as a property and use the set and get accessors to access it. To do that, right-click on the caption variable and select Refactor→Encapsulate Field (see Figure 2-54).
   Figure 2-54
   Assign a name to your property (see Figure 2-55). You have the option to update all external references or all references (including the one within the class), and you can choose to preview your reference changes. When you're ready, click OK.
   Figure 2-55
   After you've previewed the changes (see Figure 2-56), click Apply to effect the change.
   Figure 2-56
   Here is the result after applying the change:
   namespace WindowsFormsApplication1 {
    public partial class Form1 : Form {
    private string caption;
     public string Caption {
      get { return caption; }
      set { caption = value; }
     }
     private void Form1_Load(object sender, EventArgs e) {
      //...
     }
    }
   }

Extract Interface

   You can use the refactoring engine to extract an interface from a class definition. Consider the following Contact class:
   namespace WindowsFormsApplication1 {
    class Contact {
     public string FirstName {
      get; set;
     }
     public string LastName {
      get; set;
     }
     public string Email {
      get; set;
     }
     public DateTime DOB {
      get; set;
     }
    }
   }
   Right-click the Contact class name and select Refactor→Extract Interface (see Figure 2-57).
   Figure 2-57 
   The Extract Interface dialog opens, and you can select the individual public members to form the interface (see Figure 2-58).
   Figure 2-58 
   The new interface is saved in a new .cs file. In this example, the filename is IContact.cs:
   using System;
   namespace WindowsFormsApplication1 {
    interface IContact {
     DateTime DOB { get; set; }
     string Email { get; set; }
     string FirstName { get; set; }
     string LastName { get; set; }
    }
   }
   The original Contact class definition has now been changed to implements the newly created interface:
   class Contact : WindowsFormsApplication1.IContact {
    public string FirstName
    ...

Promote Local Variable to Parameter

   You can promote a local variable into a parameter. Here's an example:
   private void Form1_Load(object sender, EventArgs e) {
    LogError("File not found.");
   }
 
   private void LogError(string message) {
    string SourceFile = "Form1.cs";
    Console.WriteLine(SourceFile + ": " + message);
   }
   You want to promote the variable SourceFile into a parameter so that callers of this function can pass in its value through an argument. To do so, select the variable SourceFile, right-click, and then select Refactor→Promote Local Variable to Parameter (see Figure 2-59).
   Figure 2-59
   Note that the local variable to be promoted must be initialized or an error will occur. The promoted variable is now in the parameter list and the call to it is updated accordingly:
   private void Form1_Load(object sender, EventArgs e) {
    LogError("File not found.", "Form1.cs");
   }
 
   private void LogError(string message, string SourceFile) {
    Console.WriteLine(SourceFile + ": " + message);
   }

   Debugging is an important part of the development cycle. Naturally, Visual Studio 2008 contains debugging tools that enable you to observe the runtime behavior of your program. This section takes a look at those tools.
   Suppose that you have the following program:
   using System;
   using System.Windows.Forms;
 
   namespace WindowsFormsApplication1 {
    public partial class Form1 : Form {
     public Form1() {
      InitializeComponent();
     }
     private void Form1_Load(object sender, EventArgs e) {
      Console.WriteLine("Start");
      printAllOddNumbers(9);
      Console.WriteLine("End");
     }
     private void printAllOddNumbers(int num) {
      for (int i = 1; i <= num; i++) {
       if (i % 2 == 1) {
        Console.WriteLine(i);
       }
      }
     }
    }
   }
   The following sections show how you can insert breakpoints into the application so that you can debug the application during runtime.

   To set a breakpoint in your application, in the Visual Studio 2008 Code Editor, click in the left column beside the statement at which you want to set the breakpoint (see Figure 2-60).
   Figure 2-60 
   Press F5 to debug the application. When the execution reaches the statement with the breakpoint set, Visual Studio 2008 pauses the application and shows the breakpoint (see Figure 2-61).
   Figure 2-61 

   With the application stopped at the breakpoint, you have a choice of what to do:
   □ Step Into — Press F11 (see Figure 2-62). Stepping into the code means that if the breakpoint statement is a function call, execution is transferred to the first statement in the function and you can step through the function one statement at a time.
   Figure 2-62
   □ Step Over — Press F10. Stepping over the code means that if the breakpoint statement is a function call, the entire function is executed and control is transferred to the next statement after the function.
   □ Step Out — Press Shift+F11 to step out of the code (Step Out). If the statement at the breakpoint is part of a function, execution is resumed until the function exits. The control is transferred to the returning point in the calling function.

   Step Into and Step Over are basically the same, except when it comes to executing functions. 

   While you are at a breakpoint stepping through the code (using either F10 or F11), you can also examine the values of variables by hovering the mouse over the object you want to examine. Figure 2-63 shows value of i when the mouse is over i.
   Figure 2-63 

   You can also right-click on the object you want to monitor and select Add Watch or QuickWatch (see Figure 2-64).
   Figure 2-64
   When you use the Add Watch feature, the variable you are watching will be displayed in the Watch window (see Figure 2-65). As you step through your code, changes in the variable are reflected in the Watch window. In addition, you have the option to change the value of the variable directly in the Watch window.
   Figure 2-65
   The QuickWatch feature also enables you to monitor the value of variables, except that the execution cannot continue until you have closed the QuickWatch window (see Figure 2-66). You can also enter an expression to evaluate and at the same time add a variable into the Add Watch window.
   Figure 2-66

   To automatically view all the relevant variables in scope, you can launch the Autos window (see Figure 2-67) during a breakpoint by selecting Debug→Windows→Autos.
   Figure 2-67
   You can use the Immediate Window (see Figure 2-68) at runtime to evaluate expressions, execute statements, print variable values, and so on. You can launch the Immediate window during a breakpoint by selecting Debug→Windows→Immediate.
   Figure 2-68 

   Application testing is one of the tasks that every programmer worth his salt needs to do. For example, after writing a class, you often need to write additional code to instantiate the class and test the various methods and properties defined within it. Visual Studio 2008 Professional (and higher) provides a Unit Testing feature to auto-generate the code needed to test your application. 
   This section demonstrates how unit testing is performed in Visual Studio 2008. Use the following Point class definition located within a Class Library project:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace UnitTesting {
    class Point {
     public Point() { }
     public Point(int x, int y) {
      this.x = x;
      this.y = y;
     }
     public int x { get; set; }
     public int y { get; set; }
     //--- calculates the length between 2 points
     public double length(Point pointOne) {
      return Math.Sqrt(
       Math.Pow(this.x - pointOne.x, 2) +
       Math.Pow(this.y - pointOne.y, 2));
     }
    }
   }

   For this example, create a unit test to test the length() method. To do so, right-click on the length() method and select Create Unit Tests (see Figure 2-69).
   Figure 2-69
   In the Create Unit Tests dialog, select any other additional members you want to test and click OK (see Figure 2-70).
   Figure 2-70 
   You are prompted to name the test project. Use the default TestProject1 and click Create. You may also be prompted with the dialog shown in Figure 2-71. Click Yes.
   Figure 2-71
   The TestProject1 is be added to Solution Explorer (see Figure 2-72).
   Figure 2-72 
   The content of the PointTest.cs class is now displayed in Visual Studio 2008. This class contains the various methods that you can use to test the Point class. In particular, note the lengthTest() method:
   /// < summary>
   ///A test for length
   ///</summary>
   [TestMethod()]
   public void lengthTest() {
    Point target = new Point(); // TODO: Initialize to an appropriate value
    Point pointOne = null; // TODO: Initialize to an appropriate value
    double expected = 0F; // TODO: Initialize to an appropriate value
    double actual;
    actual = target.length(pointOne);
    Assert.AreEqual(expected, actual);
    Assert.Inconclusive("Verify the correctness of this test method.");
   }
   The lengthTest() method has the [TestMethod] attribute prefixing it. Methods with that attribute are known as test methods.
   Now modify the implementation of the lengthTest() method to basically create and initialize two Point objects and then call the length() method of the Point class to calculate the distance between the two points:
   /// <summary>
   ///A test for length
   ///</summary>
   [TestMethod()]
   public void lengthTest() {
    int x = 3;
    int y = 4;
    Point target = new Point(x, y);
    Point pointOne = new Point(0,0);
    double expected = 5F;
    double actual;
    actual = target.length(pointOne);
    Assert.AreEqual(expected, actual,
     "UnitTesting.Point.length did not return the expected value.");
   }
   Once the result is returned from the length() method, you use the AreEqual() method from the Assert class to check the returned value against the expected value. If the expected value does not match the returned result, the error message set in the AreEqual() method is displayed. 

   Before you run the unit test, take a look at the Test Tools toolbar (see Figure  2-73) automatically shown in Visual Studio 2008.
   Figure 2-73 
   To run the unit test, click the Run All Tests in Solution button in the toolbar. In this case, the lengthTest() method passed the test. The length between two points (3,4) and (0,0) is indeed 5 (see Figure 2-74).
   Figure 2-74 
   You can make modifications to the lengthTest() method to test other parameters. In the Test Results window, you have the option to view the previous test results (see Figure 2-75).
   Figure 2-75

   You need to take special note when your test involves comparing floating point numbers. Consider the following example:
   [TestMethod()]
   public void lengthTest() {
    int x = 4;
    int y = 5;
    Point target = new Point(x, y);
    Point pointOne = new Point(1,2);
    double expected = 4.24264F;
    double actual;
    actual = target.length(pointOne);
    Assert.AreEqual(expected, actual,
     "UnitTesting.Point.length did not return the expected value.");
   }
   When you run the test, the test will fail (see Figure 2-76).
   Figure 2-76
   Why is this so? The reason is that floating point numbers (such as Single and Double) are not stored exactly as what they have been assigned. For example, in this case, the value of 4.24264 is stored internally as 4.2426400184631348, and the result returned by the length() method is actually 4.2426406871192848. The AreEqual() method actually fails if you compare them directly.
   To address this issue, the AreEqual() method supports a third parameter — delta — that specifies the maximum difference allowed for the two numbers that you are comparing. In this case, the difference between the two numbers is 0.0000066865615. And so the following code will pass the test:
   Assert.AreEqual(expected, actual, 0.0000066865616,
    "UnitTesting.Point.length did not return the expected value.");
   But this code will fail:
   Assert.AreEqual(expected, actual, 0.0000066865615,
    "UnitTesting.Point.length did not return the expected value.");
   Assert.AreEqual(expected, actual, 0.0000066865614,
    "UnitTesting.Point.length did not return the expected value.");
   Although the documentation says that the delta specifies the maximum difference allowed for the two numbers, in actual testing the difference should be less than the delta for the Assert.AreEqual() method to pass. This explains why that first statement fails.

   You can insert additional test methods by adding new subroutines to the PointTest.cs file and prefixing them with the [TestMethod] attribute. For example, the following test method uses the AreSame() method of the Assert class to check whether two objects are pointing to the same reference:
   [TestMethod()]
   public void objectTest() {
    Point point1 = new Point(4, 5);
    Point point2 = new Point() { x = 4, y = 5 };
    Point point3 = point2;
    //---Failed---
    Assert.AreSame(point1, point2, "point1 is not the same as point2";
    //---Passed---
    Assert.AreSame(point2, point3, "point2 is not the same as point3";
   }
   Figure 2-77 shows the test results.
   Figure 2-77 

   Now that you have written your first C# program, let's take some time to dissect it and understand some of the important parts.
   The first few lines specify the various namespaces:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   As mentioned in Chapter 1, all the class libraries in the .NET Framework are grouped using namespaces. In C#, you use the using keyword to indicate that you will be using library classes from the specified namespace. In this example, you use the Console class's WriteLine() method to write a message to the console. The Console class belongs to the System namespace, and if you do not have the using System statement at the top of the program, you need to specify the fully qualified name for Console, which is:
   System.Console.WriteLine("Hello, world! This is my first C# program!");
   The next keyword of interest is namespace. It allows you to assign a namespace to your class, which is HelloWorld in this example:
   namespace HelloWorld {
    class Program {
     static void Main(string[] args) {
      Console.WriteLine("Hello, world! This is my first C# program!");
      Console.ReadLine();
      return;
     }
    }
   }
   Next, you define the class name as Program:
   class Program {
    static void Main(string[] args) {
     Console.WriteLine("Hello, world! This is my first C# program!");
     Console.ReadLine();
     return;
    }
   }
   All C# code must be contained within a class. Because this class is within the HelloWorld namespace, its fully qualified name is HelloWorld.Program.

   Classes and objects are discussed in detail in Chapter 4.

   Within the Program class, you have the Main() method:
   class Program {
    static void Main(string[] args) {
     Console.WriteLine("Hello, world! This is my first C# program!");
     Console.ReadLine();
     return;
    }
   }
   Every C# program must have an entry point, which in this case is Main(). An entry point is the method that is first executed when an application starts up. The static keyword indicates that this method can be called without creating an instance of the class.

   Chapters 4 and 5 provide more information about object-oriented programming.

   Unlike languages such as VB.NET in which a method can be either a function or a subroutine (a function returns a value; a subroutine does not), C# only supports functions. If a function does not return a result, you simply prefix the function name with the void keyword; otherwise, you indicate the return type by specifying its type.

   You will find more about functions in Chapter 4.

   Finally, you write the statements within the Main() method:
   static void Main(string[] args) {
    Console.WriteLine("Hello, world! This is my first C# program!");
    Console.ReadLine();
    return;
   }
   The WriteLine() method from the Console class writes a string to the command prompt. Notice that in C# you end each statement with a semicolon (;), which indicates to the compiler the end of each statement. Hence, you can rewrite the WriteLine() statement like this:
   Console.WriteLine(
    "Hello, world! This is my first C# program!");
   This is useful when you have a long statement and need to format it to fit into multiple lines for ease of reading.
   The use of the ReadLine() statement is to accept inputs from the user. The statement is used here mainly to keep the command window visible. If you run this program in Visual Studio 2008 without using the ReadLine() method, the program will print the hello world statement and then close the window immediately.

   If you run a program in the command prompt as described earlier in the chapter, you can pass in arguments to the application. For example, you might want the program to display your name. To do so, pass in the name like this:
   C:\C#>HelloWorld Wei-Meng Lee
   The argument passed into the program can be accessed by the args parameter (a string array) defined in the Main() method. Hence, you need to modify the program by displaying the values contained in the args string array, like this:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace HelloWorld {
    class Program {
     static void Main(string[] args) {
      Console.Write("Hello, ");
      for (int i = 0; i < args.Length; i++)
       Console.Write("{0} ", args[i]);
      Console.Write("! This is my first C# program!");
      Console.ReadLine();
      return;
     }
    }
   }

   Chapter 8 covers string arrays in depth.

   C# is a case-sensitive language that is highly expressive yet simple to learn and use. The following sections describe the various syntax of the language.

   In any programming language, there is always a list of identifiers that have special meanings to the compiler. These identifiers are known as keywords, and you should not use them as identifiers in your program.
   Here's the list of keywords in C# 2008:
   abstract event     new       struct
   as       explicit  null      switch
   base     extern    object    this
   bool     false     operator  throw
   break    finally   out       true
   byte     fixed     override  try
   case     float     params    typeof
   catch    for       private   uint
   char     foreach   protected ulong
   checked  goto      public    unchecked
   class    if        readonly  unsafe
   const    implicit  ref       ushort
   continue in        return    using
   decimal  int       sbyte     virtual
   default  interface sealed    volatile
   delegate internal  short     void
   do       is        sizeof    while
   double   lock      stackalloc
   else     long      static
   enum     namespace string

   In C#, you declare variables using the following format:
   datatype identifier;
   The following example declares and uses four variables:
   class Program {
    static void Main(string[] args) {
     //---declare the variables---
     int num1;
     int num2 = 5;
     float num3, num4;
     //---assign values to the variables---
     num1 = 4;
     num3 = num4 = 6.2f;
     //---print out the values of the variables---
     Console.WriteLine("{0} {1} {2} {3}", num1, num2, num3, num4);
     Console.ReadLine();
     return;
    }
   }
   Note the following:
   □ num1 is declared as an int (integer).
   □ num2 is declared as an int and assigned a value at the same time.
   □ num3 and num4 are declared as float (floating point number)
   □ You need to declare a variable before you can use it. If not, C3 compiler will flag that as an error.
   □ You can assign multiple variables in the same statement, as is shown in the assignment of num3 and num4.
   This example will print out the following output:
   4 5 6.2 6.2
   The following declaration is also allowed:
   //---declares both num5 and num6 to be float
   // and assigns 3.4 to num5---
   float num5 = 3.4f, num6;
   But this one is not allowed:
   //---cannot mix different types in a declaration statement---
   int num7, float num8;

   The name of the variable cannot be one of the C# keywords. If you absolutely must use one of the keywords as a variable name, you need to prefix it with the @ character, as the following example shows:
   int @new = 4;
   Console.WriteLine(@new);

   The scope of a variable (that is, its visibility and accessibility) that you declare in C# is affected by the location in which the variable is declared. Consider the following example where a variable num is declared within the Program class:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace HelloWorld {
    class Program {
     static int num = 7;
     static void Main(string[] args) {
      Console.WriteLine("num in Main() is {0}", num); //---7---
      HelloWorld.Program.Method1();
      Console.ReadLine();
      return;
     }
     static private void Method1() {
      Console.WriteLine("num in Method1() is {0}", num); //---7---
     }
    }
   }
   Because the num variable is declared in the class, it is visible (that is, global) to all the methods declared within the class, and you see the following output:
   num in Main() is 7
   num in Method1() is 7
   However, if you declare another variable with the same name (num) within Main() and Method1(), like this:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace HelloWorld {
    class Program {
     static int num = 7;
     static void Main(string[] args) {
      int num = 5;
      Console.WriteLine("num in Main() is {0}", num); //---5---
      HelloWorld.Program.Method1();
      Console.ReadLine();
      return;
     }
     static private void Method1() {
      int num = 10;
      Console.WriteLine("num in Method1() is {0}", num); //---10---
     }
    }
   }
   You get a very different output:
   num in Main() is 5
   num in Method1() is 10
   That's because the num variables in Main() and Method1() have effectively hidden the num variable in the Program class. In this case, the num in the Program class is known as the global variable while the num variables in Main and Method1 are known as local variables. The num variable in Main() is only visible within Main(). Likewise, this also applies to the num variable in Method1().
   What if you need to access the num declared in the Program class? In that case, you just need to specify its full name:
   Console.WriteLine("num in Program is {0}", HelloWorld.Program.num); //---7---
   While a local variable can hide the scope of a global variable, you cannot have two variables with the same scope and identical names. The following makes it clear:
   static void Main(string[] args) {
    int num = 5;
    Console.WriteLine("num in Main() is {0}", num); //---5---
    int num = 6; //---error: num is already declared---
    return;
   }
   However, two identically named variables in different scope would be legal, as the following shows:
   static void Main(string[] args) {
    for (int i = 0; i < 5; i++) {
     //--- i is visible within this loop only---
     Console.WriteLine(i);
    } //--- i goes out of scope here---
    for (int i = 0; i < 3; i++) {
     //--- i is visible within this loop only---
     Console.WriteLine(i);
    } //--- i goes out of scope here---
    Console.ReadLine();
    return;
   }
   Here, the variable i appears in two for loops (looping is covered later in this chapter). The scope for each i is restricted to within the loop, so there is no conflict in the scope and this is allowed.
   Declaring another variable named i outside the loop or inside it will cause a compilation error as the following example shows:
   static void Main(string[] args) {
    int i = 4; //---error---
    for (int i = 0; i < 5; i++) {
     int i = 6; //---error---
     Console.WriteLine(i);
    }
    for (int i = 0; i < 3; i++) {
     Console.WriteLine(i);
    }
    Console.ReadLine();
    return;
   }
   This code results in an error: "A local variable named 'i' cannot be declared in this scope because it would give a different meaning to 'i', which is already used in a 'parent or current' scope to denote something else."

   To declare a constant in C#, you use the const keyword, like this:
   //---declared the PI constant---
   const float PI=3.14f;
   You cannot change the value of a constant (during runtime) once it has been declared and assigned a value.
   As a good programming practice, you should always use constants whenever you use values that do not change during runtime.

   In C#, you can insert comments into your program using either // or a mirrored pair of /* and */. The following example shows how to insert comments into your program using //:
   //---declare the variables---
   int num1; //---num1 variable---
   int num2 = 5; //---num2 variable---
   float num3, num4; //---num3 and num4 variables---
   And here's an example of how to insert a multi-line block of comments into your program:
   /*
    Declares the following variables: num1, num2, num3, num4
   */
   int num1;
   int num2 = 5;
   float num3, num4;
   In general, use the // for short, single-line comments and /* */ for multi-line comments.

   One of the very cool features available in Visual Studio 2008 is the support for XML documentation. This feature enables you to insert comments into your code using XML elements and then generate a separate XML file containing all the documentation. You can then convert the XML file into professional- looking documentation for your code. 
   To insert an XML comment into your code, position the cursor before a class or method name and type three / characters (left window in Figure 3-6). The XML template is automatically inserted for you (see the right window in Figure 3-6).
   Figure 3-6 
   The following code shows the XML documentation template created for the Program class, the Main() method, and the AddNumbers() method (you need to fill in the description for each element):
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace HelloWorld {
    /// <summary>
    /// This is my first C# program.
    /// </summary>
    class Program {
     /// <summary>
     /// The entry point for the program
     /// </summary>
     /// <param name="args"<Argument(s) from the command line</param>
     static void Main(string[] args) {
      Console.Write("Hello, ");
      for (int i = 0; i < args.Length; i++)
       Console.Write("{0} ", args[i]);
      Console.Write("! This is my first C# program!");
      Console.ReadLine();
      return;
     }
     /// <summary>
     /// Adds two numbers and returns the result
     /// </summary>
     /// <param name="num1">Number 1</param>
     /// <param name="num2">Number 2</param>
     /// <returns> Sum of Number 1 and 2</returns>
     private int AddNumbers(int num1, int num2) {
      //---implementations here---
     }
    }
   }
   To enable generation of the XML document containing the XML comments, right-click the project name in Solution Explorer and select Properties.

   You can also generate the XML documentation file using the csc.exe compiler at the command prompt using the /doc option:
   csc Program.cs /doc:HelloWorld.xml

   In the Build tab, tick the XML Documentation File checkbox and use the default path suggested: bin\Debug\HelloWorld.XML (see Figure 3-7).
   Figure 3-7
   Build the project by right-clicking the project name in Solution Explorer and selecting Build.
   You will now find the HelloWorld.xml file (see Figure 3-8) located in the bin\Debug\ folder of the project.
   Figure 3-8
   You can now convert this XML file into a MSDN-style documentation file. Appendix C shows you how to use the SandCastle tool to do this.

   C# is a strongly typed language and as such all variables and objects must have a declared data type. The data type can be one of the following:
   □ Value
   □ Reference
   □ User-defined
   □ Anonymous

   You'll find more information about user-defined types in Chapter 4 and about anonymous types in Chapter 14.

   A value type variable contains the data that it is assigned. For example, when you declare an int (integer) variable and assign a value to it, the variable directly contains that value. And when you assign a value type variable to another, you make a copy of it. The following example makes this clear:
   class Program {
    static void Main(string[] args) {
     int num1, num2;
     num1 = 5;
     num2 = num1;
     Console.WriteLine("num1 is {0}. num2 is {1}", num1, num2);
     num2 = 3;
     Console.WriteLine("num1 is {0}. num2 is {1}", num1, num2);
     Console.ReadLine();
     return;
    }
   }
   The output of this program is:
   num1 is 5. num2 is 5
   num1 is 5. num2 is 3
   As you can observe, num2 is initially assigned a value of num1 (which is 5). When num2 is later modified to become 3, the value of num1 remains unchanged (it is still 5). This proves that the num1 and num2 each contains a copy of its own value.
   Following is another example of value type. Point is a structure that represents an ordered pair of integer x and y coordinates that defines a point in a two-dimensional plane (structure is another example of value types). The Point class is found in the System.Drawing namespace and hence to test the following statements you need to import the System.Drawing namespace.

   Chapter 4 discusses structures in more detail.

   Point pointA, pointB;
   pointA = new Point(3, 4);
   pointB = pointA;
   Console.WriteLine("point A is {0}. pointB is {1}",
    pointA.ToString(), pointB.ToString());
   pointB.X = 5;
   pointB.Y = 6;
   Console.WriteLine("point A is {0}. pointB is {1}",
    pointA.ToString(), pointB.ToString());
   These statements yield the following output:
   point A is {X=3,Y=4}. pointB is {X=3,Y=4}
   point A is {X=3,Y=4}. pointB is {X=5,Y=6}
   As in the earlier example, changing the value of the pointB does not change the value of pointA.

Predefined Value Types

   The .NET Framework ships with a set of predefined C# and .NET value types. These are described in the following table.

C# Type	.NET Framework Type	Bits	Range
bool	System.Boolean		True or false
byte	System.Byte	8	Unsigned 8-bit integer values from 0 to 255
sbyte	System.SByte	8	Signed 8-bit integer values from -128 to 127
char	System.Char	16	16-bit Unicode character from U+0000 to U+ffff
decimal	System.Decimal	128	Signed 128-bit number from ±1.0×10-28 to ±7.9×1028
double	System.Double	64	Signed 64-bit floating point number; approximately from ±5.0×10-324 to ±1.7×10308
float	System.Single	32	Signed 32-bit floating point number; approximately from ±1.5×10-45 to ±3.4×1038
int	System.Int32	32	Signed 32-bit integer number from -2,147,483,648 to 2,147,483,647
uint	System.UInt32	32	Unsigned 32-bit integer number from 0 to 4,294,967,295
long	System.Int64	64	Signed 64-bit integer number from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
ulong	System.UInt64	64	Unsigned 64-bit integer number from 0 to 18,446,744,073,709,551,615
short	System.Int16	16	Signed 16-bit integer number from -32,768 to 32,767
ushort	System.UInt16	16	Unsigned 16-bit integer number from 0 to 65,535

   To declare a variable of a predefined type, you can either use the C# type or the .NET Framework type. For example, to declare an integer variable, you can either use the int or System.Int32 type, as shown here:
   int num1 = 5;
   //---or---
   System.Int32 num2 = 5;
   To get the type of a variable, use the GetType() method:
   Console.WriteLine(num1.GetType()); //---System.Int32---
   To get the .NET equivalent of a C# type, use the typeof() method. For example, to learn the .NET type equivalent of C#'s float type, you can use the following statements:
   Type t = typeof(float);
   Console.WriteLine(t.ToString()); //---System.Single---
   To get the size of a type, use the sizeof() method:
   Console.WriteLine("{0} bytes", sizeof(int)); //---4 bytes---
   In C#, all noninteger numbers are always treated as a double. And so if you want to assign a noninteger number like 3.99 to a float variable, you need to append it with the F (or f) suffix, like this:
   float price = 3.99F;
   If you don't do this, the compiler will issue an error message: "Literal of type double cannot be implicitly converted to type 'float'; use an 'F' suffix to create a literal of this type."
   Likewise, to assign a noninteger number to a decimal variable, you need to use the M suffix:
   decimal d = 4.56M; //---suffix M to convert to decimal---
   float f = 1.23F; //---suffix F to convert to float---
   You can also assign integer values using hexadecimal representation. Simply prefix the hexadecimal number with 0x, like this:
   int num1 = 0xA;
   Console.WriteLine(num1); //---10---

Nullable Type

   All value types in C# have a default value when they are declared. For example, the following declaration declares a Boolean and an int variable:
   Boolean married; //---default value is false---
   int age; //--- default value is 0---

   To learn the default value of a value type, use the default keyword, like this:
   object x; x = default(int);
   Console.WriteLine(x); //---0---
   x = default(bool);
   Console.WriteLine(x); //---false---

   However, C# forbids you from using a variable if you do not explicitly initialize it. The following statements, for instance, cause the compiler to complain:
   Boolean married;
   //---error: Use of unassigned local variable 'married'---
   Console.WriteLine(married);
   To use the variable, you first need to initialize it with a value:
   Boolean married = false;
   Console.WriteLine(married); //---now OK---
   Now married has a default value of false. There are times, though, when you do not know the marital status of a person, and the variable should be neither true nor false. In C#, you can declare value types to be nullable, meaning that they do not yet have a value.
   To make the married variable nullable, the above declaration can be rewritten in two different ways (all are equivalent):
   Boolean? married = null;
   //---or---
   Nullable<Boolean> married = null;
   The syntax T? (example, Boolean?) is shorthand for Nullable<T> (example, Nullable<Boolean>), where T is a type.

   You read this statement as "Nullable of Boolean." The <> represents a generic type and will be discussed in more detail in Chapter 9.

   In this case, married can take one of the three values: true, false, or null.
   The following code snippet prints out "Not Married":
   Boolean? married = null;
   if (married == true)
    Console.WriteLine("Married");
   else
    Console.WriteLine("Not Married"); //---this will be printed---
   That's because the if statement evaluates to false (married is currently null), so the else block executes. A much better way to check would be to use the following snippet:
   if (married == true)
    Console.WriteLine("Married");
   else if (married==false)
    Console.WriteLine("Not Married");
   else
    Console.WriteLine("Not Sure"); //---this will be printed---
   Once a nullable type variable is set to a value, you can set it back to nothing by using null, as the following example shows:
   married = true; //---set it to True---
   married = null; //---reset it back to nothing---
   To check the value of a nullable variable, use the HasValue property, like this:
   if (married.HasValue) {
    //---this line will be executed only
    // if married is either true or false---
    Console.WriteLine(married.Value);
   }
   You can also use the == operator to test against null, like the following:
   if (married == null) {
    //---causes a runtime error---
    Console.WriteLine(married.Value);
   }
   But this results in an error because attempting to print out the value of a null variable using the Value property causes an exception to be thrown. Hence, always use the HasValue property to check a nullable variable before attempting to print its value.
   When dealing with nullable types, you may want to assign a nullable variable to another variable, like this:
   int? num1 = null;
   int num2 = num1;
   In this case, the compiler will complain because num1 is a nullable type while num2 is not (by default, num2 cannot take on a null value unless it is declared nullable). To resolve this, you can use the null coalescing operator (??). Consider the following example:
   int? num1 = null;
   int num2 = num1 ?? 0;
   Console.WriteLine(num2); //---0---
   In this statement, if num1 is null, 0 will be assigned to num2. If num1 is not null, the value of num1 will be assigned to num2, as evident in the following few statements:
   num1 = 5;
   num2 = num1 ?? 0;
   Console.WriteLine(num2); //---5---

   For reference types, the variable stores a reference to the data rather than the actual data. Consider the following:
   Button btn1, btn2;
   btn1 = new Button();
   btn1.Text = "OK";
   btn2 = btn1;
   Console.WriteLine("{0} {1}", btn1.Text, btn2.Text);
   btn2.Text = "Cancel";
   Console.WriteLine("{0} {1}", btn1.Text, btn2.Text);
   Here, you first declare two Button controls — btn1 and btn2. btn1's Text property is set to "OK" and then btn2 is assigned btn1. The first output will be:
   OK OK
   When you change btn2's Text property to "Cancel", you invariably change btn1's Text property, as the second output shows:
   Cancel Cancel
   That's because btn1 and btn2 are both pointing to the same Button object. They both contain a reference to that object instead of storing the value of the object. The declaration statement (Button btn1, btn2;) simply creates two variables that contain references to Button objects (in the example these two variables point to the same object).
   To remove the reference to an object in a reference type, simply use the null keyword:
   btn2 = null;
   When a reference type is set to null, attempting to access its members results in a runtime error. 

Value Types versus Reference Types

   For any discussion about value types and reference types, it is important to understand how the .NET Framework manages the data in memory.
   Basically, the memory is divided into two parts — the stack and the heap. The stack is a data structure used to store value-type variables. When you create an int variable, the value is stored on the stack. In addition, any call you make to a function (method) is added to the top of the stack and removed when the function returns.
   In contrast, the heap is used to store reference-type variables. When you create an instance of a class, the object is allocated on the heap and its address is returned and stored in a variable located on the stack.
   Memory allocation and deallocation on the stack is much faster than on the heap, so if the size of the data to be stored is small, it's better to use a value- type variable than reference-type variable. Conversely, if the size of data is large, it is better to use a reference-type variable.

   C# supports two predefined reference types — object and string — which are described in the following table.

C# Type	.NET Framework Type	Descriptions
object	System.Object	Root type from which all types in the CTS (Common Type System) derive
string	System.String	Unicode character string

   Chapter 4 explores the System.Object type, and Chapter 8 covers strings in more detail.

   You can create your own set of named constants by using enumerations. In C#, you define an enumeration by using the enum keyword. For example, say that you need a variable to store the day of a week (Monday, Tuesday, Wednesday, and so on):
   static void Main(string[] args) {
    int day = 1; //--- 1 to represent Monday---
    //...
    Console.ReadLine();
    return;
   }
   In this case, rather than use a number to represent the day of a week, it would be better if the user could choose from a list of possible named values representing the days in a week. The following code example declares an enumeration called Days that comprises seven names (Sun, Mon, Tue, and so forth). Each name has a value assigned (Sun is 0, Mon is 1, and so on):
   namespace HelloWorld {
    public enum Days {
     Sun = 0,
     Mon = 1,
     Tue = 2,
     Wed = 3,
     Thur = 4,
     Fri = 5,
     Sat = 6
    }
    class Program {
     static void Main(string[] args) {
      Days day = Days.Mon;
      Console.WriteLine(day); //---Mon---
      Console.WriteLine((int) day); //---1---
      Console.ReadLine();
      return;
     }
    }
   }
   Instead of representing the day of a week using an int variable, you can create a variable of type Days. Visual Studio 2008's IntelliSense automatically displays the list of allowed values in the Days enumeration (see Figure 3-9).
   Figure 3-9
   By default, the first value in an enumerated type is zero. However, you can specify a different initial value, such as:
   public enum Ranking {
    First = 100,
    Second = 50,
    Third = 25
   }
   To print out the value of an enumerated type, you can use the ToString() method to print out its name, or typecast the enumerated type to int to obtain its value:
   Console.WriteLine(day); //---Mon---
   Console.WriteLine(day.ToString()); //---Mon---
   Console.WriteLine((int)day); //---1--- 
   For assigning a value to an enumerated type, you can either use the name directly or typecast the value to the enumerated type:
   Days day;
   day = (Days)3; //---Wed---
   day = Days.Wed; //---Wed--- 

   An array is a data structure containing several variables of the same type. For example, you might have an array of integer values, like this:
   int[] nums;
   In this case, nums is an array that has yet to contain any elements (of type int). To make nums an array containing 10 elements, you can instantiate it with the new keyword followed by the type name and then the size of the array:
   nums = new int[10];
   The index for each element in the array starts from 0 and ends at n-1 (where n is the size of the array). To assign a value to each element of the array, you can specify its index as follows:
   nums[0] = 0;
   nums[1] = 1;
   //...
   nums[9] = 9;
   Arrays are reference types, but array elements can be of any type.
   Instead of assigning values to each element in an array individually, you can combine them into one statement, like this:
   int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   Arrays can be single-dimensional (which is what you have seen so far), multi-dimensional, or jagged. You'll find more about arrays in Chapter 13, in the discussion of collections.

   In the previous versions of C#, all variables must be explicitly typed-declared. For example, if you want to declare a string variable, you have to do the following:
   string str = "Hello World";
   In C# 3.0, this is not mandatory — you can use the new var keyword to implicitly declare a variable. Here's an example:
   var str = "Hello world!";
   Here, str is implicitly declared as a string variable. The type of the variable declared is based on the value that it is initialized with. This method of variable declaration is known as implicit typing. Implicitly typed variables must be initialized when they are declared. The following statement will not compile:
   var str; //---missing initializer---
   Also notice that IntelliSense will automatically know the type of the variable declared, as evident in Figure 3-10.
   Figure 3-10
   You can also use implicit typing on arrays. For example, the following statement declares points to be an array containing two Point objects:
   var points = new[] { new Point(1, 2), new Point(3, 4) };
   When using implicit typing on arrays, all the members in the array must be of the same type. The following won't compile since its members are of different types — string and Boolean:
   //---No best type found for implicitly-typed array---
   var arr = new[] { "hello", true, "world" };
   Implicit typing is useful in cases where you do not know the exact type of data you are manipulating and want the compiler to determine it for you. Do not confuse the Object type with implicit typing.
   Variables declared as Object types need to be cast during runtime, and IntelliSense does not know their type at development time. On the other hand, implicitly typed variables are statically typed during design time, and IntelliSense is capable of providing detailed information about the type. In terms of performance, an implicitly typed variable is no different from a normal typed variable.

   Implicit-typing is very useful when using LINQ queries. Chapter 14 discusses LINQ in more detail.

   C# is a strongly typed language, so when you are assigning values of variables from one type to another, you must take extra care to ensure that the assignment is compatible. Consider the following statements where you have two variables — one of type int and another of type short:
   int num;
   short sNum = 20;
   The following statement assigns the value of sNum to num:
   num = sNum; //---OK---
   This statement works because you're are assigning the value of a type (short) whose range is smaller than that of the target type (int). In such instances, C# allows the assignment to occur, and that's known as implicit conversion.

   Converting a value from a smaller range to a bigger range is known as widening.

   The following table shows the implicit conversion between the different built-in types supported by C#.

Convert from (type)	To (type)
sbyte	short, int, long, float, double, or decimal
byte	short, ushort, int, uint, long, ulong, float, double, or decimal
short	int, long, float, double, or decimal
ushort	int, uint, long, ulong, float, double, or decimal
int	long, float, double, or decimal
uint	long, ulong, float, double, or decimal
long	float, double, or decimal
char	ushort, int, uint, long, ulong, float, double, or decimal
float	double
ulong	float, double, or decimal

   If you try to assign the value of a type whose range is bigger than the target type, C# will raise an error. Consider the following example:
   num = 5;
   sNum = num; //---not allowed---
   In this case, num is of type int and it may contain a big number (such as 40,000). When assigning it to a variable of type short, that could cause a loss of data. To allow the assignment to proceed, C# requires you to explicitly type-cast (convert) the value to the target type. This process is known asexplicit conversion.

   Converting a value from a bigger range to a smaller range is known as narrowing. Narrowing can result in a loss of data, so be careful when performing a narrowing operation.

   The preceding statement could be made valid when you perform a type casting operation by prefixing the variable that you want to assign with the target type in parentheses:
   num = 5;
   sNum = (short) num; //---sNum is now 5---
   When performing type casting, you are solely responsible for ensuring that the target variable can contain the value assigned and that no loss of data will happen. In the following example, the assignment will cause an overflow, changing the value of num to -25536, which is not the expected value:

   By default, Visual Studio 2008 checks statements involving constant assignments for overflow during compile time. However, this checking is not enforced for statements whose values cannot be determined at runtime.
   int num = 40000;
   short sNum;
   sNum =(short) num; //--- -25536; no exception is raised---

   To ensure that an exception is thrown during runtime when an overflow occurs, you can use the checked keyword, which is used to explicitly enable overflow-checking for integral-type arithmetic operations and conversions:
   try {
    sNum = checked((short)num); //---overflow exception---
   } catch (OverflowException ex) {
    Console.WriteLine(ex.Message);
   }
   If you try to initialize a variable with a value exceeding its range, Visual Studio 2008 raises an error at compile time, as the following shows:
   int num = 400000 * 400000;
   //---overflows at compile time in checked mode
   To turn off the automatic check mode, use the unchecked keyword, like this:
   unchecked {
    int num = 400000 * 400000;
   }
   The compiler will now ignore the error and proceed with the compilation.
   Another way to perform conversion is to use the System.Convert class to perform the conversion for you. The System.Convert class converts the value of a variable from one type into another type. It can convert a value to one of the following types:
   Boolean Int16  UInt32 Decimal
   Char    Int32  UInt64 DateTime
   SByte   Int64  Single String
   Byte    UInt16 Double
   Using an earlier example, you can convert a value to Int16 using the following statement:
   sNum = Convert.ToInt16(num);
   If a number is too big (or too small) to be converted to a particular type, an overflow exception is thrown, and you need to catch the exception:
   int num = 40000;
   short sNum;
   try {
    sNum = Convert.ToInt16(num); //---overflow exception---
   } catch (OverflowException ex) {
    Console.WriteLine(ex.Message);
   }
   When converting floating point numbers to integer values, you need to be aware of one subtle difference between type casting and using the Convert class. When you perform a type casting on a floating point number, it truncates the fractional part, but the Convert class performs numerical rounding for you, as the following example shows:
   int num;
   float price = 5.99F;
   num = (int)price; //---num is 5---
   num = Convert.ToInt16(price); //---num is 6---
   When converting a string value type to a numerical type, you can use the Parse() method that is available to all built in numeric types (such as int, float, double, and so on). Here's how you can convert the value stored in the str variable into an integer:
   string str = "5";
   int num = int.Parse(str);
   Beware that using the Parse() method may trigger an exception, as demonstrated here:
   string str = "5a";
   int num = int.Parse(str); //---format exception---
   This statement causes a format exception to be raised during runtime because the Parse() method cannot perform the conversion. A safer way would be to use the TryParse() method, which will try to perform the conversion. It returns a false if the conversion fails, or else it returns the converted value in the out parameter:
   int num;
   string str = "5a";
   if (int.TryParse(str, out num)) Console.WriteLine(num);
   else Console.WriteLine("Cannot convert");

   In C#, there are two ways to determine the selection of statements for execution:
   □ if-else statement
   □ switch statement

   The most common flow-control statement is the if-else statement. It evaluates a Boolean expression and uses the result to determine the block of code to execute. Here's an example:
   int num = 9;
   if (num % 2 == 0) Console.WriteLine("{0} is even", num);
   else Console.WriteLine("{0} is odd", num);
   In this example, if num modulus 2 equals to 0, the statement "9 is even" is printed; otherwise (else), "9 is odd" is printed.

   Remember to wrap the Boolean expression in a pair of parentheses when using the if statement.

   If you have multiple statements to execute after an if-else expression, enclose them in {}, like this:
   int num = 9;
   if (num % 2 == 0) {
    Console.WriteLine("{0} is even", num);
    Console.WriteLine("Print something here...");
   }
   else {
    Console.WriteLine("{0} is odd", num);
    Console.WriteLine("Print something here...");
   }
   Here's another example of an if-else statement:
   int num = 9;
   string str = string.Empty;
   if (num % 2 == 0) str = "even";
   else str = "odd";
   You can rewrite these statements using the conditional operator (?:), like this:
   str = (num % 2 == 0) ? "even" : "odd";
   Console.WriteLine(str); //---odd---

   ?: is also known as the ternary operator.

   The conditional operator has the following format:
   condition ? first_expression : second_expression;
   If condition is true, the first expression is evaluated and becomes the result; if false, the second expression is evaluated and becomes the result.

   You can evaluate multiple expressions and conditionally execute blocks of code by using if-else statements. Consider the following example:
   string symbol = "YHOO";
   if (symbol == "MSFT") {
    Console.WriteLine(27.96);
   } else if (symbol == "GOOG") {
    Console.WriteLine(437.55);
   } else if (symbol == "YHOO") {
    Console.WriteLine(27.15);
   } else Console.WriteLine("Stock symbol not recognized");
   One problem with this is that multiple if and else-if conditions make the code unwieldy — and this gets worse when you have lots of conditions to check. A better way would be to use the switch keyword:
   switch (symbol) {
   case "MSFT":
    Console.WriteLine(27.96);
    break;
   case "GOOG":
    Console.WriteLine(437.55);
    break;
   case "YHOO":
    Console.WriteLine(27.15);
    break;
   default:
    Console.WriteLine("Stock symbol not recognized");
    break;
   }
   The switch keyword handles multiple selections and uses the case keyword to match the condition. Each case statement must contain a unique value and the statement, or statements, that follow it is the block to execute. Each case statement must end with a break keyword to jump out of the switch block. The default keyword defines the block that will be executed if none of the preceding conditions is met.
   The following example shows multiple statements in a case statement:
   string symbol = "MSFT";
   switch (symbol) {
   case "MSFT":
    Console.Write("Stock price for MSFT: ");
    Console.WriteLine(27.96);
    break;
   case "GOOG":
    Console.Write("Stock price for GOOG: ");
    Console.WriteLine(437.55);
    break;
   case "YHOO":
    Console.Write("Stock price for YHOO: ");
    Console.WriteLine(27.15);
    break;
   default:
    Console.WriteLine("Stock symbol not recognized");
    break;
   }
   In C#, fall-throughs are not allowed; that is, each case block of code must include the break keyword so that execution can be transferred out of the switch block (and not "fall through" the rest of the case statements). However, there is one exception to this rule — when a case block is empty. Here's an example:
   string symbol = "INTC";
   switch (symbol) {
   case "MSFT":
    Console.WriteLine(27.96);
    break;
   case "GOOG":
    Console.WriteLine(437.55);
    break;
   case "INTC":
   case "YHOO":
    Console.WriteLine(27.15);
    break;
   default:
    Console.WriteLine("Stock symbol not recognized");
    break;
   }
   The case for "INTC" has no execution block/statement and hence the execution will fall through into the case for "YHOO", which will incorrectly print the output "27.15". In this case, you need to insert a break statement after the "INTC" case to prevent the fall-through:
   switch (symbol) {
   case "MSFT":
    Console.WriteLine(27.96);
    break;
   case "GOOG":
    Console.WriteLine(437.55);
    break;
   case "INTC":
    break;
   case "YHOO":
    Console.WriteLine(27.15);
    break;
   default:
    Console.WriteLine("Stock symbol not recognized");
    break;
   }

   A loop is a statement, or set of statements, repeated for a specified number of times or until some condition is met. C# supports the following looping constructs:
   □ for
   □ foreach
   □ while and do-while

   The for loop executes a statement (or a block of statements) until a specified expression evaluates to false. The for loop has the following format:
   for (statement; expression; statement(s)) {
    //---statement(s)
   }
   The expression inside the for loop is evaluated first, before the execution of the loop. Consider the following example:
   int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   for (int i=0; i<9; i++) {
    Console.WriteLine(nums[i].ToString());
   }
   Here, nums is an integer array with nine members. The initial value of i is 0 and after each iteration it increments by 1. The loop will continue as long as i is less than 9. The loop prints out the numbers from the array:
   1
   2
   3
   4
   5
   6
   7
   8
   9
   Here' s another example:
   string[] words = { "C#","3.0","Programming","is","fun"};
   for (int j = 2; j <= 4; ++j) {
    Console.WriteLine(words[j]);
   }
   This code prints the strings in the words array, from index 2 through 4. The output is:
   Programming
   is
   fun
   You can also omit statements and expressions inside the for loop, as the following example illustrates:
   for (;;) {
    Console.Write("*");
   }
   In this case, the for loop prints out a series of *s continuously (infinite loop).

   It is common to nest two or more for loops within one another. The following example prints out the times table from 1 to 10:
   for (int i = 1; i <= 10; i++) {
    Console.WriteLine("Times table for {0}", i);
    Console.WriteLine("=================");
    for (int j = 1; j <= 10; j++) {
     Console.WriteLine ("{0} x {1} = {2}", i, j, i*j);
    }
   }
   Figure 3-11 shows the output.
   Figure 3-11 
   Here, one for loop is nested within another for loop. The first pass of the outer loop (represented by i in this example) triggers the inner loop (represented by j). The inner loop will execute to completion and then the outer loop will move to the second pass, which triggers the inner loop again. This repeats until the outer loop has finished executing.

   One common use for the for loop is to iterate through a series of objects in a collection. In C# there is another looping construct that is very useful for just this purpose — the foreach statement, which iterates over each element in a collection. Take a look at an example:
   int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   foreach (int i in nums) {
    Console.WriteLine(i);
   }
   This code block prints out all the numbers in the nums array (from 1 to 9). The value of i takes on the value of each individual member of the array during each iteration. However, you cannot change the value of i within the loop, as the following example demonstrates:
   int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   foreach (int i in nums) {
    i += 4; //---error: cannot change the value of i---
    Console.WriteLine(i);
   }
   Here is another example of the use of the foreach loop:
   string[] words = { "C#", "3.0", "Programming", "is", "fun" };
   foreach (string w in words) {
    Console.WriteLine(w);
   }
   This code block prints out:
   C#
   3.0
   Programming
   is
   fun

   In addition to for and foreach statements, you can use a while statement to execute a block of code repeatedly. The while statement executes a code block until the specified condition is false. Here's an example:
   int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   int i = 0;
   while (i < 9) {
    Console.WriteLine(nums[i++]);
   }
   This code iterates through all the elements (from index 0 to 8) in the nums array and prints out each number to the console window.
   The while statement checks the condition before executing the block of code. To execute the code at least once before evaluating the condition, use the do-while statement. It executes its code and then evaluates the condition specified by the while keyword, as the following example shows:
   string reply;
   do {
    Console.WriteLine("Are you sure you want to quit? [y/n]");
    reply = Console.ReadLine();
   } while (reply != "y");
   In this code, you first print the message on the console and then wait for the user to enter a string. If the string entered is not y, the loop continues. It will exit when the user enters y.

   To break out of a loop prematurely (before the exit condition is met), you can use one of the following keywords:
   □ break
   □ return
   □ throw
   □ goto

break

   The break keyword allows you to break out of a loop prematurely:
   int counter = 0;
   do {
    Console.WriteLine(counter++);
    //---exits the loop when counter is more than 100
    if (counter > 100) break;
   } while (true);
   In this example, you increment the value of counter in an infinite do-while loop. To break out of the loop, you use a if statement to check the value of counter. If the value exceeds 100, you use the break keyword to exit the do-while loop.
   You can also use the break keyword in while, for, and foreach loops.

return

   The return keyword allows you to terminate the execution of a method and return control to the calling method. When you use it within a loop, it will also exit from the loop. In the following example, the FindWord() function searches for a specified word ("car") inside a given array. As soon as a match is found, it exits from the loop and returns control to the calling method:
   class Program {
    static string FindWord(string[] arr, string word) {
     foreach (string w in arr) {
      //--- if word is found, exit the loop and return back to the
      // calling function---
      if (w.StartsWith(word)) return w;
     }
     return string.Empty;
    }
    static void Main(string[] args) {
     string[] words = {
      "-online", "4u", "adipex", "advicer", "baccarrat", "blackjack",
      "bllogspot", "booker", "byob", "car-rental-e-site",
      "car-rentals-e-site", "carisoprodol", "casino", "casinos",
      "chatroom", "cialis", "coolcoolhu", "coolhu",
      "credit-card-debt", "credit-report-4u"
     };
     Console.WriteLine(FindWord(words, "car")); //---car-rental-e-site---
    }
   }

throw

   The throw keyword is usually used with the try-catch-finally statements to throw an exception. However, you can also use it to exit a loop prematurely. Consider the following block of code that contains the Sums() function to perform some addition and division on an array:
   class Program {
    static double Sums(int[] nums, int num) {
     double sum = 0;
     foreach (double n in nums) {
      if (n == 0)
       throw new Exception("Nums contains zero!");
      sum += num / n;
     }
     return sum;
    }
    static void Main(string[] args) {
     int[] nums = { 1, 2, 3, 4, 0, 6, 7, 8, 9 };
     try {
      Console.WriteLine(Sums(nums, 2));
     } catch (Exception e) {
      Console.WriteLine(e.Message);
     }
    }
   }
   When the foreach loop reaches the fifth element of the array (0), it throws an exception and exits the loop. The exception is then caught by the try-catch loop in the Main() method.

goto

   The goto keyword transfers program control directly to a labeled statement. Using goto is not considered a best practice because it makes your program hard to read. Still, you want to be aware of what it does, so the following example shows its use:
   string[] words = {
    "-online", "4u", "adipex", "advicer", "baccarrat", "blackjack",
    "bllogspot", "booker", "byob", "car-rental-e-site",
    "car-rentals-e-site", "carisoprodol", "casino", "casinos",
    "chatroom", "cialis", "coolcoolhu", "coolhu",
    "credit-card-debt", "credit-report-4u"
   };
   foreach (string word in words) {
    if (word == "casino")
   goto Found;
   }
   goto Resume;
   Found:
   Console.WriteLine("Word found!");
   Resume:
   //---other statements here---
   In this example, if the word casino is found in the words array, control is transferred to the label named Found: and execution is continued from there. If the word is not found, control is transferred to the label named Resume:.

   To skip to the next iteration in the loop, you can use the continue keyword. Consider the following block of code:
   for (int i = 0; i < 9; i++) {
    if (i % 2 == 0) {
     //---print i if it is even---
     Console.WriteLine(i);
     continue;
    }
    //---print this when i is odd---
    Console.WriteLine("******");
   }
   When i is an even number, this code block prints out the number and skips to the next number. Here's the result:
   0
   ******
   2
   ******
   4
   ******
   6
   ******
   8

   C# comes with a large set of operators that allows you to specify the operation to perform in an expression. These operators can be broadly classified into the following categories:
   □ Assignment
   □ Relational
   □ Logical (also known as conditional)
   □ Mathematical 

   You've already seen the use of the assignment operator (=). It assigns the result of the expression on its left to the variable on its right:
   string str = "Hello, world!"; //---str is now "Hello, world!"---
   int num1 = 5;
   int result = num1 * 6; //---result is now 30--- 
   You can also assign a value to a variable during declaration time. However, if you are declaring multiple variables on the same line, only the variable that has the equal operator is assigned a value, as shown in the following example:
   int num1, num2, num3 = 5; //---num1 and num2 are unassigned; num3 is 5---
   int i, j = 5, k; //---i and k are unassigned; j is 5---
   You can also use multiple assignment operators on the same line by assigning the value of one variable to two or more variables:
   num1 = num2 = num3;
   Console.WriteLine(num1); //---5---
   Console.WriteLine(num2); //---5---
   Console.WriteLine(num3); //---5---
   If each variable has a unique value, it has to have its own line:
   int num1 = 4
   int num2 = 3
   int num3 = 5

Self-Assignment Operators

   A common task in programming is to change the value of a variable and then reassign it to itself again. For example, you could use the following code to increase the salary of an employee:
   double salary = 5000;
   salary = salary + 1000; //---salary is now 6000---
   Similarly, to decrease the salary, you can use the following:
   double salary = 5000;
   salary = salary - 1000; //---salary is now 4000---
   To halve the salary, you can use the following:
   double salary = 5000;
   salary = salary / 2; //---salary is now 2500--
   To double his pay, you can use the following:
   double salary = 5000;
   salary = salary * 2; //---salary is now 10000---
   All these statements can be rewritten as follows using self-assignment operators:
   salary += 1000; //---same as salary = salary + 1000---
   salary -= 1000; //---same as salary = salary - 1000 
   salary /= 2; //---same as salary = salary / 2---
   salary *= 2; //---same as salary = salary * 2---
   A self-assignment operator alters its own value before assigning the altered value back to itself. In this example, +=, -=, /=, and *= are all self-assignment operators.
   You can also use the modulus self-assignment operator like this:
   int num = 5;
   num %= 2; //---num is now 1---

Prefix and Postfix Operators

   The previous section described the use of the self-assignment operators. For example, to increase the value of a variable by 1, you would write the statement as follows:
   int num = 5;
   num += 1; //---num is now 6---
   In C#, you can use the prefix or postfix operator to increment/decrement the value of a variable by 1. The preceding statement could be rewritten using the prefix operator like this:
   ++num;
   Alternatively, it could also be rewritten using the postfix operator like this:
   num++;
   To decrement a variable, you can use either the prefix or postfix operator, like this:
   --num;
   //---or---
   num--;
   So what is the difference between the prefix and postfix operators? The following example makes it clear:
   int num1 = 5;
   int num2 = 5;
   int result;
   result = num1++;
   Console.WriteLine(num1); //---6---
   Console.WriteLine(result); //---5---
   result = ++num2;
   Console.WriteLine(num2); //---6---
   Console.WriteLine(result); //---6---
   As you can see, if you use the postfix operator (num1++), the value of num1 is assigned to result before the value of num1 is incremented by 1. In contrast, the prefix operator (++num2) first increments the value of num2 by 1 and then assigns the new value of num2 (which is now 6) to result.
   Here's another example:
   int num1 = 5;
   int num2 = 5;
   int result;
   result = num1++ + ++num2;
   Console.WriteLine(num1); //---6---
   Console.WriteLine(num2); //---6---
   Console.WriteLine(result); //---11---
   In this case, both num1 and num2 are initially 5. Because a postfix operator is used on num1, its initial value of 5 is used for adding. And because num2 uses the prefix operator, its value is incremented before adding, hence the value 6 is used for adding. This adds up to 11 (5 + 6). After the first statement, both num1 and num2 would have a value of 6.

   You use relational operators to compare two values and the result of the comparison is a Boolean value — true or false. The following table lists all of the relational operators available in C#.

Operator	Description
==	Equal
!=	Not equal
>	Greater than
>=	Greater than or equal to
<	Lesser than
<=	Lesser than or equal to

   The following statements compare the value of num with the numeric 5 using the various relational operators:
   int num = 5;
   Console.WriteLine(num == 5); //---True---
   Console.WriteLine(num != 5); //---False---
   Console.WriteLine(num > 5); //---False---
   Console.WriteLine(num >= 5); //---True---
   Console.WriteLine(num < 5); //---False---
   Console.WriteLine(num <= 5); //---True---
   A common mistake with the equal relational operator is omitting the second = sign. For example, the following statement prints out the numeric 5 instead of True:
   Console.WriteLine(num = 5);
   A single = is the assignment operator.
   C programmers often make the following mistake of using a single = for testing equality of two numbers:
   if (num = 5) //---use == for testing equality---
   {
   Console.WriteLine("num is 5");
   }
   Fortunately, the C# compiler will check for this mistake and issue a "Cannot implicitly convert type 'int' to 'bool'" error.

   C# supports the use of logical operators so that you can evaluate multiple expressions. The following table lists the logical operators supported in C#.

Operator	Description
&&	And
||	Or
!	Not

   For example, consider the following code example:
   if (age < 12 || height > 120) {
   Console.WriteLine("Student price applies");
   }
   In this case, student price applies if either the age is less than 12, or the height is less than 120cm. As long as at least one of the conditions evaluates to true, the statement is true. Following is the truth table for the Or (||) operator.

Operand A	Operand B	Result
false	false	false
false	true	true
true	false	true
true	true	true

   However, if the condition is changed such that student price applies only if a person is less than 12 years old and with height less than 120cm, the statement would be rewritten as:
   if (age < 12 && height > 120) {
    Console.WriteLine("Student price applies");
   }
   The truth table for the And (&&) operator follows.

Operand A	Operand B	Result
false	false	false
false	true	false
true	false	false
true	true	true

   The Not operator (!) negates the result of an expression. For example, if student price does not apply to those more than 12 years old, you could write the expression like this:
   if (!(age >= 12))
    Console.WriteLine("Student price does not apply");
   Following is the truth table for the Not operator.

Operand A	Result
false	true
true	false

Short-Circuit Evaluation

   C# uses short-circuiting when evaluating logical operators. In short-circuiting, the second argument in a condition is evaluated only when the first argument is not sufficient to determine the value of the entire condition. Consider the following example:
   int div = 0; int num = 5;
   if ((div == 0) || (num / div == 1)) {
    Console.WriteLine(num); //---5---
   }
   Here the first expression evaluates to true, so there is no need to evaluate the second expression (because an Or expression evaluates to true as long as at least one expression evaluates to true). The second expression, if evaluated, will result in a division-by-zero error. In this case, it won't, and the number 5 is printed.
   If you reverse the placement of the expressions, as in the following example, a division-by-zero error occurs:
   if ((num / div == 1) || (div == 0)) {
    Console.WriteLine(num);
   }
   Short-circuiting also applies to the && operator — if the first expression evaluates to false, the second expression will not be evaluated because the final evaluation is already known.

   C# supports five mathematical operators, shown in the following table.

Operator	Description
+	Addition
-	Subtraction
/	Division
*	Multiplication
%	Modulus

   One interesting thing about the division operator (/) is that when you divide two integers, the fractional part is discarded:
   int num1 = 6;
   int num2 = 4;
   double result = num1 / num2;
   Console.WriteLine(result); //---1---
   Here both num1 and num2 are integers and hence after the division result only contains the integer portion of the division. To divide correctly, one of the operands must be a noninteger, as the following shows:
   int num1 = 6;
   double num2 = 4;
   double result = num1 / num2;
   Console.WriteLine(result); //---1.5---
   Alternatively, you can use type casting to force one of the operands to be of type double so that you can divide correctly:
   int num1 = 6;
   int num2 = 4;
   double result = (double)num1 / num2;
   Console.WriteLine(result); //---1.5---
   The modulus operator (%) returns the reminder of a division:
   int num1 = 6;
   int num2 = 4;
   int remainder = num1 % num2;
   Console.WriteLine(remainder); //---2---
   The % operator is commonly used for testing whether a number is odd or even, like this:
   if (num1 % 2 == 0) Console.WriteLine("Even");
   else Console.WriteLine("Odd");

   When you use multiple operators in the same statement, you need be aware of the precedence of each operator (that is, which operator will evaluate first). The following table shows the various C# operators grouped in the order of precedence. Operators within the same group have equal precedence (operators include some keywords).

Category	Operators
Primary	x.y f(x) a[x] x++ x-- new typeof checked unchecked
Unary	+ - ! ~ ++x --x (T)x
Multiplicative	* / %
Additive	+ -
Shift	<< >>
Relational and type testing	< > <= >> is as
Equality	== !=
Logical AND	&
Logical XOR	^
Logical OR	|
Conditional AND	&&
Conditional OR	||
Conditional	?:
Assignment	= *= /= %= += -= <<= >>= &= ^= | =

   When you are in doubt of the precedence of two operators, always use parentheses to force the compiler to evaluate the expression first. For example, the formula to convert a temperature from Fahrenheit to Celsius is:
   Tc = (5/9)*(Tf-32);
   When implemented in C#, the formula looks like this:
   double fahrenheit = 100;
   double celcius = 5.0 / 9.0 * fahrenheit - 32;
   Console.WriteLine("{0:##.##} degrees C",celcius); //---23.56 degrees C---
   But this produces a wrong answer because 5.0 / 9.0 and fahrenheit - 32 must be evaluated separately before their results are multiplied to get the final answer. What's happened is that, according to the precedence table, 5.0 / 9.0 * fahrenheit is evaluated first and then 32 is subtracted from the result. This gives the incorrect answer of 23.56 degrees C.
   To correct this, you use parentheses to group all the expressions that need to be evaluated first, like this:
   double fahrenheit = 100;
   double celcius = (5.0 / 9.0) * (fahrenheit - 32);
   Console.WriteLine("{0:##.##} degrees C",celcius); //---37.78 degrees C---
   This code gives the correct answer of 37.78 degrees C.

   So far the programs you have seen in this chapter are pretty straightforward; you compile the entire program and run it from beginning until end. However, there are times when you want to inject debugging statements into your program — generally using methods such as Console.WriteLine() or MessageBox.Show() — and then remove them when the program is ready for deployment. But one common mistake is that programmers often forget to remove all those statements after debugging. The end result is that production code often contains many redundant code statements.
   A better way is to instruct the C# compile to conditionally omit some of the code during compilation. For example, you can delineate some parts of your code as debugging statements that should not be present in the production code. To do so, you can use preprocessor directives, which are special instructions to a special program (known as the processor) that will prepare your code before sending it to the compiler. C# supports the following preprocessor directives, most of which are discussed in the following sections:
   #define #elif    #line   #pragma warning
   #undef  #endif   #region #pragma checksum
   #if     #warning #endregion
   #else   #error   #pragma

   The #define preprocessor directive allows you to define a symbol so that you can use the #if preprocessor directive to evaluate and then make conditional compilation. To see how the #define preprocessor directive works, assume that you have a console application named TestDefine (saved in C:\) created using Visual Studio 2008 (see Figure 3-12).
   Figure 3-12
   The Main() method is located in the Program.cs file. The program basically asks the user to enter a number and then sums up all the odd number from 1 to that number:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     static void Main(string[] args) {
      Console.Write("Please enter a number: ");
      int num = int.Parse(Console.ReadLine());
      int sum = 0;
      for (int i = 1; i <= num; i++) {
       //---sum up all odd numbers---
       if (i % 2 == 1) sum += i;
      }
      Console.WriteLine(
       "Sum of all odd numbers from 1 to {0} is {1}",
       num, sum);
      Console.ReadLine();
     }
    }
   }
   Suppose that you want to add some debugging statements to the program so that you can print out the intermediate results. The additional lines of code are highlighted:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     static void Main(string[] args) {
      Console.Write("Please enter a number: ");
      int num = int.Parse(Console.ReadLine());
      int sum = 0;
      for (int i = 1; i <= num; i++) {
       //---sum up all odd numbers---
       if (i % 2 == 1)
       {
        sum += i;
        Console.WriteLine("i={0}, sum={1}", i, sum);
       }
      }
      Console.WriteLine(
       "Sum of all odd numbers from 1 to {0} is {1}",
       num, sum);
      Console.ReadLine();
     }
    }
   }
   You do not want the debugging statements to be included in the production code so you first define a symbol (such as DEBUG) using the #define preprocessor directive and wrap the debugging statements with the #if and #endif preprocessor directives:
   #define DEBUG
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     static void Main(string[] args) {
      Console.Write("Please enter a number: ");
      int num = int.Parse(Console.ReadLine());
      int sum = 0;
      for (int i = 1; i <= num; i++) {
       //---sum up all odd numbers---
       if (i % 2 == 1) {
        sum += i;
   #if DEBUG
        Console.WriteLine("i={0}, sum={1}", i, sum);
   #endif
       }
      }
      Console.WriteLine(
       "Sum of all odd numbers from 1 to {0} is {1}",
       num, sum);
      Console.ReadLine();
     }
    }
   }

   DEBUG is a common symbol that developers use to indicate debugging statements, which is why most books use it in examples. However, you can define any symbol you want using the #define preprocessor directive.

   Before compilation, the preprocessor will evaluate the #if preprocessor directive to see if the DEBUG symbol has been defined. If it has, the statement(s) wrapped within the #if and #endif preprocessor directives will be included for compilation. If the DEBUG symbol has not been defined, the statement — the statement(s) wrapped within the #if and #endif preprocessor — will be omitted from the compilation.
   To test out the TestDefine program, follow these steps:
   1. Launch the Visual Studio 2008 command prompt (Start→Programs→Microsoft Visual Studio 2008→Visual Studio Tools→Visual Studio 2008 Command Prompt).
   2. Change to the path containing the program (C:\TestDefine).
   3. Compile the application by issuing the command:
   csc Program.cs
   4. Run the program by issuing the command:
   Program.exe
   Figure 3-13 shows the output of the application. As you can see, the debugging statement prints out the intermediate results.
   Figure 3-13
   To undefine a symbol, you can use the #undef preprocessor directive, like this:
   #undef DEBUG
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   ...
   If you recompile the program now, the debugging statement will be omitted.
   Another popular way of using the #define preprocessor directive is to omit the definition of the symbol and inject it during compilation time. For example, if you remove the #define preprocessor directive from the program, you can define it using the /define compiler option:
   1. In Visual Studio 2008 command prompt, compile the program using:
   csc Program.cs /define:DEBUG
   2. Run the program by issuing the command:
   Program.exe
   The output is identical to what you saw in Figure 3-13 — the debugging statement prints out the intermediate results.
   If you now recompile the program by defining another symbol (other than DEBUG), you will realize that the debugging output does not appear (see Figure 3-14).
   Figure 3-14 

   As you saw in the preceding section, the #if and #endif preprocessor directives defines a block of code to include for compilation if a specified symbol is defined. You can also use the #else and #elif preprocessor directives to create compound conditional directives.
   Using the previous example, you can add the #else and #elif preprocessor directives as follows:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     static void Main(string[] args) {
      Console.Write("Please enter a number: ");
      int num = int.Parse(Console.ReadLine());
      int sum = 0;
      for (int i = 1; i <= num; i++) {
       //---sum up all odd numbers---
       if (i % 2 == 1) {
        sum += i;
   #if DEBUG
        Console.WriteLine("i={0}, sum={1}", i, sum);
   #elif NORMAL
        Console.WriteLine("sum={0}", sum);
   #else
        Console.WriteLine(".");
   #endif
       }
      }
      Console.WriteLine(
       "Sum of all odd numbers from 1 to {0} is {1}",
        num, sum);
      Console.ReadLine();
     }
    }
   } 
   Figure 3-15 shows the different output when different symbols are defined. The top screen shows the output when the DEBUG symbol is defined. The middle screen shows the output when the NORMAL symbol is defined. The bottom screen shows the output when no symbol is defined.
   Figure 3-15
   The #if preprocessor directive can also test for multiple conditions using the logical operators. Here are some examples:
   #if (DEBUG || NORMAL) //---either DEBUG or NORMAL is defined---
   #if (DEBUG && NORMAL) //---both DEBUG and NORMAL are defined---
   #if (!DEBUG && NORMAL) //---DEBUG is not defined AND NORMAL is defined---

   The #warning preprocessor directive lets you generate a warning from a specific location of your code. The following example shows how you can use it to display warning messages during compilation time.
   for (int i = 1; i <= num; i++) {
    //---sum up all odd numbers---
    if (i % 2 == 1) {
     sum += i;
   #if DEBUG
   #warning Debugging mode is on
     Console.WriteLine("i={0}, sum={1}", i, sum);
   #elif NORMAL
   #warning Normal mode is on
     Console.WriteLine("sum={0}", sum);
   #else
   #warning Default mode is on
     Console.WriteLine(".");
   #endif
   }
   }
   Figure 3-16 shows the output when the DEBUG symbol is defined using the /define compiler option.
   Figure 3-16
   The #error preprocessor directive lets you generate an error. Consider the following example:
   for (int i = 1; i <= num; i++) {
    //---sum up all odd numbers---
    if (i % 2 == 1) {
     sum += i;
   #if DEBUG
   #warning Debugging mode is on
     Console.WriteLine("i={0}, sum={1}", i, sum);
   #elif NORMAL
   #error This mode is obsolete.
     Console.WriteLine("sum={0}", sum);
   #else
   #warning Default mode is on
     Console.WriteLine(".");
   #endif
    }
   }
   Here, if the NORMAL symbol is defined, an error message is shown and the statement defined within the conditional directive is ignored. Figure 3-17 shows that when you define the NORMAL symbol, the error message is displayed and the compilation is aborted.
   Figure 3-17 

   The #line preprocessor directive lets you modify the compiler's line number and (optionally) the file name output for errors and warnings.
   The #line preprocessor directive is injected in the following example. The highlighted code indicates statements that will cause the debugger to issue warning messages:
   1.  using System;
   2.  using System.Collections.Generic;
   3.  using System.Linq;
   4.  using System.Text;
   5.
   6.  namespace TestDefine
   7.  {
   8.   class Program
   9.   {
   10.   static void Main(string[] args)
   11.   {
   12. #line 25
   13.    int i; //---treated as line 25---
   14.    char c; //---treated as line 26---
   15.    Console.WriteLine("Line 1"); //---treated as line 27---
   16. #line hidden //---treated as line 28---
   17.    Console.WriteLine("Line 2"); //---treated as line 29---
   18.    Console.WriteLine("Line 3"); //---treated as line 30---
   19. #line default
   20.    double d; //---treated as line 20---
   21.    Console.WriteLine("Line 4"); //---treated as line 21---
   22. #line 45 "Program1.cs" //---treated as line 22---
   23.    Single s; //---treated as line 45---
   24.    Console.WriteLine("Line 5"); //---treated as line 46---
   25.    Console.ReadLine(); //---treated as line 47---
   26.   }
   27.  }
   28. }

   The line numbers are for illustration purposes and are not part of the program.

   The four highlighted lines are numbered 13, 14, 20, and 23. When you build the program in Visual Studio 2008, the lines reported are 25, 26, 20, and 45 (see Figure 3-18).
   Figure 3-18 
   Let's take a look at the #line directives in the example program:
   □ #line 25 means that you want to modify the line number to use the specified line number (25 in this case) instead of the actual line number of the statement in error. This is useful if you need to assign a fixed line number to a particular part of the code so that you can trace it easily. Interestingly, the next line will continue from 25, that is, the next line is now line 26. This is evident from the warning message for the char c; line.
   □ #line default means that the compiler will report the actual line number.
   □ #line 45 "Program1.cs" means that you want to fix the line number at 45 and specify the name of the file in error (Program1.cs in this case). An example usage of it would be that the statement in error might be a call to an external DLL and by specifying the filename of the DLL here, it is clearer that the mistake might be from that DLL.
   What about the #line hidden statement? That preprocessor directive indicates to the debugger to skip the block of code beginning with the #line hidden preprocessor directive. The debugger will skip the line(s) until the next #line preprocessor directive is found. This is useful for skipping over method calls that you are not interested in (such as those not written by you).

   Interestingly, you can replace the #line hidden preprocessor directive with #line 16707566 (0xFeeFee) and it will still work correctly.

   The #region and #region preprocessor directives are used in conjunction with Visual Studio's Code Editor. Let's work with the following example:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     static void Main(string[] args) {
      //---implement ions here---
     }
     private void Method1() {
      //---implementations here---
     }
     private void Method2() {
      //---implementations here---
     }
     private void Method3() {
      //---implementations here---
     }
    }
   }
   Often, you have many functions that perform specific tasks. In such cases, it is often good to organize them into regions so that they can be collapsed and expanded as and when needed. Using this example, you can group all the methods — Method1(), Method2(), and Method3() — into a region using the #region and #region preprocessor directives:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     static void Main(string[] args) {}
   #region "Helper functions"
     private void Method1() {
      //---implementations here---
     }
     private void Method2() {
      //---implementations here---
     }
     private void Method3() {
      //---implementations here---
     }
   #endregion
    }
   }
   In Visual Studio 2008, you can now collapse all the methods into a group called "Helper functions". Figure 3-19 shows the Code Editor before and after the region is collapsed.
   Figure 3-19 
   The #region and #region preprocessor directives do not affect the logic of your code. They are used purely in Visual Studio 2008 to better organize your code.

   The #pragma warning directive enables or disables compiler warning messages. For example, consider the following program:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace TestDefine {
    class Program {
     int num = 5;
     static void Main(string[] args) {}
    }
   }
   In this program, the variable num is defined but never used. When you compile the application, the C# compiler will show a warning message (see Figure 3-20).
   Figure 3-20 
   To suppress the warning message, you can use the #pragma warning directive together with the warning number of the message that you want to suppress:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   #pragma warning disable 414
   namespace TestDefine {
    class Program {
     int num = 5;
     static void Main(string[] args) {}
    }
   }
   This example suppresses warning message number 414 ("The private field 'field' is assigned but its value is never used"). With the #pragma warning directive, the compiler will now suppress the warning message (see Figure 3-21).
   Figure 3-21 
   You can suppress multiple warning messages by separating the message numbers with a comma (,) like this:
   #pragma warning disable 414, 3021, 1959

   Everything you encounter in .NET in based on classes. For example, you have a Windows Forms application containing a default form called Form1. Form1 itself is a class that inherits from the base class System.Windows.Forms.Form, which defines the basic behaviors that a Windows Form should exhibit:
   using System.Data;
   using System.Drawing;
   using System.Linq;
   using System.Text;
   using System.Windows.Forms;
 
   namespace Project1 {
    public partial class Form1 : Form {
     public Form1() {
      InitializeComponent();
     }
    }
   }
   Within the Form1 class, you code in your methods. For example, to display a "Hello World" message when the form is loaded, add the following statement in the Form1_Load() method:
   public partial class Form1 : Form {
    public Form1() {
     InitializeComponent();
    }
    protected override void OnLoad(EventArgs e) {
     MessageBox.Show("Hello World!");
    }
   }
   The following sections walk you through the basics of defining your own class and the various members you can have in the class.

   You use the class keyword to define a class. The following example is the definition of a class called Contact:
   public class Contact {
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
   }
   This Contact class has four public members — ID, FirstName, LastName, and Email. The syntax of a class definition is:
   <access_modifiers> class Class_Name{
    //---Fields, properties, methods, and events---
   }

   Instead of defining an entire class by using the class keyword, you can split the definition into multiple classes by using the partial keyword. For example, the Contact class defined in the previous section can be split into two partial classes like this:
   public partial class Contact {
    public int ID;
    public string Email;
   }
   public partial class Contact {
    public string FirstName;
    public string LastName;
   }
   When the application is compiled, the C# compiler will group all the partial classes together and treat them as a single class.

Uses for Partial Classes

   There are a couple of very good reasons to use partial classes. First, using partial classes enables the programmers on your team to work on different parts of a class without needing to share the same physical file. While this is useful for projects that involve big class files, be wary: a huge class file may signal a design fault, and refactoring may be required.
   Second, and most compelling, you can use partial classes to separate your application business logic from the designer-generated code. For example, the code generated by Visual Studio 2008 for a Windows Form is kept separate from your business logic. This prevents developers from messing with the code that is used for the user interface. At the same time, it prevents you from losing your changes to the designer-generated code when you change the user interface.

   A class works like a template. To do anything useful, you need to use the template to create an actual object so that you can work with it. The process of creating an object from a class is known as instantiation.
   To instantiate the Contact class defined earlier, you first create a variable of type Contact:
   Contact contact1;
   At this stage, contact1 is of type Contact, but it does not actually contain the object data yet. For it to contain the object data, you need to use the new keyword to create a new instance of the Contact class, a process is known as object instantiation:
   contact1 = new Contact();
   Alternatively, you can combine those two steps into one, like this:
   Contact contact1 = new Contact();
   Once an object is instantiated, you can set the various members of the object. Here's an example:
   contact1.ID = 12;
   contact1.FirstName = "Wei-Meng";
   contact1.LastName = "Lee";
   contact1.Email = "weimenglee@learn2develop.net";
   You can also assign an object to an object, like the following:
   Contact contact1 = new Contact();
   Contact contact2 = contact1;
   In these statements, contact2 and contact1 are now both pointing to the same object. Any changes made to one object will be reflected in the other object, as the following example shows:
   Contact contact1 = new Contact();
   Contact contact2 = contact1;
   contact1.FirstName = "Wei-Meng";
   contact2.FirstName = "Jackson";
   //---prints out "Jackson"---
   Console.WriteLine(contact1.FirstName);
   It prints out "Jackson" because both contact1 and contact2 are pointing to the same object, and when you assign "Jackson" to the FirstName property of contact2, contact1's FirstName property also sees "Jackson".

   C# 3.0 introduces a new feature known as anonymous types. Anonymous types enable you to define data types without having to formally define a class. Consider the following example:
   var book1 = new {
    ISBN = "978-0-470-17661-0",
    Title="Professional Windows Vista Gadgets Programming",
    Author = "Wei-Meng Lee",
    Publisher="Wrox"
   };

   Chapter 3 discusses the new C# 3.0 keyword var.

   Here, book1 is an object with 4 properties: ISBN, Title, Author, and Publisher (see Figure 4-1).
   Figure 4-1 
   In this example, there's no need for you to define a class containing the four properties. Instead, the object is created and its properties initialized with their respective values.

   C# anonymous types are immutable, which means all the properties are read-only — their values cannot be changed once they are initialized.

   You can use variable names when assigning values to properties in an anonymous type; for example:
   var Title = "Professional Windows Vista Gadgets Programming";
   var Author = "Wei-Meng Lee";
   var Publisher = "Wrox";
   var book1 = new {
    ISBN = "978-0-470-17661-0",
    Title,
    Author,
    Publisher
   };
   In this case, the names of the properties will assume the names of the variables, as shown in Figure 4-2.
   Figure 4-2 
   However, you cannot create anonymous types with literals, as the following example demonstrates:
   //---error---
   var book1 = new {
    "978-0-470-17661-0",
    "Professional Windows Vista Gadgets Programming",
    "Wei-Meng Lee",
    "Wrox"
   };
   When assigning a literal value to a property in an anonymous type, you must use an identifier, like this:
   var book1 = new {
    ISBN = "978-0-470-17661-0",
    Title="Professional Windows Vista Gadgets Programming",
    Author = "Wei-Meng Lee",
    Publisher="Wrox"
   };
   So, how are anonymous types useful for your application? Well, they enable you to shape your data from one type to another. You will look into more about this in Chapter 14, which tackles LINQ.

   Variables and functions defined in a class are known as a class's members. The Contact class definition, for instance, has four members that you can access once an object is instantiated:
   public class Contact {
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
   }
   Members of a class are classified into two types:

Type	Description
Data	Members that store the data needed by your object so that they can be used by functions to perform their work. For example, you can store a person's name using the FirstName and LastName members.
Function	Code blocks within a class. Function members allow the class to perform its work. For example, a function contained within a class (such as the Contact class) can validate the email of a person (stored in the Email member) to see if it is a valid email address.

   Data members can be further grouped into instance members and static members.

Instance Members

   By default, all data members are instance members unless they are constants or prefixed with the static keyword (more on this in the next section). The variables defined in the Contact class are instance members:
   public int ID;
   public string FirstName;
   public string LastName;
   public string Email;
   Instance members can be accessed only through an instance of a class and each instance of the class (object) has its own copy of the data. Consider the following example:
   Contact contact1 = new Contact();
   contact1.ID = 12;
   contact1.FirstName = "Wei-Meng";
   contact1.LastName = "Lee";
   contact1.Email = "weimenglee@learn2develop.net";
   Contact contact2 = new Contact();
   contact2.ID = 35;
   contact2.FirstName = "Jason";
   contact2.LastName = "Will";
   contact2.Email = "JasonWill@company.net";
   The objects contact1 and contact2 each contain information for a different user. Each object maintains its own copy of the ID, FirstName, LastName, and Email data members.

Static Members

   Static data members belong to the class rather than to each instance of the class. You use the static keyword to define them. For example, here the Contact class has a static member named count:
   public class Contact {
    public static int count;
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
   }
   The count static member can be used to keep track of the total number of Contact instances, and thus it should not belong to any instances of the Contact class but to the class itself.
   To use the count static variable, access it through the Contact class:
   Contact.count = 4;
   Console.WriteLine(Contact.count);
   You cannot access it via an instance of the class, such as contact1:
   //---error---
   contact1.count = 4;
   Constants defined within a class are implicitly static, as the following example shows:
   public class Contact {
    public const ushort MAX_EMAIL = 5;
    public static int count;
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
   }
   In this case, you can only access the constant through the class name but not set a value to it:
   Console.WriteLine(Contact.MAX_EMAIL);
   Contact.MAX_EMAIL = 4; //---error---

Access Modifiers

   Access modifiers are keywords that you can add to members of a class to restrict their access. Consider the following definition of the Contact class:
   public class Contact {
    public const ushort MAX_EMAIL = 5;
    public static int count;
    public int ID;
    public string FirstName;
    public string LastName;
    private string _Email;
   }
   Unlike the rest of the data members, the _Email data member has been defined with the private keyword. The public keyword indicates that the data member is visible outside the class, while the private keyword indicates that the data member is only visible within the class.

   By convention, you can denote a private variable by beginning its name with the underscore (_) character. This is recommended, but not mandatory.

   For example, you can access the FirstName data member through an instance of the Contact class:
   //---this is OK---
   contact1.FirstName = "Wei-Meng";
   But you cannot access the _Email data member outside the class, as the following statement demonstrates:
   //---error: _Email is inaccessible---
   contact1._Email = "weimenglee@learn2develop.net";

   C# has four access modifiers — private, public, protected, and internal.The last two are discussed with inheritance in the next chapter.

   If a data member is declared without the public keyword, its scope (or access) is private by default. So, _Email can also be declared like this:
   public class Contact {
    public const ushort MAX_EMAIL = 5;
    public static int count;
    public int ID;
    public string FirstName;
    public string LastName;
    string _Email;
   }

   A function member contains executable code that performs work for the class. The following are examples of function members in C#:
   □ Methods
   □ Properties
   □ Events
   □ Indexers
   □ User-defined operators
   □ Constructors
   □ Destructors
   Events and indexers are covered in detail in Chapters 7 and 13.

Methods

   In C#, every function must be associated with a class. A function defined with a class is known as a method. In C#, a method is defined using the following syntax:
   [access_modifiers] return_type method_name(parameters) {
    //---Method body---
   }
   Here's an example — the ValidateEmail() method defined in the Contact class:
   public class Contact {
    public static ushort MAX_EMAIL;
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
    public Boolean ValidateEmail() {
     //---implementation here---
     Boolean valid=true;
     return valid;
    }
   } 
   If the method does not return a value, you need to specify the return type as void, as the following PrintName() method shows:
   public class Contact {
    public static ushort MAX_EMAIL;
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
    public Boolean ValidateEmail() {
     //---implementation here---
     //...
     Boolean valid=true;
     return valid;
    }
    public void PrintName() {
     Console.WriteLine("{0} {1}", this.FirstName, this.LastName);
    }
   }

Passing Arguments into Methods

   You can pass values into a method using arguments. The words parameter and argument are often used interchangeably, but they mean different things. A parameter is what you use to define a method. An argument is what you actually use to call a method.
   In the following example, x and y are examples of parameters:
   public int AddNumbers(int x, int y) {}
   When you call the method, you pass in values/variables. In the following example, num1 and num2 are examples of arguments:
   Console.WriteLine(AddNumbers(num1, num2));
   Consider the method named AddNumbers() with two parameters, x and y:
   public int AddNumbers(int x, int y) {
    x++;
    y++;
    return x + y;
   } 
   When you call this method, you also need to pass two integer arguments (num1 and num2), as the following example shows:
   int num1 = 4, num2 = 5;
   //---prints out 11---
   Console.WriteLine(AddNumbers(num1, num2));
   Console.WriteLine(num1); //---4 ---
   Console.WriteLine(num2); //---5---
   In C#, all arguments are passed by value by default. In other words, the called method gets a copy of the value of the arguments passed into it. In the preceding example, for instance, even though the value of x and y are both incremented within the method, this does not affect the values of num1 and num2.
   If you want to pass in arguments to methods by reference, you need to prefix the parameters with the ref keyword. Values of variables passed in by reference will be modified if there are changes made to them in the method. Consider the following rewrite of the AddNumbers() function:
   public int AddNumbers(ref int x, ref int y) {
    x++;
    y++;
    return x + y;
   }

   Because C# functions can only return single values, passing arguments by reference is useful when you need a method to return multiple values.

   In this case, the values of variables passed into this function will be modified, as the following example illustrates:
   int num1 = 4, num2 = 5; //---prints out 11---
   Console.WriteLine(AddNumbers(ref num1, ref num2));
   Console.WriteLine(num1); //---5---
   Console.WriteLine(num2); //---6---
   After calling the AddNumbers() function, num1 becomes 5 and num2 becomes 6. Observe that you need to prefix the arguments with the ref keyword when calling the function. In addition, you cannot pass literal values as arguments into a method that requires parameters to be passed in by reference:
   //---invalid arguments---
   Console.WriteLine(AddNumbers(4, 5));
   Also note that the ref keyword requires that all the variables be initialized first. Here's an example:
   public void GetDate(ref int day, ref int month, ref int year) {
    day = DateTime.Now.Day;
    month = DateTime.Now.Month;
    year = DateTime.Now.Year;
   }
   The GetDate() method takes in three reference parameters and uses them to return the day, month, and year.
   If you pass in the day, month and year reference variables without initializing them, an error will occur:
   //---Error: day, month, and year not initialized---
   int day, month, year;
   GetDate(ref day, ref month, ref year);
   If your intention is to use the variables solely to obtain some return values from the method, you can use the out keyword, which is identical to the ref keyword except that it does not require the variables passed in to be initialized first:
   public void GetDate(out int day, out int month, out int year) {
    day = DateTime.Now.Day;
    month = DateTime.Now.Month;
    year = DateTime.Now.Year;
   }
   Also, the out parameter in a function must be assigned a value before the function returns. If it isn't, a compiler error results.
   Like the ref keyword, you need to prefix the arguments with the out keyword when calling the function:
   int day, month, year;
   GetDate(out day, out month, out year);

The this Keyword

   The this keyword refers to the current instance of an object (in a nonstatic class; discussed later in the section Static Classes). In the earlier section on methods, you saw the use of this:
   Console.WriteLine("{0} {1}", this.FirstName, this.LastName);
   While the FirstName and LastName variable could be referenced without using the this keyword, prefixing them with it makes your code more readable, indicating that you are referring to an instance member.
   However, if instance members have the same names as your parameters, using this allows you to resolve the ambiguity:
   public void SetName(string FirstName, string LastName) {
    this.FirstName = FirstName;
    this.LastName = LastName;
   } 
   Another use of the this keyword is to pass the current object as a parameter to another method. For example:
   public class AddressBook {
    public void AddContact(Contact c) {
     Console.WriteLine(c.ID);
     Console.WriteLine(c.FirstName);
     Console.WriteLine(c.LastName);
     Console.WriteLine(c.Email);
     //---other implementations here---
     //...
    }
   }
   The AddContact() method takes in a Contact object and prints out the details of the contact. Suppose that the Contact class has a AddToAddressBook() method that takes in an AddressBook object. This method adds the Contact object into the AddressBook object:
   public class Contact {
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
    public void AddToAddressBook(AddressBook addBook) {
     addBook.AddContact(this);
    }
   }
   In this case, you use the this keyword to pass in the current instance of the Contact object into the AddressBook object. To test out that code, use the following statements:
   Contact contact1 = new Contact();
   contact1.ID = 12;
   contact1.FirstName = "Wei-Meng";
   contact1.LastName = "Lee";
   contact1.Email = "weimenglee@learn2develop.net";
   AddressBook addBook1 = new AddressBook();
   contact1.AddToAddressBook(addBook1);

Properties

   Properties are function members that provide an easy way to read or write the values of private data members. Recall the Contact class defined earlier:
   public class Contact {
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
   }
   You've seen that you can create a Contact object and set its public data members (ID, FirstName, LastName, and Email) directly, like this:
   Contact c = new Contact();
   c.ID = 1234;
   c.FirstName = "Wei-Meng";
   c.LastName = "Lee";
   c.Email = "weimenglee@learn2develop.net";
   However, if the ID of a person has a valid range of values — such as from 1 to 9999 — the following value of 12345 would still be assigned to the ID data member:
   c.ID = 12345;
   Technically, the assignment is valid, but logically it should not be allowed — the number assigned is beyond the range of values permitted for ID. Of course you can perform some checks before assigning a value to the ID member, but doing so violates the spirit of encapsulation in object- oriented programming — the checks should be done within the class.
   A solution to this is to use properties.
   The Contact class can be rewritten as follows with its data members converted to properties:
   public class Contact {
    int _ID;
    string _FirstName, _LastName, _Email;
    public int ID {
     get {
      return _ID;
     }
     set {
      _ID = value;
     }
    }
    public string FirstName {
     get {
      return _FirstName;
     }
     set {
      _FirstName = value;
     }
    }
    public string LastName {
     get {
      return _LastName;
     }
     set {
      _LastName = value;
     }
    }
    public string Email {
     get {
      return _Email;
     }
     set {
      _Email = value;
     }
    }
   }
   Note that the public members (ID, FirstName, LastName, and Email) have been replaced by properties with the set and get accessors.
   The set accessor sets the value of a property. Using this example, you can instantiate a Contact class and then set the value of the ID property, like this:
   Contact c = new Contact();
   c.ID = 1234;
   In this case, the set accessor is invoked:
   public int ID {
    get {
     return _ID;
    }
    set {
     _ID = value;
    }
   }
   The value keyword contains the value that is being assigned by the set accessor. You normally assign the value of a property to a private member so that it is not visible to code outside the class, which in this case is _ID.
   When you retrieve the value of a property, the get accessor is invoked:
   public int ID {
    get {
     return _ID;
    }
    set {
     _ID = value;
    }
   }
   The following statement shows an example of retrieving the value of a property:
   Console.WriteLine(c.ID); //---prints out 1234--- 
   The really useful part of properties is the capability for you to perform checking on the value assigned. For example, before the ID property is set, you want to make sure that the value is between 1 and 9999, so you perform the check at the set accessor, like this:
   public int ID {
    get {
     return _ID;
    }
    set {
     if (value > 0 && value <= 9999) {
      _ID = value;
     } else {
      _ID = 0;
     };
    }
   }
   Using properties, you can now prevent users from setting invalid values.

Read-Only and Write-Only Properties

   When a property definition contains the get and set accessors, that property can be read as well as written. To make a property read-only, you simply leave out the set accessor, like this:
   public int ID {
    get {
     return _ID;
    }
   }
   You can now read but not write values into the ID property:
   Console.WriteLine(c1.ID); //---OK---
   c1.ID = 1234; //---Error--- 
   Likewise, to make a property write-only, simply leave out the get accessor:
   public int ID {
    set {
     _ID = value;
    }
   }
   You can now write but not read from the ID property:
   Console.WriteLine(c1.ID); //---Error---
   c1.ID = 1234; //---OK---
   You can also restrict the visibility of the get and set accessors. For example, the set accessor of a public property could be set to private to allow only members of the class to call the set accessor, but any class could call the get accessor. The following example demonstrates this:
   public int ID {
    get {
     return _ID;
    }
    private set {
     _ID = value;
    }
   }
   In this code, the set accessor of the ID property is prefixed with the private keyword to restrict its visibility. That means that you now cannot assign a value to the ID property but you can access it: 
   c.ID = 1234; //---error---
   Console.WriteLine(c.ID); //---OK---
   You can, however, access the ID property anywhere within the Contact class itself, such as in the Email property:
   public string Email {
    get {
     //...
     this.ID = 1234;
     //...
    }
    //...
   }

Partial Methods (C# 3.0)

   Earlier on, you saw that a class definition can be split into one or more class definitions. In C# 3.0, this concept is extended to methods — you can now have partial methods. To see how partial methods works, consider the Contact partial class:
   public partial class Contact {
    //...
    private string _Email;
    public string Email {
     get {
      return _Email;
     }
     set {
      _Email = value;
     }
    }
   }
   Suppose you that want to allow users of this partial class to optionally log the email address of each contact when its Email property is set. In that case, you can define a partial method — LogEmail() in this example — like this:
   public partial class Contact {
    //...
   }
 
   public partial class Contact {
    //...
    private string _Email;
    public string Email {
     get {
      return _Email;
     }
     set {
      _Email = value;
      LogEmail();
     }
    }
    //---partial methods are private---
    partial void LogEmail();
   }
   The partial method LogEmail() is called when a contact's email is set via the Email property. Note that this method has no implementation. Where is the implementation? It can optionally be implemented in another partial class. For example, if another developer decides to use the Contact partial class, he or she can define another partial class containing the implementation for the LogEmail() method:
   public partial class Contact {
    partial void LogEmail() {
     //---code to send email to contact---
     Console.WriteLine("Email set: {0}", _Email);
    }
   }
   So when you now instantiate an instance of the Contact class, you can set its Email property as follows and a line will be printed in the output window:
   Contact contact1 = new Contact();
   contact1.Email = "weimenglee@learn2develop.net";
   What if there is no implementation of the LogEmail() method? Well, in that case the compiler simply removes the call to this method, and there is no change to your code.
   Partial methods are useful when you are dealing with generated code. For example, suppose that the Contact class is generated by a code generator. The signature of the partial method is defined in the class, but it is totally up to you to decide if you need to implement it.

   A partial method must be declared within a partial class or partial struct.

   Partial methods must adhere to the following rules:
   □ Must begin with the partial keyword and the method must return void
   □ Can have ref but not out parameters
   □ They are implicitly private, and therefore they cannot be virtual (virtual methods are discussed in the next chapter)
   □ Parameter and type parameter names do not have to be the same in the implementing and defining declarations

Automatic Properties (C# 3.0)

   In the Contact class defined in the previous section, apart from the ID property, the properties are actually not doing much except assigning their values to private members:
   public string FirstName {
    get {
     return _FirstName;
    }
    set {
     _FirstName = value;
    }
   }
   public string LastName {
    get {
     return _LastName;
    }
    set {
     _LastName = value;
    }
   }
   public string Email {
    get {
     return _Email;
    }
    set {
     _Email = value;
    }
   }
   In other words, you are not actually doing any checking before the values are assigned. In C# 3.0, you can shorten those properties that have no filtering (checking) rules by using a feature known as automatic properties. The Contact class can be rewritten as:
   public class Contact {
    int _ID;
    public int ID {
     get {
      return _ID;
     }
     set {
      if (value > 0 && value <= 9999) {
       _ID = value;
      } else {
       _ID = 0;
      };
     }
    }
    public string FirstName {get; set;}
    public string LastName {get; set;}
    public string Email {get; set;}
   }
   Now there's no need for you to define private members to store the values of the properties. Instead, you just need to use the get and set keywords, and the compiler will automatically create the private members in which to store the properties values. If you decide to add filtering rules to the properties later, you can simply implement the set and get accessor of each property.
   To restrict the visibility of the get and set accessor when using the automatic properties feature, you simply prefix the get or set accessor with the private keyword, like this:
   public string FirstName {get; private set;}
   This statement sets the FirstName property as read-only.
   You might be tempted to directly convert these properties (FirstName, LastName, and Email) into public data members. But if you did that and then later decided to convert these public members into properties, you would need to recompile all of the assemblies that were compiled against the old class.

Constructors

   Instead of initializing the individual properties of an object after it has been instantiated, it is sometimes useful to initialize them at the time of instantiation. Constructors are class methods that are executed when an object is instantiated.
   Using the Contact class as the example, the following constructor initializes the ID property to 9999 every time an object is instantiated:
   public class Contact {
    int _ID;
    public int ID {
     get {
      return _ID;
     }
     set {
      if (value > 0 && value <= 9999) {
       _ID = value;
      } else {
       _ID = 0;
      };
     }
    }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public Contact() {
     this.ID = 9999;
    }
   }
   The following statement proves that the constructor is called:
   Contact c = new Contact();
   //---prints out 9999---
   Console.WriteLine(c.ID);
   Constructors have the same name as the class and they do not return any values. In this example, the constructor is defined without any parameters. A constructor that takes in no parameters is called a default constructor. It is invoked when you instantiate an object without any arguments, like this:
   Contact c = new Contact();

   If you do not define a default constructor in your class, an implicit default constructor is automatically created by the compiler.

   You can have as many constructors as you need to, as long as each constructor's signature (parameters) is different. Let's now add two more constructors to the Contact class:
   public class Contact {
    //...
    public Contact() {
     this.ID = 9999;
    }
    public Contact(int ID) {
     this.ID = ID;
    }
    public Contact(int ID, string FirstName, string LastName, string Email) {
     this.ID = ID;
     this.FirstName = FirstName;
     this.LastName = LastName;
     this.Email = Email;
    }
   }
   When you have multiple methods (constructors in this case) with the same name but different signatures, the methods are known as overloaded. IntelliSense will show the different signatures available when you try to instantiate a Contact object (see Figure 4-3).
   Figure 4-3
   You can create instances of the Contact class using the different constructors:
   //---first constructor is called---
   Contact c1 = new Contact();
   //---second constructor is called---
   Contact c2 = new Contact(1234);
   //---third constructor is called---
   Contact c3 = new Contact(1234, "Wei-Meng", "Lee", "weimenglee@learn2develop.net");

Constructor Chaining

   Suppose that the Contact class has the following four constructors:
   public class Contact {
    //...
    public Contact() {
     this.ID = 9999;
    }
    public Contact(int ID) {
     this.ID = ID;
    }
    public Contact(int ID, string FirstName, string LastName) {
     this.ID = ID;
     this.FirstName = FirstName;
     this.LastName = LastName;
    }
    public Contact(int ID, string FirstName, string LastName, string Email) {
     this.ID = ID;
     this.FirstName = FirstName;
     this.LastName = LastName;
     this.Email = Email;
    }
   }
   Instead of setting the properties individually in each constructor, each constructor itself sets some of the properties for other constructors. A more efficient way would be for some constructors to call the other constructors to set some of the properties. That would prevent a duplication of code that does the same thing. The Contact class could be rewritten like this:
   public class Contact {
    //...
    //---first constructor---
    public Contact() {
     this.ID = 9999;
    }
    //---second constructor---
    public Contact(int ID) {
     this.ID = ID;
    }
    //---third constructor---
    public Contact(int ID, string FirstName, string LastName) :
     this(ID) {
     this.FirstName = FirstName;
     this.LastName = LastName;
    }
    //---fourth constructor---
    public Contact(int ID, string FirstName, string LastName, string Email) :
     this(ID, FirstName, LastName) {
     this.Email = Email;
    }
   }
   In this case, the fourth constructor is calling the third constructor using the this keyword. In addition, it is also passing in the arguments required by the third constructor. The third constructor in turn calls the second constructor. This process of one constructor calling another is call constructor chaining.
   To prove that constructor chaining works, use the following statements:
   Contact c1 = new Contact(1234, "Wei-Meng", "Lee", "weimenglee@learn2develop.net");
   Console.WriteLine(c1.ID); //---1234---
   Console.WriteLine(c1.FirstName); //---Wei-Meng---
   Console.WriteLine(c1.LastName); //---Lee---
   Console.WriteLine(c1.Email); //---weimenglee@learn2develop.net---
   To understand the sequence of the constructors that are called, insert the following highlighted statements:
   class Contact {
    //...
    //---first constructor---
    public Contact() {
     this.ID = 9999;
     Console.WriteLine("First constructor");
    }
    //---second constructor---
    public Contact(int ID) {
     this.ID = ID;
     Console.WriteLine("Second constructor");
    }
    //---third constructor---
    public Contact(int ID, string FirstName, string LastName) :
     this(ID) {
     this.FirstName = FirstName;
     this.LastName = LastName;
     Console.WriteLine("Third constructor");
    }
    //---fourth constructor---
    public Contact(int ID, string FirstName, string LastName, string Email) :
     this(ID, FirstName, LastName) {
     this.Email = Email;
     Console.WriteLine("Fourth constructor");
    }
   }
   The statement:
   Contact c1 = new Contact(1234, "Wei-Meng", "Lee", "weimenglee@learn2develop.net");
   prints the following output:
   Second constructor
   Third constructor
   Fourth constructor

Static Constructors

   If your class has static members, it is only sometimes necessary to initialize them before an object is created and used. In that case, you can add static constructors to the class. For example, suppose that the Contact class has a public static member count to record the number of the Contact object created. You can add a static constructor to initialize the static member, like this:
   public class Contact {
    //...
    public static int count;
    static Contact() {
     count = 0;
     Console.WriteLine("Static constructor");
    }
    //---first constructor---
    public Contact() {
     count++;
     Console.WriteLine("First constructor");
    }
    //...
   }
   When you now create instances of the Contact class, like this:
   Contact c1 = new Contact();
   Contact c2 = new Contact();
   Console.WriteLine(Contact.count);
   the static constructor is only called once, evident in the following output:
   Static constructor
   First constructor
   First constructor
   2
   Note the behavior of static constructors:
   □ A static constructor does not take access modifiers or have parameters.
   □ A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
   □ A static constructor cannot be called directly.
   □ The user has no control on when the static constructor is executed in the program.

Copy Constructor

   The C# language does not provide a copy constructor that allows you to copy the value of an existing object into a new object when it is created. Instead, you have to write your own.
   The following copy constructor in the Contact class copies the values of the properties of an existing object (through the otherContact parameter) into the new object:
   class Contact {
    //...
    //---a copy constructor---
    public Contact(Contact otherContact) {
     this.ID = otherContact.ID;
     this.FirstName = otherContact.FirstName;
     this.LastName = otherContact.LastName;
     this.Email = otherContact.Email;
    }
    //...
   }
   To use the copy constructor, first create a Contact object:
   Contact c1 = new Contact(1234, "Wei-Meng", "Lee",
    "weimenglee@learn2develop.net");
   Then, instantiate another Contact object and pass in the first object as the argument:
   Contact c2 = new Contact(c1);
   Console.WriteLine(c2.ID); //---1234--- 
   Console.WriteLine(c2.FirstName); //---Wei-Meng---
   Console.WriteLine(c2.LastName); //---Lee---
   Console.WriteLine(c2.Email); //---weimenglee@learn2develop.net---

Object Initializers (C# 3.0)

   Generally, there are two ways in which you can initialize an object — through its constructor(s) during instantiation or by setting its properties individually after instantiation. Using the Contact class defined in the previous section, here is one example of how to initialize a Contact object using its constructor:
   Contact c1 = new Contact(1234, "Wei-Meng", "Lee", "weimenglee@learn2develop.net");
   You can also set an object's properties explicitly:
   Contact c1 = new Contact();
   c1.ID = 1234;
   c1.FirstName = "Wei-Meng";
   c1.LastName = "Lee";
   c1.Email = "weimenglee@learn2develop.net";
   In C# 3.0, you have a third way of initializing objects — when they are instantiated. This feature is known as the object initializers. The following statement shows an example:
   Contact c1 = new Contact() {
    ID = 1234,
    FirstName = "Wei-Meng",
    LastName = "Lee",
    Email = "weimenglee@learn2develop.net"
   };
   Here, when instantiating a Contact class, you are also setting its properties directly using the {} block. To use the object initializers, you instantiate an object using the new keyword and then enclose the properties that you want to initialize within the {} block. You separate the properties using commas.
   Do not confuse the object initializer with a class's constructor(s). You should continue to use the constructor (if it has one) to initialize an object. The following example shows that you use the Contact's constructor to initialize the ID property and then the object initializers to initialize the rest of the properties:
   Contact c2 = new Contact(1234) {
    FirstName = "Wei-Meng",
    LastName = "Lee",
    Email = "weimenglee@learn2develop.net"
   };

Destructors

   In C#, a constructor is called automatically when an object is instantiated. When you are done with the object, the Common Language Runtime (CLR) will destroy them automatically, so you do not have to worry about cleaning them up. If you are using unmanaged resources, however, you need to free them up manually.
   When objects are destroyed and cleaned up by the CLR, the object's destructor is called. A C# destructor is declared by using a tilde (~) followed by the class name:
   class Contact : Object {
    //---constructor--- 
    public Contact() {
     //...
    }
    //---destructor---
    ~Contact() {
     //---release unmanaged resources here---
    }
    //...
   }
   The destructor is a good place for you to place code that frees up unmanaged resources, such as COM objects or database handles. One important point is that you cannot call the destructor explicitly — it will be called automatically by the garbage collector.
   To manually dispose of your unmanaged resources without waiting for the garbage collector, you can implement the IDisposable interface and the Dispose() method.

   Chapter 5 discusses the concept of interfaces in more detail.

   The following shows the Contact class implementing the IDisposable class and implementing the Dispose() method:
   class Contact : IDisposable {
    //...
    ~Contact() {
     //-–-call the Dispose() method---
     Dispose();
    }
    public void Dispose() {
     //---release unmanaged resources here---
    }
   }
   You can now manually dispose of unmanaged resources by calling the Dispose() method directly:
   Contact c1 = new Contact(); //...
   //---done with c1 and want to dispose it---
   c1.Dispose();
   There is now a call to the Dispose() method within the destructor, so you must make sure that the code in that method is safe to be called multiple times — manually by the user and also automatically by the garbage collector.

The Using Statement

   C# provides a convenient syntax for automatically calling the Dispose() method, using the using keyword. In the following example, the conn object is only valid within the using block and will be disposed automatically after the execution of the block.
   using System.Data.SqlClient;
   ...
   using (SqlConnection conn = new SqlConnection()) {
    conn.ConnectionString = "...";
    //...
   }
   Using the using keyword is a good way for you to ensure that resources (especially COM objects and unmanaged code, which will not be unloaded automatically by the garbage collector in the CLR) are properly disposed of once they are no longer needed.

   You can also apply the static keyword to class definitions. Consider the following FilesUtil class definition:
   public class FilesUtil {
    public static string ReadFile(string Filename) {
     //---implementation---
     return "file content...";
    }
    public static void WriteFile(string Filename, string content) {
     //---implementation---
    }
   }
   Within this class are two static methods — ReadFile() and WriteFile(). Because this class contains only static methods, creating an instance of this class is not very useful, as Figure 4-4 shows.
   Figure 4-4 
   As shown in Figure 4-4, an instance of the FilesUtil class does not expose any of the static methods defined within it. Hence, if a class contains nothing except static methods and properties, you can simply declare the class as static, like this:
   public static class FilesUtil {
    public static string ReadFile(string Filename) {
     //---implementation---
     return "file content...";
    }
    public static void WriteFile(string Filename, string content) {
     //---implementation---
    }
   }
   The following statements show how to use the static class:
   //---this is not allowed for static classes---
   FilesUtil f = new FilesUtil();
   //---these are OK---
   Console.WriteLine(FilesUtil.ReadFile(@"C:\TextFile.txt"));
   FilesUtil.WriteFile(@"C:\TextFile.txt", "Some text content to be written");
   Use static classes when the methods in a class are not associated with a particular object. You need not create an instance of the static class before you can use it.

   In C#, all classes inherit from the System.Object base class (inheritance is discussed in the next chapter). This means that all classes contain the methods defined in the System.Object class.
   All class definitions that do not inherit from other classes by default inherit directly from the System.Object class. The earlier Contact class definition:
   public class Contact
   for example, is equivalent to:
   public class Contact: Object
   You can create an instance of the System.Object class if you want, but it is by itself not terribly useful:
   Object o = new object();
   The System.Object class exposes four instance methods (see Figure 4-5):
   □ Equals() — Checks whether the value of the current object is equal to that of another object. By default, the Equals() method checks for reference equality (that is, if two objects are pointing to the same object). You should override this method for your class.
   □ GetHashCode() — Returns a hash code for the class. The GetHashCode() method is suitable for use in hashing algorithms and data structures, such as a hash table. There will be more about hashing in Chapter 11
   □ GetType() — Returns the type of the current object
   □ ToString() — Returns the string representation of an object
   Figure 4-5 
   In addition, the System.Object class also has two static methods (see Figure 4-6):
   □ Equals() — Returns true if the two objects are equal (see next section for more details)
   □ ReferenceEquals() — Returns true if two objects are from the same instance
   Figure 4-6
   All classes that inherit from System.Object also inherit all the four instance methods, a couple of which you will learn in more details in the following sections.

   Consider the following three instances of the Contact class, which implicitly inherits from the System.Object class:
   Contact c1 = new Contact() {
    ID = 1234,
    FirstName = "Wei-Meng",
    LastName = "Lee",
    Email = "weimenglee@learn2develop.net"
   };
   Contact c2 = new Contact() {
    ID = 1234,
    FirstName = "Wei-Meng",
    LastName = "Lee",
    Email = "weimenglee@learn2develop.net"
   };
   Contact c3 = new Contact() {
    ID = 4321,
    FirstName = "Lee",
    LastName = "Wei-Meng",
    Email = "weimenglee@gmail.com"
   };
    As you can see, c1 and c2 are identical in data member values, while c3 is different. Now, let's use the following statements to see how the Equals() and ReferenceEquals() methods work:
   Console.WriteLine(c1.Equals(c2)); //---False---
   Console.WriteLine(c1.Equals(c3)); //---False---
   c3 = c1;
   Console.WriteLine(c1.Equals(c3)); //---True---
   Console.WriteLine(Object.ReferenceEquals(c1, c2)); //---False---
   Console.WriteLine(Object.ReferenceEquals(c1, c3)); //---True---
   The first statement might be a little surprising to you; did I not just mention that you can use the Equals() method to test for value equality?
   Console.WriteLine(c1.Equals(c2)); //---False---
   In this case, c1 and c2 have the exact same values for the members, so why does the Equals() method return False in this case? It turns out that the Equals() method must be overridden in the Contact class definition. This is because by itself, the System.Object class does not know how to test for the equality of your custom class; the Equals() method is a virtual method and needs to be overridden in derived classes. By default, the Equals() method tests for reference equality.
   The second statement is straightforward, as c1 and c3 are two different objects:
   Console.WriteLine(c1.Equals(c3)); //---False---
   The third and fourth statements assign c1 to c3, which means that c1 and c3 are now two different variables pointing to the same object. Hence, Equals() returns True:
   c3 = c1;
   Console.WriteLine(c1.Equals(c3)); //---True---
   The fifth and sixth statements test the reference equality of c1 against c2 and then c1 against c3:
   Console.WriteLine(Object.ReferenceEquals(c1, c2)); //---False---
   Console.WriteLine(Object.ReferenceEquals(c1, c3)); //---True---

   If two objects have reference equality, they also have value equality, but the reverse is not necessarily true.

   By default the Equals() method tests for reference equality. To ensure that it tests for value equality rather than reference equality, you need to override the Equals() virtual method.
   Using the same Contact class used in the previous section, add the methods highlighted in the following code:
   public class Contact {
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
    public override bool Equals(object obj) {
     //---check for null obj---
     if (obj == null) return false;
     //---see if obj can be cast to Contact---
     Contact c = obj as Contact;
     if ((System.Object)c == null) return false;
     //---check individual fields---
     return
      (ID == c.ID) && (FirstName == c.FirstName) &&
      (LastName == c.LastName) && (Email == c.Email);
    }
    public bool Equals(Contact c) {
     //---check for null obj---
     if (c == null) return false;
     //---check individual fields---
     return
      (ID == c.ID) && (FirstName == c.FirstName) &&
      (LastName == c.LastName) && (Email == c.Email);
    }
    public override int GetHashCode() {
     return ID;
    }
   }
   Essentially, you're adding the following:
   □ The Equals(object obj) method to override the Equals() virtual method in the System.Object class. This method takes in a generic object (System.Object) as argument.
   □ The Equals(Contact c) method to test for value equality. This method is similar to the first method, but it takes in a Contact object as argument.
   □ The GetHashCode() method to override the GetHashCode() virtual method in the System.Object class.

The as Keyword

   In the Equals(object obj) method you saw the use of the as keyword:
   Contact c = obj as Contact;
   The as operator performs conversions between compatible types. In this case, it tries to cast the obj object into a Contact object. The as keyword is discussed in detail in Chapter 5.

   Notice that the Equals() methods essentially performs the following to determine if two objects are equal in value:
   □ It checks whether the object passed is in null. If it is, it returns false.
   □ It checks whether the object passed is a Contact object (the second Equals() method need not check for this). If it isn't, it returns false.
   □ Last, it checks to see whether the individual members of the passed-in Contact object are of the same value as the members of the current object. Only when all the members have the same values (which members to test are determined by you) does the Equals() method return true. In this case, all the four members' values must be equal to the passed-in Contact object.
   The following statement will now print out True:
   Console.WriteLine(c1.Equals(c2)); //---True---

   All objects in C# inherits the ToString() method, which returns a string representation of the object. For example, the DateTime class's ToString() method returns a string containing the date and time, as the following shows:
   DateTime dt = new DateTime(2008, 2, 29);
   //---returns 2/29/2008 12:00:00 AM---
   Console.WriteLine(dt.ToString());
   For custom classes, you need to override the ToString() method to return the appropriate string. Using the example of the Contact class, an instance of the Contact class's ToString() method simply returns the string "Contact":
   Contact c1 = new Contact() {
    ID = 1234,
    FirstName = "Wei-Meng",
    LastName = "Lee",
    Email = "weimenglee@learn2develop.net"
   };
   //---returns "Contact"---
   Console.WriteLine(c1.ToString());
   This is because the ToString() method from the Contact class inherits from the System.Object class, which simply returns the name of the class.
   To ensure that the ToString() method returns something appropriate, you need to override it:
   class Contact {
    public int ID;
    public string FirstName;
    public string LastName;
    public string Email;
    public override string ToString() {
     return ID + "," + FirstName + "," + LastName + "," + Email;
    }
    //...
   }
   In this implementation of the ToString() method, you return the concatenation of the various data members, as evident in the output of the following code:
   Contact c1 = new Contact() {
    ID = 1234,
    FirstName = "Wei-Meng",
    LastName = "Lee",
    Email = "weimenglee@learn2develop.net"
   };
   //---returns "1234,Wei-Meng,Lee,weimenglee@learn2develop.net" ---
   Console.WriteLine(c1.ToString());

   Attributes are descriptive tags that can be used to provide additional information about types (classes), members, and properties. Attributes can be used by .NET to decide how to handle objects while an application is running.
   There are two types of attributes:
   □ Attributes that are defined in the CLR.
   □ Custom attributes that you can define in your code.

CLR Attributes

   Consider the following Contact class definition:
   class Contact {
    public string FirstName;
    public string LastName;
    public void PrintName() {
     Console.WriteLine("{0} {1}", this.FirstName, this.LastName);
    }
    [Obsolete("This method is obsolete. Please use PrintName()")]
    public void PrintName(string FirstName, string LastName) {
     Console.WriteLine("{0} {1}", FirstName, LastName);
    }
   }
   Here, the PrintName() method is overloaded — once with no parameter and again with two input parameters. Notice that the second PrintName() method is prefixed with the Obsolete attribute:
   [Obsolete("This method is obsolete. Please use PrintName()")]
   That basically marks the method as one that is not recommended for use. The class will still compile, but when you try to use this method, a warning will appear (see Figure 4-7).
   Figure 4-7
   The Obsolete attribute is overloaded — if you pass in true for the second parameter, the message set in the first parameter will be displayed as an error (by default the message is displayed as a warning):
   [Obsolete("This method is obsolete. Please use PrintName()", true)]
   Figure 4-8 shows the error message displayed when you use the PrintName() method marked with the Obsolete attribute with the second parameter set to true.
   Figure 4-8
   Attributes can also be applied to a class. In the following example, the Obsolete attribute is applied to the Contact class:
   [Obsolete("This class is obsolete. Please use NewContact")]
   class Contact {
    //...
   }

Custom Attributes

   You can also define your own custom attributes. To do so, you just need to define a class that inherits directly from System.Attribute. The following Programmer class is one example of a custom attribute:
   public class Programmer : System.Attribute {
    private string _Name;
    public double Version;
    public string Dept { get; set; }
    public Programmer(string Name) {
     this._Name = Name;
    }
   }
   In this attribute, there are:
   □ One private member (_Name)
   □ One public member (Version)
   □ One constructor, which takes in one string argument
   Here's how to apply the Programmer attribute to a class:
   [Programmer("Wei-Meng Lee", Dept="IT", Version=1.5)]
   class Contact {
    //...
   }
   You can also apply the Programmer attribute to methods (as the following code shows), properties, structure, and so on:
   [Programmer("Wei-Meng Lee", Dept="IT", Version=1.5)]
   class Contact {
    [Programmer("Jason", Dept = "CS", Version = 1.6)]
    public void PrintName() {
     Console.WriteLine("{0} {1}", this.FirstName, this.LastName);
    }
    //...
   }
   Use the AttributeUsage attribute to restrict the use of any attribute to certain types:
   [System.AttributeUsage(System.AttributeTargets.Class |
    System.AttributeTargets.Method |
    System.AttributeTargets.Property)]
   public class Programmer : System.Attribute {
    private string _Name;
    public double Version;
    public string Dept { get; set; }
    public Programmer(string Name) {
     this._Name = Name;
    }
   }
   In this example, the Programmer attribute can only be used on class definitions, methods, and properties.

   Implementation inheritance is when a class derives from another base class, inheriting all the base class's members. To add new members to a class, you can define another class that derives from the existing base class. Using implementation inheritance, the new derived class inherits all of the implementation provided in the base class.
   To understand how inheritance works in C#, define a simple class as follows:
   public class Shape {
    //---properties---
    public double length { get; set; }
    public double width { get; set; }
    //---method---
    public double Perimeter() {
     return 2 * (this.length + this.width);
    }
   }
   Here, the Shape class contains two properties and a single method. By itself, this class does not specify a particular shape, but it does assume that a basic shape contains length and width. It also assumes that the perimeter of a shape is simply double the sum of its length and width.
   Using this base class, you can define other shapes such as square, rectangle, and circle. Let's start with the rectangle shape. Using Shape as the base class, you can define a Rectangle class (a derived class because it derives from the Shape class) by inheriting from the Shape class, like this:
   public class Rectangle : Shape {}
   In C#, you use the colon (:) operator to indicate that a class inherits from another class (known as the base class). This example reads: "The Rectangle class inherits from the Shape class." This means that whatever members the Shape class has are inherited by the Rectangle class. (In this example, the Rectangle class has no implementation; that will be added in the next few sections.)
   C# supports only single-class inheritance, which means that a class can inherit directly from only one base class. If you do not specify the base class, the C# compiler assumes that it is inheriting from the System.Object class. Because the Shape class did not specify who it is inheriting from, it is equivalent to:
   public class Shape : Object {
    //---properties---
    public double length { get; set; }
    public double width { get; set; }
    //---method---
    public double Perimeter() {
     return 2 * (this.length + this.width);
    }
   }
   To use the Rectangle class, you instantiate it as you would other classes:
   Rectangle r = new Rectangle();
   Because the Rectangle class inherits all the members of the Shape class, you can access its members as if they are defined within the Rectangle class itself:
   r.length = 4;
   r.width = 5;
   Console.WriteLine(r.Perimeter()); //---18---

   The Shape class does not specify a particular shape, and thus it really does not make sense for you to instantiate it directly, like this:
   Shape someShape = new Shape();
   Instead, all other shapes should inherit from this base class. To ensure that you cannot instantiate the Shape class directly, you can make it an abstract class by using the abstract keyword:
   public abstract class Shape {
    //---properties---
    public double length { get; set; }
    public double width { get; set; }
    //---method---
    public double Perimeter() {
     return 2 * (this.length + this.width);
    }
   }
   Once a class is defined as abstract, you can no longer instantiate it directly; the following is now not permitted:
   //---cannot instantiate directly---
   Shape someShape = new Shape();
   The abstract keyword indicates that the class is defined solely for the purpose of inheritance; other classes need to inherit from it in order to have objects of this base type.

   Besides making a class abstract by using the abstract keyword, you can also create abstract methods. An abstract method has no implementation, and its implementation is left to the classes that inherit from the class that defines it. Using the Shape class as an example, you can now define an abstract method called Area() that calculates the area of a shape:
   public abstract class Shape {
    //---properties---
    public double length { get; set; }
    public double width { get; set; }
    //---method---
    public double Perimeter() {
     return 2 * (this.length + this.width);
    }
    //---abstract method---
    public abstract double Area();
   }
   It is logical to make the Area() method an abstract one because at this point you don't really know what shape you are working on (circle, square, or triangle, for example), and thus you don't know how to calculate its area.
   An abstract method is defined just like a normal method without the normal method block ({}). Classes that inherit from a class containing abstract methods must provide the implementation for those methods.
   The Rectangle class defined earlier must now implement the Area() abstract method, using the override keyword:
   public class Rectangle : Shape {
    //---provide the implementation for the abstract method---
    public override double Area() {
     return this.length * this.width;
    }
   }
   Instead of using the this keyword to access the length and width properties, you can also use the base keyword:
   public class Rectangle : Shape {
    public override double Area() {
     return base.length * base.width;
    }
   }
   The base keyword is used to access members (such as properties and variables) of the base class from within a derived class. You can also use the base keyword to access methods from the base class; here's an example:
   public class Rectangle : Shape {
    public override sealed double Area() {
     return this.length * this.width;
     //return base.length * base.width;
    }
    public override double Perimeter() {
     //---invokes the Perimeter() method in the Shape class---
     return base.Perimeter();
    }
   }
   You can now use the Rectangle class like this:
   Rectangle r = new Rectangle();
   r.length = 4;
   r.width = 5;
   Console.WriteLine(r.Perimeter()); //---18---
   Console.WriteLine(r.Area()); //---20---

   An abstract method can only be defined in an abstract class.

   The base keyword refers to the parent class of a derived class, not the root class. Consider the following example where you have three classes — Class3 inherits from Class2, which in turn inherits from Class1:
   public class Class1 {
    public virtual void PrintString() {
     Console.WriteLine("Class1");
    }
   }
   public class Class2: Class1 {
    public override void PrintString() {
     Console.WriteLine("Class2");
    }
   }
   public class Class3 : Class2 {
    public override void PrintString() {
     base.PrintString();
    }
   }
   In Class3, the base.PrintString() statement invokes the PrintString() method defined in its parent, Class2. The following statements verify this:
   Class3 c3 = new Class3();
   //---prints out "Class2"---
   c3.PrintString();

   Using the Rectangle class, you can find the perimeter and area of a rectangle with the Perimeter() and Area() methods, respectively. But what if you want to define a Circle class? Obviously, the perimeter (circumference) of a circle is not the length multiply by its width. For simplicity, though, let's assume that the diameter of a circle can be represented by the Length property.
   The definition of Circle will look like this:
   public class Circle : Shape {}
   However, the Perimeter() method should be reimplemented as the circumference of a circle is defined to be 2*π*radius (or π*diameter). But the Perimeter() method has already been defined in the base class Shape. In this case, you need to indicate to the compiler that the Perimeter() method in the Shape class can be reimplemented by its derived class. To do so, you need to prefix the Perimeter() method with the virtual keyword to indicate that all derived classes have the option to change its implementation:
   public abstract class Shape {
    //---properties---
    public double length { get; set; }
    public double width { get; set; }
    //---make this method as virtual---
    public virtual double Perimeter() {
     return 2 * (this.length + this.width);
    }
    //---abstract method--- 
    public abstract double Area();
   }
   The Circle class now has to provide implementation for both the Perimeter() and Area() methods (note the use of the override keyword):
   public class Circle : Shape {
    //---provide the implementation for the abstract method---
    public override double Perimeter() {
     return Math.PI * (this.length);
    }
    //---provide the implementation for the virtual method---
    public override double Area() {
     return Math.PI * Math.Pow(this.length/2, 2);
    }
   }
   Bear in mind that when overriding a method in the base class, the new method must have the same signature (parameter) as the overridden method. For example, the following is not allowed because the new Perimeter() method has a single input parameter, but this signature does not match that of the Perimeter() method defined in the base class (Shape):
   public class Circle : Shape {
    //---signature does not match Perimeter() in base class---
    public override double Perimeter(int Diameter) {
      //...
    }
   }
   If you need to implement another new method also called Perimeter() in the Circle class but with a different signature, use the new keyword, like this:
   public class Circle : Shape {
    //---a new Perimeter() method---
    public new double Perimeter(int diameter) {
     //...
    }
   }
   When a class has multiple methods each with the same name but a different signature (parameter), the methods are known as overloaded. The Perimeter() method of the Circle class is now overloaded (see Figure 6-2). Note that IntelliSense shows that the first method is from the Shape base class, while the second one is from the Circle class.
   Figure 6-2 

   See the "Overloading Methods" section later in this chapter. 

   So far you've seen the class definition for Shape, Rectangle, and Circle. Now let's define a class for the shape Square. As you know, a square is just a special version of rectangle; it just happens to have the same length and width. In this case, the Square class can simply inherit from the Rectangle class:
   public class Square : Rectangle {}
   You can instantiate the Square class as per normal and all the members available in the Rectangle would then be available to it:
   Square s = new Square();
   s.length = 5;
   s.width = 5;
   Console.WriteLine(s.Perimeter()); //---20--- 
   Console.WriteLine(s.Area()); //---25--- 
   To ensure that no other classes can derive from the Square class, you can seal it using the sealed keyword. A class prefixed with the sealed keyword prevents other classes inheriting from it. For example, if you seal the Square class, like this:
   public sealed class Square : Rectangle {}
   The following will result in an error:
   //---Error: Square is sealed---
   public class Rhombus : Square {}
   A sealed class cannot contain virtual methods. In the following example, the Square class is sealed, so it cannot contain the virtual method called Diagonal():
   public sealed class Square : Rectangle {
    //---Error: sealed class cannot contain virtual methods---
    public virtual Single Diagonal() {
     //---implementation here---
    }
   }
   This is logical because a sealed class does not provide an opportunity for a derived class to implement its virtual method. By the same argument, a sealed class also cannot contain abstract methods:
   public sealed class Square : Rectangle {
    //---Error: sealed class cannot contain abstract method--- 
    public abstract Single Diagonal();
   }
   You can also seal methods so that other derived classes cannot override the implementation that you have provided in the current class. For example, recall that the Rectangle class provides the implementation for the abstract Area() method defined in the Shape class:
   public class Rectangle : Shape {
    public override double Area() {
     return this.length * this.width;
    }
   }
   To prevent the derived classes of Rectangle (such as Square) from modifying the Area() implementation, prefix the method with the sealed keyword:
   public class Rectangle : Shape {
    public override sealed double Area() {
     return this.length * this.width;
    }
   }
   Now if you try to override the Area() method in the Square class, you get an error:
   public sealed class Square : Rectangle {
    //---Error: Area() is sealed in Rectangle class---
    public override double Area() {
     //---implementation here---
    }
   }

   When you have multiple methods in a class having the same name but different signatures (parameters), they are known as overloaded methods. Consider the following class definition:
   public class BaseClass {
    public void Method(int num) {
     Console.WriteLine("Number in BaseClass is " + num);
    }
    public void Method(string st) {
     Console.WriteLine("String in BaseClass is " + st);
    }
   }
   Here, BaseClass has two methods called Method() with two different signatures — one integer and another one string.
   When you create an instance of BaseClass, you can call Method() with either an integer or string argument and the compiler will automatically invoke the appropriate method:
   BaseClass b = new BaseClass();
   //---prints out: Number in BaseClass is 5---
   b.Method(5);
   //---prints out: String in BaseClass is This is a string---
   b.Method("This is a string");
   Suppose that you have another class inheriting from BaseClass with a Method() method that has a different signature, like this:
   public class DerivedClass : BaseClass {
    //---overloads the method---
    public void Method(char ch) {
     Console.WriteLine("Character in DerivedClass is " + ch);
    }
   }
   Then, DerivedClass now has three overloaded Method() methods, as illustrated in Figure 6-3.
   Figure 6-3 
   You can now pass three different types of arguments into Method() — character, integer, and string:
   DerivedClass d = new DerivedClass();
   //---prints out: Character in DerivedClass is C--- 
   d.Method('C');
   //---prints out: Number in BaseClass is 5---
   d.Method(5);
   //---prints out: String in BaseClass is This is a string---
   d.Method("This is a string");
   What happens if you have a Method() having the same signature as another one in the base class, such as the following?
   public class DerivedClass : BaseClass {
    //---overloads the method with the same parameter list---
    public void Method(int num) {
     Console.WriteLine("Number in DerivedClass is " + num);
    }
    //---overloads the method
    public void Method(char ch) {
     Console.WriteLine("Character in DerivedClass is " + ch);
    }
   }
   In this case, Method(int num) in DerivedClass will hide the same method in BaseClass, as the following printout proves:
   DerivedClass d = new DerivedClass();
   //---prints out: Number in DerivedClass is 5---
   d.Method(5);
   //---prints out: String in BaseClass is This is a string---
   d.Method("This is a string");
   //---prints out: Character in DerivedClass is C---
   d.Method('C');
   If hiding Method(int num) in BaseClass is your true intention, use the new keyword to denote that as follows (or else the compiler will issue a warning):
   //---overloads the method with the same parameter list
   public new void Method(int num) {
    Console.WriteLine("Number in DerivedClass is " + num);
   }

   In C#, you use the new keyword to hide methods in the base class by signature. C# does not support hiding methods by name as is possible in VB.NET by using the Shadows keyword.

   The following table summarizes the different keywords used for inheritance.

Modifier	Description
new	Hides an inherited method with the same signature.
static	A member that belongs to the type itself and not to a specific object.
virtual	A method that can be overridden by a derived class.
abstract	Provides the signature of a method/class but does not contain any implementation.
override	Overrides an inherited virtual or abstract method.
sealed	A method that cannot be overridden by derived classes; a class that cannot be inherited by other classes.
extern	An "extern" method is one in which the implementation is provided elsewhere and is most commonly used to provide definitions for methods invoked using .NET interop.

   Besides overloading methods, C# also supports the overloading of operators (such as +, -, /, and *). Operator overloading allows you to provide your own operator implementation for your specific type. To see how operator overloading works, consider the following program containing the Point class representing a point in a coordinate system:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace OperatorOverloading {
    class Program {
     static void Main(string[] args) {}
    }
    class Point {
     public Single X { get; set; }
     public Single Y { get; set; }
     public Point(Single X, Single Y) {
      this.X = X;
      this.Y = Y;
     }
     public double DistanceFromOrigin() {
      return (Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2)));
     }
    }
   }
   The Point class contains two public properties (X and Y), a constructor, and a method — DistanceFromOrigin().
   If you constantly perform calculations where you need to add the distances of two points (from the origin), your code may look like this:
   static void Main(string[] args) {
    Point ptA = new Point(4, 5);
    Point ptB = new Point(2, 7);
    double distanceA, distanceB;
    distanceA = ptA.DistanceFromOrigin(); //---6.40312423743285---
    distanceB = ptB.DistanceFromOrigin(); //---7.28010988928052---
    Console.WriteLine(distanceA + distanceB); //---13.6832341267134---
    Console.ReadLine();
   }
   A much better implementation is to overload the + operator for use with the Point class. To overload the + operator, define a public static operator within the Point class as follows:
   class Point {
    public Single X { get; set; }
    public Single Y { get; set; }
    public Point(Single X, Single Y) {
     this.X = X;
     this.Y = Y;
    }
    public double DistanceFromOrigin() {
     return (Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2)));
    }
    public static double operator +(Point A, Point B) {
     return (A.DistanceFromOrigin() + B.DistanceFromOrigin());
    }
   }
   The operator keyword overloads a built-in operator. In this example, the overloaded + operator allows it to "add" two Point objects by adding the result of their DistanceFromOrigin() methods:
   static void Main(string[] args) {
    Point ptA = new Point(4, 5);
    Point ptB = new Point(2, 7);
    Console.WriteLine(ptA + ptB); //---13.6832341267134---
    Console.ReadLine();
   }
   You can also use the operator keyword to define a conversion operator, as the following example shows:
   class Point {
    public Single X { get; set; }
    public Single Y { get; set; }
    public Point(Single X, Single Y) {
     this.X = X;
     this.Y = Y;
    }
    public double DistanceFromOrigin() {
     return (Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2)));
    }
    public static double operator +(Point A, Point B) {
     return (A.DistanceFromOrigin() + B.DistanceFromOrigin());
    }
    public static implicit operator double(Point pt) {
     return (pt.X / pt.Y);
    }
   }
   Here, the implicit keyword indicates that you want to implicitly perform a conversion of the Point class to a double value (this value is defined to be the ratio of the X and Y coordinates).
   Now when you assign a Point object to a double variable, the ratio of the X and Y coordinates is assigned automatically, as the following statements prove:
   static void Main(string[] args) {
    Point ptA = new Point(4, 5);
    Point ptB = new Point(2, 7);
    double ratio = ptA; //---implicitly convert to a double type---
    ptB = ptA; //---assign to another Point object---
    Console.WriteLine(ratio); //---0.8---
    Console.WriteLine((double)ptB); //---0.8---
    Console.ReadLine();
   }

   Whenever you add additional methods to a class in previous versions of C#, you need to subclass it and then add the required method. For example, consider the following predefined (meaning you cannot modify it) classes:
   public abstract class Shape {
    //---properties---
    public double length { get; set; }
    public double width { get; set; }
    //---make this method as virtual--- 
    public virtual double Perimeter() {
     return 2 * (this.length + this.width);
    }
    //---abstract method---
    public abstract double Area();
   }
 
   public class Rectangle : Shape {
    public override sealed double Area() {
     return this.length * this.width;
    }
   }
   The only way to add a new method Diagonal() to the Rectangle class is to create a new class that derives from it, like this:
   public class NewRectangle : Rectangle {
    public double Diagonal() {
     return Math.Sqrt(Math.Pow(this.length, 2) + Math.Pow(this.width, 2));
    }
   }
   In C# 3.0, you just use the new extension method feature to add a new method to an existing type. To add the Diagonal() method to the existing Rectangle class, define a new static class and define the extension method (a static method) within it, like this:
   public static class MethodsExtensions {
    public static double Diagonal(this Rectangle rect) {
     return Math.Sqrt(Math.Pow(rect.length, 2) + Math.Pow(rect.width, 2));
    }
   }
   In this example, Diagonal() is the extension method that is added to the Rectangle class. You can use the Diagonal() method just like a method from the Rectangle class:
   Rectangle r = new Rectangle();
   r.length = 4;
   r.width = 5;
   //---prints out: 6.40312423743285---
   Console.WriteLine(r.Diagonal());
   The first parameter of an extension method is prefixed by the this keyword, followed by the type it is extending (Rectangle in this example, indicating to the compiler that this extension method must be added to the Rectangle class). The rest of the parameter list (if any) is then the signature of the extension method. For example, to pass additional parameters into the Diagonal() extension method, you can declare it as:
   public static double Diagonal(this Rectangle rect, int x, int y) {
    //---additional implementation here---
    return Math.Sqrt(Math.Pow(rect.length, 2) + Math.Pow(rect.width, 2));
   }
   To call this modified extension method, simply pass in two arguments, like this:
   Console.WriteLine(r.Diagonal(3,4));
   Figure 6-4 shows IntelliSense providing a hint on the parameter list.
   Figure 6-4
   Although an extension method is a useful new feature in the C# language, use it sparingly. If an extension method has the same signature as another method in the class it is trying to extend, the method in the class will take precedence and the extension method will be ignored.

   Chapter 4 discussed two primary access modifiers — public and private, and introduced two others: protected and internal. Let's take a look at how the latter are used. Consider the following class definition:
   public class A {
    private int v;
    public int w;
    protected int x;
    internal int y;
    protected internal int z;
   }
   The A class has four data members, each with a different access modifiers. The fifth data member, z, has a combination of two access modifiers — protected and internal. To see the difference between all these different modifiers, create an instance of A and observe the members displayed by IntelliSense.
   Figure 6-5 shows that only the variables w, y, and z are accessible.
   Figure 6-5
   At this moment, you can conclude that:
   □ The private keyword indicates that the member is not visible outside the type (class).
   □ The public keyword indicates that the member is visible outside the type (class).
   □ The protected keyword indicates that the member is not visible outside the type (class).
   □ The internal keyword indicates that the member is visible outside the type (class).
   □ The protected internal keyword combination indicates that the member is visible outside the type (class).
   Now define a second class, B, that inherits from class A:
   public class B : A {
    public void Method() {}
   }
   Try to access the class A variables from within Method(). In Figure 6-6, IntelliSense shows the variables that are accessible.
   Figure 6-6
   As you can see, member x is now visible (in addition to w, y, and z), so you can conclude that:
   □ The private keyword indicates that the member is not visible outside the type (class) or to any derived classes.
   □ The public keyword indicates that the member is visible outside the type (class) and to all derived classes.
   □ The protected keyword indicates that the member is not visible outside the type (class) but is visible to any derived classes.
   □ The internal keyword indicates that the member is visible outside the type (class) as well as to all derived classes.
   □ The protected internal keyword combination indicates that the item is visible outside the type (class) as well as to all derived classes.
   From these conclusions, the difference among private, public, and protected is obvious. However, there is no conclusive difference between internal and protected internal. The internal access modifier indicates that the member is only visible within its containing assembly. The protected internal keyword combination indicates that the member is visible to any code within its containing assembly as well as derived types.
   Besides applying the access modifiers to data members, you can also use them on type definitions. However, you can only use the private and public access modifiers on class definitions. 

   Consider the following BaseClass definition consisting of one default constructor:
   public class BaseClass {
    //---default constructor---
    public BaseClass() {
     Console.WriteLine("Constructor in BaseClass");
    }
   }
   Anther class, DerivedClass inheriting from the BaseClass, also has a default constructor:
   public class DerivedClass : BaseClass {
    //---default constructor---
    public DerivedClass() {
     Console.WriteLine("Constructor in DerivedClass");
    }
   }
   So when an object of DerivedClass is instantiated, which constructor will be invoked first? The following statement shows that the constructor in the base class will be invoked before the constructor in the current class will be invoked:
   DerivedClass dc = new DerivedClass();
   The outputs are:
   Constructor in BaseClass
   Constructor in DerivedClass
   What happens if there is no default constructor in the base class, but perhaps a parameterized constructor like the following?
   public class BaseClass {
    //---constructor---
    public BaseClass(int x) {
     Console.WriteLine("Constructor in BaseClass");
    }
   }
   In that case, the compiler will complain that BaseClass does not contain a default constructor.

   Remember that if a base class contains constructors, one of them must be a default constructor.

   Suppose BaseClass contains two constructors — one default and one parameterized:
   public class BaseClass {
    //---default constructor---
    public BaseClass() {
     Console.WriteLine("Default constructor in BaseClass");
    }
    //---parameterized constructor---
    public BaseClass(int x) {
     Console.WriteLine("Parameterized Constructor in BaseClass");
    }
   }
   And DerivedClass contains one default constructor:
   public class DerivedClass : BaseClass {
    //---default constructor---
    public DerivedClass() {
     Console.WriteLine("Constructor in DerivedClass");
    }
   }
   When an instance of the DerivedClass is created like this:
   DerivedClass dc = new DerivedClass();
   The default constructor in BaseClass is first invoked followed by the DerivedClass. However, you can choose which constructor you want to invoke in BaseClass by using the base keyword in the default constructor in DerivedClass, like this:
   public class DerivedClass : BaseClass {
    //---default constructor--- 
    public DerivedClass(): base(4) {
     Console.WriteLine("Constructor in DerivedClass");
    }
   }
   In this example, when an instance of the DerivedClass is created, the parameterized constructor in BaseClass is invoked first (with the argument 4 passed in), followed by the default constructor in DerivedClass. This is shown in the output:
   DerivedClass dc = new DerivedClass();
   //---prints out:---
   //Parameterized Constructor in BaseClass
   //Constructor in DerivedClass
   Figure 6-7 shows that IntelliSense lists the overloaded constructors in BaseClass.
   Figure 6-7 

   In C#, a delegate is a reference type that contains a reference to a method. Think of a delegate as a pointer to a function. Instead of calling a function directly, you use a delegate to point to it and then invoke the method by calling the delegate. The following sections explain how to use a delegate and how it can help improve the responsiveness of your application. 

   To understand the use of delegates, begin by looking at the conventional way of invoking a function. Consider the following program:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace Delegates {
    class Program {
     static void Main(string[] args) {
      int num1 = 5;
      int num2 = 3;
      Console.WriteLine(Add(num1, num2).ToString());
      Console.WriteLine(Subtract(num1, num2).ToString());
      Console.ReadLine();
     }
     static int Add(int num1, int num2) {
      return (num1 + num2);
     }
     static int Subtract(int num1, int num2) {
      return (num1 - num2);
     }
    }
   }
   The program contains three methods: Main(), Add(), and Subtract(). Notice that the Add() and Subtract() methods have the same signature. In the Main() method, you invoke the Add() and Subtract() methods by calling them directly, like this:
   Console.WriteLine(Add(num1, num2).ToString());
   Console.WriteLine(Subtract(num1, num2).ToString());
   Now create a delegate type with the same signature as the Add() method:
   namespace Delegates {
    class Program {
     delegate int MethodDelegate(int num1, int num2);
     static void Main(string[] args) {
      ...
   You define a delegate type by using the delegate keyword, and its declaration is similar to that of a function, except that a delegate has no function body.
   To make a delegate object point to a function, you create an object of that delegate type (MethodDelegate, in this case) and instantiate it with the method you want to point to, like this:
   static void Main(string[] args) {
    int num1 = 5;
    int num2 = 3;
    MethodDelegate method = new MethodDelegate(Add);
   Alternatively, you can also assign the function name to it directly, like this:
   MethodDelegate method = Add;
   This statement declares method to be a delegate that points to the Add() method. Hence instead of calling the Add() method directly, you can now call it using the method delegate:
   //---Console.WriteLine(Add(num1, num2).ToString());---
   Console.WriteLine(method(num1, num2).ToString());
   The beauty of delegates is that you can make the delegate call whatever function it refers to, without knowing exactly which function it is calling until runtime. Any function can be pointed by the delegate, as long as the function's signature matches the delegate's.
   For example, the following statements check the value of the Operation variable before deciding which method the method delegate to point to:
   char Operation = 'A';
   MethodDelegate method = null;
   switch (Operation) {
   case 'A':
    method = new MethodDelegate(Add);
    break;
   case 'S':
    method = new MethodDelegate(Subtract);
    break;
   }
   if (method != null)
    Console.WriteLine(method(num1, num2).ToString());
   You can also pass a delegate to a method as a parameter, as the following example shows:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace Delegates {
    class Program {
     delegate int MethodDelegate(int num1, int num2);
     static void PerformMathOps(MethodDelegate method, int num1, int num2) {
      Console.WriteLine(method(num1, num2).ToString());
     }
     static void Main(string[] args) {
      int num1 = 5;
      int num2 = 3;
      char Operation = 'A';
      MethodDelegate method = null;
      switch (Operation) {
      case 'A':
       method = new MethodDelegate(Add);
       break;
      case 'S':
       method = new MethodDelegate(Subtract);
       break;
      }
      if (method != null)
       PerformMathOps(method, num1, num2);
      Console.ReadLine();
     }
     static int Add(int num1, int num2) {
      return (num1 + num2);
     }
     static int Subtract(int num1, int num2) {
      return (num1 - num2);
     }
    }
   }
   In this example, the PerformMathOps() function takes in three arguments — a delegate of type MethodDelegate and two integer values. Which method to invoke is determined by the Operation variable. Once the delegate is assigned to point to a method (Add() or Subtract()), it is passed to the PerformMathOps() method.

   In the previous section, a delegate pointed to a single function. In fact, you can make a delegate point to multiple functions. This is known as delegates chaining. Delegates that point to multiple functions are known as multicast delegates.
   Consider the following example:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
 
   namespace Delegates {
    class Program {
     delegate void MethodsDelegate();
     static void Main(string[] args) {
      MethodsDelegate methods = Method1;
      methods += Method2;
      methods += Method3;
      //---call the delegated method(s)---
      methods();
      Console.ReadLine();
     }
     static private void Method1() {
      Console.WriteLine("Method 1");
     }
     static private void Method2() {
      Console.WriteLine("Method 2");
     }
     static private void Method3() {
      Console.WriteLine("Method 3");
     }
    }
   }
   This program three methods: Method1(), Method2(), and Method3(). The methods delegate is first assigned to point to Method1(). The next two statements add Method2() and Method3() to the delegate by using the += operator:
   MethodsDelegate methods = Method1;
   methods += Method2;
   methods += Method3;
   When the methods delegate variable is called, the following output results:
   Method 1
   Method 2
   Method 3
   The output shows that the three methods are called in succession, in the order they were added.
   What happens when your methods each return a value and you call them using a multicast delegate? Here's an example in which the three methods each return an integer value:
   class Program {
    delegate int MethodsDelegate(ref int num1, ref int num2);
    static void Main(string[] args) {
     int num1 = 0, num2 = 0;
     MethodsDelegate methods = Method1;
     methods += Method2;
     methods += Method3;
     //---call the delegated method(s)--- 
     Console.WriteLine(methods(ref num1, ref num2));
     Console.WriteLine("num1: {0} num2: {1}", num1, num2);
     Console.ReadLine();
    }
    static private int Method1(ref int num1, ref int num2) {
     Console.WriteLine("Method 1");
     num1 = 1;
     num2 = 1;
     return 1;
    }
    static private int Method2(ref int num1, ref int num2) {
     Console.WriteLine("Method 2");
     num1 = 2;
     num2 = 2;
     return 2;
    }
    static private int Method3(ref int num1, ref int num2) {
     Console.WriteLine("Method 3");
     num1 = 3;
     num2 = 3;
     return 3;
    }
   }
   When the methods delegate is called, Method1(), Method2(), and Method3() are called in succession. However, only the last method (Method3()) returns a value back to the Main() function, as the output shows:
   Method 1
   Method 2
   Method 3
   3
   num1: 3 num2: 3
   If one of the methods pointed to by a delegate causes an exception, no results are returned.
   The following modifications to the preceding program shows that Method2() throws an exception and is caught by the try-catch block:
   class Program {
    delegate int MethodsDelegate(ref int num1, ref int num2);
    static void Main(string[] args) {
     int num1 = 0, num2 = 0;
     MethodsDelegate methods = Method1;
     methods += Method2;
     methods += Method3;
     try {
      //---call the delegated method(s)---
      Console.WriteLine(methods(ref num1, ref num2));
      Console.WriteLine("num1: {0} num2: {1}", num1, num2);
     } catch (Exception ex) {
      Console.WriteLine(ex.Message);
     }
     Console.WriteLine("num1: {0} num2: {1}", num1, num2);
     Console.ReadLine();
    }
    static private int Method1(ref int num1, ref int num2) {
     Console.WriteLine("Method 1");
     num1 = 1;
     num2 = 1;
     return l;
    }
    static private int Method2(ref int num1, ref int num2) {
     throw new Exception();
     Console.WriteLine("Method 2");
     num1 = 2;
     num2 = 2;
     return 2;
    }
    static private int Method3(ref int num1, ref int num2) {
     Console.WriteLine("Method 3");
     num1 = 3;
     num2 = 3;
     return 3;
    }
   }
   The following output shows that num1 and num2 retain the values set by the last method that was successfully invoked by the delegate:
   Method 1
   Exception of type 'System.Exception' was thrown.
   num1: 1 num2: 1
   Just as you use the += operator to add a method to a delegate, you use the -= operator to remove a method from a delegate:
   static void Main(string[] args) {
    int num1 = 0, num2 = 0;
    MethodsDelegate methods = Method1;
    methods += Method2;
    methods += Method3;
    //...
    //...
    //---removes Method3---
    methods -= Method3;

   One of the useful things you can do with delegates is to implement callbacks. Callbacks are methods that you pass into a function that will be called when the function finishes execution. For example, you have a function that performs a series of mathematical operations. When you call the function, you also pass it a callback method so that when the function is done with its calculation, the callback method is called to notify you of the calculation result.
   Following is an example of how to implement callbacks using delegates:
   class Program {
    delegate void callbackDelegate(string Message);
    static void Main(string[] args) {
     callbackDelegate result = ResultCallback;
     AddTwoNumbers(5, 3, result);
     Console.ReadLine();
    }
    static private void AddTwoNumbers(
     int num1, int num2, callbackDelegate callback) {
     int result = num1 + num2;
     callback("The result is: " + result.ToString());
    }
    static private void ResultCallback(string Message) {
     Console.WriteLine(Message);
    }
   }
   First, you declare two methods:
   □ AddTwoNumbers() — Takes in two integer arguments and a delegate of type callbackDelegate
   □ ResultCallback() — Takes in a string argument and displays the string in the console window
   Then you declare a delegate type:
   delegate void callbackDelegate(string Message);
   Before you call the AddTwoNumbers() function, you create a delegate of type callbackDelegate and assign it to point to the ResultCallback() method. The AddTwoNumbers() function is then called with two integer arguments and the result callback delegate:
   callbackDelegate result = ResultCallback;
   AddTwoNumbers(5, 3, result);
   In the AddTwoNumbers() function, when the calculation is done, you invoke the callback delegate and pass to it a string:
   static private void AddTwoNumbers(
    int num1, int num2, callbackDelegate callback) {
    int result = num1 + num2;
    callback("The result is: " + result.ToString());
   }
   The callback delegate calls the ResultCallback() function, which prints the result to the console. The output is:
   The result is: 8

   Callbacks are most useful if they are asynchronous. The callback illustrated in the previous example is synchronous, that is, the functions are called sequentially. If the AddTwoNumbers() function takes a long time to execute, all the statements after it will block. Figure 7-1 shows the flow of execution when the callback is synchronous.
   Figure 7-1
    A better way to organize the program is to call the AddTwoNumbers() method asynchronously, as shown in Figure 7-2. Calling a function asynchronously allows the main program to continue executing without waiting for the function to return.
   Figure 7-2
   In this asynchronous model, when the AddTwoNumbers() function is called, the statement(s) after it can continue to execute. When the function finishes execution, it calls the ResultCallback() function.
   Here's the rewrite of the previous program, using an asynchronous callback:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Runtime.Remoting.Messaging;
 
   namespace Delegates {
    class Program {
     //---delegate to the AddTwoNumbers() method---
     delegate int MethodDelegate(int num1, int num2);
     static void Main(string[] args) {
      //---assign the delegate to point to AddTwoNumbers()---
      MethodDelegate del = AddTwoNumbers;
      //---creates a AsyncCallback delegate---
      AsyncCallback callback = new AsyncCallback(ResultCallback);
      //---invoke the method asychronously---
      Console.WriteLine("Invoking the method asynchronously...");
      IAsyncResult result = del.BeginInvoke(5, 3, callback, null);
      Console.WriteLine("Continuing with the execution...");
      Console.ReadLine();
     }
     //---method to add two numbers---
     static private int AddTwoNumbers(int num1, int num2) {
      //---simulate long execution---
      System.Threading.Thread.Sleep(5000);
      return num1 + num2;
     }
     static private void ResultCallback(IAsyncResult ar) {
      MethodDelegate del =
       (MethodDelegate)((AsyncResult)ar).AsyncDelegate;
      //---get the result---
      int result = del.EndInvoke(ar);
      Console.WriteLine("Result of addition is: " + result);
     }
    }
   }
   First, you define a delegate type so that you can point to the AddTwoNumbers() method:
   delegate int MethodDelegate(int num1, int num2);
   Then create a delegate, and assign it to point to the AddTwoNumbers() method:
   //---assign the delegate to point to AddTwoNumbers()---
   MethodDelegate del = AddTwoNumbers;
   Next, define a delegate of type AsyncCallback:
   //---creates a AsyncCallback delegate---
   AsyncCallback callback = new AsyncCallback(ResultCallback);
   The AsyncCallback is a delegate that references a method to be called when an asynchronous operation completes. Here, you set it to point to ResultCallback (which you will define later). 
   To call the AddTwoNumbers() methods asynchronously, you use the BeginInvoke() method of the del delegate, passing it two integer values (needed by the AddTwoNumbers() method), as well as a delegate to call back when the method finishes executing:
   //---invoke the method asynchronously---
   Console.WriteLine("Invoking the method asynchronously...");
   IAsyncResult result = del.BeginInvoke(5, 3, callback, null);
   Console.WriteLine("Continuing with the execution...");
   The BeginInvoke() method calls the delegate asynchronously, and the next statement continues execution after the async delegate is called. This method returns a variable of type IAsyncResult to represent the status of an asynchronous operation.
   To obtain the result of the calculation, you define the ResultCallback() method, which takes in an argument of type IAsyncResult:
   static private void ResultCallback(IAsyncResult ar) {
    MethodDelegate del =
     (MethodDelegate)((AsyncResult)ar).AsyncDelegate;
    //---get the result---
    int result = del.EndInvoke(ar);
    Console.WriteLine("Result of addition is: " + result);
   }
   Within the ResultCallback() method, you first obtain the delegate to the AddTwoNumbers() method by using the AsyncDelegate property, which returns the delegate on which the asynchronous call was invoked. You then obtain the result of the asynchronous call by using the EndInvoke() method, passing it the IAsyncResult variable (ar).
   Finally, to demonstrate the asynchronous calling of the AddTwoNumbers() method, you can insert a Sleep() statement to delay the execution (simulating long execution):
   static private int AddTwoNumbers(int num1, int num2) {
    //---simulate long execution---
    System.Threading.Thread.Sleep(5000);
    return num1 + num2;
   }
   Figure 7-3 shows the output of this program.
   Figure 7-3
   When using asynchronous callbacks, you can make your program much more responsive by executing different parts of the program in different threads.

   Chapter 10 discusses more about threading.

   Beginning with C# 2.0, you can use a feature known as anonymous methods to define a delegate.
   An anonymous method is an "inline" statement or expression that can be used as a delegate parameter. To see how it works, take a look at the following example:
   class Program {
    delegate void MethodsDelegate(string Message);
    static void Main(string[] args) {
     MethodsDelegate method = Method1;
     //---call the delegated method---
     method("Using delegate.");
     Console.ReadLine();
    }
    static private void Method1(string Message) {
     Console.WriteLine(Message);
    }
   }
   Instead of defining a separate method and then using a delegate variable to point to it, you can shorten the code using an anonymous method:
   class Program {
    delegate void MethodsDelegate(string Message);
    static void Main(string[] args) {
     MethodsDelegate method = delegate(string Message) {
      Console.WriteLine(Message);
     };
     //---call the delegated method---
     method("Using anonymous method.");
     Console.ReadLine();
    }
   }
   In this expression, the method delegate is an anonymous method:
   MethodsDelegate method = delegate(string Message) {
    Console.WriteLine(Message);
   };
   Anonymous methods eliminate the need to define a separate method when using delegates. This is useful if your delegated method contains a few simple statements and is not used by other code because you reduce the coding overhead in instantiating delegates by not having to create a separate method.
   In C# 3.0, anonymous methods can be further shortened using a new feature known as lambda expressions. Lambda expressions are a new feature in .NET 3.5 that provides a more concise, functional syntax for writing anonymous methods.
   The preceding code using anonymous methods can be rewritten using a lambda expression:
   class Program {
    delegate void MethodsDelegate(string Message);
    static void Main(string[] args) {
     MethodsDelegate method = (Message) => { Console.WriteLine(Message); };
     //---call the delegated method---
     method("Using Lambda Expression.");
     Console.ReadLine();
    }
   }

   Lambda expressions are discussed in more detail in Chapter 14.

   One of the most important techniques in computer science that made today's graphical user interface operating systems (such as Windows, Mac OS X, Linux, and so on) possible is event-driven programming. Event-driven programming lets the OS react appropriately to the different clicks made by the user. A typical Windows application has various widgets such as buttons, radio buttons, and checkboxes that can raise events when, say, a user clicks them. The programmer simply needs to write the code to handle that particular event. The nice thing about events is that you do not need to know when these events will be raised — you simply need to provide the implementation for the event handlers that will handle the events and the OS will take care of invoking the necessary event handlers appropriately.
   In .NET, events are implemented using delegates. An object that has events is known as a publisher. Objects that subscribe to events (in other words, handle events) are known as subscribers. When an object exposes events, it defines a delegate so that whichever object wants to handle this event will have to provide a function for this delegate. This delegate is known as an event, and the function that handles this delegate is known as an event handler. Events are part and parcel of every Windows application. For example, using Visual Studio 2008 you can create a Windows application containing a Button control (see Figure 7-4).
   Figure 7-4
   When you double-click the Button control, an event handler is automatically added for you:
   public partial class Form1 : Form {
    public Form1() {
     InitializeComponent();
    }
    private void button1_Click(object sender, EventArgs e) {
    }
   }
   But how does your application know which event handler is for which event? Turns out that Visual Studio 2008 automatically wires up the event handlers in the code-behind of the form (FormName.Designer.cs; see Figure 7-5) located in a function called InitializeComponent():
   this.button1.Location = new System.Drawing.Point(12, 12);
   this.button1.Name = "button1";
   this.button1.Size = new System.Drawing.Size(75, 23);
   this.button1.TabIndex = 0;
   this.button1.Text = "button1";
   this.button1.UseVisualStyleBackColor = true;
   this.button1.Click += new System.EventHandler(this.button1_Click);
   Figure 7-5
   Notice that the way you wire up an event handler to handle the Click event is similar to how you assign a method name to a delegate.
   Alternatively, you can manually create the event handler for the Click event of the Button control. In the Form() constructor, type += after the Click event and press the Tab key. Visual Studio 2008 automatically completes the statement (see Figure 7-6).
   Figure 7-6
   Press the Tab key one more time, and Visual Studio 2008 inserts the stub of the event handler for you (see Figure 7-7).
   Figure 7-7 
   The completed code looks like this:
   public Form1() {
    InitializeComponent();
    this.button1.Click += new EventHandler(button1_Click);
   }
   void button1_Click(object sender, EventArgs e) {
   }
   Notice that Click is the event and the event handler must match the signature required by the event (in this case, the event handler for the Click event must have two parameter — object and EventArgs). By convention, event handlers in the .NET Framework return void and have two parameters. The first is the source of the event (that is, the object that raises this event), and the second is an object derived from EventArgs. The EventArgs parameter allows data to be passed from an event to the event handler. The EventArgs class is discussed further later in this chapter.
   Using the new lambda expressions in C# 3.0, the preceding event handler can also be written like this:
   public Form1() {
    InitializeComponent();
    this.button1.Click += (object sender, EventArgs e) => {
     MessageBox.Show("Button clicked!");
    };
   }

   Let's take a look at how to handle events using a couple of simple examples. The Timer class (located in the System.Timers namespace) is a class that generates a series of recurring events at regular intervals. You usually use the Timer class to perform some background tasks, such as updating a ProgressBar control when downloading some files from a server, or displaying the current time.
   The Timer class has one important event that you need to handle — Elapsed. The Elapsed event is fired every time a set time interval has elapsed.
   The following program shows how you can use the Timer class to display the current time in the console window:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Runtime.Remoting.Messaging;
   using System.Timers;
 
   namespace Events {
    class Program {
     static void Main(string[] args) {
      Timer t = new Timer(1000);
      t.Elapsed += new ElapsedEventHandler(t_Elapsed);
      t.Start();
      Console.ReadLine();
     }
     static void t_Elapsed(object sender, ElapsedEventArgs e) {
      Console.SetCursorPosition(0, 0);
      Console.WriteLine(DateTime.Now);
     }
    }
   }
   First, you instantiate a Timer class by passing it a value. The value is the time interval (in milliseconds) between the Timer class's firing (raising) of its Elapsed event. You next wire the Elapsed event with the event handler t_Elapsed, which displays the current time in the console window. The Start() method of the Timer class activates the Timer object so that it can start to fire the Elapsed event. Because the event is fired every second, the console is essentially updating the time every second (see Figure 7-8).
   Figure 7-8 
   Another useful class that is available in the .NET Framework class library is the FileSystemWatcher class (located in the System.IO namespace). It watches the file system for changes and enables you to monitor these changes by raising events. For example, you can use the FileSystemWatcher class to monitor your hard drive for changes such as when a file/directory is deleted, is created, or has its contents changed.
   To see how the FileSystemWatcher class works, consider the following program:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Runtime.Remoting.Messaging;
   using System.IO;
 
   namespace Events {
    class Program {
     static void Main(string[] args) {
      FileSystemWatcher fileWatcher = new FileSystemWatcher() {
       Path = @"c:\", Filter = "*.txt"
      };
      //---wire up the event handlers---
      fileWatcher.Deleted += new FileSystemEventHandler(fileWatcher_Deleted);
      fileWatcher.Renamed += new RenamedEventHandler(fileWatcher_Renamed);
      fileWatcher.Changed += new FileSystemEventHandler(fileWatcher_Changed);
      fileWatcher.Created += new FileSystemEventHandler(fileWatcher_Created);
      //---begin watching---
      fileWatcher.EnableRaisingEvents = true;
      Console.ReadLine();
     }
     static void fileWatcher_Created(object sender, FileSystemEventArgs e) {
      Console.WriteLine("File created: " + e.FullPath);
     }
     static void fileWatcher_Changed(object sender, FileSystemEventArgs e) {
      Console.WriteLine("File changed: " + e.FullPath);
     }
     static void fileWatcher_Renamed(object sender, RenamedEventArgs e) {
      Console.WriteLine("File renamed: " + e.FullPath);
     }
     static void fileWatcher_Deleted(object sender, FileSystemEventArgs e) {
      Console.WriteLine("File deleted: " + e.FullPath);
     }
    }
   }
   You first create an instance of the FileSystemWatcher class by initializing its Path and Filter properties:
   FileSystemWatcher fileWatcher = new FileSystemWatcher() {
    Path = @"c:\", Filter = "*.txt"
   };
   Here, you are monitoring the C:\ drive and all its files ending with the .txt extension.
   You then wire all the events with their respective event handlers:
   //---wire up the event handlers---
   fileWatcher.Deleted += new FileSystemEventHandler(fileWatcher_Deleted);
   fileWatcher.Renamed += new RenamedEventHandler(fileWatcher_Renamed);
   fileWatcher.Changed += new FileSystemEventHandler(fileWatcher_Changed);
   fileWatcher.Created += new FileSystemEventHandler(fileWatcher_Created);
   These statements handle four events:
   □ Deleted — Fires when a file is deleted
   □ Renamed — Fires when a file is renamed
   □ Changed — Fires when a file's content is changed
   □ Created — Fires when a file is created
   Finally, you define the event handlers for the four events:
   static void fileWatcher_Created(object sender, FileSystemEventArgs e) {
    Console.WriteLine("File created: " + e.FullPath);
   }
   static void fileWatcher_Changed(object sender, FileSystemEventArgs e) {
    Console.WriteLine("File changed: " + e.FullPath);
   }
   static void fileWatcher_Renamed(object sender, RenamedEventArgs e) {
    Console.WriteLine("File renamed: " + e.FullPath);
   }
   static void fileWatcher_Deleted(object sender, FileSystemEventArgs e) {
    Console.WriteLine("File deleted: " + e.FullPath);
   }
   To test the program, you can create a new text file in C:\drive, make some changes to its content, rename it, and then delete it. The output window will look like Figure 7-9.
   Figure 7-9

   So far you have been subscribing to events by writing event handlers. Now you will implement events in your own class. For this example, you create a class called AlarmClock. AlarmClock allows you to set a particular date and time so that you can be notified (through an event) when the time is up. For this purpose, you use the Timer class.
   First, define the AlarmClock class as follows:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Timers;
 
   class AlarmClock {
   }
   Declare a Timer variable and define the AlarmTime property to allow users of this class to set a date and time:
   class AlarmClock {
    Timer t;
    public DateTime AlarmTime { get; set; }
   }
   Next, define the Start() method so that users can start the monitoring by turning on the Timer object:
   class AlarmClock {
    //...
    public void Start() {
     t.Start();
    }
   }
   Next, define a public event member in the AlarmClock class:
   public event EventHandler TimesUp;
   The EventHandler is a predefined delegate, and this statement defines TimesUp as an event for your class.
   Define a protected virtual method in the AlarmClock class that will be used internally by your class to raise the TimesUp event:
   protected virtual void onTimesUp(EventArgs e) {
    if (TimesUp != null) TimesUp(this, e);
   }
   The EventArgs class is the base class for classes that contain event data. This class does not pass any data back to an event handler.

   The next section explains how you can create another class that derives from this EventArgs base class to pass back information to an event handler.

   Define the constructor for the AlarmClock class so that the Timer object (t) will fire its Elapsed event every 100 milliseconds. In addition, wire the Elapsed event with an event handler. The event handler will check the current time against the time set by the user of the class. If the time equals or exceeds the user's set time, the event handler calls the onTimesUp() method that you defined in the previous step:
   public AlarmClock() {
    t = new Timer(100);
    t.Elapsed += new ElapsedEventHandler(t_Elapsed);
   }
   void t_Elapsed(object sender, ElapsedEventArgs e) {
    if (DateTime.Now >= this.AlarmTime) {
     onTimesUp(new EventArgs());
     t.Stop();
    }
   }
   That's it! The entire AlarmClock class is:
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Timers;
 
   class AlarmClock {
    Timer t;
    public DateTime AlarmTime { get; set; }
    public void Start() {
     t.Start();
    }
    public AlarmClock() {
     t = new Timer(100);
     t.Elapsed += new ElapsedEventHandler(t_Elapsed);
    }
    void t_Elapsed(object sender, ElapsedEventArgs e) {
     if (DateTime.Now >= this.AlarmTime) {
      onTimesUp(new EventArgs());
      t.Stop();
     }
    }
    public event EventHandler TimesUp;
    protected virtual void onTimesUp(EventArgs e) {
     if (TimesUp != null) TimesUp(this, e);
    }
   }
   To use the AlarmClock class, you first create an instance of the AlarmClock class and then set the time for the alarm by using the AlarmTime property. You then wire the TimesUp event with an event handler so that you can print a message when the set time is up:
   class Program {
    static void Main(string[] args) {
     AlarmClock c = new AlarmClock() {
      //---alarm to sound off at 16 May 08, 9.50am---
      AlarmTime = new DateTime(2008, 5, 16, 09, 50, 0, 0),
     };
     c.Start();
     c.TimesUp += new EventHandler(c_TimesUp);
     Console.ReadLine();
    }
    static void c_TimesUp(object sender, EventArgs e) {
     Console.WriteLine("Times up!");
    }
   }

   Events are implemented using delegates, so what is the difference between an event and a delegate? The difference is that for an event you cannot directly assign a delegate to it using the = operator; you must use the += operator. 
   To understand the difference, consider the following class definitions — Class1 and Class2:
   namespace DelegatesVsEvents {
    class Program {
     static void Main(string[] args) {}
    }
    class Class1 {
     public delegate void Class1Delegate();
     public Class1Delegate del;
    }
    class Class2 {
     public delegate void Class2Delegate();
     public event Class2Delegate evt;
    }
   }
   In this code, Class1 exposes a public delegate del, of type Class1Delegate. Class2 is similar to Class1, except that it exposes an event evt, of type Class2Delegate. del and evt each expect a delegate, with the exception that evt is prefixed with the event keyword.
   To use Class1, you create an instance of Class1 and then assign a delegate to the del delegate using the "=" operator:
   static void Main(string[] args) {
    //---create a delegate---
    Class1.Class1Delegate d1 =
     new Class1.Class1Delegate(DoSomething);
    Class1 c1 = new Class1();
    //---assign a delegate to del of c1---
    c1.del = new Class1.Class1Delegate(d1);
   }
   static private void DoSomething() {
    //...
   }
   To use Class2, you create an instance of Class2 and then assign a delegate to the evt event using the += operator:
   static void Main(string[] args) {
    //...
    //---create a delegate---
    Class2.Class2Delegate e2 =
     new Class2.Class2Delegate(DoSomething);
    Class2 c2 = new Class2();
    //---assign a delegate to evt of c2---
    c2.evt += new Class2.Class2Delegate(d1);
   }
   If you try to use the = operator to assign a delegate to the evt event, you will get a compilation error:
   c2.evt = new Class2.Class2Delegate(d1); //---error---
   This important restriction of event is important because defining a delegate as an event will ensure that if multiple clients are subscribed to an event, another client will not be able to set the delegate to null (or simply set it to another delegate). If the client succeeds in doing so, all the other delegates set by other client will be lost. Hence, a delegate defined as an event can only be set with the += operator.

   In the preceding program, you simply raise an event in the AlarmClock class; there is no passing of information from the class back to the event handler. To pass information from an event back to an event handler, you need to implement your own class that derives from the EventArgs base class.
   In this section, you modify the previous program so that when the set time is up, the event passes a message back to the event handler. The message is set when you instantiate the AlarmClock class.
   First, define the AlarmClockEventArgs class that will allow the event to pass back a string to the event handler. This class must derive from the EventArgs base class:
   public class AlarmClockEventArgs : EventArgs {
    public AlarmClockEventArgs(string Message) {
     this.Message = Message;
    }
    public string Message { get; set; }
   }
   Next, define a delegate called AlarmClockEventHandler with the following signature:
   public delegate void AlarmClockEventHandler(object sender, AlarmClockEventArgs e);
   Replace the original TimesUp event statement with the following statement, which uses the AlarmClockEventHandler class:
   //---public event EventHandler TimesUp;---
   public event AlarmClockEventHandler TimesUp;
   Add a Message property to the class so that users of this class can set a message that will be returned by the event when the time is up:
   public string Message { get; set; }
   Modify the onTimesUp virtual method by changing its parameter type to the new AlarmClockEventArgs class:
   protected virtual void onTimesUp(AlarmClockEventArgs e) {
    if (TimesUp != null) TimesUp(this, e);
   }
   Finally, modify the t_Elapsed event handler so that when you now call the onTimesUp() method, you pass in an instance of the AlarmClockEventArgs class containing the message you want to pass back to the event handler:
   void t_Elapsed(object sender, ElapsedEventArgs e) {
    if (DateTime.Now >= this.AlarmTime) {
     onTimesUp(new AlarmClockEventArgs(this.Message));
     t.Stop();
    }
   }
   Here's the complete program: using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Timers;
 
   public class AlarmClockEventArgs : EventArgs {
    public AlarmClockEventArgs(string Message) {
     this.Message = Message;
    }
    public string Message { get; set; }
   }
 
   public delegate void AlarmClockEventHandler(object sender, AlarmClockEventArgs e);
 
   class AlarmClock {
    Timer t;
    public event AlarmClockEventHandler TimesUp;
    protected virtual void onTimesUp(AlarmClockEventArgs e) {
     if (TimesUp != null) TimesUp(this, e);
    }
    public DateTime AlarmTime { get; set; }
    public string Message { get; set; }
    public AlarmClock() {
     t = new Timer(100);
     t.Elapsed += new ElapsedEventHandler(t_Elapsed);
    }
    public void Start() {
     t.Start();
    }
    void t_Elapsed(object sender, ElapsedEventArgs e) {
     if (DateTime.Now >= this.AlarmTime) {
      onTimesUp(new AlarmClockEventArgs(this.Message));
      t.Stop();
     }
    }
   }
   With the modified AlarmClock class, your program will now look like this:
   namespace Events {
    class Program {
     static void c_TimesUp(object sender, AlarmClockEventArgs e) {
      Console.WriteLine(DateTime.Now.ToShortTimeString() + ": " + e.Message);
     }
     static void Main(string[] args) {
      AlarmClock c = new AlarmClock() {
       //---alarm to sound off at 16 May 08, 9.50am---
       AlarmTime = new DateTime(2008, 5, 16, 09, 50, 0, 0),
       Message = "Meeting with customer."
      };
      c.TimesUp += new AlarmClockEventHandler(c_TimesUp);
      c.Start();
      Console.ReadLine();
     }
    }
   }
   Figure 7-10 shows the output when the AlarmClock fires the TimesUp event.
   Figure 7-10

   The .NET Framework contains the System.String class for string manipulation. To create an instance of the String class and assign it a string, you can use the following statements:
   String str1;
   str1 = "This is a string";
   C# also provides an alias to the String class: string (lowercase "s"). The preceding statements can be rewritten as:
   string str1; //---equivalent to String str1;---
   str1 = "This is a string";
   You can declare a string and assign it a value in one statement, like this:
   string str2 = "This is another string";
   In .NET, a string is a reference type but behaves very much like a value type. Consider the following example of a typical reference type:
   Button btn1 = new Button() { Text = "Button 1" };
   Button btn2 = btn1;
   btn1.Text += " and 2"; //---btn1.text is now "Button 1 and 2"---
   Console.WriteLine(btn1.Text); //---Button 1 and 2---
   Console.WriteLine(btn2.Text); //---Button 1 and 2---
   Here, you create an instance of a Button object (btn1) and then assign it to another variable (btn2). Both btn1 and btn2 are now pointing to the same object, and hence when you modify the Text property of btn1, the changes can be seen in btn2 (as is evident in the output of the WriteLine() statements).
   Because strings are reference types, you would expect to see the same behavior as exhibited in the preceding block of code. For example:
   string str1 = "String 1";
   string str2 = str1;
   str1 and str2 should now be pointing to the same instance. Make some changes to str1 by appending some text to it:
   str1 += " and some other stuff";
   And then print out the value of these two strings:
   Console.WriteLine(str1); //---String 1 and some other stuff---
   Console.WriteLine(str2); //---String 1---
   Are you surprised to see that the values of the two strings are different? What actually happens when you do the string assignment (string str2 = str1) is that str1 is copied to str2 (str2 holds a copy of str1; it does not points to it). Hence, changes made to str1 are not reflected in str2.

   A string cannot be a value type because of its unfixed size. All values types (int, double, and so on) have fixed size.

   A string is essentially a collection of Unicode characters. The following statements show how you enumerate a string as a collection of char and print out the individual characters to the console:
   string str1 = "This is a string";
   foreach (char c in str1) {
    Console.WriteLine(c);
   }
   Here's this code's output:
   T
   h
   i
   s
 
   i
   s
 
   a
 
   s
   t
   r
   i
   n
   g

   Certain characters have special meaning in strings. For example, strings are always enclosed in double quotation marks, and if you want to use the actual double-quote character in the string, you need to tell the C# compiler by "escaping" the character's special meaning. For instance, say you need to represent the following in a string:
   "I don't necessarily agree with everything I say." Marshall McLuhan
   Because the sentence contains the double-quote characters, simply using a pair of double- quotes to contain it will cause an error:
   //---error--- string quotation;
   quotation = ""I don't necessarily agree with everything I say." Marshall McLuhan";
   To represent the double-quote character in a string, you use the backslash (\) character to turn off its special meanings, like this:
   string quotation =
    "\"I don't necessarily agree with everything I say.\" Marshall McLuhan";
   Console.WriteLine(quotation);
   The output is shown in Figure 8-1.
   Figure 8-1
   A backslash, then, is another special character. To represent the C:\Windows path, for example, you need to turn off the special meaning of \ by using another \ , like this:
   string path = "C:\\Windows";
   What if you really need two backslash characters in your string, as in the following?
   "\\servername\path"
   In that case, you use the backslash character twice, once for each of the backslash characters you want to turn off, like this:
   string UNC = "\\\\servername\\path";
   In addition to using the \ character to turn off the special meaning of characters like the double-quote (") and backslash (\), there are other escape characters that you can use in strings.
   One common escape character is the \n. Here's an example:
   string lines = "Line 1\nLine 2\nLine 3\nLine 4\nLine 5";
   Console.WriteLine(lines);
   The \n escape character creates a newline, as Figure 8-2 shows.
   Figure 8-2
   You can also use \t to insert tabs into your string, as the following example shows (see also Figure 8-3):
   string columns1 = "Column 1\tColumn 2\tColumn 3\tColumn 4";
   string columns2 = "1\t5\t25\t125";
   Console.WriteLine(columns1);
   Console.WriteLine(columns2);
   Figure 8-3

   You learn more about formatting options in the section "String Formatting" later in this chapter.

   Besides the \n and \t escape characters, C# also supports the \r escape character. \r is the carriage return character. Consider the following example:
   string str1 = "       One";
   string str2 = "Two";
   Console.Write(str1);
   Console.Write(str2);
   The output is shown in Figure 8-4.
   Figure 8-4 
   However, if you prefix a \r escape character to the beginning of str2, the effect will be different:
   string str1 = "       One";
   string str2 = "\rTwo";
   Console.Write(str1);
   Console.Write(str2);
   The output is shown in Figure 8-5.
   Figure 8-5
   The \r escape character simply brings the cursor to the beginning of the line, and hence in the above statements the word "Two" is printed at the beginning of the line. The \r escape character is often used together with \n to form a new line (see Figure 8-6):
   string str1 = "Line 1\n\r";
   string str2 = "Line 2\n\r";
   Console.Write(str1);
   Console.Write(str2);
   Figure 8-6

   By default, when you use the \n to insert a new line, the cursor is automatically returned to the beginning of the line. However, some legacy applications still require you to insert newline and carriage return characters in strings.

   The following table summarizes the different escape sequences you have seen in this section:

Sequence	Purpose
\n	New line
\r	Carriage return
\r\n	Carriage return; New line
\"	Quotation marks
\\	Backslash character
\t	Tab

   In C#, strings can also be @-quoted. Earlier, you saw that to include special characters (such as double-quote, backslash, and so on) in a string you need to use the backslash character to turn off its special meaning:
   string path="C:\\Windows";
   You can actually use the @ character, and prefix the string with it, like this:
   string path=@"C:\Windows";
   Using the @ character makes your string easier to read. Basically, the compiler treats strings that are prefixed with the @ character verbatim — that is, it just accepts all the characters in the string (inside the quotes). To better appreciate this, consider the following example where a string containing an XML snippet is split across multiple lines (with each line ending with a carriage return):
   string XML = @"
    <Books>
     <title>C# 3.0 Programmers' Reference</title>
    </Book>";
   Console.WriteLine(XML);
   Figure 8-7 shows the output. The WriteLine() method prints out the line verbatim.
   Figure 8-7
   To illustrate the use of the @ character on a double-quoted string, the following:
   string quotation =
    "\"I don't necessarily agree with everything I say.\" Marshall McLuhan";
   Console.WriteLine(quotation);
   can be rewritten as:
   string quotation =
    @"""I don't necessarily agree with everything I say."" Marshall McLuhan";
   Console.WriteLine(quotation);

Escape Code for Unicode

   C# supports the use of escape code to represent Unicode characters. The four-digit escape code format is: \udddd. For example, the following statement prints out the £ symbol:
   string symbol = "\u00A3";
   Console.WriteLine(symbol);
   For more information on Unicode, check out http://unicode.org/Public/UNIDATA/NamesList.txt.