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

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>

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!”

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

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

Now full source code is available as well as the OneClick installer and a Windows standard installer.

Here is just one example of what kind of analysis this tool facilitates:

Anything that can be captured as a statistic (which is anything that is available via XPath in your legacy XML Build results) can be regenerated and graphed as above.

We typically include:

• FxCop Code Metrics
• NCover Code Coverage with NCoverExplorer Display
• NDepend Code Metrics for Architectural Quality
• NUnit test results
• Standard Metrics like the one shown above
• Custom Metrics we have developed in-house

Key NDepend Metric Explanation

I think one of the most compelling easy wins there is today in software development for teams (regardless of size) is the compelling use of Continuous Integration.

In fact my company has packaged a ‘pre-configured Server’ that already includes everything I am talking about. You simply install it and configure for your environment (like your specific source control provider).

We are always updating this and providing upgrades to our customers as new innovations become available and upgrades occur to the components of the build server.

This service will soon be made public, so I suppose I am ‘letting the cat out of the bag’ here in announcing it. From the initial responses I have received, it’s exciting to thing of the impact we can help being about in lowering the bar on getting this complex configuration running, and also dramatically improving the development activities of teams who are not satisfied with ’status quo’.

Thanks,

Damon

Last changed on May 23, 2005 by Valentin Kipiatkov
Build 165
Bugfixes
Build 164
Bugfixes
Build 163
Bugfixes
Build 162
Bugfixes
Build 161
A single option to switch between ReSharper’s and Visual Studio’s IntelliSense (ReSharper > Options > General)
Bugfixes
Build 160 (1.5)
Bugfixes
Build 159 (RC5)
Bugfixes
Build 158 (RC4)
Bugfixes
Build 157 (RC3)
Bugfixes
Build 156 (RC2)
Added “move member up/down” functionality. One can now move current type member up and down using Ctrl+Alt+Shift+Up/Down shortcut
Important bugfixes
Build 155 (RC1)
References to project output are treated as project references
Important bugfixes
Build 154
Added “Convert Interface to Abstract Class” refactoring
Added “Convert Abstract Class to Interface” refactoring
Fixed bugs
Build 153
Added “Introduce Parameter” refactoring
“Extract Interface” refactoring now suggests public members from base classes
Added “protected internal” modifier to the “Introduce Field” refactoring dialog
Bugfixes
Build 152
Fixed bugs
Added “Delegate Members” generate item and several quickfixes
Build 151
Extract Interface refactoring
Extract Superclass refactoring
Introduce Field refactoring
Encapsulate Field refactoring
Copy Type refactoring

If you are a C# developer you simply owe it to yourself to get this tool. It has dramatically made my life better (SERIOUSLY!). I put it up there with amazing tools like devAdvantage from Anticipating Minds and Sparx Enterprise Architect from Sparx.

Here is the product page:

http://www.jetbrains.com/resharper/

For the features see:

http://www.jetbrains.com/resharper/features/index.html

I appload all of you on your achievement:

Eugene Belyaev
Co-founder, President, Chief Technology Officer

With a PhD in Economics and a MS in Computer Science, Eugene Belyaev has more than nine years of experience working with human-computer interaction (HCI) as he honed his skills at user interface design and software usability on a wide range of end-user application development projects. For the past five years he has focused on creating and perfecting complex tools for developers in the real world. Prior to co-founding JetBrains, he was a senior developer and project manager for Together Control Center at TogetherSoft.

Sergey Dmitriev
Co-founder, Chief Executive Officer

Sergey Dmitriev holds a MS in mathematics and brings over 15 years of development and entrepreneurial experience to the JetBrains management team. Prior to co-founding JetBrains he led the development of key projects at TogetherSoft as a project manager and core developer. In 1993, before joining TogetherSoft, Sergey was co-founder and CTO of GIS software company Horis, Ltd.

Valentin Kipiatkov
Co-founder, Chief Scientist, Vice President of Product Development

Valentin Kipiatkov holds a MS degree in mathematics and brings to JetBrains more than eight years of professional experience in mathematics and computer science-related fields. Before co-founding JetBrains, he headed key teams as lead developer and system architect at TogetherSoft. Prior to TogetherSoft, he headed a team devoted to research and development of CPU instruction set optimizers for mobile devices.

It is rare for me to react this positively, but I will spread the word on this amazing tool. I know for a fact it is heavily used inside Microsoft in their Patterns group (a group I consider one of the best).

Kind Regards,
Damon Carr, CEO agilefactor
www.agilefactor.com
.NET SIG Leader – New York Software Industry Association