This one was bugging us for a long time, until we got message from Jay (thanks!) who had similar problem and was willing to help.
Story 2 -- Mysterious Component
The problem itself is mysterious. From time to time it happens that Visual Studio stops loading any add-ins. ReSharper is installed, but its menus are suddenly all gray and it is not listed in the "Tools \ Add-in manager" dialog. It happens after installing various products, it could be service pack, SQL server tools, Visual Studio components - anything! Some users install them and all works fine. Some users loose their favorite productivity tool.
Logging, debugging, trying to reproduce for may be several years(!) led to no result. ReSharper was simply not loaded into the process, though all registration information appears to be in the right place. We checked encodings, verified files are not corrupted, verified registry access rights - all we can think of. As you can guess now, the reason was not anywhere near.
After lots of email exchanges with Jay, including mini-dumps, Process Monitor traces, registry excerpts, configuration files and such we suddenly found ourselves staring at the right thing. It was msxml6.dll. Actually, it was the fact that there were no msxml6.dll in the call stack. Instead, there was msxml3.dll.
We use .addin files to register our add-in in Visual Studio. It is XML file describing add-in, containing information about primary assembly, descriptions, load options and Visual Studio version compatibility information. The latter was that msxml3 was not able to process and thus Visual Studio refused add-in as non-compatible. In fact, msxml6 was there in System32, but it somehow happened to be not registered as COM object. Using regsvr32 on msxml6.dll repaired the system, resurrected ReSharper and enabled customers to enjoy our productivity add-in again.
Case closed.
31 October 2008
30 October 2008
Wild World of Visual Studio -- Unfriendly Package
While developing "The Most Intelligent Add-In To Visual Studio" we often face issues that originates from the outside of our code. Being that Visual Studio itself, other packages and add-ins installed, OS components or other things added to the mix - it is always extremely hard to reproduce, debug and understand. Usually we have to perform post-mortem debugging, when all we have is mini-dump from the user experiencing the crash. And we are very happy when we have mini-dump! Often we have to resort to psychic debugging, speculating about what could have happened, trying this and that until we find the cause and issue the fix.
I though I could share some stories of pure insanity we happened to participate in recently. May be another add-in developer is scratching his head in an attempt to understand the source of strange sounds from beneath the ground, and these stories will help. Or it may be just interesting reading for you. Or not :)
The first one is the most recent one and is pretty simple.
Story 1 -- Unfriendly Package
Our customers were complaining about Visual Studio crashing on start with ReSharper installed when running non-admin. Disabling ReSharper allows Visual Studio to load normally. When you see such behavior, you are absolutely sure ReSharper is guilty, aren't you?
We've learned to be cautious in such cases. So I asked user (thanks Jon!) to capture mini-dump and send it to me for investigation. While downloading it, I was preparing myself to long hours of WinDbg magic, but !ClrStack revealed it in a second. SnippetDesigner was not able to access its files, since it placed it in privileged folder. It did so in the background thread and didn't catch exceptions. The result is CLR termination, which get Visual Studio to nowhere with itself.
But wait! Why disabling ReSharper helped to avoid crash? Well, actually crash happens during SnippetDesigner package loading. Normally, it occurs when its window is opened (and it indeed crashes VS at this point without ReSharper). However, ReSharper uses Visual Studio API to get some configuration information, which can be extended with packages. So, by calling this API ReSharper caused those packages to load, essentially triggering the bug in SnippetDesigner on startup.
Case closed, opened another one.
I though I could share some stories of pure insanity we happened to participate in recently. May be another add-in developer is scratching his head in an attempt to understand the source of strange sounds from beneath the ground, and these stories will help. Or it may be just interesting reading for you. Or not :)
The first one is the most recent one and is pretty simple.
Story 1 -- Unfriendly Package
Our customers were complaining about Visual Studio crashing on start with ReSharper installed when running non-admin. Disabling ReSharper allows Visual Studio to load normally. When you see such behavior, you are absolutely sure ReSharper is guilty, aren't you?
We've learned to be cautious in such cases. So I asked user (thanks Jon!) to capture mini-dump and send it to me for investigation. While downloading it, I was preparing myself to long hours of WinDbg magic, but !ClrStack revealed it in a second. SnippetDesigner was not able to access its files, since it placed it in privileged folder. It did so in the background thread and didn't catch exceptions. The result is CLR termination, which get Visual Studio to nowhere with itself.
But wait! Why disabling ReSharper helped to avoid crash? Well, actually crash happens during SnippetDesigner package loading. Normally, it occurs when its window is opened (and it indeed crashes VS at this point without ReSharper). However, ReSharper uses Visual Studio API to get some configuration information, which can be extended with packages. So, by calling this API ReSharper caused those packages to load, essentially triggering the bug in SnippetDesigner on startup.
Case closed, opened another one.
06 October 2008
ReSharper Combos - Hiding Details
Today my day started with the question from Oleg Stepanov, Project Manager of ReSharper. He asked about avoiding huge amount of manual code changes, and after short discussion we got it done with ReSharper. I was very excited! We were able to solve refactoring task in seconds, invent new refactoring combo, and ReSharper was so smart to handle it absolutely right. No manual code changes outside of the type being refactored. Here is simplified version of what we had, what we were to accomplish and how we did it.
Consider PersonInformation class above. We wanted to decouple it from Person class and make it store Name and Age itself. However, we had a lot of usages like in Processor.Process, where Person property was being used to access Name and Age. How would we do it?
First, we use Generate (Alt-Ins) and select Delegating Members to generate Name and Age properties in PersonInformation class:
Then we change Person Property to return PersonInformation instead. Since there are all required properties already, usages are not broken. They are now routed through delegating members and use Name and Age properties of PersonInformation:
And here magic happens, we use Inline Property refactoring to get rid of the property!
Look how Processor now uses Name and Age directly on PersonInformation class and has no idea about Person class used inside! Now the fact that PersonInformation uses Person is implementation detail and we can change it any way we like.
Refactor With Pleasure!
public class Person
{public string Name { get; set; }
public int Age { get; set; }
}
public class PersonInformation
{private readonly Person myPerson;
public PersonInformation(Person person)
{myPerson = person;
}
public Person Person
{get { return myPerson; }
}
}
internal class Processor
{private readonly PersonInformation myPersonInformation;
public Processor(PersonInformation personInformation)
{myPersonInformation = personInformation;
}
public int Process()
{switch (myPersonInformation.Person.Name)
{case "Mike":
return 1;case "Sally":
return myPersonInformation.Person.Age > 30 ? 2 : 3;
}
return myPersonInformation.Person.Age < 20 ? 0 : 1;
}
}
Consider PersonInformation class above. We wanted to decouple it from Person class and make it store Name and Age itself. However, we had a lot of usages like in Processor.Process, where Person property was being used to access Name and Age. How would we do it?
First, we use Generate (Alt-Ins) and select Delegating Members to generate Name and Age properties in PersonInformation class:
public string Name
{get { return myPerson.Name; }
set { myPerson.Name = value; }
}
public int Age
{get { return myPerson.Age; }
set { myPerson.Age = value; }
}
Then we change Person Property to return PersonInformation instead. Since there are all required properties already, usages are not broken. They are now routed through delegating members and use Name and Age properties of PersonInformation:
public PersonInformation Person
{get { return this; }
}
And here magic happens, we use Inline Property refactoring to get rid of the property!
public class Person
{public string Name { get; set; }
public int Age { get; set; }
}
public class PersonInformation
{private readonly Person myPerson;
public PersonInformation(Person person)
{myPerson = person;
}
public string Name
{get { return myPerson.Name; }
set { myPerson.Name = value; }
}
public int Age
{get { return myPerson.Age; }
set { myPerson.Age = value; }
}
}
internal class Processor
{private readonly PersonInformation myPersonInformation;
public Processor(PersonInformation personInformation)
{myPersonInformation = personInformation;
}
public int Process()
{switch (myPersonInformation.Name)
{case "Mike":
return 1;case "Sally":
return myPersonInformation.Age > 30 ? 2 : 3;
}
return myPersonInformation.Age < 20 ? 0 : 1;
}
}
Look how Processor now uses Name and Age directly on PersonInformation class and has no idea about Person class used inside! Now the fact that PersonInformation uses Person is implementation detail and we can change it any way we like.
Refactor With Pleasure!
03 October 2008
ReSharper Guidelines -- First Time Users
Harry L. wrote in review of ReSharper on Visual Studio Gallery:
Indeed, most important ReSharper features can be instantly learned right from the code editor without reading any documentation. However, I thought that having some guidelines about where to look and how to improve own productivity would be nice anyway. So I'm going to write several posts about how to use ReSharper in a form of guidelines.
Shortcuts are given for Visual Studio keyboard scheme, but you can easily find shortcuts for your configuration in ReSharper menu.
First Time Users guidelines:
After you familiarize yourself with these basic actions, download and print key map and start exploring other commands.
... I have found that I used the features of Resharper almost without knowing it. What amazed me was how many features I use without going up a long learning curve...
Indeed, most important ReSharper features can be instantly learned right from the code editor without reading any documentation. However, I thought that having some guidelines about where to look and how to improve own productivity would be nice anyway. So I'm going to write several posts about how to use ReSharper in a form of guidelines.
Shortcuts are given for Visual Studio keyboard scheme, but you can easily find shortcuts for your configuration in ReSharper menu.
First Time Users guidelines:
- DO open your real project in Visual Studio with ReSharper enabled. Playing with the productivity tool in a sandbox doesn't really give you understanding about its effect. It can take some time for ReSharper to analyze your solution for the first time, but it will be much faster during subsequent runs.
- DO NOT run away from your Visual Studio when you first open your source code with ReSharper :) You will see colored identifiers, a lot of squiggles indicating warnings and suggestions, redundant code painted in gray -- your code most likely will be overhighlighted. You will clean it up pretty fast with ReSharper. You can switch Color Identifiers off if you wish (ReSharper / Options / Code Inspection / Settings).
- DO configure your naming (ReSharper / Options / Languages / Common / Naming Style) and formatting preferences (ReSharper / Options / Languages / C# / Formatting Style). ReSharper uses these settings when guessing on identifiers, while updating the code and doing other automatic code generation and transformation for you.
- DO learn 4 keyboard shortcuts to use in code editor:
- Alt-Enter - opens code transformation menu with Quick Fixes and Context Actions. Try it whenever you see light bulb to the left of your code, and see what you can do with it.
- Alt-` (Navigate from Here) to open menu with actions to navigate from currently selected symbol, like "Go to base", "Go to derived" and "Go to usages"
- Alt-Ins (Generate) -- generates type members, like properties, constructors, overrides and implementations, Equals, GetHashCode and ToString methods.
- Ctrl-Shift-R (Refactor This) -- opens menu with all refactorings available at current caret position (or current selection in any ReSharper tool window).
- Alt-Enter - opens code transformation menu with Quick Fixes and Context Actions. Try it whenever you see light bulb to the left of your code, and see what you can do with it.
- DO NOT use Solution Explorer to find code, use "Go to Type" (Ctrl-T), "Go to File" (Ctrl-Shift-T), "Recent Files" (Ctrl-,) and other commands from ReSharper / Go To menu. This will help you navigate much faster.
After you familiarize yourself with these basic actions, download and print key map and start exploring other commands.
13 August 2008
ReSharper Combos -- Refactoring To Components
ReSharper has a number of features which are powerful by themselves, but reveal even more coolness when combined with other features. It's like Kung-Fu, when master can outperform enemies by wisely combining basic movements and strikes.
Let's take for example a task of converting existing system, where all types are instantiated explicitly, to some component container system. Without ReSharper, this task is SCARY! Just imagine, going through hundreds or even thousands of files, checking where particular component is used, where instance is created and how passed to clients and manually updating all that code. Days or weeks to complete? No, we aren't going to do this...
With ReSharper the task is still not simple one, but it can be achieved in a reasonable amount of time. Here is simple example:
Now let's make it utilize some fictional ComponentContainer:
1. Create temporary static class ComponentFactory to put factory methods in
2. Execute Replace constructor with factory method refactoring against component constructor, specify ComponentFactory as containing type.
3. Use Extract Interface refactoring from the component implementation.
4. Utilize Use base type where possible refactoring, select extracted interface. This should update all usages from specific class to interface.
5. Find Usages of component and verify you don't have any references to the class except instantiation inside ComponentFactory. Having other references mean interface was not complete, or there are dependencies on component implementation. Refactor as needed.
Now you should have something like this:
Note, how TheProcessor now uses ITheManager interface instead of specific implementation.
What you do next depends on what framework for components you are going to use. If you plan to use one of the Dependency Injection frameworks out there, you will continue with other components (TheProcessor in our example) and let framework inject ITheManager dependency into constructor. If you are going to use component querying system, you will update component constructor to use factory method instead of parameters, and use Safe Delete on parameters to remove them and update usages.
After you finish with refactoring all component access to ComponentFactory static class, you can change the implementation of factory methods to query your component framework of choice.
Finally, you are ready for the last strike to finish it off: use Inline Method refactoring to get rid of temporary factory methods and finish conversion of your code.
Let's take for example a task of converting existing system, where all types are instantiated explicitly, to some component container system. Without ReSharper, this task is SCARY! Just imagine, going through hundreds or even thousands of files, checking where particular component is used, where instance is created and how passed to clients and manually updating all that code. Days or weeks to complete? No, we aren't going to do this...
With ReSharper the task is still not simple one, but it can be achieved in a reasonable amount of time. Here is simple example:
public class TheManager
{public void Manage(string text) { }
}
public class TheProcessor
{private readonly TheManager myManager;
public TheProcessor(TheManager manager)
{myManager = manager;
}
public void Process(IEnumerable<string> texts)
{foreach (var text in texts)
myManager.Manage(text);
}
}
internal class Program
{public static void Main(string[] args)
{var processor = new TheProcessor(new TheManager());
processor.Process(args);
}
}
Now let's make it utilize some fictional ComponentContainer:
1. Create temporary static class ComponentFactory to put factory methods in
2. Execute Replace constructor with factory method refactoring against component constructor, specify ComponentFactory as containing type.
3. Use Extract Interface refactoring from the component implementation.
4. Utilize Use base type where possible refactoring, select extracted interface. This should update all usages from specific class to interface.
5. Find Usages of component and verify you don't have any references to the class except instantiation inside ComponentFactory. Having other references mean interface was not complete, or there are dependencies on component implementation. Refactor as needed.
Now you should have something like this:
public static class ComponentFactory
{public static ITheManager CreateTheManager()
{return new TheManager();
}
}
public interface ITheManager
{void Manage(string text);
}
public class TheManager : ITheManager
{public void Manage(string text) { }
}
public class TheProcessor
{private readonly ITheManager myManager;
public TheProcessor(ITheManager manager)
{myManager = manager;
}
public void Process(IEnumerable<string> texts)
{foreach (var text in texts)
myManager.Manage(text);
}
}
internal class Program
{public static void Main(string[] args)
{var processor = new TheProcessor(ComponentFactory.CreateTheManager());
processor.Process(args);
}
}
Note, how TheProcessor now uses ITheManager interface instead of specific implementation.
What you do next depends on what framework for components you are going to use. If you plan to use one of the Dependency Injection frameworks out there, you will continue with other components (TheProcessor in our example) and let framework inject ITheManager dependency into constructor. If you are going to use component querying system, you will update component constructor to use factory method instead of parameters, and use Safe Delete on parameters to remove them and update usages.
After you finish with refactoring all component access to ComponentFactory static class, you can change the implementation of factory methods to query your component framework of choice.
Finally, you are ready for the last strike to finish it off: use Inline Method refactoring to get rid of temporary factory methods and finish conversion of your code.
29 July 2008
What's Next? -- Life After Release
We released ReSharper 4 in June and I didn't post since then. First, I was on vacation and it was great. Then, our team left the city to spend 4 full days discussing ReSharper future, inventing new features, building plans and coordinating efforts. Awesome experience, I must say. After that, we focused on preparing maintenance release 4.0.1 which will be out as soon as we verify it against recently released Visual Studio 2008 SP1. Now we are starting to work towards 4.5 release, which is tentatively planned to be released by the end of the year, or may be at the beginning of year 2009. So, what are we going to do?
Please note, that it is preliminary plan only and is subject to change at any time.
1. More performance
2. Less memory usage
Yes, we are going to spend about four months tackling performance and memory issues, optimizing various parts of our product and improving architecture to prepare for the next major step forward.
In addition to the overall product quality improvement, we are going to improve some existing features, based on your feedback, and add some new.
3. New refactorings are being developed, which will allow you to perform more intelligent solution-wide code transformation. We didn't finalize the list yet, but most likely they will be from "Inline" family.
4. Enhanced setup for naming conventions which will be supported by all ReSharper features. We are not going to implement all functionality of the AgentSmith plugin, but we want to stop naming issues experienced by some of ReSharper users once and for all.
5. Visual Build - new feature to display build process inside Visual Studio in a better way. Think "Unit Test Session" style, but for building your solution. This feature will also lay the foundation for future features, like optimizing build procedure.
6. Visual Basic 9 support. Our cross-language refactorings and editing experience enhancements will fully support VB9 constructs, like anonymous functions and XML literals.
As usual, once we perform all potentially dangerous changes to our code base and stabilize the build, we will start publishing nightly builds for your Early Access Pleasure.
PS: If you didn't express your opinion about ReSharper 4 on Visual Studio Gallery, you can let other people know what do you think via rating and review functionality recently added to this site.
Please note, that it is preliminary plan only and is subject to change at any time.
1. More performance
2. Less memory usage
Yes, we are going to spend about four months tackling performance and memory issues, optimizing various parts of our product and improving architecture to prepare for the next major step forward.
In addition to the overall product quality improvement, we are going to improve some existing features, based on your feedback, and add some new.
3. New refactorings are being developed, which will allow you to perform more intelligent solution-wide code transformation. We didn't finalize the list yet, but most likely they will be from "Inline" family.
4. Enhanced setup for naming conventions which will be supported by all ReSharper features. We are not going to implement all functionality of the AgentSmith plugin, but we want to stop naming issues experienced by some of ReSharper users once and for all.
5. Visual Build - new feature to display build process inside Visual Studio in a better way. Think "Unit Test Session" style, but for building your solution. This feature will also lay the foundation for future features, like optimizing build procedure.
6. Visual Basic 9 support. Our cross-language refactorings and editing experience enhancements will fully support VB9 constructs, like anonymous functions and XML literals.
As usual, once we perform all potentially dangerous changes to our code base and stabilize the build, we will start publishing nightly builds for your Early Access Pleasure.
PS: If you didn't express your opinion about ReSharper 4 on Visual Studio Gallery, you can let other people know what do you think via rating and review functionality recently added to this site.
09 June 2008
ReSharper 4.0 Gone Diamond
Here it is, ReSharper 4.0. After faceting our diamond, we are finally ready to release it!
In this new release, C# 3.0 is supported in all its power -- lambdas, extension methods, language integrated queries (aka LINQ), object and collection initializers, anonymous types, automatic properties and partial methods. Ah, of course implicitly typed locals ("vars") are there to argue for or against using them. I already wrote about some of the features, and you can find more information on the New Features page. Here is small final touch about how deeeeep we dived into the language: try introducing parameter from expression which uses local variables and play with checkboxes for local variables.
Except for new language support, we also improved our product in many other ways:
I can't really enumerate all the improvements in ReSharper 4.0 made during last year. It would take too much space on this blog. Try it yourself! Feel the difference!
develop.With(pleasure => pleasure * 4.0);
In this new release, C# 3.0 is supported in all its power -- lambdas, extension methods, language integrated queries (aka LINQ), object and collection initializers, anonymous types, automatic properties and partial methods. Ah, of course implicitly typed locals ("vars") are there to argue for or against using them. I already wrote about some of the features, and you can find more information on the New Features page. Here is small final touch about how deeeeep we dived into the language: try introducing parameter from expression which uses local variables and play with checkboxes for local variables.
Except for new language support, we also improved our product in many other ways:
- We added new powerful refactorings and greatly improved existing.
- We extended typing helpers with CamelCase completion and Complete Statement. Now you can achieve more in less time.
- We analysed many .NET Framework assemblies for you, and maked them up for you with CanBeNull/NotNull attributes. And ReSharper's value analysis raised to the next level.
- We tested it with numerious other addons, plugins, SDKs and packages. And improved ReSharper's integration into Visual Studio ecosystem by a wonderful degree.
- Of course we fixed a lot of problems and eliminated many performance bottlenecks.
I can't really enumerate all the improvements in ReSharper 4.0 made during last year. It would take too much space on this blog. Try it yourself! Feel the difference!
develop.With(pleasure => pleasure * 4.0);
03 June 2008
ReSharper 4.0 Release Candidate
After extensive testing and fixing problems in Beta we are ready to publish Release Candidate build. Some critical fixes can still happen in this branch, but otherwise we are almost ready to release.
If you are using any nightly build or beta, please upgrade to Release Candidate. If by chance you find a problem that prevents ReSharper 4 from being used on a regular basis, please tell us! You can submit request into our issue tracking system, and we will try hard to fix any critical problem, if we can reproduce it. So please, please, please, include as much information about your environment, projects and source files as you can.
Thank you very much for participating in our Early Access Program!
If you are using any nightly build or beta, please upgrade to Release Candidate. If by chance you find a problem that prevents ReSharper 4 from being used on a regular basis, please tell us! You can submit request into our issue tracking system, and we will try hard to fix any critical problem, if we can reproduce it. So please, please, please, include as much information about your environment, projects and source files as you can.
Thank you very much for participating in our Early Access Program!
26 May 2008
Functional Style -- Highlight Mutable Variables
Once you go for lambdas, lazy computations and other functional techniques in programming, you may want your code to be mostly immutable. With ReSharper 4 we didn't do much about data analysis, like do not detect immutable objects or methods. However, one analysis is already available to you: highlight mutable local variables. Open Tools menu, select Options, browse for Fonts and Colors under Environment group. In the Display items find ReSharper Mutable Local Variable and change the appearance as you like. I use Bold font. ReSharper will now highlight every variable that changes its value after the value has been already used.
Try it, and tell us what do you think!
Try it, and tell us what do you think!
21 May 2008
ReSharper 4 Beta
Did you use one of the nightly builds we publish for several months already? If you thought it is dangerous for you to run early development bits, today we present you ReSharper 4 Beta, which we optimized, stabilized and verified to be of better quality than ordinary nightlies. It is not complete product yet, we have some more work to do in various areas of product, but otherwise this build is pretty stable and usable.
C# 3.0
This major language update was not an easy thing to support. It was tough to make it right, when tool knows the code inside out and understands every detail of what is written. There are many little things that you probably will not even notice, but which were well thought out and implemented to provide flawless code editing, navigating and refactoring experience.
I'd like to highlight some features: global completion for extension methods, which inserts required namespace imports; optional parameter info in form of lambda, like "IEnumerable<string> => string" instead of Func<IEnumerable<string>,string>; refactorings specific to new language features, like creating named type from anonymous one or converting static method to extension method and updating usages.
.NET Framework Annotations
Since version 2.5 we have "Null Reference Analysis", which is capable to warn developer about potential NullReferenceException in the code. To aid this analysis, developers can annotate methods with NotNull or CanBeNull attributes, which ReSharper then uses to initialize variable states. That's cool enough by itself, but there are thousands of methods you can't annotate in source: the .NET Framework assemblies. We took up a challenge and implemented the way to annotate libraries with external annotations. And we made second step, too. We annotated most of .NET Framework (56 assemblies!), so that you can get potential NullReferenceException warning on the code like (SomeStruct)Marshal.PtrToStructure(...);
Completion-on-steroids
That's something I like most. No, wait, I love new refactorings, recent edits window, to-do browser understanding of NotImplementedException, and all other features mentioned on the official site.
Two things: "CamelHumps Completion" and "Complete Statement" bring my coding speed to a new level. I don't know what it would be called in Jedi hierarchy, but it seems to me that I can create code withlightning teleportation speed.
ASP.NET speed-up
The last, but not least thing I'd like to mention is our raid against ASP.NET problems. It is something that had speed and memory problems through all versions of ReSharper, and we finally managed to identify them, and fix. Now, if you develop ASP.NET web sites, go try ReSharper 4 Beta.
Download
In this release we bring you the single installer for both Visual Studio 2005 and 2008, as well as all editions we have. Download, install, select "Free Evaluation", choose edition - and you are ready to be productive.
C# 3.0
This major language update was not an easy thing to support. It was tough to make it right, when tool knows the code inside out and understands every detail of what is written. There are many little things that you probably will not even notice, but which were well thought out and implemented to provide flawless code editing, navigating and refactoring experience.
I'd like to highlight some features: global completion for extension methods, which inserts required namespace imports; optional parameter info in form of lambda, like "IEnumerable<string> => string" instead of Func<IEnumerable<string>,string>; refactorings specific to new language features, like creating named type from anonymous one or converting static method to extension method and updating usages.
.NET Framework Annotations
Since version 2.5 we have "Null Reference Analysis", which is capable to warn developer about potential NullReferenceException in the code. To aid this analysis, developers can annotate methods with NotNull or CanBeNull attributes, which ReSharper then uses to initialize variable states. That's cool enough by itself, but there are thousands of methods you can't annotate in source: the .NET Framework assemblies. We took up a challenge and implemented the way to annotate libraries with external annotations. And we made second step, too. We annotated most of .NET Framework (56 assemblies!), so that you can get potential NullReferenceException warning on the code like (SomeStruct)Marshal.PtrToStructure(...);
Completion-on-steroids
That's something I like most. No, wait, I love new refactorings, recent edits window, to-do browser understanding of NotImplementedException, and all other features mentioned on the official site.
Two things: "CamelHumps Completion" and "Complete Statement" bring my coding speed to a new level. I don't know what it would be called in Jedi hierarchy, but it seems to me that I can create code with
if(CVM.I.SV(SCV.FU <Ctrl-Shift-Enter>When I hit keys like above, it is completed into:
if (CodeViewManager.Instance.SupportsView(StandardCodeViews.FindUsages))And caret is inside braces for me to type in the body of the "if" statement.
{
}
ASP.NET speed-up
The last, but not least thing I'd like to mention is our raid against ASP.NET problems. It is something that had speed and memory problems through all versions of ReSharper, and we finally managed to identify them, and fix. Now, if you develop ASP.NET web sites, go try ReSharper 4 Beta.
Download
In this release we bring you the single installer for both Visual Studio 2005 and 2008, as well as all editions we have. Download, install, select "Free Evaluation", choose edition - and you are ready to be productive.
Subscribe to:
Posts (Atom)
