Every developer that has used Visual Studio has become dependent on IntelliSense. When it is gone, you really notice how much you take it for granted and you find how dependent you really have become on it. Well, as great as IntelliSense is, in Visual Studio 2010 it just got better. The addition of partial string matching allows IntelliSense to more intelligently display entries based on what the developer has typed. For example, if the developer types OC, IntelliSense will display entries such as ObservableCollection, as shown in Figure 2-3, (notice OC are the capital letters of the Pascal-Cased object). In addition, if you type "collect", ObservableCollection will also appear since build is contained in the object name.

Figure 2.3. Improved IntelliSense in Visual Studio 2010

In addition to the partial string matching, the performance of IntelliSense has been dramatically improved. This allows developers to code without delays in IntelliSense and keep their rolls rolling.

In Visual Studio 2008 and previous versions, developers have noticed that when you open the Add Reference dialog (see Figure 2-4), it takes quite a bit of time for it to full display the listing of components, especially for the COM components. In Visual Studio 2010, the Add Reference dialog has undergone many performance improvements, which will help prevent developers form having to wait on the Visual Studio IDE.

Figure 2.4. Add Reference dialog

When you click anywhere within a symbol (class name, variable, object, field, etc), all instances of that item are highlighted throughout the current document, as shown in Figure 2-5. This is not a simple text matching; the editor is smart enough to understand the scope of the different variables. So even if you have two items with identical names that belong to different objects, they are not both highlighted.

You can easily navigate between the different highlighted instances as well by pressing Ctrl-Shift-Up to move to the next instance, or Ctrl-Shift-Down to move to the previous instance.

Figure 2.5. Highlight references

Another cool feature of Visual Studio 2010 is box selection. Consider the situation where you would have the following source:

public string Nickname { get; set; }
public string Notes { get; set; }
public string Card1 { get; set; }
public string Card2 { get; set; }

Let's say that you wanted to change all of these to be private properties instead of public. In Visual Studio 2010 you can hold down the Alt key and drag a box around just the public declarations, as shown in Figure 2-6.

Figure 2.6. Box selection in Visual Studio 2010

Better yet, once you have this box selected you can edit all of the lines at once. So with the selection made, simply type private and it will automatically replace the public in each of the lines, as shown in Figure 2-7.

Figure 2.7. Editing a box selection in Visual Studio 2010

The Call Hierarchy window displays two lists regarding a given member: First all calls to the member (incoming) and all calls from the member (outgoing). Within each of those lists, you can then drill into each member and see its incoming and outgoing calls, forming a very useful call hierarchy.

To open the Call Hierarchy window, simply right-click on any method, property, or constructor and select View Call Hierarchy. An example of the Call Hierarchy window is shown in Figure 2-8.

Figure 2.8. Call Hierarchy window

Visual Studio 2008 introduced the ability to generate a method stub from a given call in the source. Consider the following line of code calling the method SomeMethod that did not exist, and passing it an integer and a string:

Person.NewMethod(123, "Bob");

If you type this, Visual Studio will provide you with the option to Generate method stub for 'NewMethod'. By selecting this, Visual Studio will automatically create the following method stub in the Person class:

class Person
{
    internal static void NewMethod(int p, string p_2)
    {
        throw new NotImplementedException();
    }
}

Visual Studio 2010 expands on this code generation functionality by now allowing you to automatically generate classes, structs, and enumerations.

A Visual Studio web site is nothing more than a group of files and folders in a folder. There is no project file. Instead, the site simply contains all the files under the specific folder, including all text files, images, and other file types.

A Visual Studio web site is compiled dynamically at runtime. An assembly will not be created, and you won't have a bin directory.

The following are some advantages of using a Visual Studio web site:

The following are some disadvantages of this approach:

A Visual Studio web application project is the more traditional type of web project used prior to Visual Studio 2005. When Microsoft developers introduced the "web site" concept, they did not take into account the many developers who were comfortable with the project-based solution approach. To accommodate those developers, Microsoft announced the Visual Studio 2005 Web Application project as an add-on to Visual Studio 2005. In Visual Studio 2008 and 2010, this project type is once again a part of Visual Studio.

The following are some of the advantages of using a Web Application project:

A disadvantage is that it can be more difficult to share your solution with others, if that is your intent.

In the end, both approaches have their pros and cons. You need to determine which one is more suitable for your application, depending on your specific purpose and goals. For more information about these project types, refer to the MSDN documentation.