JetBrains .NET Tools Blog

While you’re waiting for the first public build of the recently announced ReSharper 6, here’s a follow-up on the “Introducing ReSharper 5″ blog post series that we did earlier this year. One feature that we have not highlighted before but that’s a major presence in ReSharper 5 is navigation to and within external sources.

When you want to know how a certain method is implemented, with ReSharper you expect to be able to quickly navigate to the declaration of an identifier. In most cases you can do this perfectly well. However, things get tricky in the following two scenarios:

1. The method you’d like to zoom in on is part of the .NET Framework.
2. Your really huge project is broken down into several subprojects. You’re working in one of them but the class or method that you want to navigate to is declared in another subproject.

ReSharper 5 covers both scenarios with a fresh feature called “External Sources”. External Sources makes all sources available to a developer even if they should be accessed remotely. This is the first step to eliminating differences between your local working copy and actual sources of all components involved in your project.

Let’s take a look at standard use cases when you need access to sources not included in the current project.

.NET Framework Sources

Microsoft provides free access (with certain licensing restrictions) to source code of the entire Microsoft .NET Framework. Within plain Visual Studio, you generally access it during debugging sessions. ReSharper complements this use case with the following extended functionality:

1. Navigation to.NET Framework sources.
2. Find Usages over all .NET Framework public symbols.

This enables you to easily and transparently access sources of complex .NET Framework classes such as DataGrid.

Your Company’s Library Sources

When working on a big project, a developer usually either doesn’t have the entire sources on their local machine, or they do have them but not in the current project.

In the latter case, if the sources are available but not included in the current project, ReSharper allows you to specify the path to these sources. So, when you try to navigate to an external symbol, ReSharper will search the local (or network) drive for the appropriate file and open it. The only requirement is having .pdb files available for external components.

In the former case, if the sources are way too numerous (or if it is simply impractical to store them all locally, i.e. if they are used infrequently or if there are just too many versions), you can use the Microsoft Source Server. There’s a good chance that it’s already installed in your place of work. ReSharper provides full support for the Microsoft Source Server and relies on it to implement navigation to the source of the .NET Framework. All you need to do is specify the path to the local server(s) in Visual Studio (Tools | Options | Debugging | Symbols).

Reflector Plugin

Now, what do you do if you don’t have .pdb’s, or even no sources at all? Or if you can’t set up Source Server?

For many developers the answer is Reflector. But as you probably know, it is rather cumbersome to use: first you find the right .dll, then you look inside it for the symbol you need. ReSharper PowerToys include a plugin that lets you to connect Reflector with Visual Studio. On the outside it will look like you’re navigating to the source, only Reflector will be used ‘behind the curtains’ to retrieve them.

You might ask, in what way is Reflector integration with Visual Studio inferior to that of ReSharper? We at ReSharper wanted to make the integration seamless, and that’s exactly what our plugin does. You no longer have to think about where a particular symbol is declared - ReSharper finds it for you, wherever it is. First it looks for it on your local drive, then it polls the Source Server, and if that fails, finally it decompiles the sources you need via Reflector.

About Options

If you open ReSharper Options and select External Sources, you will see a list of configured source providers. Use this dialog window to define the order in which these providers will be polled. For some providers you can define additional options, e.g. set C# or VB as the presentation language, show XML-doc or not, etc.

The first time you try to navigate to an external source, ReSharper will ask you which provider to use by default:

If you’re not happy with the current provider or the default provider, you can always click on a symbol to bring up the Navigate To menu (ReSharper | Navigate | Navigate To…) and switch the view:

The Way Forward for External Sources

In Internal mode, you can already see the feature called “Find Usages In Compiled Code”. This works like Find Usages which lets you search for symbols used in builds already compiled. This tool is indispensable for situations such as when you’re developing a system core and you must know exactly where and how your public API methods are used.

Another area JetBrains will focus on in growing this functionality is integration with TeamCity — one of today’s most powerful Continious Integration products. Oftentimes, different development teams work on different parts of a system, and synchronizing all their source versions and compiled libraries becomes a real challenge. Enter TeamCity: it knows at all times which source version corresponds to each local library version. Why maintain a huge codebase locally, when you can rely on TeamCity to be your company’s internal Source Server — with no extra configuration required?

Author: Alexander Zverev, senior ReSharper developer

ReSharper 5.0 is finally here, and you can download it right now!

We’ve blogged for a while now about the great new stuff in ReSharper 5.0 (and we’ll continue blogging about it), but here’s a short recap:

• Web Development: You get an extensive toolset for ASP.NET development to work with markup files and web site infrastructure. ASP.NET MVC developers get a bonus with additional syntax highlighting, inspections, navigation, and completion for actions and controllers.
• Project and Team: Powerful, shareable structural search and replace patterns to remove code smells or comply with team policies; project-level refactorings; localization assistance; and full support for navigation to library sources — all this to help you and your team easily view, change and maintain the structure of complex projects.
• Code Analysis: Lots of improvements, from viewing all code smells in your solution from a single tool window to upgrading foreach and for loops to LINQ queries, to value tracking and call tracking.
• Support for Visual Studio 2010: Yes, we did it! ReSharper 5.0 has sim-shipped with the latest Visual Studio! Did you see it coming in your wildest dreams?
• Other enhancements relating to IntelliSense, bookmarking, native NUnit support, and more.

What’s New has more details we haven’t yet covered in our blogs.

So, what are you waiting for? Grab ReSharper 5.0 while it’s hot!

When you’ve been convinced, buy ReSharper 5.0 or upgrade. The upgrade is free if your 4.5 license is dated October 15, 2009, or later!

Structural Search and Replace is one of the most powerful yet less explored ReSharper 5.0 features. It allows you to find code that matches a structured template, parts of which may have certain restrictions. For example, you can set the type of the expression you are looking for, or specify the number of arguments. In addition to plainly finding parts of code that match the template, you can instantly replace them using an equally powerful replace template, or even configure ReSharper to inspect your solution for code that matches the search pattern and suggest replacing it using a quick-fix. Simply put, Structural Search and Replace provides you with an opportunity to easily extend built-in ReSharper code inspections with your custom ones.

Smart Search

Let’s look at a specific example. We’ll search for all expressions matching the pattern enumerable.Count() > 0, where enumerable is any expression of type IEnumerable.

If you were to solve this task with Find Usages, you would step through all the calls of the Count() method. This means you would have to go through tens or hundreds of calls, which is tiring and prone to error. Find Text might look slightly more promising, but once you think about it, problems come up too:

1. The expression may be written with line returns or comments.
2. The Count() method in your project may be implemented by objects of different types.

Find Text doesn’t cut it either.

Choose ReSharper | Find | Search With Pattern and enter the following pattern in the text box:

   $enumerable$.Count() > 0

The $enumerable$ string will be highlighted red. This is because dollar signs signify placeholders — a placeholder is replaced with any text matching the specified restrictions: the placeholder type and its parameters. In our case, $enumerable$ will match any expression of type IEnumerable. We must define this placeholder by clicking Add Placeholder, selecting Expression and entering “enumerable” in the Name field (the placeholder name without the dollar signs). For Expression Type enter “IEnumerable” (just start typing and ReSharper will suggest suitable options). Make sure to check Or derived type as well.

So, in just a few seconds, without even going near regular expressions we’ve created an effective search pattern. But here’s another feature that’s extra-useful! Note the Match similar constructs check box below the edit field. If you select it, ReSharper will search not only for exact matches but also for constructs that are semantically identical. For example, a > 0 and 0 < a are semantically identical. In our case, you should probably select this check box, because you’re likely to be looking for all the different conditional statements where Count() is compared with zero.

That’s all! Now click Find and see the results.

Smart Replace

A search feature this powerful would not be nearly as useful without a replace feature. You don’t want to just locate all the bad code — you want to replace it with good code! So, go ahead and click Replace in the Search With Pattern dialog. You will get a box to enter the replace pattern. The replace pattern can be any text that is valid for the language you’re using, plus placeholders if you need them. For example, enter the following:

$enumerable$.Any()

And click Replace!

Turn a Pattern into a Highlighting and a Quick-Fix

Now you have a search template and a replace pattern. It makes sense to create a highlighting and a quick-fix based on these patterns. To do so, click Save in the pattern editing dialog, and your pattern will be saved to the Pattern Catalog. This catalog is used to store commonly used patterns, and may turn into a powerful tool for creating your own code inspections.

If you open the catalog (ReSharper | Tools | Pattern Catalog), you can define a tooltip for your pattern, which will pop up in the corresponding quick-fix, as well as the type of highlighting you want to apply:

Once you set these options for your pattern, the highlighting works! Now all code that matches your pattern will be highlighted — on the fly. Also, the appropriate quick-fix will appear as soon as you position the caret on the highlighted expression. Ain’t it cool?!

Search Pattern Examples

This search pattern is designed to simplify expressions:

In this example we used placeholders for the types of the expression and the identifier. We didn’t impose any restrictions on them, but used them in the replace pattern. The only placeholder with restrictions is $seq$ — it’s an IEnumerable.

And here’s a pattern that implements highlighting and a quick-fix for Replace ‘if’ with ‘?:’:

Sharing Patterns

If you have created a useful search and replace pattern that detects and removes a code smell, share your knowledge with colleagues using import/export functionality in the the Pattern Catalog! As an option, leave comments with your patterns, and with your permission, we may include the most interesting patterns in the next version of ReSharper!

UPDATE! A sample Pattern Catalog is now available from the ReSharper web site. Learn details in this blog post.

Author: Alexander Zverev, senior ReSharper developer. Translated from original article (in Russian)

JetBrains is a platinum sponsor for this year’s DevConnections conference taking place in Las Vegas, Nevada, April 12-14, featuring the official launch of Visual Studio 2010.

Join us at booth 207 and get to know the .NET Team — the people behind ReSharper, dotTrace and dotCover. Yes, they get to go there and hang out with you, while the folks back home work their butts off to sim-ship ReSharper 5.0!

In addition to presence at the booth, JetBrains .NET tools evangelist Hadi Hariri will host a vendor session on Test-Driven Development of ASP.NET MVC Applications.

If you’re planning to visit Launch events in London, Bangalore, Kuala Lumpur or Beijing, we’re sponsoring them too, but we won’t be there in person.

Recently we posted about Call Tracking, which is a new feature in ReSharper 5.0.

A logical next step from Call Tracking is Value Tracking. Value Tracking is designed to help you determine how a certain incorrect value might have passed to a given point in your program, and where it might be passed next. This helps you investigate possible NullReferenceExceptions, inappropriate behavior and reasons why you get incorrect values.

You can call Value Tracking by choosing ReSharper | Inspect | Value Origin or ReSharper | Inspect | Value Destination over a local variable, parameter, or another kind of value, and you can also use a new shortcut to Call Tracking, Value Tracking, and Type Hierarchy: Inspect This (Ctrl+Shift+Alt+A).

Without theorizing too much, I will review some use cases and scenarios where Value Tracking is useful.

A Basic Example

In this example, a NullReferenceException is thrown in the VisitData method. Let’s determine where the null comes from. Position the caret at the usage of the dc parameter in VisitData and run the analysis (ReSharper | Inspect | Value Origin):

    public class Main
    {
      void Start()
      {
        Console.WriteLine(Do(new DataClass()));
      }

      void Start2()
      {
        Console.WriteLine(Do(null));
      }

      int Do(DataClass data)
      {
        var v = new Visitor();
        return v.VisitData(data);
      }
    }

    public class DataClass
    {
      public int GetData()
      {
        return 0;
      }
    }

    public class Visitor
    {
      public int VisitData(DataClass dc)
      {
        return dc.GetData();
      }
    }

If you run the analysis in your own code (using the same example) and try to navigate around the results tree, you will see that it contains all the nodes you might be interested in:

• Our usage of dc (the place the exception is thrown).
• The data parameter passed to VisitData
• A call of Do with “good data” (in the graphic above, the values we need are in bold).
• A call of Do with the null value – the culprit.

Basically, this is a massive Find Usages. However, Value Tracking:

• Skips the unimportant steps, thus saving time.
• Displays values in a convenient way, so you can find the source of your problem without looking through all the symbol usages one by one.

Value Tracking is especially useful if variable names are changed often, or if values are placed in collections or passed via closures. Let’s look at these more complex use cases in more detail.

Inheritance

So we have an interface, its implementation, fields, field initializers, and constructors. Our task is to figure out which values Main.Start can display. Highlight dataProvider.Foo and invoke Value Origin on it (ReSharper | Inspect | Value Origin):

    public interface IInterface
    {
      int Foo();
    }

    public class Base1 : IInterface
    {
      public virtual int Foo()
      {
        return 1;
      }
    }

    public class Base2 : IInterface
    {
      private readonly int _foo = 2;

      public Base2()
      {
      }

      public Base2(int foo)
      {
        this._foo = foo;
      }

      public virtual int Foo()
      {
        return _foo;
      }
    }

    public class Main
    {
      public void Start(IInterface dataProvider)
      {
        Console.WriteLine(dataProvider.Foo());
      }

      public void Usage()
      {
        Start(new Base2(3));
      }
    }

The results of this Value Tracking include:

• Implementation of Foo that returns the constant 1.
• Implementation of Foo that returns the value of _foo as well as all value sources of that field:
  • The assignment of a value to the field in the constructor.
  • Call of constructor with parameter = 3.
  • Initializer of the field with value = 2.

Note how in just a few seconds we found all the possible values. Imagine how much time you would save on highly-branched hierarchies and complex logic!

Collections

Now let’s look at working with collections. Let’s identify the set of all values that the following code will print to screen. To do this, position the caret on the usage of i inside Console.WriteLine and run the Value Origin analysis (ReSharper | Inspect | Value Origin):

   class Main
   {
     void Foo()
     {
       var list = new List<int>();
       list.AddRange(GetData());
       list.AddRange(GetDataLazy());
       ModifyData(list);

       foreach (var i in list)
       {
         Console.WriteLine(i);
       }
     }

     void ModifyData(List<int> list)
     {
       list.Add(6);
     }

     private IEnumerable<int> GetData()
     {
       return new[] { 1, 2, 3 };
     }

     IEnumerable<int> GetDataLazy()
     {
       yield return 4;
       yield return 5;
     }
   }

We found an explicit creation of the array, the values that come from the lazy enumerator, and even the Add call. Awesome!

Collections backwards, or where values pass to

Now let’s try going the other direction and see where the number 5 passes. Highlight it and run Value Destination (ReSharper | Inspect | Value Destination):

   public class testMy
   {
     void Do()
     {
       int x = 5;
       var list = Foo(x);

       foreach (var item in list)
       {
         Console.WriteLine(item);
        }
     }

     List<int> Foo(int i)
     {
       var list = new List<int>();
       list.Add(i);
       return list;
     }
   }

We find rather quickly that:

• 5 is passed to Foo
• 5 is added to the collection.
• The collection is returned and used.
• Collection elements are printed to screen.

Note how, in this and earlier examples, tree nodes are marked with a special pink icon whenever Value Tracking switches from tracking a value to tracking a collection.

Lambdas

Lambdas tend to cause problems, especially if there are many of them or they’re nested. Let’s see how ReSharper handles the following situation. We’re going to track the value paths in both directions:

   public class MyClass
   {
     void Main()
     {
       var checkFunction = GetCheckFunction();
       Console.WriteLine(checkFunction(1));
     }

     Func<Func<int, bool>, int, bool> GetCheckFunction()
     {
       Func<Func<int, bool>, int, bool> myLambda = x =>
                  {
                   Console.WriteLine(x);
                   return x > 100; // this is where we start searching from
                  };
       return myLambda;
     }
   }

First, let’s find out where the values of x come from. Highlight its usage in the Console.WriteLine call and invoke Value Origin (ReSharper | Inspect | Value Origin):

• We found the lambda that contains the parameter.
• Next, the analysis tracked where this lambda was passed. Note how all the nodes in which we track the lambda are marked with a special icon.
• On the last step, we see that the lambda is called with the argument of 1. This is the value of x we’re looking for.

Let’s find out where the value that the lambda returned is used. Highlight x>100 and invoke Value Destination (ReSharper | Inspect | Value Destination):

• The analysis identifies that the expression is returned when the lambda is executed.
• Next, ReSharper tracks where the lambda was passed.
• Finally, we see a WriteLine call that uses the value returned by the lambda.

You can come up with a more complex example using nested lambdas, by replacing the Console.WriteLine call with these two lines:

    Func<Func<int, bool>, int, bool> invocator = (func, i) => func(i);
    Console.WriteLine(invocator (checkFunction,1));

The analysis will still work, and you will easily see where the value of x>100 is passed.

Code that uses nested lambdas is difficult to understand for most people, making this kind of analysis even more useful. You can even try to create a collection of nested lambdas — and it will still work! Go ahead and try it… if you’re into hardcore fun!

Author: Alexander Zverev, senior ReSharper developer. Translated from original article (in Russian)

Front seats at the ballet: $200

Front seats at the ball game: $100

Quickly spotting bottlenecks in your .NET application: priceless

There are some performances money can buy. For everything else, there’s dotTrace 4.0 Performance.

Jokes aside, here’s what dotTrace 4.0 Performance, currently in Beta, brings to the table.

Support for:

• Visual Studio 2005, 2008, and 2010
• .NET Compact Framework 3.5
• .NET Framework 1.0 to 4.0
• Silverlight 4

New profiling modes:

• Remote profiling: connect to a remote machine to profile a standalone or web application, or a Windows service.
  
• Line-by-line profiling: view detailed timing information for every statement in methods that have source code available.
  

What-if scenarios:

• Ever thought, “What if I optimize this function by 40%?”? Now dotTrace knows the answer! It can recalculate a snapshot without reprofiling your application, so you can instantly estimate potential performance gains.
  

New edition scheme:

• dotTrace 4.0 Performance comes in two editions: Standard and Professional. Standard Edition provides all the functionality that is available in Professional Edition, excluding support for .NET Compact Framework 3.5, Silverlight 4, and remote profiling.

Other goodies:

• Improved speed and accuracy in all modes, plus a ‘high accuracy’ flag to take into account the time spent inside the profiler.
• Extremely robust handling of huge snapshots (up to hundreds of GB!)
• Snapshot annotations:
  

Read more at What’s New.

Download a free 30-day trial of dotTrace 4.0 Performance Beta today.

More questions? Check out the updated dotTrace FAQ.

There’s a cool new feature in ReSharper 5.0 called Call Tracking (or, alternatively, Call Hierarchy). Basically, it’s a convenient way to perform an all-out Find Usages or Go To Declaration. You can access it by choosing ReSharper | Inspect | Outgoing Calls or ReSharper | Inspect | Incoming Calls.

There’s also Inspect This, a new shortcut to Call Tracking, Value Tracking, and Type Hierarchy features: Ctrl+Shift+Alt+A.

At first we thought of comparing our Call Tracking to Call Hierarchy in Visual Studio 2010. However, it turned out that the VS 2010 version is just not up to par: it doesn’t support events, interfaces, closures and a few other things. It offers no help at all with the use cases we present here. So we’re only going to talk about Call Tracking in ReSharper 5.0.

Events

Let’s search for an outgoing call from Foo (ReSharper | Inspect | Outgoing Calls):

   using System;
   public class C2
   {
     public event EventHandler E = (sender, args) => Subscription_In_Initializer();

     static void Subscription_In_Initializer()
     {
     }

     void Foo()
     {
       E(this, EventArgs.Empty);
     }
   }

   class C3
   {
     void Bar()
     {
       new C2().E += Subscription_In_Method;
     }

     void Subscription_In_Method(object sender, EventArgs e)
     {
     }
   }

Pretty self-explanatory. ReSharper easily finds all subscriptions to E and displays them as possible calls. Nothing too special, but handy for sure.

Generics

Consider this code sample:

   public abstract class Base<T>
   {
     public void Do(T value)
     {
       DoImplementation(value);
     }

     protected abstract void DoImplementation(T value);
   }

   public class Concrete1 : Base<int>
   {
     protected override void DoImplementation(int value)
     {
     }
   }

   public class Concrete2 : Base<string>
   {
     protected override void DoImplementation(string value)
     {
     }
   }

Now let’s look at outgoing calls from Base.Foo:

Speaks for itself.

Now, let’s add a Main class and try searching for outgoing calls from Foo:

   class Main
   {
     void Foo()
     {
       Concrete2 c = null; // null so that we don't clutter the call tree
       c.Do("string");
     }
   }

Concrete1.DoImplementation doesn’t show up anymore! That’s because ReSharper looked at the type parameters and realized that Base.Do will be called with T->string (see the second line of results: Base<string>.Do — string means we’re calling a method that substitutes a specific type). Accordingly, ReSharper filtered out Concrete1 because it uses inheritance with the substitution T->int.

Now let’s look at a slightly more complex, yet very vital example using the Visitor pattern. Let’s search for incoming calls from ConcreteVisitor1.VisitNode1 (ReSharper | Inspect | Incoming Calls). Note how we’re going the other way here, in the direction opposite of method calls:

   public interface IVisitor<T>
   {
     void VisitNode1(T data);
   }

   class Node1
   {
     public void Accept<T>(IVisitor<T> v, T data)
     {
       v.VisitNode1(data);
     }
   }

   public class ConcreteVisitor1 : IVisitor<int>
   {
     public void VisitNode1(int data)
     {
     }
   }

   public class ConcreteVisitor2 : IVisitor<string>
   {
     public void VisitNode1(string data)
     {
     }
   }

   public class C1
   {
     void Foo()
     {
       var v = new ConcreteVisitor1();
       new Node1().Accept(v, 1);
     }

     void Foo2()
     {
       var v = new ConcreteVisitor2();
       new Node1().Accept(v, "string");
     }
   }

The result:

While traversing the generic Visitor, ReSharper did not lose any details about the substituted type parameters and successfully filtered out the irrelevant call from Foo2. When you have a highly-branched hierarchy and a large number of generic types, this kind of logic helps to really narrow down your search.

Constructors

Let’s also look at an artificial example using constructors and field initializers. Let’s search for outgoing calls from the Derived class constructor:

   class Base
   {
     public Base()
     {
       Base_Bar();
     }

     void Base_Bar()
     {
     }
   }

   class Derived : Base
   {
     int _i = Foo();

     public Derived()
     {
       Bar();
     }

     void Bar()
     {
     }

     static int Foo()
     {
       return 0;
     }
   }

Again, nothing out of the ordinary. ReSharper simply displays calls in their the natural order, mindfully listing the implicit call of the base constructor. For a less-experienced developer, this saves a lot of time spent understanding code, and is a nice crutch to lean on for an expert.

Value Tracking

And here’s the final tidbit. If you open the ReSharper | Inspect menu, you’ll see two very interesting items: Value Origin and Value Destination. These functions implement value tracking: they let you track where a particular variable value or parameter value came from, or where it is headed. Naturally, it works with collections and delegates (it determines that an item was taken from a collection and then searches for usages of that particular collection) and is indispensable for identifying the causes of NullReferenceExceptions.

Illustrating this will take a whole batch of screenshots and examples, so please stay tuned for our next post.

Author: Alexander Zverev, senior ReSharper developer. Translated from original article (in Russian)

JetBrains ReSharper has earned two of the most coveted awards at the Visual Studio Magazine 2009 Readers Choice awards:

• Best Development Tool (Readers Choice): In one of the most hotly contested categories: Development Tools, ReSharper beat out 80 other products to claim the top honor.
• Most Valuable Tool (Editors Choice): Readers and panelists were asked to single out the one product in the entire survey that stood out as the most valuable, effective and compelling tool for developers. JetBrains ReSharper was their choice.

“We won’t develop without [ReSharper],” wrote one voter. No .NET developer at JetBrains does, and we don’t recommend you do either!

Seriously though, we can’t thank all of you enough for your support and recognition. Feedback like this is worth triple the effort we put into product development!

Keep developing with pleasure!

- JetBrains ReSharper Team

A couple of weeks ago we attended NDC Norway. The conference was organized on a very high level and went very well. We were excited and surprised to see how popular our products are in that part of the world!

It was also nice to chat with all those who stopped by our booth. And on that note - congratulations to the following lucky winners of ReSharper + dotTrace productivity packs:

Lars Kristian Hagen
Harry Solsem
Gante Magnussa
Alf Kare Lefdal
Ronny Hansen

Your licenses should be waiting for you in your e-mail inbox!

Have you ever wanted to really customize ReSharper, just the way you want it?

Now you can build your own, with our brand new ReSharper Configurator. Choose the analysis engine, select the feature packages you need, the supported languages, and even the colors! Go lightweight or feature-rich - it’s all up to you.

Click here to build your ReSharper now: http://www.jetbrains.com/resharper/build_now.html