• Support for Visual Studio 2008 and .NET Framework 3.x. You can now launch dotTrace from Visual Studio 2008 and profile solutions running under latest versions of .NET Framework.
• Support for Windows Vista and Windows Server 2008.
• Support for web-based JetBrains License Server, a utility that serves as a central source of license tickets and distributes them between workstations seamlessly.
• A new floating license that any member of your development team can use.
• Stability and performance improvements.

 
As usual, you can download a 10-day evaluation copy. Current dotTrace 3.0 customers can upgrade for free.
 
For more details on changes in dotTrace 3.1 as compared to 3.0, see Release Notes.

• There are still three Completion features, but what was previously known as Basic Completion is now called Symbol Completion, while Type Name Completion was renamed to Import Symbol Completion.
• In ReSharper 4.0, all three completion features support CamelHumps - for example, you can complete a long type name by entering only its uppercase characters (can you say “DecoderReplacementFallbackBuffer”? forget it - just type DRFB instead)
  To make sure it works, clear the Case-sensitive prefix matching check box in Resharper | Options | Environment | IntelliSense | Completion Behavior. Note that the Use CamelHumps check box in ReSharper | Options | Environment | Editor doesn’t have any impact on how CamelHumps works in completion.
• Needless to say, Code Completion as of R# 4.0 supports C# 3.0 features, including:
  • Extension methods. Both Smart Completion and Symbol Completion are enabled to suggest extension methods. Import Symbol Completion works after dot for extension methods and inserts required using directives:
    
  • Object and collection initializers. Smart Completion in initializers displays available properties/fields to initialize:
    
  • Lambdas. Smart Completion generates lambda-expression syntax as an alternative for anonymous and named methods:
    
• Complete Statement. Complete Statement is a feature that inserts necessary syntax elements with a simple shortcut - Ctrl+Shift+Enter. It comes to the rescue in numerous situations, including auto-closing parentheses, adding semicolons, completing if, while and for statements, declaring classes, methods, and structs, and so on:
  
• There are also some minor changes and fixes, including completion for boolean fields in XAML files, auto-inserting closing single quotes in XML attributes, and so forth.

 
Additional references

• ReSharper Horizons: Code Completion with ReSharper
• Oleg Stepanov’s Weblog: Code Completion Illustrated, Part I. Basic Completion (attention! this one is antique!)
• ReSharper 4.0 EAP Notes

Updated! This post is not a place to suggest new features/improvements for whatever version of ReSharper. The most efficient way to do it is using JIRA.

• Errors (to highlight uncompilable code)
• Warnings (to mark code items that don’t prevent your code from compiling but may nevertheless represent serious coding inefficiencies)
• Suggestions (to draw your attention to things that are not necessarily wrong but useful to know)

 
R# 4.0 introduces a new, considerably less intrusive level of code analysis results - hints.
 
Unlike errors, warnings and suggestions, hints are not taken into account when you navigate to next/previous highlights, not shown in the Marker Bar and therefore do not influence the color of the Status Indicator. A hint simply brings your attention to a particular code detail and recommends a way of improvement. Code items that have associated hints are highlighted with a solid green underline. Move the mouse pointer over a highlighted item to view the corresponding hint in a tooltip:
 

 
Putting the caret at a highlighted item allows you to display the hint in the status bar.
 
As usual, for any code inspection item that is shown as a hint by default, you can modify inspection severity to display it as a suggestion, error or warning. You can do that in one of the two alternative ways:
 

• using the general list of code inspection items in ReSharper | Options | Code Inspection | Inspection Severity, or
• using an item-specific Inspection options dialog box (which is new in ReSharper 4.0, by the way) that you can open by Alt+Entering a specific hint and choosing Inspection options for [name of inspection item] in the drop-down list.

 
In practice, hints turned out to be a convenient way for ReSharper to suggest migrating to C# 3.0 features without disturbing your coding sessions too much. That’s a reason why they’re somewhat left out of ReSharper’s traditional “show code highlights and let user navigate between them” routine.

Take this simple method for example:

We need to take the CreateUser method and add a new parameter to it. However, we also need to keep the old CreateUser method signature around for other code that still uses that version of the method signature. Using ReSharper’s Change Signiture (Control-F6) feature will allow us to create an overloaded method to solve our problem.

When the Change Signature dialog opens for this method, we will go ahead and add our new email parameter to this method.

In the above screenshot, notice the option “Delegate via overloading method” circled in red. Clicking this box is what will take the signature changes and turn them into a new overloaded method.

When the changes are ready, clicking Next in the Change Signature dialog will now produce the following code.

Notice that in the SaveNewUser method, the original method signature remains intact, but it is now delegated through an overloaded method. The CreateUser method now has two overloaded variations, the delegating method and the main method, where we can now add code to handle the new email parameter.

Jeff Pennal
JetBrains .NET Evangelist

Creating and using your own templates is a quick and easy way to help eliminate repetitive code or to automate common tasks. To demonstrate this functionality, I am going to show how to use custom templates to add log entries using the Apache log4net library.

Lets start with a class that looks like this:

    public class SampleClass {
        public void doSomething() {
            try {
                String value;
	
                value = getSomeValueFromDatabase();
                Console.Out.WriteLine(value);
            } catch(Exception e) {
            }
        }
	
        private string getSomeValueFromDatabase() {
            return null;
        }
    }

The first thing we want to do is to create a template that will allow us to add a new logger to a class.

To do this, we’ll open up he ReSharper Template editor, under the Visual Studio.Net menu
ReSharper -> Options…, and then in the options dialog, choose Live Templates.

Next, we’ll create a new template by selecting the User Templates item from the available templates and clicking the Create Template button . This will bring up the Edit Template dialog.

Now we can start to write our template, the first thing we want to do is to give our template an abbreviation. This is the name that we will use to activate this template and make it run, for this example, we’ll call this “logger”.

The next thing we want to do is to give our template a description, for which I will enter Create a new logger instance for a class.

Once these values are filled in, we are ready to write our template. In the Template Text box, we’ll fill in the value:

protected static readonly ILog log = LogManager.GetLogger(typeof($CLASS$));


You’ll notice the declaration $CLASS$. A word surrounded by a $ sign indicates to ReSharper that this is a variable that you want to do something with. In the section below Template Text, called Template Variables, ReSharper has automatically created an entry for $CLASS$ that looks like this:

The power of templates comes when you click the Choose Macro link. The macro that we want is called “Containing Type Name”. When the template is run, this variable $CLASS$ will run that macro. This will take our template text and replace $CLASS$ with the name of the type containing it. In our case, this will be SampleClass.

You’ll notice that there is a check box for this variable for Editable Occurrence. This allows you to have the user edit the value once it has been applied. We don’t want it for this case, so we will uncheck this box.

Now, click Save and you’ll see that you have a new User Defined template. Click Ok in the Options dialog to go back to your code.

Lets see this template in action. Under my class declaration for SampleClass, I will place my caret and hit Control-J, Insert Live Template. In this list that appears I will see my new template logger.

After hitting tab, I now have:

So now, every time I create a new class and I want to create a log field for it, I only have to use my new template to do it automatically.

Let’s do just one more example. For my code, in my try…catch block, I want to write an entry to the log file that looks lik this:
log.Error("[SampleClass::doSomething] An error as occurred", e);
But I want this entire line to be automatically created for me with the values already filled in.

Let’s create a new User Template, following the same procedure as before and create a new template that looks like this:

This template is a lot more complex then our last one and works like this. In our Template Text, $logger$.Error("[$CLASS$::$METHOD$] $MESSAGE$", $EXCEPTION$); we are using five variables.

When the template is run, these five variable will fill in the following information:

Finally, when we save and run this template, we see the following:

Step 1: We find our new template “le” and run it

Step 2: Our template is created with our editable area surrounded in red. We type in our message

Step 3: With our message typed in, our template is finished

Now, every time I want to write a log.Error entry, I can use my le template to do this automatically for me, saving me the trouble of writing it out each time.

As you can see, custom templates can be very powerful. If you would like more information on what you can do with custom templates, check out ReSharpers help contents. There is a lot of information available on what you are able to do when creating your own custom templates.

Jeff Pennal
JetBrains .NET Evangelist