Peter Ritchie's MVP Blog : Resharper

Working with Resharper's External Annotation XML Files

PeterRitchie — Mon, 21 Jul 2008 20:32:00 GMT

Resharper 4.0 has external annotation XML files that you can create to give Resharper more information about your code. For example, you can tell Resharper that a particular method does not accept a null argument. For example, the following method does not accept a null argument:

using System;

namespace Utility

    public static class Text

        public static int GetLength(String text)

            if (text == null) throw new ArgumentNullException("text");

            return text.Length;

An external annotation file can be created to inform Resharper of this fact and have it warn you when possible null values are passed as an argument:

            String text = null;

            Utility.Text.GetLength(text);

First, you need to create a directory within the Resharper ExternalAnnotations directory. This ExternalAnnotations directory is usually in the form of "%SystemDrive%\Program Files\JetBrains\ReSharper\vBuild#\Bin\ExternalAnnotations" for example "C:\Program Files\JetBrains\ReSharper\v4.0.816.4\Bin\ExternalAnnotations".

The directory we need to create is the same name as our assembly (without the extension). In our case this would be "C:\Program Files\JetBrains\ReSharper\v4.0.816.4\Bin\ExternalAnnotations\Utility".

Next, we need to create an XML file to contain the information required by Resharper. The name of this file is the same as the directory name, plus ".xml". So, the full file name would be "C:\Program Files\JetBrains\ReSharper\v4.0.816.4\Bin\ExternalAnnotations\Utility\Utility.xml". This file essentially has an assembly element with child member elements that provide meta-data about methods and arguments. In our case we want to tell Resharper that the Utility.Text.GetLength(String) method does not accept null values for the argument named "text". To do this we populate the file with the following XML:

<?xml version="1.0" encoding="utf-8" ?>

<assembly name="Utility">

    <member name="M:Utility.Text.GetLength(System.String)">

        <parameter name="text">

            <attribute ctor="M:JetBrains.Annotations.NotNullAttribute.#ctor" />

        </parameter>

    </member>

</assembly>

After restarting Visual Studio, Resharper will now warn that "text", when passed to GetLength, in the following code, has a "Possible 'null' assignment to entity marked with "NotNull" attribute".

            String text = null;

            Utility.Text.GetLength(text);

I've tried this with the GA build and with both Visual Studio 2005 (SP1) and Visual Studio 2008.

For more information about the annotation options, search for AssertionConditionType in the Resharper help and browse around "%SystemDrive%\Program Files\JetBrains\ReSharper\vBuild#\Bin\ExternalAnnotations" for examples.

Comparing CodeRush Refactor! Pro and Resharper 4, part 1 or N -- first glance.

PeterRitchie — Thu, 26 Jun 2008 01:17:00 GMT

Metadata view of code in referenced assemblies
This is a big one for me. For whatever reason, Refactor 4 (and prior) completely disables this and sends you to the Object Browser instead. You get metadata view with CodeRush Refactor! Pro.

Keyboard layout
As you might imagine, CodeRush Refactor! Pro and Resharper had completely different keyboard layouts. So, if you're used to R# then Refactor! Pro will take a bit of getting used to.

One thing I don't like with the default Refactor! Pro keyboard layout, is they've replaced Ctrl-. with Quick Navigation. I use Ctrl-. (instead of Shift-Alt-F10 to get at the smart-tag menu). Shift-Alt-F10 for smart-tag menu seems more common; so I'll have to get use to Shift-Alt-F10.

Refactor! Pro's Editor enhancements
R# doesn't change to how the editor looks as much as CodeRush Refactor! Pro. It has the Marker Bar, error/warning/info colouring, and action light-bulbs. Refactor! Pro with CodeRush has many more, like region painting, flow-break evaluation, Visibility Icons, structural highlighting, etc.

Real-time analysis
Both R# and CodeRush Refactor! Pro do real-time code analysis. R# has text colouring and the right-hand marker bar. CodeRush Refactor Pro has a marker bar on both the left and the right. The left marker bar in CodeRush Refactor! Pro highlights issues for each line, and the right (as does R#) shows a file-wide view of issues. I find the R# marker bar sometimes doesn't align with the scroll bar so that an issue may be beside the scroll-bar in the marker bar but is actually scrolled off the screen. CodeRush Refactor Pro doesn't do that and in fact shows the visible portion of the document in its marker bar. i.e. the marker bar is beside the Visual Studio Indicator Margin (where the breakpoint bullets appear).

Refactorings
They both have many of the same refactorings. When it comes to non-refactorings the two sometimes approach things differently. For example R# deals with adding members to a class through "Generate Code" list; whereas CodeRush Refactor Pro uses templates. E.g. in R#, to add a constructor you hit Alt-Ins and select Constructor. With Refactor you simply enter "cc "(that 'c', 'c', space).

Smart-Tags
Both approach smart-tags slightly differently. With R# they use the actions light-bulb at the left margin. This includes fixes for warnings, errors, plus refactorings, but doesn't include code generation options. CodeRush Refactor Pro uses an ellipsis-like icon that appears right at the site of the potential refactoring. Code Refactor Pro is a richer experience. It will show you the result of a refactoring with arrows showing where things will move, red strike-out showing what will be removed, and highlights for things that will be changed/renamed.

Resharper 4.0 EAP Settings and Installing Latest Build

PeterRitchie — Tue, 20 May 2008 02:10:00 GMT

The 4.0 EAP tends to do a full uninstall before installing (it's pre-beta, pre-alpha even; so it's no wonder).

This tends to blow away your settings changes. If that's a pain point for you, the settings are stored in "%userprofile%\application data\jetbrains\resharper\v4.0\vs9.0". There are a couple of xml files in there that store your settings. Before you upgrade to the latest build, just copy those to another directory.

It's very likely that the format of these files has changed since the last build so copying the backups over the new version could possibly make Resharper to blow-up. So, use with caution.

Resharper Isn't Always Smart

PeterRitchie — Mon, 31 Mar 2008 17:47:00 GMT

I was writing some code today, essentially like this:

public class MyClass
{
    private int value;
    public MyClass(int value)
    {
        this.value = value;
    }
    public static bool operator==(MyClass left, MyClass right)
    {
        return left.value == right.value;
    }
 
    public static bool operator !=(MyClass left, MyClass right)
    {
        return !(left == right);
    }
}

    //...
    MyClass myClass1 = new MyClass(1);
    MyClass myClass2 = new MyClass(1);
    if((Object)myClass1 != (Object)myClass2) // "Type cast is reundant"
    {
        Console.WriteLine("not equal");
    }
    else
    {
        Console.WriteLine("equal");
    }

...where Resharper warned that both the casts to Object were redundant and offered a "Quick-fix" (red light bulb) to "Remove cast". Well, doing that to one of the casts results in a compile error so you have to manually change the other; but what it's suggesting is this:

    if(myClass1 != myClass2)

This completely changes the output of my application from "not equal" to "equal". What Resharper doesn't know (or doesn't care to check) is that removing those casts switches from a reference comparison to a value comparison and may have different results. What I wrote with the original code was to test if the two references referenced the same object. The default behaviour of a class is to do a reference check; but I've overloaded operator== (and operator !=) to perform a value comparison (I've left out the lovely bits that truly gives MyClass value semantics for clarity).

So, when Resharper offers to change your code, be sure you know side-effects of that change before you let it do it. You could introduce a nasty bug.