In Visual Studio, is there a way to sort private methods by usage?

Question

In Visual Studio, with or without an extension, is there a way to automatically sort private methods inside a class based on the order of their usage (their location in the call stack)?

For example consider the following class:

public class MyClass
{
    public void MyMethod()
    {
        TestC();
    }

    private void TestA()
    {
        TestB();
    }

    private void TestB()
    {
        Console.WriteLine("Hello");
    }

    private void TestC()
    {
        TestA();
    }
}

The public method in this class is MyMethod, it calls TestC which calls TestA which calls TestB. I would like to (automatically) order these methods by this order so that the class looks like this:

public class MyClass
{
    public void MyMethod()
    {
        TestC();
    }

    private void TestC()
    {
        TestA();
    }

    private void TestA()
    {
        TestB();
    }

    private void TestB()
    {
        Console.WriteLine("Hello");
    }
}

I need to be able to select a class, request such method sorting, and have the methods sorted automatically. I.e., I don't want to manually sort these methods.

I understand that there are some nuances. For example, there could be a private method that is called from two methods which are at two different levels in the call stack. I guess in this case it makes sense to consider the smallest (call stack) distance from the public method.

UPDATE:

This idea of sorting the methods in this way comes from the Clean Code book by Robert C. Martin. In chapter 3, the Stepdown rule is defined which talks about having the higher level functions appear before the low level functions.

Doing a quick search for stepdown rule on google, I found a netbeans plugin at: http://plugins.netbeans.org/plugin/58863/stepdownruleplugin

I would guess that it does something similar to what I need, but for netbeans.

Answer 1

The ReSharper Plugin "Greenkeeper" does the job:

https://bitbucket.org/denniskniep/greenkeeper

The plugin can sort the methods in "newspapermode": Important code first and details at the bottom. The newspapermode has the same behaviour as the "Stepdown rule".

https://bitbucket.org/denniskniep/greenkeeper/wiki/SortingDeclarations

Answer 2

I don't know whether it's possible to do this natively within Visual Studio. However, I think that the best method would be to use ReSharper (a Visual Studio extension) to do this.

It provides at least two options that comes to mind:

1) Using the File and Type Layout preferences with patterns,

2) Using the File Structure window (this might be the quickest way if the class you want to reorder doesn't have too many methods). You can check it out here.

Hope that helps.

Answer 3

Here are the other products that no one has referenced that could add the functionality with a friendly request:

• NArrange
• CodeSorter
• CodeMaid

Its not that hard to write this yourself. The new Visual Studio VSIX Project templates are available in the VS2015 setup, if you cant find them under (File > New > Project.. Visual C# > Extensibility) just Modify the Install (cmd > appwiz.cpl > VS2015 Change/Modify).

The great news is that the CodeMaid project is open source and contains most of the code & logic you will need to reorder chunks of code.

The other thing you will need is the Call Stack and one of our helpful fellow Stackoverflow'rs has provided the code for that here: How to get stack trace of a running process from within a Visual Studio add-in?

_{Given this is a bounty you were probably expecting a full solution, sorry I dont have time to code it up for you right now but am happy to give you a hand if you run into any issues. Let me know in the comments.}

To get up and running quickly I'd personally just copy the code in this Visual Studio extension and replace the guts with Re-Ordering by Call Stack: Debug Single Thread.

Answer 4

if you want to trigger that logic manually and you use vs 2015, you can create a visual studio CodeFix that will use Roslyn. see: Build CodeFix ex

The steps that you should do are:

1. Create CodeFix project
2. The logic of the CodeFix, using Roslyn, will analyze all the methods in the document and create a dependency graph between the methods. Than it will change the order and rewrite the code to the document
3. Install the CodeFix, as an analyzer, and use it for every visual studio document you want

Answer 5

Short answer is NO See the reason is simply because majority of developers try to write code that is easily readable. If I need to make an update to TestB and looking at the code I would expect TestB to be defined after TestA and before TestC. Then you also take into account defined fields for the class and the use of get/set methods for setting and getting the value of a defined field.

The code below shows 2 classes. The first class is in the layout that I personally use for readability should another developer need to update the code they aren't wasting time hunting down through the code. The second class follows the way you are wanting them to be re-arranged.

            public class MyClass
            {
                private string _HelloWorld;
                public string HelloWorld
                {
                    get {return _HelloWorld;}
                    set {_HelloWorld = value;}
                }

                public void MyMethod
                {
                    TestC();
                }

                public void TestA()
                {
                    TestB();
                }

                public void TestB()
                {
                    Console.WriteLine(HelloWorld);
                }

                public void TestC()
                {
                    TestA();
                }

            }

---

            public class MyClass2
            {
                private string _HelloWorld;

                public void MyMethod
                {
                    TestC();
                }

                public void TestC()
                {
                    TestA();
                }

                public void TestA()
                {
                    TestB();
                }

                public void TestB()
                {
                    Console.WriteLine(HelloWorld);
                }

                public string HelloWorld
                {
                    get {return _HelloWorld;}
                    set {_HelloWorld = value;}
                }
            }