Click Here to Watch What’s New

9 our of 10 studies prove: Resharper make your your hair grow back, your dog come home (yes even if he died), your wife will love you again and your kids will listen to you.

OK perhaps it is not a country music song played backwards.

BUT your nuts to even think about wasting all that time not using it. For someone who knows it is people not tools that always win, this is my only exception in 20 years that I will stand behind.

Why stare at a keyboard for hours wondering how to navigate a nasty tangled refactoring you know you must do when you can do the right thing AND make the 5:30 train.

Me? I hit the shift-ctrl-space repeatedly and am shocked when nothing happens. Then I install it and life is good again.

ReSharper 4.5 Released

April 8, 2009

In This Issue

Introduction
Performance and Memory Usage Improvements
Solution-Wide Code Inspections

VB9 Support
Extended Naming Style Configuration
Other Enhancements

Introduction

ReSharper 4.5 is finally out, so your next productivity upgrade is just a mouse click away!

As announced, the new version features major improvements in performance and memory usage. After all, what is a productivity tool for if not for being agile, robust and responsive?

In addition to focusing on performance enhancements, we also added a number of intelligence features and improvements.

We’ve prepared a short Flash movie to introduce the new features in ReSharper 4.5. Get the hang of things in just a few minutes!

For users of older versions we have a ReSharper 3.0 vs. ReSharper 4.5 Comparison matrix.

However, if you believe a thousand words say more than a picture does, or even a movie, go ahead and read the descriptions below :)

Alex Morozov
NET product marketing manager 
JetBrains

Performance and Memory Usage Improvements

We have managed to make ReSharper load and work faster and more smoothly in general, particularly on big (and we mean BIG) solutions:

• Wall-time measurements of solution loading show 20 to 40 percent acceleration until the solution is ready for code editing.
• Web site loading time has also been reduced by a third.
• For instance, a certain mixed-language solution consisting of about 15 thousand classes now takes only 70 seconds to load, and this includes making every ReSharper feature available.

The list of significantly accelerated operations includes:

• renaming symbols
• finding commonly used symbols
• creating symbols from usage
• analyzing large XAML files.

We’ve also cut down the volume of memory resources required to analyze jumbo autogenerated code files, which should especially benefit those who work with ASP.NET and LINQ to SQL.

Solution-Wide Code Inspections

To enable you to detect unused non-private members on the fly, we have enlisted the help of our ever-improving solution-wide analysis. We have introduced a set of specialized code inspections that only work when you let ReSharper analyze your whole solution. They help you discover:

• Unused non-private declarations
• Unused return values of non-private methods
• Unaccessed non-private fields
• Unused parameters in non-private members
• Abstract or virtual events that are never invoked
• Unassigned fields
• Members and types that can be made internal instead of public

Look for these inspections in your code and on the Marker Bar, highlighted as warnings or suggestions. In addition, new code annotations are available that you can use to mark certain unused non-private types and members to prevent ReSharper from fussing about them.

VB9 Support – We can forgive this transgression (Damon)

Visual Basic .NET developers can now benefit from VB9 language support that includes implicitly typed local variables, object initializers, anonymous types, extension methods, lambda expressions, partial methods, and embedded XML. VB9 support is all around you, courtesy of new context actions, code completion, refactorings, and Parameter Info, among other supporting features.

Extended Naming Style Configuration

Now you can define custom naming style settings for different languages and symbols including:

• types
• namespaces
• interfaces
• parameters
• method properties and events
• static and instance fields, etc.

For every kind of symbol, you can configure one of five casing options, prefixes and suffixes, variations for different access rights, abbreviations to preserve, or enable naming inspections. As a result, you can precisely align the way ReSharper completes and generates code with your specific coding guidelines.

Other Enhancements

• Go to Implementation – This new navigation feature lets you jump from usage of a base type or member to any of its end implementations, bypassing intermediate steps in the inheritance chain.
• New and Improved Refactorings – ReSharper 4.5 has added Inline Field to its family of Inline refactorings. Rename refactoring now provides name completion, and some of the other refactorings were thoroughly refactored themselves, to make them perform faster.
• Native MSTest Support – Initially available through VstsUnit Plugin and then Gallio, MSTest support has finally made its way to being provided natively in ReSharper, on par with nUnit.
• Wider Cross-Language Capabilities – Quick-fixes and context actions work better in many cross-language scenarios: for example, you can extend a control written in VB.NET+XAML by choosing "create from usage" right from a C# usage. Add increased coverage for XAML and ASP.NET, and you get a substantial package of improvements.
• Smoother Language and Framework Support – Following the tradition of ReSharper 4.1, we have improved compatibility with F#, Compact Framework, Silverlight 2, and other languages and tools.

Grab your all-new productivity – download ReSharper 4.5 now at http://www.jetbrains.com/resharper/download.

ReSharper 4.5 is provided as a free upgrade from ReSharper 4.0. If you own an older version, please contact us to check your upgrade availability at sales@jetbrains.com.

JetBrains Team

• Sergey
  Anchipolevsky

• Igor
  Alshannikov

• Alexander
  Anisimov

• Dmitry
  Avdeev

• Sergey
  Baranov

• Yury
  Belyaev

• Natalia
  Belyaeva

• Elena
  Bukreeva

• Bulenkov
  Konstantin

• Jana
  Charif

• Nikolay
  Chashnikov

• Alexander
  Chernikov

• Roman
  Chernyatchik

• Sergey
  Coox

• Sergey
  Dmitriev

• Ilia
  Dumov

• Kirill
  Falk

• Michael
  Gerasimov

• Sergey
  Golovachev

• Alexey
  Gopachenko

• Peter
  Gromov

• Michaela
  Hroncová

• Dmitry
  Jemerov

• Maria
  Khalusova

• Valentin
  Kipiatkov

• Cyril
  Konopko

• Anna
  Kozlova

• Mikhail
  Kropotov

• Eugene
  Kudelevsky

• Alexey
  Kudravtsev

• Olga
  Lobacheva

• Vyacheslav
  Lukianov

• Anton
  Makeev

• Egor
  Malyshev

• Maria
  Marakulina

• Kirill
  Maximov

• Sasha
  Maximova

• Irina
  Megorskaya

• Lucie
  Morawiecova

• Alexander
  Morozov

• Maxim
  Mossienko

• Ekaterina
  Musienko

• Ann
  Oreshnikova

• Eugene
  Pasynkov

• Vaclav
  Pech

• Alexey
  Pegov

• Eugene
  Petrenko

• Irina
  Petrovskaya

• Mikhail
  Pilin

• Julia
  Repina

• Elizaveta
  Revyakina

• Ilya
  Ryzhenkov

• Andrew
  Serebryansky

• Ilya
  Sergey

• Maxim
  Shafirov

• Tatiana
  Slavina

• Olesya
  Smirnova

• Konstantin
  Solomatov

• Oleg
  Stepanov

• Pavel
  Sher

• Ekaterina
  Shliakhovetskaja

• Oleg
  Shpynov

• Gregory
  Shrago

• Eugene
  Toporov

• George
  Udov

• Sergey
  Vasiliev

• Natalie
  Yaremych

• Yegor
  Yarko

• Timur
  Zambalayev

• Sergey
  Zhukov

• Eugene
  Zhuravlev

• Alexander
  Zverev

JetBrains Team

On the heels of their 4.0 release which is arguably their most strategic in the .NET world to date, JetBrains continues to innovate with this beta.

Click here to download the new EAP post 4.0 release of 4.01 (a maintenance focused release).

Please participate by providing your experiences to JetBrains so they can evolve this work into another solid must have upgrade.

We’re using this release with great success (however we do not use the VB.NET aspects so no comment there).

Also make sure to check out the add-ins for 4.0 here.

Keep in mind, this post is not focused on DSL topics (one any developer cannot really afford to miss now), so one could debate the merits of the link I make. My argument is this:

My definition of a DSL is very simply :

A Domain Specific Language is a way, typically using a combination of visual and textual methods, or just textual, to solve a limited but typically non-trivial set of problems. It is typically a smaller stand-alone ‘language’ or language-extension to a larger more horizontal language such as C# (the point I make here is C# has evolved to allow you to expand C# with DSLs you write in C#. This is very different the the DSL Toolkit and I have never had this opinion until I finally got to be immersed deeply in functional style programming enhancements to C# and the ease of extending just about any API with extensions..

I continue the discussion of what a DSL is here. I will be adding to this section of the site over time but if you just want the listed info, no need to go on a tangent now.

Now that new .NET 3.5 C# 3.0 features are allowing us to make the Framework API of .NET work in ways not present ‘out of the box’ the scope of what is possible can be deep and broad.

Part 1 : The DSL Perspective – A Real Example

I’ll use a project we are working on now, which is quite specifically aimed to

• Minimize the configuration overhead of using an Inversion of Control container
• Provide the benefit of ‘provider/container’ independence
• Allow the consumer to change ‘container provider’ vendors with a simple change in ‘meta configuration’

In other words, we are trying to create an abstraction on top of an abstraction, as we believe this particular area is now mature enough (and indeed this is how software engineering historically more then not progresses over time) to do so.

This project has no intention of BEING an inversion of control container nor a dependency injector, rather its aim is to allow people to make use of these critical concepts in much easier ways while eliminating hesitation related to provider lock-in.

It’s no secret we are massive fans of the work of the Castle Project and they are indeed the first ‘plug-in’ adapter we are on schedule to deliver. However the architecture (something this post is NOT trying to explain) of our solution models the DOMAIN of this area, and is not specific to any particular offering (although to be blunt I would say if any bias existed it would be from the conceptual framework that exists now in the Windsor Container/MicroKernal trunk).

A domain specific example

In the area of ASP.NET one technique for loading our solution into memory is via the IHttpModule implementation we provide. Here is what the custom global.asax.cs code looks like:

public abstract class IntegrationPoint : HttpApplication, IDomainApplication {

private static IZeroConfigDI _container;

/// <summary>
/// Executes custom initialization code after
/// all event handler
/// modules have been added.
/// Also acquire a reference to the HttpModule
/// for IoC / DI if present as a module
/// </summary>
 public override void Init() {        

The interesting areas which are not provided by Microsoft include:

1. IDomainApplication interface
2. IZeriConfigDI Interface static reference
3. Modules.GetIoCModule()

The first two have more to do with our solution then the topic of this post, so I’ll focus on #3.

As this code is inside the HttpApplication, we have access to the Modules property which is read-only. Here is the documentation:

Your first reaction if your familiar with this collection is that it does not have anything even close to the GetIoCModule() method we are calling above.

Indeed this is our ‘domain specific’ extension to the .NET Framework API (one of many for this solution).

Here is the implementation of this ‘DSL’ extension:

/// <summary>
/// Provides ‘DSL specific’ extensions to the ASP.NET environment for
/// the IoC Zero Config environment which is not new (after all this becomes a static)
/// </summary>
/// The entire point for extension methods is ‘Fluency in API’ as it allows ‘shorthand’ code

public static class ZeroConfigInstanceResolver {

private const string ZeroConfigTypeString = "IoCConfigModule.IHttpModel";

 /// <summary>
/// Gets the IZeroConfigDI reference
/// (using domain specific logic and the 
/// generic logic extending the container)
/// </summary>
/// <param name="container">The container.</param>
/// <returns></returns>

public static IZeroConfigDI GetIoCModule(this HttpModuleCollection container) {

                        return
                              container.FindInstance(
                                () =>
                                        container.Get(ZeroConfigTypeString)
                                                    as IZeroConfigDI);

}

As you can see above we are very specific in our intent to add this to the HttpModuleCollection. There is nothing that interesting above except for the method call FindInstance(Func<TResult>) off the target ‘container’. This is a peek into the non-DSL related extension that represents. You might be aware that there is no such FindInstance available off the HttpModuleCollection.

One of our many goals in creating a fluent, easily used API is reducing complexity and providing very maintainable code. Here you can see the Lambada expression required to locate our service is hidden from the developer completely, yet this code is not a ‘one-off’ as we have provided both a DSL level extension in concert with a far more generic extension.

Part 2: Extending the Horizontal to Empower the Domain Specific

In looking at the HttpModuleCollection, and in our desire to facilitate other sources of resolving our module, it inherits from the abstract parent NameObjectCollectionBase.

Here is the definition of what inherits from this abstract parent:

The issue arises as this abstract base leaves it up to its concrete implementer to provide the indexer (or say Get() method) to access the object desired. Therefore a nice way to enhance this abstract type to work across all of the children is to literally pass in the method to resolve the object desired.

Part 3 : The Generic Extension

Here is the trivial extension method used to ‘open up’ the NameObjectCollectionBase and which is used above:

/// <summary>
/// Finds the instance in the NameObjectCollectionBase
/// using the Functor
/// </summary>
/// <typeparam name="TContainer">The type of the container.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="container">The container.</param>
/// <param name="finder">The finder.</param>
/// <returns></returns>
public static TResult FindInstance<TContainer, TResult>
       (this TContainer container, Func<TResult> finder)
              where TContainer : NameObjectCollectionBase where TResult : class {

                    return finder();

}

Since we cannot abstract up the get method, we take a page from Functional Programming and literally pass in the code to execute (which we do above).

A common pattern is to expose methods like the above, but add additional versions that allow more parameters into the Func<TResult>. This is well covered well by many of the Linq references and books available.

Part 4: How this allows us to embrace deep/wide change

A simplistic example is supporting the acquisitions of our target reference (IZeroConfigDI) if it is set as ApplicationState or as an IHttpModule. We could make the design decision to allow our find method to reside literally as an extension method of our HttpApplication (and indeed this turns out to be a reasonable choice as the valid inheritors from NameObjectCollectionBase are sealed and therefore invalid as generic constraints). Here is one approach (not ideal and not our final code but this illustrates the point.) Why not offer your optimized solution?

CODE:

public abstract class IntegrationPoint : HttpApplication, IDomainApplication {

private static IZeroConfigDI _container;

/// <summary>
/// Executes custom initialization code after
/// all event handler
/// modules have been added.
/// Also acquire a reference to the HttpModule
/// or Application State
/// for IoC / DI if present
/// </summary>
public override void Init() {

                  _container = this.GetIoCModule(); base.Init();

}

And the extension on HttpApplication:

public static class ZeroConfigInstanceResolver {

private const string ZeroConfigTypeString = "IoCConfigModule.IHttpModel";

/// <summary>
/// Gets the IZeroConfigDI reference if possible (null if not found)
/// using domain specific logic and the
/// generic logic extending the container.
/// </summary>
/// <param name="container">The container.</param>
/// <returns></returns>
public static IZeroConfigDI GetIoCModule(this HttpApplication container) {

                       var modules = container.Modules;
                       var applicationState = container.Application; 
                     

                        var resultVar = modules.ToInstance(
                                   () => modules.Get(ZeroConfigTypeString)
                         )
                        ?? 
                        applicationState.ToInstance(
                                   () => applicationState.Get(ZeroConfigTypeString)
                         );

                       return resultVar as IZeroConfigDI;

}

No change is required on the extension to the FindInstance extension.

Can you see how the above can be improved?

We expand this to make the ‘rule for finding the IZeroConfigDI external. To be specific, above we have a business rule implemented that we typically would not want ‘hard coded’. In fact more then not all things considered we want this. So we do the4 following:

• Determine the Delegate signature for the business rule.
• For the above, we need as input (at a minimum) an HttpApplication instance as that is the container for the models and state, and those two items lack a shared interface or base (or we could use that).
• The signature returns (in all cases) an instance cast where it implement IZeroConfigDI to resolve this business rule.
• Therefore the business rule signature is Func<HttpApplication ,IZeroConfigDI>

This content assumes you have an introductory knowledge of C# 3.0 language features in .NET 3.5 and mastery of legacy C# 2.0 Generics, Generic Type Constraints, Anonymous Delegates and related material.

I use a ‘pair programming’ approach with continued refactoring as this is how I would discuss it if you were coding with me, with an unfortunate one-way delivery.

The Brief Strategic View

Microsoft has slowly been moving C# in a very productive direction (this is not new, as these features existed in 2.0 although not nearly as well integrated) to provide ‘Functional Language’ features. If you don’t know or care about language semantics, just know that Linq and especially Lambada Expressions are about empowering you to use executable code like a variable, aka to leverage the power of functional programming. For more on this, read this MSDN article by Joel Pobar (former CLR Team) or read the next set of posts (part 2 onward) as I will go into the depths of this.

Painless Intro

I’ll start with a fairly trivial, yet important example (I use it every day). Many times when comparing Strings I want to ignore case and culture (the InvariantCulture). This is provided by an overload as such as you likely know:

[Test,Category("BaselineCore")]
public void shouldAsserStringCloneInvokeEqual() {

var baselineString = “This is a TEST CASE to IgnOrE Casing”;

var stringUpper = baselineString.ToUpperInvariant();

Assert.IsTrue(baselineString.Equals(stringUpper,
StringComparison.InvariantCultureIgnoreCase));

The test results are shown above. Pass. Ok so I really like short, concise code that is understandable at a glance. Also it’s a pain to always (even with ReSharper) use this (and I have seen people use RegEx for this! RegEx is awesome but overkill for this issue).

Refactoring

• Create an extension method on String
• Decide on a good name for the method (this is SO important and for most an afterthought!)

I’ve settled on calling this new method on String ‘EqualsCore’ as that is what we are doing, making the conditions for a match ’simpler’ and seeing ‘just the core values’ are the same (anyway it makes sense to me)., I suppose this could be ‘EqualsRelaxed’ or whatever..

Here is the test case (no code yet):

[Test, Category("BaselineCore")]
public void shouldAsserStringsEqualUsingExtension() {
var baselineString = “This is a TEST CASE to IgnOrE Casing”;
Assert.IsTrue(baselineString. EqualsSimple(baselineString.ToUpperInvariant())); }

Now we write the code. Here is the container for the extension method:

public static class StringExtensions {

public static bool EqualsSimple(this string sTarget, string compare) {

return sTarget.Equals(compare, StringComparison.InvariantCultureIgnoreCase); }

}

Indeed they both pass:

Since every type inherits from Object, and Equals is defined on Object, all instances should support this approach, and I could be early bound by using Generics…. Hmm…

I tried this (note: I gave it a new new ‘EqualsThis’ to separate them.

public static bool EqualsThis<TTarget>(this TTarget sTarget, TTarget compare){

return sTarget.Equals(compare);

}

Functionally not that interesting at all, but a test. So I typed in the following and wow… It works from Intellisense’s view… Ok it compiled! Wait…..FAIL! But why:?

OK here is the new test:

[Test, Category("BaselineCore")]

public void shouldAsserANYTHINGEqualUsingExtension() {

const String baselineString =”This is a TEST CASE to IgnOrE Casing”;

var sb = new StringBuilder(baselineString);

Assert.IsTrue(sb.EqualsThis(new StringBuilder(sb.ToString())));

}

Interesting…

Here is the documentation for what Equals means by default from Microsoft:

So our code fails using the extension yet this returns true:

[Test] public void shouldAssertStringBuilderExplicit() {

const String baselineString = “This is a TEST CASE to IgnOrE Casing”;

var sb = new StringBuilder(baselineString);

var sb2 = new StringBuilder(baselineString); Assert.IsTrue(sb.Equals(sb2));

}

So Reflector to the rescue once again. I could see in Reflector what I believed the issue was. Indeed the StringBuilder class has an overloaded Equals, and even making the extension method cast to the generic type directly was a no go.

This exposes one of the dangers that we must be incredibly careful with. It has always been poor design in my opinion to encourage developers to override common methods such as ToString() and Equals(object X) with their own behaviors as you force consumers of the API to understand IMPLEMENTATION. You cannot ensure your OK simply from a contract. This is known to be evil….

Of course this is a legacy style and will be slowly phased out.

Spin up reflector and look at the code for the OVERLOAD that StringBuilder has:

busy developing ReSharper 4 :) Here is quick update. We are currently working on preparing ReSharper for Beta – performance, memory, overall stability and reliability. Beta should be out very soon. Then we will have

post-Beta cleanup, more stabilization for Release, fill in missing bricks found during Beta, and then … Well, overall time scope for ReSharper 4 release is about a month. Thank you for your patience, we really appreciate your participation in our early access program! We are doing our best to deliver smart and quality product. And while we are here, what is *single* most important thing you want to be fixed/changed before release?

Sincerely,

Ilya Ryzhenkov

JetBrains, Inc

http://www.jetbrains.com “Develop with pleasure!”

From ReSharper’s EAP Site

I’ve been using the 4.0 EAP (pre-beta) since the first preview and it’s awesome… Rocky at times, but I’ve never lost any code (however you should use at your own risk!).

There is something very comforting in auto-creating an anonymous delegate and having it convert automagically to lambata syntax….

For example, here is a step by step from a real code sample:

C# 3.0 support

Implicitly typed locals and arrays

Fully supported, including suggestions to omit explicit type specification, Introduce Variable refactoring and context actions to convert to implicit or explicit form.

Extension Methods support

Fully supported, with Import Symbol completion (previously known as Type Name completion) after dot which can import suitable extension method and insert appropriate using directive. Analysis will suggest converting invocations from static-like to instance-like form. Context action can convert it back, and there are refactorings to convert static method of static class to Extension Method and update all call sites. There is also reverse refactoring, of course.

Object and collection initializers

Fully supported, with suggestions and context actions to fold series of statements to collection or object to initializer, if possible.

ReSharper also provides smart intellisense features in such places, like completing settable properies or displaying correct parameter information for Add method used in collection initializer.

Automatic properties

Fully supported, with context actions to convert to property with backing field and back. Analysis can show properties which are candidates for conversion. Code generation features may suggest creating automatic property in addition to property with backing field, if appropriate.

Anonymous types

Fully supported. ReSharper can search for similar anonymous types throughout the project or solution, give a name to anonymous type and replace usages, rename properties, suggest reordering properties if two anonymous types look similar and more.

Lambdas

Partially supported. By partially, it means that not all features we want there are ready. The code shouldn’t be red and intellisense should be working, but some context actions, quickfixes, analysis and such may be missing. We are actively working on those features, so as time passes ReSharper will be more and more smart about lambdas. We have conversion actions like delegate to lambda and back and some suggestions. Note, that not all features of ReSharper are lambda-aware yet, so they may fail when they happen to operate on lambdas.

LINQ

Almost supported. We import appropriate extension methods, provide intellisense, a number quickfixes, our refactorings are aware of queries. We also provide special live templates.

Partial methods

Not supported.

New and updated features

Go to Type, File, Symbol and Find Results

You can now put results of “Go to” features to find results for browsing

External Annotations

Ability to annotate external (non-source) symbols with ReSharper-specific attributes, like CanBeNull and NotNull. Note, that we standardized attribute names for better interoperability and less configuration hassle, so you may need to refactor you code a bit if you use these attributes.

Code Cleanup

Successor of Reformat Code, Optimize Usings and other code cleaning features – all in one interface with many more modules. Includes things like processing readonly fields, removing redundancies, updating file header, converting to automatic properties, replacing explicit types with vars and more. All in batch mode, so that you can instantly clean the whole project or even solution.

Plenty of new analyses

We added many more inspections in ReSharper 4. Some of them are related to C# 3.0 and deal with new language constructs. Also, there are new structure-related inspections, like “if” statement analysis, anonymous method closure analysis, and more. We also added new severity level for analysis results – Hint – which is a lot less intrusive. It does not participate in next/previous highlight navigation and is not shown on error stripe. It simply tells you: “Pssst! Take a look here, it can make your code look better.”

Complete Statement

Also known as Smart Enter, it inserts required syntax elements to complete the code you are writing. It can close parentheses as needed, add semicolon, complete constructs such as if, while, for and so on.

Completion with CamelHumps

All kinds of code completion (Symbol completion, Import Symbol Completion and Smart Completion) now supports filtering by CamelHumps, which tremendously speeds things up. E.g. if you know you have DefaultCodeCompletionManager type somewhere you just type DCCM and invoke Import symbol completion. Full type name will be inserted and using directive will be added as needed.

Refactorings

There are new refactorings related to C# 3.0 features, like “Convert Property to Automatic Property” and back, “Convert Static Method to Extension Method” and back and “Name Anonymous Type”. “Introduce Variable” is now dialogless and this improves coding flow a lot! Another great new refactoring is “Inline Method”, which can replace method call with method body at specific point or all over your code. “Method to Indexer” is a nice addition to “Method to Property” refactoring. There are also improvements in almost all refactorings, both in usability and smartness.

Recent Edits

In addition to Recent Files we created Recent Edits feature, which shows what you’ve been changing recently. If appropriate, it displays type and member the change occured in.

To-do items on identifiers and string literals

You can now configure ReSharper to search for specific patterns not only in comments, but also in string literals and identifiers. It is quite useful to set NotImplementedException pattern to have a quick access to code you have to write.

Support for solutions using different targets

ReSharper now fully supports solutions where different projects use different versions of CLR like .NET Compact Framework or Silverlight. You can now have e.g. Smart Device projects and normal projects in the same solution and all ReSharper features will work perfectly fine in this scenario.

Project References

This is more like preview of the feature which may or may not come into final bits of ReSharper 4. It can show dependencies between projects and libraries in terms of assembly references.

Live Templates Editor

We are improving usability of Live Templates editor and currently it is large work in progress. Be careful with it if you use custom templates.

Easier creation of new folders through generate (Alt+Insert shortcut)

Dozens of other features

We also have dozens of other minor features, keep track of

this tracker query for the current list.

ReSharper 4.0 EAP Notes – JetBrains.net

This is fantastic stuff coming from one of my all-time favorite companies, JetBrains. Here is a start:

Framework-usage pattern in MPS

Cyril Konopko, Konstantin Solomatov

Introduction

Language Oriented Programming or LOP is a software development approach which employs domain specific languages, or DSLs for short. A domain specific language, in contrast to general purpose languages, is a language which is designed to deal with one specific kind of tasks or with several related task kinds within a specific domain. For example, SQL is a DSL in a domain of database queries. LOP solves your main problem by dividing it into several subproblems in different domains, then each subproblem is solved using an appropriate DSL. In rather big projects, LOP can reduce singificantly the amount of work which has to be done.

In this article we will speak about JetBrains MPS, being developed by JetBrains, Inc., which is a so-called “language workbench”, i.e. a tool that helps you to use LOP in practice. You can read more about language workbenches on Martin Fowler’s site and about LOP in Sergey Dmitriev’s article.

A lot of people who heard about MPS don’t realize how it’s possible to take advantage of it. The current state of MPS is far from the point where you can throw away your Java or C# IDE and start writing everything in MPS with LOP, however it’s possible to use LOP and simplify some tasks significantly today. Actually, you probably use in your current project some kind of poor man’s LOP, techniques which make it possible to create small sublanguages in the program written on a language like Java, C#, or Ruby (Martin Fowler called such sublanguages Internal DSLs). This article explains the pattern that can employ MPS in its current state, describes prevalent poor man’s LOP tricks and presents several examples of it.

….

Seriously, check this out. Download the EAP, start using…..

Thanks,

Damon

Software Engineers (especially the .NET community due to their near ubiquitous refusal to support non-Microsoft aspects of their world) are entering what I have observed to be a disastrous collision which the ‘non-technical’ domain and business stakeholders. The cat is out of the bag that limitations such as this are almost always arbitrary, destructive, and based on human refusal to change. This is completely out of sync with trends now established in this decade and will not be allowed to play the common role of the past in a dramatic lowering of overall return on investment.

It’s asking a lot but don’t think this is not already in every shop as anything more then the pain of the shift. The technology has worked for years and any market driven economy will certainly not accept 100-1000% waste lying down. When these trains collide be prepared by already mastering the items here or I believe you are putting your future at unnecessary risk. SOA and Domain-Driven Development: One more nail in the coffin of business/technology separation the first part of this decade we saw the unique focus on eliminating barriers between platforms and the views of the business experts and the technologists who must implement their vision. Both of these areas are quite disruptive and one could say key to solving the utter inability of software engineering to satisfy their stakeholder with high probability.I love that light is being shined into areas that many hide in under the excuse of ‘incompatible systems’ or ‘unreasonable expectations for both expertise in the technology AND business’. Any opportunities for professionals to be ignorant of their domain (and even not to be experts in a domain) are not diminishing and it is safe to say will soon be almost gone completely.

Reality Check

Software engineering is empowered (perhaps for the first time at this level of real value-added abstraction) to ignore what previously occupied most of our days. This is no suprise as

we are defined by layers of abstraction.To be specific it is not acceptable to deliver solutions which are constrained by com

mon factors such as database vendor, operating system, protocols, browser version, and all of the other technical reasons that often emerge and often deeply diminish the return on investment in software. After all what reason is there to resist your ability to maximize the benefits to people who use and benefit from your work? It’s your conscious decision to ignore areas where this posts make the case will potentially be fatal.

.NET professionals are just now being forced to do the common sense items that our Java compatriots understood years ago. I like both platforms and I do far more work in .NET, however let there be no doubt on the fact that compared to the Java world as a group we pale miserable on average. This is factual to the point of the reality of evolution and I am amazed at the (what always emerges) utter ignorance of the big picture by those who argue otherwise.

ALT.NET as a group is nothing more then group who collectively understands they know what is going on in our world, on what it means to be passionate and strive for amazing achievement in their work. No such group exists that I am aware of for any other platform NOR DOES IT NEED TO. Unfortunately .NET is bifurcated between the lost and the often amazing with a middle class that is growing.Although the initial shorter term rapid development benefits in .NET were great for the inexperienced managers who had no clue that pain would emerge soon, it’s now mature enough to prove the Java guys were right all along. The issue is the migrations have occured and nobody wants to eat their words.Luckily there is no need to as .NET is an amazing platform (as is the J2EE) however that pales in comparison to the handicap inherited by the available resources. No comparison,even if the platform has areas that are better any benefit is lost in the general limitation in the people. I hate this as much as anyone and spend much of my life tring to help fix this. What I have realized is all I am doing is helping to seperate the classes further.

Clearly now I can see with my new glasses

In spite of decades of study, by necessity and the stated SOA and Domain wok the blinders are off and bluffs are being called everywhere I look. A real understanding of ’sustainable’ architecture’ is finally a consideration and the fact that more people will increase your failure expectation. In additi

on expectations do not allow for the inability to adapt not only in key business inflections but also most conceivable technology inflections. Don’t box yourself into an inability to deliver at the ‘business leve’ full stop. In other words, if technical limitations such as an inability to support mono on Linux will be no more acceptable then flexibility in continual requirements modifications. Consider focusing NOW your ability to deliver BUSINESS value that has limited risk of interruption due to technical issues and/or incompatibilities. I am finalizing this section of the book so expect a super set to be there, however if lucky some ideas will be developed here (and I can credit people who offer guidance in their domain).Specifically this is about strategic/transformation projects with a foundation in software product line development (including SaaS and SOA as well as innovative reinvention of what software is and how it is sold, marketed, developed, and optimized), and other forms of software where the downsides are measured in lost jobs, dreams destroyed, and even human death.

Software fails far more then it succeeds by any metric

However my point is not so much around this as ‘failure’ is arbitrary and definitions such as making budget, time, quality and scope are now laughably simple and irrelevant when software is often expected to REALLY be a meta-meta abstraction of itself, able to transform into whatever someone wants it to be. Why does this now exist in the face of continued failure and utter lack of predictability in most software development?I will raise a few here (and go deeper later) and frankly it is about time non-technical stakeholders said ‘enough is enough’ even if their alternative are incredibly limited. After all, outsourcing is a failure except for now well understood areas. That being said, software teams on average are often too busy wallowing in the ‘operational overhead’ world of ‘no respect’ deliveries then being invigorated to fix themselves (which is all about human deficiencies not real limitations more then not).If there was ever a time to wake up and transform your entire world it is now. If there was a central theme then here it is this: Life will be getting much harder for even the best groups, and again statistics would show you are likely not one of them. Therefore, your challenges if action is not taken now could be fatal for the first time as alternatives are emerging that actually work to allow a CEO to fire his entire development shop. Outsourcing? Nah they all go away as the barriers between the business experts and the tangled technical experts is well into disappearing and will be almost certainly gone soon (a good thing for those of us who see the opportunity this presents).

Recent Factors that Changed Expectations : Don’t talk to me about non-business constraints

No one can argue the effective and ubiquitous expectations using Domain focused development to minimize the barriers derived from software due to ‘pure technical constraints’. In other words nobody wants to hear that something is deeply broken due to reasons related to bits and bytes. That will not fly for much longer and frankly it almost always is due to inept and unmotivated teams refusing to make hard but common sense changes.I hear C-Level execs performing push-back and feeling emboldened to refuse to be ‘baffled by bull**it from a collection of quickly articulated acronyms).After all, enough is enough. No individual can be blamed to have reached the end of their tolerance for the nightmare most software teams inflict on all in their business stakeholders. Even amazing technical teams often fail due to an arrogant refusal to allow the business strategy to drive the solutions they develop. With the obvious exception of companies ‘in the business of software innovation.

People forget that their technical brilliance means little if it is not aligned to the ‘measure of goodness’ defined by their stakeholders in the business.

For example, Service Oriented Architecture eliminates waste in software due to eliminating the massive historic energy in system integration, high level strategic software asset reuse, full realization of return on investment in software as well as a common sense way to ‘make it work and don’t make excuses about technology I do not understand’.Another force is the acceptance and imperative around ‘domain driven’ teams, A main reason this is now a mandate?Why suffer by allowing technologists to refuse to master their domain? This is not viable for many reasons (although of course certain deep specializations will always exist).

Consider that the key areas which have transformed software are already set in stone, yet as is common only the minority leverages there utterly fundamental empowerments. Said another doing Object to Relational Mapping, leveraging the ‘Enterprise Architecture as a Commodity’ and many key areas further creates a small upper class, an almost non-existent ‘upper class’ and a ‘mass market’ lower class which wallows in the muck of the past, continuing to fail their stakeholders as regularly as ever.

It is the pioners and amazing minds in the open source movement (especially the Castle Project, NHibernate, etc.) which have TAUGHT US what is possible, and there is no going back or denying that is real, installable and fully able to handle most of the most demanding requirements in an ‘inflective’ manner (this includes but goes well beyond the elimination of code in favor of run-time configuration at the most fundamental levels).

Continuing to ignore the shift required of all of us (yes you REALLY must forget ADO.NET for the most part, and that is a good thing) will get you fired in most top technology shops as it damn well should. After all this is not even close to ‘bleeding edge’ let alone ‘cutting edge’ anymore. If you fail to adapt you are stealing from your emploter, full stop (and it is your job to educate them more then not and no, you cannot say it’s not your job). If they want to be mediocre and cause your career to flounder LEAVE AND FIND A NEW JOB.

But it’s not like I have an opinion (grin)…..

With Respect,

Damon Wilder Carr

This is known by many who have been doing VSX for a while, but I ran into it again recently and thought since many are no getting into this fresh, more sources are good.

“Unhandled Exception: System.IO.FileNotFoundException: Error while loading file ‘EnvDTE, Version=7.0.3300.0″

<configuration>

<runtime>

<assemblyBinding xmlns="urn:schemas-microsoft- com:asm.v1"

appliesTo="v2.0.50318">

<dependentAssembly>

<assemblyIdentity name="EnvDTE" publicKeyToken= "b03f5f7f11d50a3a"/>

<bindingRedirect oldVersion="7.0.3300.0" newVersion="8.0.0.0"/>

</dependentAssembly>

</assemblyBinding>

</runtime>

</configuration>

Today JetBrains released the final version before 4.0 comes out it appears. Here are all the goodies.They got to some REALLY nice ones…

 Has anyone else struggled with the VS Debugger treating the ReSharper assemblies as if they were ‘user code’?

• Overview
• Features
• Docs and Demos
• Download
• Licensing & Upgrade

• ReSharper 3.1

Complete List of 3.1 Release Notes

Bug-fixes Exception Performance Problem Usability Problem

Cosmetics New Feature Task

Bug-fixes

• [RSRP-18041] – Incorrect message “Cannot resolve symbol ‘Bind’”
• [RSRP-30232] – Solution analysis progress should be hidden, when user disables analysis when progress is shown
• [RSRP-33809] – False error report: cannot convert source type ’string’ to target type ‘byte?’
• [RSRP-35188] – Solution-wide error analysis does not proceed .xaml files
• [RSRP-35849] – Operator resolve problem [equality operator for lifted bool]
• [RSRP-36350] – Bad nullable management
• [RSRP-38275] – Errors view: multiline error messages are drawn incorrectly
• [RSRP-38667] – Go to Next/Prev error in solution: do not show “No errors found in solution” when analysis in progress
• [RSRP-41475] – Solution Analysis should use delayed control creation – ErrorsViewControl takes 5% of solution load time
• [RSRP-43079] – VB property return value assignment resolve problem
• [RSRP-44587] – SWA: Changes in Delegate Signature -> Event Subscriptions Not Checked
• [RSRP-44590] – SWA: Changes in Event Type -> Event Subscriptions Not Checked
• [RSRP-44591] – Hightlight expression usages does not work for delegate creation expression
• [RSRP-44592] – Hightlight expression usages does not work for cast expression
• [RSRP-44985] – [VB] Assignment operator like += should have reference
• [RSRP-46385] – ASP ApplicationInstance property is not generated
• [RSRP-46530] – web.config file added to the website is not processed by ReSharper unless website is reloaded
• [RSRP-46996] – XAML Import popup in {x:Type xxx} works incorrectly
• [RSRP-46997] – XAML resources referenced by key
• [RSRP-46998] – XAML TemplateBinding without an attribute name
• [RSRP-47104] – ParameterInfo shouldn’t consume TAB strokes in case there is only one or two arguments in the invocation
• [RSRP-47244] – SWA: “DLL Not Referenced” Error Is Not ReChecked After Adding a Reference
• [RSRP-47451] – Code completion in aspx inserts erroneous text
• [RSRP-47475] – Implement members: wrapping into regions generates regions into wrong places!!
• [RSRP-47555] – Extract interface -> wrong interface is suggested to be used
• [RSRP-47694] – SafeDelete removes ’set’ property accessor that has usages
• [RSRP-47991] – SWA: Upon an Exception in the Daemon, the Analysis Never Stops
• [RSRP-48015] – “Go To Definition” for System.Collections.Generic.Dictionary.TryGetValue() selects the namespace, not the method
• [RSRP-48132] – ‘Find Dependent Code’ is disabled for projects in a simple solution
• [RSRP-48265] – String formatting methods persistence doesn’t work
• [RSRP-48529] – Generate Implementation @VB: Does Not Expand Generic Parameters
• [RSRP-48651] – Go to next error doesn’t work inside file, when SWEA is turned off
• [RSRP-48806] – ReSharper resolves symbol to a class while C# compiler resolves that symbol to property
• [RSRP-49306] – error CS0165: Use of unassigned local variable ‘z’
• [RSRP-49307] – error CS0221: Constant value ‘-1′ cannot be converted to a ‘byte’ (use ‘unchecked’ syntax to override)
• [RSRP-49309] – ‘checked’ statements are not taken into account during constant expression evaluation
• [RSRP-49325] – [SWEA] Adding of private constructor to class A does not invalidate ‘new A( )’ expressions in other files
• [RSRP-49532] – Suggestions are no longer considered by Go To Next Highlight
• [RSRP-49587] – “String Formatting Methods” settings are not persisted across restarts
• [RSRP-49637] – Turning solution analysis off does not clear “x files with errors” and Errors view
• [RSRP-49865] – Solution analysis: support openning one solution by multiple instances of VS
• [RSRP-50146] – In build 532, Resharper does not highlight wrong arguments in format string in string.Format
• [RSRP-50195] – Refactorings: it always says that changes in conflicts detected when I try to ignore conflicts!
• [RSRP-50233] – UI meshing (see picture)
• [RSRP-50319] – Quick fix ‘Change Signature of the Base Method’ doesn’t open the base type in the editor
• [RSRP-50349] – Custom String Formatting Methods are not persisted between Resharper installations
• [RSRP-50554] – Doesn’t recognize standart XAML keywords (see picture)
• [RSRP-50559] – Not all usages of property setter found
• [RSRP-50607] – Solution analysis does not reanalyze necessary files when adding abstract member implementation
• [RSRP-50650] – Solution analysis: drop all data structures from memory on disabling
• [RSRP-50739] – Generate ctor in vb doesn’t consider base type’s ctors
• [RSRP-50742] – Delegating properties in VB is broken
• [RSRP-50751] – Create Property from usage doesn’t work when Property is defined in VB and usage is in C#
• [RSRP-50752] – QF to change property parameter type doesn’t work from C# when property is declared in VB
• [RSRP-50827] – Quotes autoinsertion doesn’t work in VB
• [RSRP-50869] – TypeIndex is rebuilt on each LoadAssemblies, thus useless when plugins are installed
• [RSRP-50905] – Solution analysis crashes when using “Clear Caches” button
• [RSRP-51047] – ReSharper is unable to parse russian stacktrace
• [RSRP-51121] – XAML::VB: Caps and Underscore in Error Text
• [RSRP-51139] – Global analysis page layout is bad under Vista
• [RSRP-51188] – Overrides are not recognized in VB when signature of base method (in c#) contians ‘out’ parameters.
• [RSRP-51214] – Refactor -> Safe Delete -> delete parameter from method without checking for usages (C# & VB.NET)
• [RSRP-51221] – VS seems to fail if it is being closed while solution analisys is running
• [RSRP-51317] – VB: Implement on an Interface in the Implements List: Lists Accessor Methods for Properties, Which Throws If Selected
• [RSRP-51363] – Completion in ASP inserts bogus parenthesis
• [RSRP-51382] – ReSharper cannot load solution is on RO drive (caches loading hangs)
• [RSRP-51388] – Generate::Implement::VB: “Implement Via” Column Is Always Empty
• [RSRP-51469] – “OK” in options dialog dosn’t save solution-level settings
• [RSRP-51548] – Unit Test Session shows time [5:43.30001] that is consfusing!
• [RSRP-51569] – Publisher policy should be installed during upgrade
• [RSRP-51577] – CA::VB::IterateCollForeach: Not Available on some Strings
• [RSRP-51579] – CA::VB::ForeachToFor: Restore Missing Method Call Parens When Adding Array Index Parens
• [RSRP-51626] – Bug in VB parser
• [RSRP-51716] – CA::VB::IntroduceVar: Should Place a HotSpot on the Type
• [RSRP-51733] – TypeCompletion::VB: Add Square Brackets When Conflicting with Keywords
• [RSRP-51736] – ChangeSIgnature::VB: Fails on Writable Properties
• [RSRP-51738] – SmartCompletion::VB: Does Not Include “Nothing” When Appropriate
• [RSRP-51760] – “On Error Goto Label” should be handled in control flow
• [RSRP-51769] – IntroVar::VB: Should Remove the Original Expression When Just Creating a Declaration
• [RSRP-51783] – CA::VB::CreateFromUsage: Invalid Access Modifiers
• [RSRP-51819] – CA::VB::CreateFromUsage: “Create Method” Kills Suggested Names As Executing the LiveTemplate
• [RSRP-51820] – LiveTemplates::VB::TypeCompletionMacro Doesn’t Work
• [RSRP-51821] – CA::VB::ImplementMembers: Fails on Events
• [RSRP-51823] – CA::VB::CreateFromUsage: “Create Method” Fails Where a Typed Delegate Is Expected
• [RSRP-51824] – CA::VB::CreateFromUsage: “Create Class” Fails to Set the Correct Access Modifier
• [RSRP-51867] – CA::VB::Implement: “Copy Documentation Comments” CheckBox Does Not Work
• [RSRP-51874] – CA::VB::ForeachToFor: Fails on 2D Arrays
• [RSRP-51877] – CA::VB::SplitDeclaration: Should Be Available on the Assignment Operator
• [RSRP-51878] – VB::MoveStatementOut: Eats the Statement Being Moved Out of “Case”
• [RSRP-51888] – Refac::VB::IntroduceVar: Fails to Suppress PrettyListing
• [RSRP-51922] – Expand selection in ASP.NET strings (attribute values) should select text without quotes if invoked right before closing quote
• [RSRP-51936] – Default “sub” template should have parenthesis after $NAME$
• [RSRP-51938] – IntroduceVariable::VB: Fails to Infer the Type in an Obvious Case
• [RSRP-51979] – CA::VB::IfToSwitch: Don’t Create CaseElse If There Were no Unconditional Else
• [RSRP-52027] – Uncomment block in VB cause exception and breaks code
• [RSRP-52099] – Move type to namespace in XAML VB does not take default namespace into account
• [RSRP-52162] – Cannot resolve symbols “DataItem” error inside <%# block
• [RSRP-52252] – Create method from usage doesn’t select method body at the end
• [RSRP-52425] – Does not recognize LINQ syntax
• [RSRP-52560] – Wrong result for Alt+Enter context action
• [RSRP-52638] – ErrorInfo seem to be loaded, even if SWEA is off
• [RSRP-52899] – SWEA doesn’t recognize hierarchy dependencies when renaming interface member
• [RSRP-52939] – Solution Settings Are Not Saved upon Closing Solution / Exiting VS
• [RSRP-53127] – “Analyzing changes” animated icon in errors view should not include background from statusbar
• [RSRP-53328] – SWEA errors view: files with error are not shown
• [RSRP-53420] – ReSharper 3.1 doesn’t upgrade from ReSharper 3.0 settings
• [RSRP-53444] – Solution analysis should be removed from VB edition
• [RSRP-53493] – CLONE -Cannot resolve symbol ‘onclick’ on asp.net controls
• [RSRP-53750] – R# overrides parameter info in Visual Studio IntelliSense
• [RSRP-53784] – Errors view: popup menu resets multiselection
• [RSRP-53846] – VS 2008 halt down during editing hex value of “color” property in css file
• [RSRP-53948] – Unit Testing from derived type.
• [RSRP-54074] – Errors view: errors inside file are not sorted
• [RSRP-54076] – Exception
• [RSRP-54155] – Editing CSS Files Crashes VS 2008
• [RSRP-54199] – Extract Interface suggest Object instead of the Interface for replacing the usings.
• [RSRP-54258] – incorretly analyze soultion with errors in XAML files
• [RSRP-54879] – IDE crashes with R# and BlackBerry plugin
• [RSRP-54919] – Disabling SWEA or even closing solution does not release SWEA caches for this solution
• [RSRP-54958] – In build 583 all ReSharper menu items are disabled in both VS 2005 and 2008. Completion and highlighting do not work.

Cosmetics

• [RSRP-48928] – “SWEA is off. Click for options”. But click does not work. Double-click is needed.
• [RSRP-49729] – ErrorsView: Use Standard Icon for Options
• [RSRP-49730] – ErrorsView: SkipFile Should Be Green Not Red
• [RSRP-50200] – Precompose the SWA Indicator Before Blitting to the Screen
• [RSRP-51228] – SWA ErrorsView: “Checking for Changes…” Section Heading Should not Have the Ellipsis
• [RSRP-51691] – SWEA options: Add/Remove buttons should have accelerators
• [RSRP-51694] – SWEA status is displaying conflicting information
• [RSRP-54716] – Visual Studio splash still displays 3.0.3 EAP instead of 3.1 RC

Exception

• [RSRP-30299] – Duplicating record in solution analisys dependencies cache
• [RSRP-31523] – Duplicating record in word index cache
• [RSRP-31661] – Duplicating record in TODO cache
• [RSRP-37559] – Untested case : /// <summary>
• [RSRP-38509] – Duplicating record in file images cache
• [RSRP-39411] – Untested case : __ReSharper_Property_Binder__( __TEMP_f119d676_b23d_4bd4_b0c3_72c4c577b50f,@”OnItemDataBound”,@&q uot;changeCategoryList_ItemDataBound” )
• [RSRP-40633] – Object reference not set to an instance of an object.
• [RSRP-41117] – PsiManager is null in write action!
• [RSRP-42405] – One layouter of the ParameterInfo kind has already been created over this text control, and it is still active.
• [RSRP-43032] – Object reference not set to an instance of an object.
• [RSRP-45359] – Project root does not belong to the project
• [RSRP-45427] – Offset/Line transformation failed: Line is ‘ <input type=”button” id=”m_buttonDeclineWithdrawal” onclick=”window.location=’./Page.aspx?pgtid=3′” value=”<%=CancelText%>” class=”AppButtons” />’, coords: (91,4), line range: (5166,5320), text ran
• [RSRP-45587] – Object reference not set to an instance of an object.
• [RSRP-45687] – Project root does not belong to the project
• [RSRP-46063] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-46084] – Unknown comment! ’s doch gar nicht. ;-)
• [RSRP-46337] – at VSSolutionManager.<UpdateSolution_Done>b__1d : CurrentSolution != null
• [RSRP-46596] – at CSharpExtractMethodFactory.GetStatementsRange : Object reference not set to an instance of an object.
• [RSRP-47222] – JetBrains.Util.InternalErrorException: The indicator “JetBrains.ReSharper.Daemon.Impl.SolutionAnalysis.UI.Indicator.StatusBa rIndicatorControl” [...] desired size {Width=127, Height=21} does not respect the limit {Width=126, Height=21}.
• [RSRP-47321] – at ThrowHelper.ThrowInvalidOperationException : Collection was modified; enumeration operation may not execute.
• [RSRP-47349] – at ParameterInfoControl.LayoutControls : MaxWidth must be positive
• [RSRP-47436] – at CommonDataRules.DocumentToReferenceRule : Object reference not set to an instance of an object.
• [RSRP-47460] – Culture name ‘n’ is not supported.
• [RSRP-47478] – at ThrowHelper.ThrowKeyNotFoundException : The given key was not present in the dictionary.
• [RSRP-47508] – Collection was modified; enumeration operation may not execute.
• [RSRP-47635] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-47688] – at LowLevelModificationUtil.GetManager : PsiManager is null in write action!
• [RSRP-47698] – range.EndOffset should not break CR-LF
• [RSRP-47830] – !typeDeclaration.IsValid()
• [RSRP-47896] – at VisualStyleRenderer.IsCombinationDefined : Visual Styles-related operation resulted in an error because no visual style is currently active.
• [RSRP-47935] – at TreePresenter.PresentFile : Object reference not set to an instance of an object.
• [RSRP-47959] – at ProjectFileWrapper.UpdateTimeStamp : Object reference not set to an instance of an object.
• [RSRP-47963] – at Daemon.GetInstance : Object reference not set to an instance of an object.
• [RSRP-48080] – at StringBuilder.Append : Index was out of range. Must be non-negative and less than the size of the collection.
• [RSRP-48103] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48267] – alt + ins create a contructor
• [RSRP-48304] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48326] – at DeclaredElementPointer.FindDeclaredElement : Documents are not committed when trying to restore IDeclaredElement from pointer.
• [RSRP-48402] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48502] – at VisualStyleRenderer.IsCombinationDefined : Visual Styles-related operation resulted in an error because no visual style is currently active.
• [RSRP-48566] – at Control.get_Handle : Object reference not set to an instance of an object.
• [RSRP-48582] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48625] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48636] – at ProjectImpl.RemoveProjectRoot : Project root does not belong to the project
• [RSRP-48675] – at ThrowHelper.ThrowKeyNotFoundException : The given key was not present in the dictionary.
• [RSRP-48732] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48741] – at MethodDeclarationBase.CalculateHashInternal : Das Objekt des Typs JetBrains.ReSharper.Psi.VB.Impl.Tree.ExternalMethodDeclaration kann nicht in Typ JetBrains.ReSharper.Psi.VB.Tree.IMethodDeclarationNode umgewandelt werden.
• [RSRP-48762] – at ProjectImpl.RemoveProjectRoot : Project root does not belong to the project
• [RSRP-48776] – exception in Re# (VS 2005)
• [RSRP-48780] – at VSTypeBrowser.GetLibNameForVB : Object reference not set to an instance of an object.
• [RSRP-48803] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-48818] – at ProjectImpl.RemoveProjectRoot : Project root does not belong to the project
• [RSRP-48834] – at SolutionAnalysisIndicatorWrapper.<SetNonIdle>b__8 : Object reference not set to an instance of an object.
• [RSRP-48923] – at PsiManager.PsiFile : Object reference not set to an instance of an object.
• [RSRP-48935] – at String.CtorCharArrayStartLength : Exception of type ‘System.OutOfMemoryException’ was thrown.
• [RSRP-48984] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-49051] – at DstRangeRemovedAction..ctor : Expected 1 token, found: 5. Removed text: [__ReSharperSynthetic]
• [RSRP-49112] – at ThrowHelper.ThrowInvalidOperationException : Collection was modified; enumeration operation may not execute.
• [RSRP-49220] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-49272] – Object reference not set to an instance of an object.
• [RSRP-49384] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-49391] – at ProjectFileWrapper.RestoreProjectFile : !myProjectFile.IsValid
• [RSRP-49646] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-49663] – at TextControlToPsi.GetSourceTokenAtCaret : Object reference not set to an instance of an object.
• [RSRP-49894] – Object reference not set to an instance of an object.
• [RSRP-49911] – Reformat code – Reorder type members – Exception thrown
• [RSRP-49950] – at ThrowHelper.ThrowArgumentNullException : Value cannot be null.
• [RSRP-50060] – at Resolver.get_ProcessingIsFinished : Exception of type ‘JetBrains.Shell.Progress.ProcessCancelledException’ was thrown.
• [RSRP-50175] – JetBrains.Util.InternalErrorException: typeElement.IsValid()
• [RSRP-50190] – End offset should be less or equal then text length
• [RSRP-50205] – at Path.CheckInvalidPathChars : Illegal characters in path.
• [RSRP-50209] – at ThrowHelper.ThrowArgumentOutOfRangeException : Index was out of range. Must be non-negative and less than the size of the collection.
• [RSRP-50223] – at ContextTracker..ctor : textRange.StartOffset <= textControl.CaretModel.Offset
• [RSRP-50254] – at ModificationUtil.CreateCopy : node.IsValid()
• [RSRP-50255] – at CSharpExpressionBase.CompileTimeConstantValue : Object reference not set to an instance of an object.
• [RSRP-50353] – at Gdip.GdipDrawImageRectI : Attempted to read or write protected memory. This is often an indication that other memory is corrupt.
• [RSRP-50480] – at SkipFileAction.Execute : Object reference not set to an instance of an object.
• [RSRP-50501] – at SolutionAnalysisManager.GetFilesToAnalyze : Condition (!HasChangesToFlush) is false
• [RSRP-50604] – JetBrains.Util.InternalErrorException: range.EndOffset > textLength
• [RSRP-50681] – at ThrowHelper.ThrowKeyNotFoundException : The given key was not present in the dictionary.
• [RSRP-50691] – at ProjectModelWrapper.FileRemoved : !file.IsValid
• [RSRP-50705] – at AbstractPersistentCache`2.Save : Condition (!myDiskCacheReleased) is false
• [RSRP-50803] – Write lock can be aquired only from primary thread, when read lock os being held
• [RSRP-50809] – at Property`1.SetValue : This property is not allowed to be Null.
• [RSRP-50872] – at DocumentManagerImpl.GetProjectFile : Value cannot be null.
• [RSRP-50978] – at LookupUtil.AssertDocumentRangeIsValid : Invalid range: cuts line break
• [RSRP-51124] – at ProgressStatusControl.DrawRoundProgress : Index was outside the bounds of the array.
• [RSRP-51125] – at __Error.WinIOError : Access to the path ‘_ReSharper.TempSolution\WordIndex.New’ is denied.
• [RSRP-51130] – at ThrowHelper.ThrowInvalidOperationException : Collection was modified; enumeration operation may not execute.
• [RSRP-51340] – Opening a Build Type always results in an Unhandled Exception
• [RSRP-51342] – Unloading a project resulted in Unhandled Exception – JetBrains.Util.InternalErrorException: !file.IsValid
• [RSRP-51383] – JetBrains.Util.InternalErrorException: Object reference not set to an instance of an object.
• [RSRP-51413] – at ForEachToForAction.ExecuteInternalEx : Unable to cast object of type ‘JetBrains.ReSharper.Psi.VB.Impl.Tree.LiteralExpression’ to type ‘JetBrains.ReSharper.Psi.VB.Tree.IIndexExpression’.
• [RSRP-51431] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-51449] – at ThrowHelper.ThrowArgumentOutOfRangeException : capacity was less than the current size.
• [RSRP-51855] – at CreateFieldFromUsageFix.IsAvailableEx : Object reference not set to an instance of an object.
• [RSRP-51863] – at TreeModelView.ViewToModel : Value cannot be null.
• [RSRP-51882] – at LabelDeclaration.SetName : Operation is not valid due to the current state of the object.
• [RSRP-51911] – at TreePresenter.PresentFile : Object reference not set to an instance of an object.
• [RSRP-51937] – at VBMoveStaticMembers.GetOrCreateTypeMemberDeclarationInTargetType : Unable to cast object of type ‘JetBrains.ReSharper.Psi.Xaml.Impl.Tree.XamlTypeDeclaration’ to type ‘JetBrains.ReSharper.Psi.VB.Tree.IClassLikeDeclaration’.
• [RSRP-52040] – at ModifierFixBase.ExecuteEx : Unable to cast object of type ‘JetBrains.ReSharper.Psi.VB.Impl.Tree.EnumDeclaration’ to type ‘JetBrains.ReSharper.Psi.CSharp.Tree.ICSharpTypeMemberDeclaration’.
• [RSRP-52082] – at VBExpressionBase.NeedToParenthise : Object reference not set to an instance of an object.
• [RSRP-52159] – at TreePresenter.PresentFile : Object reference not set to an instance of an object.
• [RSRP-52179] – at ArraySortHelper`1.QuickSort : Failed to compare two elements in the array.
• [RSRP-52242] – at ModifierFixBase.ExecuteEx : Unable to cast object of type ‘JetBrains.ReSharper.Psi.VB.Impl.Tree.VariableDeclaration’ to type ‘JetBrains.ReSharper.Psi.CSharp.Tree.ICSharpTypeMemberDeclaration’.
• [RSRP-52279] – at Mutex.ReleaseMutex : Object synchronization method was called from an unsynchronized block of code.
• [RSRP-52317] – at SplitDeclarationAction.IsAvailableInternal : Object reference not set to an instance of an object.
• [RSRP-52340] – at MemoryStream..ctor : Buffer cannot be null.
• [RSRP-52349] – at AbstractPersistentCache`2.Save : Condition (!myDiskCacheReleased) is false
• [RSRP-52387] – at XmlAttribute.get_AttributeName : Object reference not set to an instance of an object.
• [RSRP-52625] – at ThrowHelper.ThrowArgumentOutOfRangeException : Index was out of range. Must be non-negative and less than the size of the collection.
• [RSRP-52792] – Es wurde versucht, im geschützten Speicher zu lesen oder zu schreiben. Dies ist häufig ein Hinweis darauf, dass anderer Speicher beschädigt ist.
• [RSRP-53046] – at CodeCompletionActionBase.Execute : Object reference not set to an instance of an object.
• [RSRP-53179] – at BulbManagerImpl.ShowIndicator : Object reference not set to an instance of an object.
• [RSRP-53208] – at BulbManagerImpl.ShowIndicator : Object reference not set to an instance of an object.
• [RSRP-53652] – at SolutionAnalysisManager.SetFileState : The condition (state == FileState.UP_TO_DATE) is false.
• [RSRP-53755] – JetBrains.Util.InternalErrorException: Unkown feature id:BasicCompletion
• [RSRP-53938] – Cannot access components before instantiation of all components. E.g. in constructor of a component, use Init() method instead.
• [RSRP-53974] – JetBrains.Util.InternalErrorException: Object reference not set to an instance of an object.
• [RSRP-54018] – at ThrowHelper.ThrowArgumentException : An item with the same key has already been added.
• [RSRP-54019] – at DocumentManagerImpl.GetDocument : Attempted to retrieve document for invalid project file
• [RSRP-54606] – at VBConstructorGenerator.GetFields : Unable to cast object of type ‘JetBrains.ReSharper.Psi.Xaml.Impl.Tree.FieldDeclaration’ to type ‘JetBrains.ReSharper.Psi.VB.Tree.IVariableDeclaration’.
• [RSRP-54719] – myHighlightingResultsMap[file] != null for file:18BEB3AF-C6BD-46DF-8771-76C19F9C9B13/d:Tests/f:PersonManagerTests.cs
• [RSRP-54848] – at Image.get_RawFormat : Object is currently in use elsewhere.
• [RSRP-54849] – The tool area {X=1,Y=2,Width=19,Height=19} described by the JetBrains.ReSharper.Daemon.Impl.SolutionAnalysis.UI.Indicator.ProgressStatus Control tool info must include the point {X=6,Y=0} for which the info was requested.
• [RSRP-54870] – at VSTextControl.GetSafePointOfLineColumn : Unable to call IVsTextView.GetPointsOfLineColumn. NullReferenceException occoured.
• [RSRP-54896] – Unhandled exception at repeated switching on Solution-Wide Error Analysis + error submitting exception to JIRA (see attachment)

New Feature

• [RSRP-28020] – Navigation to the member wich has the same name
• [RSRP-29021] – Improve namespace matching with folder structure
• [RSRP-49514] – [SWEA] If I click error indicator on status bar with a single error, go directly to that error, instead of opening error list.
• [RSRP-50310] – Solutuon analysis: add “Pause” button
• [RSRP-50649] – Solution analysis: change UI for progress and status in the errors view
• [RSRP-50760] – Solution analysis: show warning/explanation on turning on
• [RSRP-51065] – Allow to set up in options a regular expression to parse localized stack trace.
• [RSRP-52813] – Support HTML IMPORT construct
• [RSRP-53099] – License Server – implement support for went down license server

Performance Problem

• [RSRP-47721] – Code completion for attribute takes too much time
• [RSRP-52738] – ProjectModelWrapper should not initialize its data structures, unless SWEA is enabled

Task

• [RSRP-36155] – Show modal dialog on first time initialization instead of displaying text in status bar
• [RSRP-51404] – Section nodes in options tree are not bold anymore after my changes

Usability Problem

• [RSRP-51225] – SWA ErrorsView: “Analysing File” Section Heading Should not be All Bold
• [RSRP-51226] – SWA ErrorsView: “Analysing File” Section Heading Counter Should not Be Jumping
• [RSRP-51227] – SWA Icon “Checking for Changes” Should Not Be Shown If Duration Is Small
• [RSRP-51690] – SWEA: Ignored file list should support multiselection
• [RSRP-51843] – Unit Test Runner doesn’t respect text editor background
• [RSRP-52095] – Errors view: support multiselection
• [RSRP-52324] – Evaluation of other edition should be available, even if user already has valid key for another edition
• [RSRP-54156] – ReSharper installation should support UAC
• [RSRP-54171] – ReSharper License Checker should have “Bounce” mode

December 20, 2007

I will soon be posting a new article which (in my opinion) could be far more useful to everyone then this article ever was as it:

• Has far greater scope and use as Is a ‘domain collection’ engine and I believe the first solution to something I have been struggling with for years: The pain of building clean, quick web views in the world of Ajax, controls that expect datasets, and programmers not understanding ORM. It so far works with NHIbernate (and ActiveRecord) and I am finalizing Linq to Entity support
• Leverages advanced .NET intrinsic’s (CustomTypeDescriptors, etc…) that are leveraged by the third-part component community

• Support any ‘domain projection/entity set’ operation – the same engine backs both bindable sets and non-bindable sets.. You just pass the HQL into the user control in VS 2005/2008

Also stop by the new global repository I am bringing up with some others around ‘best practices’ for domain driven (obsessed) work. This has a .NET 3.5 focus (as we will deeply discuss linq I am planning) however it is an architects site, so we will cover mono, java, and likely 50% of the content will be platform agnostic.More to come!