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. Figure 2-10

To customize the items displayed in the Menu bar, select Tools

Figure 2.11. 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. Figure 2-12

The Toolbar (see Figure 2-13) contains shortcuts to many of the often used commands contained in the Menu bar.

Figure 2.13. 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. Figure 2-14

To customize the Toolbar, select Tools

Figure 2.15. 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 Toolsv

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. Figure 2-17

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. 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. 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. Figure 2-20

You can add the following types of controls to the Toolbox:

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. 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. Figure 2-22

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. Figure 2-23

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. 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. 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. 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. Figure 2-27

Then when you press F5, the projects configured to start launch at the same time.

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. 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. Figure 2-29

The Error List window (see Figure 2-30) is used to display:

Figure 2.30. Figure 2-30

To display the Error List window, select View

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.

The Output window (View

Console.WriteLine(DateTime.Now.ToString());

Figure 2-31 shows the message displayed in the Output window.

Figure 2.31. Figure 2-31

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).

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.32. Figure 2-32

Figure 2.33. Figure 2-33

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. 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-35

Figure 2-36 shows the code view and design view displaying horizontally.

Figure 2.36. Figure 2-36

Figure 2-37 shows the code view and design view displaying vertically.

Figure 2.37. Figure 2-37

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

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. Figure 2-45

You can preview the change (see Figure 2-46) before it is applied to your code.

Figure 2.46. Figure 2-46

Click the Apply button to change the variable name.

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

Figure 2.47. 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. 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. Figure 2-49

Here are some observations:

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

Figure 2.50. Figure 2-50

You can then rearrange the order of the parameter list (see Figure 2-51).

Figure 2.51. Figure 2-51

Click OK. You can preview the changes before they are made (see Figure 2-52).

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

Figure 2.53. Figure 2-53

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

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. Figure 2-55

After you've previewed the changes (see Figure 2-56), click Apply to effect the change.

Figure 2.56. 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)
        {
           //...
        }
    }
}

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

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. 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
        ...

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

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);
        }