Treeview与深层嵌套的对象？

Question

So, I'm trying to get a bit more into Roslyn and therefore writing an application that helps me analysing my solutions.

Should be said, I'm still relatively new to C# and WPF, so I may miss something important or obvious here.

I would like to display the structure of my solution in a Treeview. I'm already able to export the structure of my solution to a textfile with an output like this:

+ Analysing the following project: Testtool  
|+ Analysing the following document: Converters.cs  
||+ The following namespaces are referenced for the analysed file:  
|||- System  
|||- System.Collections.Generic  
|||- System.Linq  
|||- System.Text  
|||- System.Threading.Tasks  
|||- System.Windows.Data  
||- The file lives in the following namespace: Testtool  
||+ Analysing the following class of the current file: BooleanInverter  
|||+ The following modifiers are used for the class:  
||||- public  
||||- partial  
|||+ The following methods are defined in the currently analysed class:  
||||+ Convert  
|||||+ The following modifiers are used for the method:  
||||||- public  
||||+ ConvertBack  
|||||+ The following modifiers are used for the method:  
||||||- public  
|+ Analysing the following document: LoadingControl.xaml.cs  
||+ The following namespaces are referenced for the analysed file:  
|||- System  
|||- System.Collections.Generic  
|||- System.Linq  
|||- System.Text  
|||- System.Threading.Tasks  
|||- System.Windows  
|||- System.Windows.Controls  
|||- System.Windows.Data  
|||- System.Windows.Documents  
|||- System.Windows.Input  
|||- System.Windows.Media  
|||- System.Windows.Media.Imaging  
|||- System.Windows.Navigation  
|||- System.Windows.Shapes  
|||- System.ComponentModel  
||- The file lives in the following namespace: Testtool  
||+ Analysing the following class of the current file: LoadingControl  
|||+ The following modifiers are used for the class:  
||||- public  
||||- partial  
|||+ The following methods are defined in the currently analysed class:  
||||+ OnPropertyChanged  
|||||+ The following modifiers are used for the method:  
||||||- public  
|||+ The following properties are defined in the currently analysed class:  
||||+ SpinnerText  
|||||+ The following modifiers are used for the Property:  
||||||- public  

Now I'm not sure what a good way would be to display this structure in an object. I mean, if there isn't a better possibility, I would create a corresponding object model, but I feel the need for such deeply nested objects feels wrong. So, maybe someone has a better idea on this?

Answer 1

As Dudi already indicates, the Syntax Visualizer also provides a treeview with the entire syntax tree, however, looking at your console output, it seems that you want to show a summary of the "bare syntax tree". I would go for a corresponding object model, indeed, since your analysis summarises the syntax tree very much, so you shouldn't need that many view models.

I don't have any experience using the treeview with WPF, but probably you can just bind to the top level view model, which would represent the Solution , and it's children return the Project view models. Using implicit data templates would do the rest.

If you want some sample code for this, I'm happy to add that.

Answer 2

at first thanks a lot for your answers. They both helped me and brought up some good thoughts. That said, there were still several things I greatly disliked about the „pure object model“ approach. But after some searching, thinking I have a solution that fits my needs while still is good to maintain in my opinion. The source code of the Syntax Visualizer from Roslyn brought me up to some of it. Key points:

• Defining a single “SyntaxTreeNode” property. This property can contain a list of other SyntaxTreeNode objects.
• Iterating through the solution with a given way, extract the informations I want.
• Implementing a way to specify the “parentNode” a new Node should be added to. Check the kind of the currently examined SyntaxNode/Token.
• Depending on the kind set the parameters of the node accordingly (here's still some good room for improvement/refactoring).
• Once a subnode is build, add it to the determined parent.
• Define the property as ObservableCollection and then bind the TreeViews ItemSource to it.

Note that I'm using Syncfusions sfTreeGrid, so the way for handling the columns may differ. But it should get the point.

SyntaxTreeNode definition

public class SyntaxTreeNode 
{
    // A node can contain other nodes
    public ObservableCollection<SyntaxTreeNode> SyntaxTreeNodes { get; set; }
    public string Name { get; set; }
    public string Type { get; set; }
}

In the class that examines the solution

    // The property used for binding the ItemsSource of the sfTreeView
    private ObservableCollection<SyntaxTreeNode> _TreeViewNodes;
    public ObservableCollection<SyntaxTreeNode> TreeViewNodes
    {
        get { return _TreeViewNodes; }
        set
        {
            _TreeViewNodes = value;
        }
    }

Central method for getting the hierarchical object. Not properly refactored yet. public void displaySyntaxTree() { // Init the property TreeViewNodes = new ObservableCollection();

        // Open the solution from the supplied path
        string solutionPath = @"Path to your solution";
        MSBuildWorkspace msWorkspace = MSBuildWorkspace.Create();
        Solution solution = msWorkspace.OpenSolutionAsync(solutionPath).Result;

        // Analyze each project.
        foreach (var project in solution.Projects)
        {
            // Set project node
            SyntaxTreeNode projectNode = new SyntaxTreeNode();
            projectNode.Name = project.Name;
            projectNode.Type = "Project";
            projectNode.SyntaxTreeNodes = new ObservableCollection<SyntaxTreeNode>();

            // Add the defined node to the collection (first tree level).
            TreeViewNodes.Add(projectNode);

            // Set the recently added node as a “parentNode”. This will be used later to add the prebuild subnode (or a list of subnodes).
            SyntaxTreeNode parentProjectNode = CommonDataAccess.TreeViewNodes[CommonDataAccess.TreeViewNodes.Count - 1];

            // Get the list of referenced assemblies for the project. Subsequently create a new node that will then show them (a “root node” for the references if you want to say so). At this point the node does NOT yet get added to the collection that’s bound to the TreeView.
            IReadOnlyList<MetadataReference> projectReferences = project.MetadataReferences;
            SyntaxTreeNode referenceNode = new SyntaxTreeNode();
            referenceNode.Name = "Referenced assemblies";
            referenceNode.Type = "Reference list";
            referenceNode.SyntaxTreeNodes = new ObservableCollection<SyntaxTreeNode>();

            // Create a new node for each reference entry under the reference “root node” defined above.
            foreach (MetadataReference reference in projectReferences)
            {
                SyntaxTreeNode refNode = new SyntaxTreeNode();
                int refNameStart = reference.Display.LastIndexOf("\\") + 1;
                int refNameLength = reference.Display.Length - refNameStart;
                refNode.Name = reference.Display.Substring(refNameStart, refNameLength);
                refNode.Type = "Reference";
                referenceNode.SyntaxTreeNodes.Add(refNode);
            }

            // Now add the prebuild reference “root node” with the single reference nodes to the earlier defined project node (therefore creating a structure with two sublevels).
            parentProjectNode.SyntaxTreeNodes.Add(referenceNode);

            // Now go through the documents for the current project.
            foreach (Document document in project.Documents)
            {
                // Add a subnode to the current project for the document.
                SyntaxTreeNode TreeNode = new SyntaxTreeNode();
                TreeNode.Name = document.Name;
                TreeNode.Type = "File";

                parentProjectNode.SyntaxTreeNodes.Add(TreeNode);

                string path = document.FilePath;
                FileStream stream = File.OpenRead(path);

                SyntaxTree tree = CSharpSyntaxTree.ParseText(SourceText.From(stream), path: path);

                CompilationUnitSyntax root = (CompilationUnitSyntax)tree.GetRoot();

                // Similar to the project level, determine the node for each document now and set it as “parentNode”. So this is actually now on a sublevel (most likely the first).
                SyntaxTreeNode actNode = parentProjectNode.SyntaxTreeNodes[parentProjectNode.SyntaxTreeNodes.Count - 1];

                // Call the method for adding the subnodes for the current document. Passing with ref so no need to return a node.
                getSubNodes(root, ref actNode);
            }
        }
    }

    // Simple method for getting the childs of the SyntaxTree, init the sublevel collection and adding prepared subnodes to the parent node.
    public void getSubNodes(CompilationUnitSyntax parentTree, ref SyntaxTreeNode parentNode)
    {
        ChildSyntaxList childs = parentTree.ChildNodesAndTokens();
        List<SyntaxTreeNode> nodesToAdd = iterateSubNodes(childs);
        foreach (SyntaxTreeNode node in nodesToAdd)
        {
            if (parentNode.SyntaxTreeNodes == null)
                parentNode.SyntaxTreeNodes = new ObservableCollection<SyntaxTreeNode>();
            parentNode.SyntaxTreeNodes.Add(node);
        }
    }

    // Method for examing the kind of the current node. If no proper kind was found “recursively” searching through the nodes. Has to be improved, expanded and refactored still (dictionary could be suitable for this).
    public List<SyntaxTreeNode> iterateSubNodes (ChildSyntaxList syntaxList)
    {
        List<SyntaxTreeNode> nodesToReturn = new List<SyntaxTreeNode>();

        foreach (SyntaxNodeOrToken nodeOrToken in syntaxList)
        {
            SyntaxKind childKind = nodeOrToken.Kind();
            if (childKind == SyntaxKind.UsingDirective)
            {
                SyntaxTreeNode tokenToAdd = new SyntaxTreeNode();
                UsingDirectiveSyntax usingNode = (UsingDirectiveSyntax)nodeOrToken;
                tokenToAdd = addUsing(usingNode);
                nodesToReturn.Add(tokenToAdd);
            }
            else if (childKind == SyntaxKind.NamespaceDeclaration)
            {
                SyntaxTreeNode tokenToAdd = new SyntaxTreeNode();
                NamespaceDeclarationSyntax namespaceNode = (NamespaceDeclarationSyntax)nodeOrToken;
                tokenToAdd = addNamespace(namespaceNode);
                nodesToReturn.Add(tokenToAdd);
            }
            else
            {
                iterateSubNodes(nodeOrToken.ChildNodesAndTokens());
            }
        }

        // Return the node (or a list of them) for further processing.
        return nodesToReturn;
    }

    // Method for defining the parameters for a NameSpaceDeclaration.
    private SyntaxTreeNode addNamespace(NamespaceDeclarationSyntax namespaceSyntax)
    {
        SyntaxTreeNode nodeToReturn = new SyntaxTreeNode();
        nodeToReturn.Name = namespaceSyntax.Name.ToString();
        nodeToReturn.Type = "Namespace Definition";

        return nodeToReturn;
    }

    // The same as for Namespace, here just for usingDirectives.
    private SyntaxTreeNode addUsing(UsingDirectiveSyntax usingSyntax)
    {
        SyntaxTreeNode nodeToReturn = new SyntaxTreeNode();
        nodeToReturn.Name = usingSyntax.Name.ToString();
        nodeToReturn.Type = usingSyntax.Kind().ToString();

        return nodeToReturn;
    }

The code above gives me a view like this in the end: