The Environment section is where you begin in the Options dialog box. Sections here include the font details of code-editing screens, key mappings, and the RSS feed settings for the Start page.

The Font and Colors settings will probably be of interest only when you need them for a presentation. Sixteen points is the size of choice for most speakers, including myself. There are a number of "code friendly" fonts out there, and this is where you select them.

By language, I don't mean the Internationalization setting that enables you to change the display language of Visual Studio if you have additional language packs installed (although that is neat). I am talking about the programming languages you work in with Visual Studio. The Languages option is where you can provide settings for each of these programming languages.

The Text Editor options change the way the Code Editor behaves. All the languages that Visual Studio supports out of the box appear in the tree view under the main heading and allow you to alter general options, tabbing, formatting, sometimes advanced options, and miscellaneous features of the text editor.

For instance, look at C#. To open the C# view, click where it says C# with the little triangle in the Options tree view (that's a WPF tree view — you'll get used to it). The first view in the Options panel is the General view. Here you can change the default options for statement completion, various behavior settings, and what the Code Editor should display aside from the code.

After you click the little triangle next to the C# node, you see the General panel (which is the default view) and then the other panels you can use:

I provide a canonical list of the options that I always forget are in here, but that I have to use frequently. Right now, they probably won't make a lot of sense, but you may remember them when you need them later.

You can use a snippet in a few different ways, most of which are somewhat slow. The fastest way is through the use of key commands. To use a snippet this way, type its shortcut code and press Tab twice. For instance, try these steps:

Figure 3-2. The automatically generated property snippet.

You can get to a snippet in other ways, including this one:

After they're inserted, populating the variables works just like the shortcut version.

Surround snippets are very cool. Have you ever written a few lines of code, and then realized that you should probably try and catch errors? You have to add a little code at the beginning, and then add a little code at the end, and then make sure the middle is in the right place. It's a pain.

Surround snippets are designed to solve that problem. They are normal snippets with a bit of logic in them that says "This part goes above the selection, and this part goes below the selection." If you want to handle errors for a section, you highlight that section, and the snippet will put the try before the selection and the catch at the end. To use a surround snippet, follow these steps:

The snippet will appear appropriately above and below the selected text. For instance, if I had this chunk of code:

for (int loopcounter = 1; loopcounter <= 10; loopcounter++)
{
     Console.WriteLine(string.Format("The number is {0}.",
   loopcounter));
}

and I felt that I needed a try ... catch block around it, I could highlight that code and do the preceding steps. If I select try from the menu, I will get this:

try
{
    for (int loopcounter = 1; loopcounter <= 10;
   loopcounter++)
    {
        Console.WriteLine(string.Format("The number is {0}.",
   loopcounter));
    }
}
catch (Exception)
{
     throw;
}

Exception is highlighted in green; I can tab to that and add the exception type I am expecting. It's a slick system.

Snippets are XML files that follow a format understood by Visual Studio. They include a Header and Snippet element. The Header includes a title, which is how the snippet is referred. The Snippet element, where all the work is done, includes a Code element, which has the code to be inserted.

The best way to make a new snippet is to modify an existing one. Snippets can be found in your Visual Studio install directory, which should be C:Program Files (x86)Microsoft Visual Studio 10.0VC#Snippets1033 if you are on a 64-bit operating system (otherwise you can drop the x86).

In the folder referenced in the preceding paragraph, let's look at a simple example: cw.snippet is a Console.Writeline command. Right-click the file to open it. Here's the code:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
   <CodeSnippet Format="1.0.0">
    <Header>
         <Title>cw</Title>
         <Shortcut>cw</Shortcut>
         <Description>Code snippet for Console.WriteLine</Description>
         <Author>Microsoft Corporation</Author>
         <SnippetTypes>
            <SnippetType>Expansion</SnippetType>
         </SnippetTypes>
      </Header>
      <Snippet>
         <Declarations>
            <Literal Editable="false">
               <ID>SystemConsole</ID>
               <Function>SimpleTypeName(global::System.Console)</Function>
            </Literal>
         </Declarations>
         <Code Language="csharp">
            <![CDATA[$SystemConsole$.WriteLine($end$);]]>
         </Code>
      </Snippet>
   </CodeSnippet>
</CodeSnippets>

This list describes what's in the Header element:

The Snippet element is where the work is done. In the cw.snippet example there are two elements in Snippet: Declarations and Code. Declarations declares the variables, and Code is what gets inserted. Within these, these statements are true:

To deploy a snippet of your own, use the Code Snippets Manager. The manager is found on the Tools menu and looks like the one shown in Figure 3-3.

Figure 3-3. The Code Snippets Manager.

Adding a new snippet this way is fairly simple. After you create your snippets file, click the Import button, and select the .snippet file. It's placed in the selected folder, so make sure you have the snippet folder highlighted.

The Add and Remove buttons in the Manager refer to directories, not files. Use them to make new snippet folders. The Search Online feature just searches Help for IntelliSense Code Snippets.

Sharing a snippet is a more complicated act than it should be. One would think that you could just create a .snippet file, send it to someone, and that would be that. It isn't so.

I should amend that — it is so if you are just sending it to a friend — then it is just a matter of using the Manager. On the other hand, if you are making a package of snippets for a group to install, you get to the nitty-gritty.

A snippet sharing escapade has three components:

The first, most obvious target for hacking are the project types because they are text based and have a lot of useful information in them. Found in the IDE folder referenced in the preceding paragraph, the ProjectTemplates folder follows the hierarchy of the New Project tree view. (See Figure 3-4.)

Figure 3-4. A bunch of project-type Zips.

I focus on the CSharp directory tree because this book is about C#. To keep examples to a minimum, open the Windows/1033 folder, in order to view Windows project types. In a default install, that looks something like this:

The explorer should look like Figure 3-4. The files are Zip files and should stay that way. The setup process for the development environment reads right from the Zips.

The ConsoleApplication is about the simplest project type, and it is a great place to begin creating your own. Open the ConsoleApplication zip and take a look at the four files it includes:

So where does that leave you? You can change the projects. Try these steps:

Now, when you open Visual Studio and click New Project, there should be a new project type, called Console And Class. Create a new project based on this type, and it will make you a Console .cs file and a class .cs file.

Items work the same way. Check into C:Program FilesMicrosoft Visual Studio 10.0Common7IDEItemTemplatesCSharp and you'll see the same set of items types that show in the Add New Item dialog box:

If you dig into a directory through the Code/1033 folder, you will find more or less the same kinds of things you saw in the project templates in the preceding section. The templates are in Zip files (and have to stay that way). These files include a .vstemplate file that has the details Visual Studio needs. The files that go into the project are in there, too.

Yes, some of these item templates are duplicates of the items in the project templates. I don't like that, but I can't see any way around it.

Look in the Code/1033 folder. There is a Class.zip file that maintains the Class template, if you were to right-click a project name and select Add New Class. Suppose that you want to put the default comment block in here too. Here's what to do: