The simplest feature of IntelliSense gives you immediate feedback about bad code in your code listings. Figure 7-1 shows one such example, in which an unknown data type is used to instantiate an object. Because the data type is unknown where this code appears, Visual Studio draws a red (C#) or blue (VB) wavy line underneath to indicate a problem.

Figure 7-1. Figure 7-1

Hovering the mouse over the offending piece of code displays a tooltip to explain the problem. In this example the cursor was placed over the data type, with the resulting tooltip "The type or namespace name 'Customer' could not be found."

Visual Studio is able to look for this kind of error by continually precompiling the code you write in the background, and looking for anything that will produce a compilation error. If you were to add the Customer class to your project, Visual Studio would automatically process this and remove the IntelliSense marker.

Figure 7-2 displays the smart tag associated with the error. This applies only to errors for which Visual Studio 2010 can offer you corrective actions. Just below the problem code, a small blue (C#) or red (VB) rectangle is displayed. Placing the mouse cursor over this marker displays the smart tag action menu associated with the type of error — in this case the action menu provides options for generating your Customer class from what Visual Studio is able to determine from the way you have used it.

Figure 7-2. Figure 7-2

The smart tag technology found in Visual Studio is not solely reserved for the code window. In fact, Visual Studio 2010 also includes smart tags on visual components when you are editing a form or user control in Design view (see Figure 7-3).

Figure 7-3. Figure 7-3

When you select a control that has a smart tag, a small triangle appears at the top-right corner of the control itself. Click this button to open the smart tag Tasks list — Figure 7-3 shows the Tasks list for a standard TextBox control.

The power of IntelliSense in Visual Studio 2010 becomes apparent as soon as you start writing code. As you type, various drop-down lists are displayed to help you choose valid members, functions, and parameter types, thus reducing the number of potential compilation errors before you even finish writing your code. Once you become familiar with the IntelliSense behavior, you'll notice that it can greatly reduce the amount of code you actually have to write. This can be a significant savings to developers using more verbose languages such as Visual Basic.

In Context

In Visual Studio 2010, IntelliSense appears almost as soon as you begin to type within the code window. Figure 7-4 illustrates the IntelliSense displayed during the creation of a For loop in Visual Basic. On the left side of the image, IntelliSense appeared as soon as the f was entered, and the list of available words progressively shrank as each subsequent key was pressed. As you can see, the list is made up of all the alternatives, whether they be statements, classes, methods, or properties, that match the letters entered (in this case those containing the word For).

Figure 7-4. Figure 7-4

Notice the difference in the right-hand image of Figure 7-4, where a space has been entered after the word for. Now the IntelliSense list has expanded to include all the alternatives that could be entered at this position in the code. In addition, there is a tooltip that indicates the syntax of the For statement. Lastly, there is a <new variable> item just above the IntelliSense list. This is to indicate that it's possible for you to specify a new variable at this location.

Note

The <new variable> item appears only for Visual Basic users.

Although it can be useful that the IntelliSense list is reduced based on the letters you enter, this feature is a double-edged sword. Quite often you will be looking for a variable or member but won't quite remember what it is called. In this scenario, you might enter the first couple of letters of a guess and then use the scrollbar to locate the right alternative. Clearly, this won't work if the letters you have entered have already eliminated the alternative. To bring up the full list of alternatives, simply hit the Backspace key with the IntelliSense list visible.

In previous versions of Visual Studio, IntelliSense has only been able to help you find members that began with the same characters that you typed into the editor. In Visual Studio 2010 this is no longer true. Now it is possible to find words that appear in the middle of member names as well. It does this by looking for word boundaries within the member names. Figure 7-5 shows an example in C# where typing Console.in will find In, InputEncoding, OpenStandardInput, SetIn, and TreatControlCAsInput but does not find LargestWindowHeight despite the fact that it contains the substring "in."

Figure 7-5. Figure 7-5

Note

If you know exactly what you are looking for, you can save even more keystrokes by typing the first character of each word in uppercase. As an example, if you type System.Console.OSI, then OpenStandardInput will be selected by IntelliSense.

If you find that the IntelliSense information is obscuring other lines of code, or you simply want to hide the list, you can press Esc. Alternatively, if you simply want to view what is hidden behind the IntelliSense list without closing it completely, you can hold down the Ctrl key. This makes the IntelliSense list translucent, enabling you to read the code behind it, as shown in Figure 7-6.

Figure 7-6. Figure 7-6

The IntelliSense list is not just for informational purposes. You can select an item from this list and have Visual Studio actually insert the full text into the editor window for you. You have a number of ways to select an item from the list. You can double-click the desired item with the mouse; you can use the arrow keys to change which item is highlighted and then press the Enter or Tab keys to insert the text; and finally, when an item is highlighted in the list it will automatically be selected if you enter a commit character. Commit characters are those that are not normally allowed within member names. Examples include parentheses, braces, mathematical symbols, and semicolons.

List Members

Because IntelliSense has been around for so long, most developers will be familiar with the member list that appears when you type the name of an object and immediately follow it by a period. This indicates that you are going to refer to a member of the object, and Visual Studio automatically displays a list of members available to you for that object (see Figure 7-7). If this is the first time you've accessed the member list for a particular object, Visual Studio simply shows the member list in alphabetical order with the top of the list visible. However, if you've used it before, it highlights the last member you accessed to speed up the process for repetitive coding tasks.

Figure 7-7 also shows another helpful aspect of the member list for Visual Basic programmers. The Common and All tabs (at the bottom of the member list) enable you to view either just the commonly used members or a comprehensive list.

Figure 7-7. Figure 7-7

Note

Only Visual Basic gives you the option to filter the member list down to commonly accessed properties, methods, and events.

Suggestion Mode

By default, when Visual Studio 2010 shows the IntelliSense member list, one member is selected and as you type, the selection is moved to the item in the list that best matches the characters entered. If you press Enter, Space, or type one of the commit characters (such as an open parenthesis), the currently selected member is inserted into the editor window. This default behavior is known as "completion mode."

In most cases completion mode provides the desired behavior and can save you a great deal of typing, but it can be problematic for some activities. One such activity is test-driven development where references are frequently made to members that have not yet been defined. This causes IntelliSense to select members that you didn't intend it to and insert text that you do not want.

To avoid this issue Microsoft has introduced a new IntelliSense mode into Visual Studio 2010 called suggestion mode. When IntelliSense is in suggestion mode one member in the list will have focus but will not be selected by default. As you type, IntelliSense moves the focus indicator to the item that most closely matches the characters you typed, but it will not automatically select it. Instead, the characters that you type are added to the top of the IntelliSense list and if you type one of the commit characters or press Space or Enter, the exact string that you typed is inserted into the editor window.

Note

You can still make a selection from the IntelliSense list by using the arrow keys. Also, you can select the item that has focus in the member list by pressing the Tab key.

Figure 7-8 shows an example of the problem that suggestion mode is designed to address. On the left-hand side we are writing a test for a new method called Load on the CustomerData class. The CustomerData class does not have a method called Load yet but it does have a method called LoadAll.

On the right-hand side of Figure 7-8 we have typed Load followed by the open parenthesis character. IntelliSense has incorrectly assumed that we wanted the LoadAll method and has inserted it into the editor.

Figure 7-8. Figure 7-8

To avoid this behavior we can turn on suggestion mode by pressing Ctrl+Alt+Space. Now when we type Load it appears at the top of the IntelliSense list. When we type the open parenthesis character we get Load as originally intended (see Figure 7-9).

Figure 7-9. Figure 7-9

Note

IntelliSense remains in suggestion mode until you press Ctrl+Alt+Space again to revert back to completion mode.

Generate From Usage

Rather than generating code from a definition that already exists, sometimes it is more convenient to generate the definition of a code element from the way you have used it. This is especially true if you practice test-driven development where you write tests for classes that have not been defined yet. It would be convenient to be able to generate the classes from the tests themselves and this is the purpose of the Generate From Usage feature in C# and Visual Basic.

To understand how you might use this in practice, the following steps outline the creation of a very simple Customer class by writing some client code that uses it and then generating the class from that usage:

1. Start Visual Studio 2010 and create a C# Command Line project. When the IDE is ready open the Program.cs file.

2. Update the Main method with the following code:

   C#

   Customer c = new Customer
   {
     FirstName = "Joe",
     LastName = "Smith"
   };
   
   Console.WriteLine(c.FullName);
   c.Save();

3. You should see a red wiggly line underneath both instances of the class name Customer. Right-click one of them and select Generate

   

4. For each property that does not exist, right-click it and select Generate

   

5. You can do the same for the Save method by right-clicking and selecting Generate

   

Note

Though generated properties and classes can be used straight away, method stubs are generated to throw a NotImplementedException.

Figure 7-13. Figure 7-13

If the undefined code that you are trying to generate is a type, you will have the option to Generate Class or Generate Other. If you select Generate Other, the Generate New Type dialog is shown (see Figure 7-13). This dialog gives you more options to configure your new type including whether you want a class, enumeration, interface, or structure; whether the new type should be public, private, or internal; and where the new type should go.

In old versions of Microsoft development tools, such as Visual Basic 6, as you created the call to a function, IntelliSense would display the parameter information as you typed. Thankfully, this incredibly useful feature is still present in Visual Studio 2010.

The problem with the old way parameter information was displayed was that it would only be shown if you were actually modifying the function call. Therefore, you could see this helpful tooltip as you created the function call or when you changed it but not if you were just viewing the code. The result was that programmers sometimes inadvertently introduced bugs into their code because they intentionally modified function calls so they could view the parameter information associated with the calls.

Visual Studio 2010 eliminates that risk by providing an easily accessible command to display the information without modifying the code. The keyboard shortcut Ctrl+Shift+Space displays the information about the function call, as displayed in Figure 7-14. You can also access this information through the Edit

Figure 7-14. Figure 7-14

In a similar vein, sometimes you want to see the information about an object or interface without modifying the code. The Ctrl+K, Ctrl+I keyboard shortcut displays a brief tooltip explaining what the object is and how it was declared (see Figure 7-15).

You can also display this tooltip through the Edit

Figure 7-15. Figure 7-15

To prevent you from accidentally referring to JavaScript elements that are not available, Visual Studio 2010 builds up an "IntelliSense context" based on the location of the JavaScript block that you are editing. The context is made up of the following items:

Note

Visual Studio keeps track of files in the context and updates JavaScript IntelliSense whenever one of them changes. Sometimes this update may be pending and the JavaScript IntelliSense data will be out of date. You can force Visual Studio to update the JavaScript IntelliSense data by selecting Edit

Occasionally something will go wrong and Visual Studio will be unable to build a JavaScript IntelliSense context. Often, though, Visual Studio will be able to determine what caused the error and provide you with feedback that you can use to correct the issue. In Figure 7-16, Visual Studio has detected that we have made a reference to a JavaScript file that does not exist. When you add the file to the project, Visual Studio will detect its presence and remove the error indicator and error message. Although this error detection normally happens as a background process you can force Visual Studio to check a page by selecting Edit

Figure 7-16. Figure 7-16

Sometimes one JavaScript file builds upon the base functionality of another. When this happens they are usually referenced together by any page using them but have no direct reference explicitly defined. Because there is no explicit reference, Visual Studio 2010 is unable to add the file with the base functionality to the JavaScript IntelliSense context and you won't get full IntelliSense support.

To allow Visual Studio to discover the base file and add it to the context you can provide a reference to it by using a references directive. A references directive is a special kind of comment that provides information about the location of another file. You can use references directives to make a reference to any of the following:

Following are some examples of references directives. These must appear before any other code in your JavaScript file.

JavaScript

// JavaScript file in current folder
/// <reference path="Toolbox.js" />

// JavaScript file in parent folder
/// <reference path="../Toolbox.js" />

// JavaScript file in a path relative to the root folder of the site
/// <reference path="~/Scripts/Toolbox.js" />

// JavaScript file embedded in Assembly
/// <reference name="Ajax.js" path="System.Web.Extensions, ..." />

// Web Service file
/// <reference path="MyService.asmx" />

// Standard Page
/// <reference path="Default.aspx" />

The first options to look at are in the Environment section under the Keyboard group. Every command available in Visual Studio has a very specific entry in the keyboard mapping list (see the Options dialog shown in Figure 7-17, accessible via Tools

Figure 7-17. Figure 7-17

You can override the predefined keyboard shortcuts or add additional ones. The commands for the IntelliSense features are shown in Table 7-1.

Use the techniques discussed in Chapter 3 to add additional keyboard shortcuts to any of these commands.

You can control how IntelliSense works on a global language scale (see Figure 7-18) or per individual language. In the General tab of the language group in the Options dialog, you want to change the Statement Completion options to control how member lists should be displayed, if at all.

Figure 7-18. Figure 7-18

Besides the general IDE and language options for IntelliSense, some languages, such as C#, provide an additional IntelliSense tab in their own sets of options. Displayed in Figure 7-19, the IntelliSense for C# can be further customized to fine-tune how the IntelliSense features should be invoked and used.

First, you can turn off completion lists so they do not appear automatically, as discussed earlier in this chapter. Some developers prefer this because the member lists don't get in the way of their code listings. If the completion list is not to be automatically displayed, but instead only shown when you manually invoke it, you can choose what is to be included in the lists in addition to the normal entries, including keywords and code snippet shortcuts.

Figure 7-19. Figure 7-19

To select an entry in a member list, you can use any of the characters shown in the Selection In Completion List section, or optionally after the spacebar is pressed. Finally, as mentioned previously, Visual Studio automatically highlights the member in a list that was last used. You can turn this feature off for C# or just clear the history.

Code snippets are sections of code that can be automatically generated and pasted into your own code, including associated references and using statements, with variable phrases marked for easy replacement. To invoke the Code Snippets dialog, press Ctrl+K, Ctrl+X. Navigate the hierarchy of snippet folders (shown in Figure 7-20) until you find the one you need. If you know the shortcut for the snippet, you can simply type it and press Tab, and Visual Studio invokes the snippet without displaying the dialog. In Chapter 8, you see just how powerful code snippets are.

Figure 7-20. Figure 7-20

XML comments are described in Chapter 12 as a way of providing automated documentation for your projects and solutions. However, another advantage of using XML commenting in your program code is that Visual Studio can use it in its IntelliSense engine to display tooltips and parameter information beyond the simple variable-type information you see in normal user-defined classes.

You can also add your own IntelliSense schemas, normally useful for XML and HTML editing, by creating a correctly formatted XML file and installing it into the Common7Packagesschemasxml subfolder inside your Visual Studio installation directory (the default location is C:Program FilesMicrosoft Visual Studio 10.0). An example of this would be extending IntelliSense support for the XML editor to include your own schema definitions. The creation of such a schema file is beyond the scope of this book, but you can find schema files on the Internet by searching for "IntelliSense schema in Visual Studio."