Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/controlflow/resharper-heapview
ReSharper Heap Allocations Viewer plugin
https://github.com/controlflow/resharper-heapview
Last synced: about 2 months ago
JSON representation
ReSharper Heap Allocations Viewer plugin
- Host: GitHub
- URL: https://github.com/controlflow/resharper-heapview
- Owner: controlflow
- License: mit
- Created: 2014-04-30T13:46:10.000Z (over 10 years ago)
- Default Branch: master
- Last Pushed: 2024-04-16T10:05:55.000Z (5 months ago)
- Last Synced: 2024-05-02T04:31:07.349Z (5 months ago)
- Language: C#
- Size: 8.57 MB
- Stars: 299
- Watchers: 18
- Forks: 28
- Open Issues: 10
-
Metadata Files:
- Readme: Readme.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
HeapAllocationViewer for Rider and ReSharper
--------------------------------------------
[](https://plugins.jetbrains.com/plugin/9223-heap-allocations-viewer)
[](https://plugins.jetbrains.com/plugin/12390-heap-allocations-viewer)
This plugin statically analyzes C# code to find all local object allocations happening.
It can be used to reduce number of heap allocations in hot paths of your C# program.
#### Features
* It can detect and visualize [all boxing cases](http://stackoverflow.com/questions/7995606/boxing-occurrence-in-c-sharp), including:
```c#
struct Boxing {
void M(string a) {
object obj = 42; // implicit conversion Int32 ~> Object
string path = a + '/' + obj; // implicit conversion Char ~> Object
int code = this.GetHashCode(); // non-overriden virtual method call on struct
string caseA = E.A.ToString(); // the same, virtual call
IComparable comparable = E.A; // valuetype conversion to interface type
Action action = this.M; // delegate from value type method
Type type = this.GetType(); // GetType() call is always virtual
}
enum E { A, B, C }
}
```
* It can visualize some hidden allocations happening in C#, including:
```c#
class HeapAllocations {
List _xs = new List(); // explicit object creation expressions
int[] _ys = {1, 2, 3}; // allocation via array initializer syntax
void M(params string[] args) {
string c = args[0] + "/"; // string concatenation
M("abc", "def"); // parameters array allocation
M(); // the same, hidden 'new string[0]'
var xs = Enumerable.Range(0,1); // iterator method call
var ys = from x in xs
let y = x + 1 // anonymous type creation for 'let'
select x + y;
}
void N(List xs) {
foreach (var s in xs) F(s); // no allocations, value type enumerator
IEnumerable ys = xs;
foreach (var s in ys) F(s); // IEnumerator allocation in foreach
}
}
```
* It can detect delegate instances allocation, ignoring cached delegates:
```c#
class Delegates {
static void M(string s) {
Action method = M; // non-cached delegate from method group
Action lambda = () => M("a"); // cached delegate from static lambda
Action closure = () => M(s); // non-cached lambda with closure 's'
}
void M() {
Action generic = () => { }; // non-cached, lambda in generic method
Action closure = () => M(); // non-cached, captures 'this' to closure
}
}
```
* It can detect closure ("display classes") creation points:
```c#
class Closures {
IEnumerable StupidExample(string str) {
// <= hidden closure class allocation happens here
if (str == null)
return Enumerable.Empty();
if (str.Length == 0) {
return Enumerable.Empty();
} else {
// <= second hidden closure allocation (nested closure)
int value = str.Count(x => x == '_');
return Enumerable
.Range(0, str.Length)
.Select(count => // delegate instance allocation
str.Substring(Math.Max(value, count)));
}
}
}
```
#### Notes
* Please, avoid premature optimizations. Use this tool with care, only when it matters to reduce allocations count;
* You can change default colors of highlightings in Visual Studio settings: go *Tools* - *Settings* - *Fonts and colors*
and check colors for items *"ReSharper HeapView Boxing"* and *"ReSharper HeapView Allocation"*;
* You can change highlighting severity or search for all issues in project/solution as usual - via Alt+Enter menu over highlighting;
* This plugin highly relies on Microsoft's implementation of C# compiler shipping with VS,
it may produce false positives for other C# implementations like Mono C# compiler;
* Plugin's [changelog is here](CHANGELOG.md).