Plugins in Resharper Visual studio

Resharper Advanced 1: A brief introduction to 
Resharper Advanced 2: Quickly locate 
Resharper Advanced 3: Quickly complete 
Resharper Advanced 4: Universal Alt+Enter 
Resharper Advanced 5: Efficient code structure adjustment 
Resharper Advanced 6: Refactoring is the key The King's  Way (Part 1
) Resharper Advanced Seven: Reconstruction is the King's Way (Part 2) 
Resharper's Advanced Eight: Enhanced Browsing Functions

This series is not Chinese help for each function, but I use Resharper to complete the functional requirements that may be involved in the development. Some are in Visual Studio but don't do well, and some are not and Resharper invented them. The overall purpose is only one, is to speed up the speed you write code. After all, our ultimate goal is to shut down the computer and go home contentedly by 5:30.

Granted, learning a new language, or a new tool, has a problem of getting started. I hope my article will help you get acquainted with Resharper as soon as possible. After you get used to it, the frequency of using the mouse or invalid keystrokes will be greatly reduced. Of course, this also requires a certain foundation for the use of visual studio itself, after all, Resharper is based on such a powerful IDE.

Resharper Advanced 1: Brief Introduction 
Faced with such a question: Why can .net complete development faster than java? Probably the biggest advantage is that Microsoft provides an incredibly powerful IDE. Its power lies in being applicable to developers of all levels. When you are a little bird, you can learn to drag & drop, and when you start writing code, you will realize how stupid and bloated the code generated by the designer is. When you can write clean code yourself, you may never want to switch to the designer again (toggle /F7). I believe most of us, even the most seasoned Windows developers, are much more productive coding in VS than in Notepad, because we need IDE help to increase our productivity after all. But in that era without Resharper, your productivity was stuck in the era of two wheels at most, and the other two wheels can only be turned after you are familiar with Resharper.

The productivity gains that Resharper can bring you are so high that in all the blogs of .net experts I subscribe to, everyone is following it. You must know that they are not ordinary coders, most of them are CTOs or technical directors. When I started using Resharper three months ago, it was very difficult to find some Chinese introductions or empirical articles. Most people don't seem to care that it exists. The blog garden is full of arguments that the installation of Resharper slows down the system, causes VS to be unstable, the response speed of the machine decreases, and the startup speed of VS decreases. Fortunately, I have not encountered these here, maybe because of the 2G memory, anyway, the 200~300m memory occupied by devenv.exe does not make me feel that the machine is slowing down, and my VS is almost always In operation, there is no time to close and open for a while, so I only need to tolerate the initialization of Resharper once every half a minute when loading. Compared to the efficiency gains it can bring you, these problems are trivial (one family's words).

If you almost don't use shortcut keys when writing code in the VS environment, then I don't think you need to look down. Because Resharper improves your efficiency through shortcut keys. But trust me, if you have been abused over and over again in the interstellar space, you should be able to appreciate how big a difference the shortcut keys bring.

First, after installing Resharper, you use or see it in three main ways:

One is on the menu bar, if it is version 3.0, it will block the "refactoring" menu bar by default, that is to say, when you press Alt+R, the drop-down menu of Resharper will pop up instead of "refactoring" ,why? Because you don't need to "refactor" the menu anymore. If it is a previous version, such as 2.0, it seems that you need to complete this step manually, as follows:

Tools - Customize - Rearrange commands, then remove the "Refactor" menu without hesitation!

You can simply experience it like this: Alt+R, N, Enter, you can add a class to the current project, remember how you did it before? Select a project in the solution explorer, then right-click and select from the long pop-up menu: Add - Class, if your computer is slow enough, a dialog box will pop up to ask you after 3 seconds file name.

Another way: see the vertical scroll bar? There is an extra border to the right of it, a "green/yellow/red" box above it, and a red-orange horizontal bar will appear on the border. What it means: When the red bar appears, it means that there is an error in your code at that position. If it is an orange bar, it means that it is a warning, mostly because the null value is not detected or it is not used after the declaration.

If all errors and warnings for the current document are handled appropriately, the bar will no longer appear and the top box will turn green;

If there is no error but there is a warning, it is yellow, then the compilation can pass;

If the box is red, it means that there is an error that cannot be compiled, and you should modify your code by clicking the red bar. If you even compile, it will report an error and fail to generate. Doing this allows you to catch your errors as you write your code, instead of waiting until compile time. Doing so also increases your efficiency. Because compiling will take you at least half a minute, and your hard disk will be intensively read and written, especially when your hard disk speed is slow, such as on a laptop, this process is so heart-wrenching.

The third way to get in touch with Resharper is the shortcut keys. Of course, the right-click menu also has many functions, but it is too mentally retarded and too slow. What we need is professionalism. The tools we use are not the aunts who make sweaters, but the development professionals. If you can't even master the shortcut keys, then you really have to put a big question mark on your development skills. Just imagine this scenario, when the thought pops up in your mind, ah, this class, should come up with an interface, this method, this, and this, and these two events. Ah, no, I have to mention it now or forget it. I have to create a new interface, which one to click. Ah, where to create a new one... It's built, by the way, which methods should I extract. (I fainted) Many times your thoughts are fleeting, and you need to keep up with your actions accordingly. This operation in Resharper is to move the cursor to the class name, and then click Ctrl+Shift+R. In addition to the extraction interface you want, other refactoring functions are also clear at a glance. And it's much faster than the one that comes with VS.

As for the right key, if you really can't remember the shortcut key at first, you can only use it, or Alt+R, which is actually a little faster than the right-click menu.

What's really exciting is the many conveniences that Resharper can bring as you become more familiar with it, which I will describe in the next series of essays.

Resharper Advanced II: Quick Positioning

Summary

The core of fast code positioning is three functions:

•     Go to Definition: Ctrl+B;
•     Find all use: Alt+F7;
•     Browse from here: Ctrl+Shift+G.

go to definition

When your cursor is on a variable, pressing Ctrl+B will jump to the place where the variable is declared. This could be a field, a method parameter or a local variable.

When your cursor is on a type, pressing Ctrl+B may occur in two situations. One is that when the definition of this type has source code in your project, it will jump to the source code file. If there is no source code, an Object Browser opens. Some users prefer to jump to the metadata file, but I prefer the object browser, so that the public properties, methods, and events of this type are listed and can be seen at a glance. In my experience, lists are always easier to find than drop-down boxes and marquee boxes.

But this function has a side effect. Years of experience in using Windows tells us that when you hold down Ctrl and click the left mouse button, the default operation is to select a whole word, but after installing Resharper, this operation is actually equivalent to Ctrl+B. That is to say, you may want to choose the name of the variable and copy it elsewhere, but jump to the declaration of the variable, which makes you annoyed for a while. At present, I haven't found an option to block this operation, so I can only use the mouse to double-click to select the word (hint: if you jump to another place and want to go back, press Ctrl+-)

Find all uses

Alt+F7, do you feel it? Yes, it is the shortcut key for searching in TotalCommand. I have never used TC, and are you still using the resource manager? That shouldn't be the case. In short, Alt+F7 displays all uses of the variable where your cursor is located in a list, and the resulting form can be docked like any other form.

Its advantages include:

• It is possible to choose from all usages to show only read usage or write usage, sometimes we just want to know where a variable has been changed. The icon in front of the found location also tells you this.
• You can preview it below, even if we list all the uses and don't want to jump to every place where it is used, the preview can help you a lot.
• When you change some usage in the code editor, such as deleting a row, it will be indicated by strikethrough in the form of search results.
• The default is to find all uses in the solution and organize them by namespace, which is very easy to choose.

I can't remember now how I looked up before Alt+F7. Anyway, now I hardly Ctrl+F, unless I forget the name of a variable. If so, most likely the name requires refactor, which is another big chunk of Resharper's functionality. Some people may scoff at this function, but those who have used CAB know that the signature of subscribing and publishing an event is a string. Exactly how many handlers are working behind the scenes. Using Alt+F7 to search for this string is equivalent to finding all the callers behind it.

However, I remind you that when the cursor stays on a type, use Alt+F7 with caution. Assuming it is a string, you should be able to imagine how many uses you can find.

Browse from here

I really don't know what Chinese to use to translate this navigate from here..., so I had to translate it literally. You may need it at these times:

When you want to find all the inheritors of this class, or all the implementers of the interface, hold down Ctrl+Shift+G and a menu will pop up with Inheritor, use the arrow keys to select and enter, if there is only one implementation, then Jump directly to this implementation, if there is more than one, or because of the use of partial to distribute across several files, another menu will pop up for you to choose from. Similarly, if you choose base, you will jump to the base class or interface.

At the same time, this function also includes the previous Go to Definition and Find usage. If you are lazy, just remember this. Although the shortcut keys of Ctrl+Shift+G are a bit uncommon, you will find it easy to use. .

This function is a powerful tool for familiarizing yourself with a set of frameworks. It allows you to quickly find all implementations of an interface. Combined with Alt+F7, you can feel like a duck to water in a huge solution.

Next time, it's time for us to talk about the mighty Alt+Enter

Resharper Advanced Level 3: 
People who often write code quickly should have a certain favorable impression of Visual Studio's IntelliSense. Through it, they don't feel tired when entering long object names. I'm afraid this is one factor that makes the code more readable on the .net platform than on other platforms, because each variable name is more meaningful, rather than the obscure varIdx, pElemDisp, etc. Although it looks cool. 
Before Resharper, Visual Studio's autocompletion was powerful. It's just that the shortcut keys it defines are really uncomfortable. Alt+right arrow key, I can't help pressing them both with my head down. So I changed the shortcut key to Ctrl+; (semicolon), which is much more convenient to press. 
Resharper adds some features to Visual Studio. For example, in native auto-completion, keywords, such as private, override, are not provided with auto-completion (is there, I don't remember). There are also some of the following, which Visual Studio does not have natively: 
when you write a new field, such as string _field; Resharper will automatically add private to the front for you, some people may think it is redundant, but I think It should be. 
When you enter foreach, the template will automatically appear, which is convenient for you to enter the type and name of the collection and its children, and then enter the block after pressing Enter. You can define such templates yourself and share them with your team. In this way, when dealing with some specific scenarios, the execution of the code is basically the same. 
When you need to enter {, Resharper can automatically add } for you, and the cursor is in it. If you hit the Enter key, the two brackets and the code in the block you are going to write are indented and aligned. . This function is far more than that simple, when you find that you can forget to include it every time, how comfortable it is. 
Similarly, when you type [ or (, Resharper also adds pairs of parentheses for you. 
This is also inconvenient. For example, when you call a method, you only want to enter (, then start to write parameters, and then write), and then write a semicolon, but it happens to help you write, especially when parameters When it's still a string, you type ", it automatically wrote it for you again", and put the cursor in between, which makes you very annoyed a lot of times. Because you have to hit the end key to move to the end of the line, and then write ;, and the end key is also difficult to press accurately without bowing your head. In fact, your choice at this time is not as good as writing ") honestly, and it is faster than typing end. Therefore, the function of automatically adding parentheses to the method is the most comfortable only when it is used without parameters. 
Always In other words, it is still a very practical function to automatically complete the input of the function. Now if you need to input ToString(), you only need to type up to four ToS and ;, and Resharper will automatically complete the rest for you. 
Finally, to show off, it's really cool to replace the autocomplete shortcut with Ctrl+;, even if you don't have Resharper installed, you may consider changing the native shortcut. On all the computers I use, I secretly Add Ctrl+; in. Because these two keys are really too good to press.

Resharper Advanced Four: Almighty Alt+Enter

The almighty Alt+Enter can help you complete a lot of dirty work in the process of writing code, which can be summed up as follows:

• Help you implement a method of an interface or abstract base class;
• Provide you with some suggestions for dealing with current warnings;
• Give you some advice on how to deal with the current error (not necessarily a real error);
• Simplify your current bloated code;

Help you implement a method of an interface or abstract base class. 
Visual Studio has also provided it for you, that is, every time you add: ISomeInterface after the class name, it will prompt you to press the Tab key to generate the interface. Stubs for all methods. If you don't press it at this time, later, you can also hover the mouse over the interface name, there will be a small intellisense symbol that can't be smaller, and it takes a lot of effort to click on it, and then the method will be generated. . With Resharper installed, this feature is treated the same as any other warning. If you: ISomeInterface, and there is no method to implement it, this line of code will be marked with a tilde, indicating that a warning or error occurs. Pressing Alt+Enter will generate these methods for you. 
Don't think I'm making a fuss. After you modify the ISomeInterface interface, such as adding an Initial method, the fastest way is: click Ctrl+Shift+G on ISomeInterface to browse to the implementation class of this interface, and then Alt +Enter, the method Initial is added to this class immediately, and you can start writing code. 

Gives you some advice on how to deal with the current warning. 
Sometimes you may ignore some details that Resharper will not ignore, such as when you use an implicit type conversion:

Button btn = sender as Button; //Implicit type conversion

It is used directly without checking whether it is empty next. At this point Resharper will prompt you with a warning. If you press Alt+Enter, it wraps the code after you in an if statement:

if (btn != null) 
{ 
//your next code 
}

But to my dissatisfaction, I often want this effect:

if (btn == null) 
return;

I don't know if this behavior can be modified in the configuration. 
Gives you some advice on how to deal with the current error. 
Those marked in red by Resharper are errors, and sometimes errors may be intentional. For example, you randomly wrote in View.cs:

_presenter.GetAllLayers ();

In fact, there is no such method in your Presenter.cs, so pressing Alt+Enter will immediately add this method in Presenter.cs, and jump to this method, if Presenter is distributed in more than one file, it will pop up A dialog lets you choose. Compared with Visual Studio's often bloated dialogs, Resharper's pop-up dialogs are often very straightforward. You just need to use the arrow keys to select what you need and press Enter. 
Simplify your current bloated code for 
you. If your code is deemed redundant by Resharper, it will be grayed out, for example:

this.Text = "Title bar text" //this is gray 
btnOK.Click += new EventHandler(btnOK_Click) //new EventHandler is gray

The extra code isn't harmful, it's just less concise, and if you open up the code you've written for the first time after installing Reshaper, you'll find a lot of gray code. If you look at the code generated by the designer, you'll see that the Reshaper's vertical bar has almost turned orange. Basically, you can use Reshaper to slim down your own code, designer-generated, such as Forms, or Datasets.

Resharper advanced five: efficient code structure adjustment

Through the Alt+F7 and Ctrl+B I introduced earlier, you can quickly know the calling of the function in a code file. But sometimes, the code file is very complex, and there are dozens of functions in it, which are considered pediatrics, and even a constructor has N multiple overloads. At this time, you want to clearly understand the various functions, properties, fields, events, etc. in the file, it is not so easy.

In Visual Studio, you can organize or review your code in these ways:

Use region, which is the most commonly used. My favorite division method is: Field, Property, Event, EventHander, and then according to the actual situation, Constructors (if there are many overloaded constructors), Helper (if there are many common processes) ), and then a series of methods that you want to associate with a particular task to form a class. 
When you organize your code with regions, it does look very concise. But here comes the problem, when a colleague checks your code and is ready to modify it, at this time, he wants to clarify your thinking, so he starts fighting in your code, ah, this calls that, oh, this place Can accept 0 or 1 or 3 parameters... After an hour, he can finally start writing the part he wants to change. The disadvantage of region is that the writers understand it, but the readers still struggle.

You can use the object browser to display your method structure, but the fatal thing is that it is sorted alphabetically. For us Chinese, it is really difficult to find such a self-explanatory method as FilterSelectableLayerByName. In fact, you put it into a "layer control" region, and your readers can't understand your intentions. (If you often download the code on codeproject, you will know that this kind of thing often happens.) Having 
said so much, in fact, I want to combine the strengths of the object browser and region, which can be clearly classified and found at a glance required method. Resharper is here to help you a lot. Use Ctrl+F12 to pop up a window like the one on the right.

Here, it is displayed according to your region, so that people who read your code also benefit. The parameters and return values ​​of each method are listed as UML.

• If you need to browse to a method, double-click its name directly;
• If you want to load some methods into a new region, you can select the method and click the icon like the box on the toolbar; click the cross to delete the region and move the corresponding method outside.
• If you want to adjust the position of a method, such as moving it to another region, just drag the method here.
• What's more gratifying is that the functions you want to browse from here, find all the uses and refactorings are also provided here, and you can start the operation by right-clicking on a method.

This is definitely the coolest feature in Resharper, just open Visual Studio and try it out.

Resharper Advanced Six: Refactoring is King (Part 1)

Refactoring is the spirit of proving that you are committed to delivering efficient, refined, robust code, not messy, obscure, buggy code. 
In Visual Studio 2005, Microsoft provided refactoring tools for the first time. But not enough, far from enough. The refactoring we need is very broad, we want to make quick tweaks to the code, fast enough that my tools can do what I think. This is the realm of pursuit of reconstruction. So in that sense, almost Resharper gives you huge productivity. 
The refactorings provided by Visual Studio 2005 include the following:

1. encapsulation field
2. method of extraction
3. Extract interface
4. promote local variables
5. remove parameter
6. Rename
7. rearrange parameters

These methods are all supported in Resharper (but the refactoring of Resharper is much more than these), and they correspond to:

1. Encapsulation Field - Introduce Field
2. Extraction method - Extract Method
3. Extract interface - Extract Interface  (Added Extract Superclass to extract as a base class)
4. Promote local variables - Introduce Variable
5. Removed parameters - moved to Change Signature
6. Rename - Rename  (Resharper will provide you with several optional most appropriate names based on the type name of the object)
7. Rearranged parameters - moved to Change Signature

I know that many people claim that their E-writing is not good, but these are really very simple words, which can't be difficult for anyone. These refactoring functions are well known. Let me tell you some unique features of Resharper. First, the shortcut key for refactoring is Ctrl+Shift+R: 
1. For classes, in addition to extracting interfaces and base classes, you can also Move it to other namespaces and to other files, this is a practical function, maybe you don't believe it, but I really have a person who writes all business entities in one DataObject.cs. You can't imagine how much my mouth opened when I opened it. 
2. For fields, provide:

• Safe Delete, will detect all used places and ask how to delete;
• Pull Member Up and Push Member Down, you can move this field in the base class and the inherited class;
• Use base type where possible, use the base class as much as possible. Since the ArcGIS platform is based on com components, many times we need the properties or methods exposed by interfaces such as IGeometry and IPointCollection, so you do not need to save a polygon object, Instead, base types can be used;
• Encapsulate Field, encapsulates the field, but this function is far less useful than another operation that provides the same function. I can talk about it later.

3. For the method, provided:

• Similar functionality to fields, in addition;
• Change Signature, changing the function signature, including changing the name, return value type, various information of parameters, adding and deleting parameters, is quite practical. If you are operating on an overridden method, you will be prompted to make changes in the base class.
• Make Static, if Resharper detects that this method is not associated with a non-static member, it will automatically prompt you (in the form of a yellow horizontal bar) that can be changed to static, if you make changes to some methods at your own discretion Nothing wrong, but at your own risk.
• Extract class from parameter, if you have seven or eight parameters, then consider using a class to encapsulate these parameters, so this function came into being.
• Method to Property, as the name suggests, if you are still using GetField() or SetField(..), you must be from a non-.net star.

4. Inside the method body: 
Extract Method, no need to introduce it. 
Introduce Variable/Parameter/Field, depending on the object your cursor is on, can provide conversion functions. 
Inline Variable: is to put:

IPoint point = new PointClass(); 
point.PutCoords(_point.X, _point.Y);

becomes like this:

new PointClass().PutCoords(_point.X, _point.Y); //this is a bad example

5. Renaming: 
Why renaming is worth picking out, because Resharper provides the golden feature of naming suggestions. So, wanting to change the name to a more readable name is not such a brain-tackling thing. Resharper will provide you with several alternative names according to the type of this variable. The list of names is listed at the cursor position (a dialog box will pop up when renaming the method), you just need to use the arrow keys to select and hit Enter. , this kind of name is mostly obtained by changing the first letter of the type name to lowercase, or even rooting to the type name of the base class, you can also improve it on this basis. If you're still using obscure names like i,j, quickly change them to readable names like outIndex, pointCount. 
Resharper actually provides more advanced functions. When you name a variable, there is a shortcut key to provide you with an alternative name, but Ctrl+Space is our precious input method switching key, so I often finalize the variable name. It was a bad one first, and then renamed. 
There are also some more general functions that help you adjust the code. I will write another article, otherwise it will be too long.

Resharper Advanced Seven: Refactoring is King (Part 2)

Insert code 
Resharper's Alt+Insert shortcut provides you with the function of inserting code. Since these two keys are very difficult to press (this is my feeling), when I actually use them, I use Alt-RCG, which means to open the Resharper menu - Code - Generate, which only requires your left hand, so that How cool is it that you can gesture with your right hand while still writing code.

• The most commonly used ones in the generated code are constructors and properties. When you have no private fields, only an empty default constructor is generated, and there is no function to generate properties. In the case where you have private fields, it will let you choose which private fields need to be used as parameters of the constructor before generation, and generate initialization code, which is extremely convenient to write overloads. Build properties are similar.
• Again, the most common method is to override the method of the base class or interface. Select Implement Interface Member or Override Inheritate Member, Resharper will find the base class or interface of the current class, and then list them by inheritance hierarchy, override or implement these methods according to your choice.
• Not too commonly used are the generated Equals and GetHashCode methods, which are rarely overridden in my application scenarios. But according to the .NET Design Specification, Equals for both value types and reference types is recommended to be overridden, and the GetHaseCode method should be overridden because they are interdependent. If you have this requirement, then generating these three functions will definitely help you a lot.

Surrounding code 
Visual Studio also provides the function of outer code, you can press Ctrl+K, Ctrl+S to activate this function, although I don't mean to despise Visual Studio, but Resharper's shortcut keys are indeed more reasonable (I'm pressing It's really hard to press S when Ctrl is down), and the entries are much clearer. The shortcut key for this function in Resharper is Ctrl+Alt+J, and then you can choose to surround the current line of code in a try-catch block or using. This is a very efficient method. We tend to try not to catch exceptions in the early stages of development, and add exception handling mechanisms in the middle and later stages. So you have a lot of work at one point in extending them into try-catch blocks. And when you want to use objects that support dispose, the best way is to use a using block. (Selling cakes, when I know that my code is not optimal, I always sleep and sleep.) Naturally, there is also the function of extending the code to the region block, which is also one of the commonly used functions.
Adjusting the position of a method 
As I said earlier, if you want to adjust the position of a method, you can drag and drop it in the code structure window. If you feel that just moving a method to the front and having to open the code structure window is too heavyweight, there is a lightweight way: when the cursor is on the name of the method, use Ctrl+Shift+Up/Down to move The location of the method, including the xml comment for the method, but sorry if you used two / instead of three xml comments. 
For other trivial functions, 
you must often copy and paste the code of the current line. For example, when using StringBuilder.Append, Ctrl+D can simplify your Ctrl+C, Ctrl+V work. 
There used to be a key combination to comment out the current line, and another to uncomment, but I have forgotten about it, because Ctrl+/ should be the shortcut key that really belongs to it, and press it again to uncomment. 
That's all about Resharper's refactoring features. I may naively count a lot of extra features in refactoring, but it does help you quickly adjust and optimize your code. So please don't delve into whether my conceptual understanding of refactoring is confusing.

Resharper Advanced Eight: Enhanced Browsing Features

When entering the method by browsing the parameters 
, we have become accustomed to the parameter prompts provided by the IDE, which greatly facilitates our selection of overloaded methods. Visual Studio already does it without Resharper. So why did Resharper enhance this feature and get great acclaim. Just ask, does Visual Studio's narrow line of parameter prompts make you feel aggrieved. We have a large 19-inch screen with a resolution of 1600, but we have to stare at the narrow bar and carefully press the up and down buttons to find the reload we need. At least, the guys who developed Resharper can't stand this kind of suffocation, so a wide-open version of the parameter list appears, and the long parameter overload is displayed in the form of a list. When you are using the GDT+ method, you can see When you overload with huge parameters, you will sigh from the bottom of your heart: you sell cake. 
At the same time, the shortcut key for Resharper to display parameters has become Ctrl+P. If you think it is a joke to block the shortcut key for printing, then ask yourself how many times you have printed your own code. 
Browsing open documents 
I thought you already knew the way to switch documents in Visual Studio, they include: 
Ctrl+Alt+Up and Down arrow keys, you can switch between open documents; 
Ctrl+Tab, not only can switch before the document, And you can switch to the solution folder, go to the properties view, you need to press the left and right keys. 
But how to open files that have been recently edited and closed, Visual Studio is very polite and does not provide this function, so it is left to Resharper. In my case, the shortcut key is Ctrl+E, Ctrl+E, yes, press it twice. If yours isn't, look under the Resharper-View-Recent Files menu to see what it is. Because you will use it from time to time. To open a list of files, use the arrow keys to select and enter to open it in the editor. 
Many people say that Resharper has performance problems. I think one of the possible reasons is that there are too many open documents. If you have the habit of closing unnecessary documents at all times, the performance may not be so bad, and you can open these at any time. You close opened documents, just like switching between open documents. 
My team doesn't use the advanced things of agile development, but we still maintain the good habit of only involving two or three files per change, and frequently commit to the source code server. So, there are not many files that I really want to edit each time, and performance is not an issue. 
I have shared with you a lot of techniques used by Resharper, and every bit of it has been integrated into my daily development work. Of course, it is not comprehensive, such as the integration with Nunit. Since we are not test-driven, we don’t have any experience, and naturally we don’t dare to speak out. It is also very subjective. I think it is good, but you may think it is not good. . Besides, it's not a place without idiots. A Close All function added by right-clicking on a document can close all open documents. What are you doing when you close it? Are you staring at a blank screen in a daze? I think the native "close everything else" is enough. There is also a positioning function (Locate in Solution Explorer), which is really useless. If you set it in the VS options to track the active item in the solution manager, then VS will automatically locate it for you. 
Anyway, it brings me a faster and more convenient development experience and frees me from some trivial, inhuman features. From this point of view, I hope more and more people will like it, start using it, and help it develop better.

 

 

PM me if you need documents