通过Roslyn将代码连接到using语句

问题描述

反正有使用Roslyn框架将一段代码连接到其“使用”语句吗？

例如，给出这段代码：

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Serilog;
using System.Collections.Generic;

namespace CodeAnalyzer.Service.CodeAnalysis.CSharp
{
public static class CSharpCodeAnalyser
{

/// <summary>
/// Retrieves all of the using statements from a code page
/// </summary>
/// <param name="codeDocument"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static List<string> IdentifyUsings(string codeDocument,ILogger logger)
{
    var usingList = new List<string>();

    try
    {
        SyntaxTree tree = CSharpSyntaxTree.ParseText(codeDocument);
        CompilationUnitSyntax root = tree.GetCompilationUnitRoot();
        foreach (var item in root.Usings)
        {
            usingList.Add(item.Name.ToString());
        }
    }
    catch (System.Exception ex)
    {
        logger.Error(ex,ex.Message);
        throw;
    }

    return usingList;
}

} }

我可以知道“ CSharpSyntaxTree”程序集属于什么程序集吗？

解决方法

所以我想出了办法。

首先，我需要构建一个包含整个解决方案的工作区。我是通过Buildalyzer工具完成的

        public static Tuple<AdhocWorkspace,IEnumerable<Project>> GetWorkspace(string solutionFilePath,ILogger logger)
    {
        Tuple<AdhocWorkspace,IEnumerable<Project>> results;
        var projectList = new List<Project>();
        AdhocWorkspace workspace = new AdhocWorkspace();


        try
        {
            AnalyzerManager manager = new AnalyzerManager(solutionFilePath);
            foreach (var project in manager.Projects)
            {
                projectList.Add(project.Value.AddToWorkspace(workspace));
            }
            results = new Tuple<AdhocWorkspace,IEnumerable<Project>>(workspace,projectList);
        }
        catch (Exception ex)
        {
            logger.Error(ex,ex.Message);
            throw;
        }
        return results;
    }

一旦我有了一个工作区，我要做的就是以下事情：

var workspace = GetWorkspace(solutionName,_logger);


                foreach (var project in workspace.Item1.CurrentSolution.Projects)
                {
                    foreach (var document in project.Documents)
                    {
                        _logger.Information("");
                        _logger.Information(project.Name + "\t\t\t" + document.Name);
                        var semanticModel = await document.GetSemanticModelAsync();
                        var root = await document.GetSyntaxRootAsync();

                        foreach (var item in root.DescendantNodes())
                        {
                            var typeInfo = semanticModel.GetTypeInfo(item);
                            if (typeInfo.Type != null)
                            {
                                _logger.Information(String.Format("Node: {0}",item.ToString()));
                                _logger.Information(String.Format("Type:{0}",typeInfo.Type.Name.ToString()));
                                _logger.Information(String.Format("ContainingAssembly:{0}",typeInfo.Type.ContainingAssembly));
                                _logger.Information(String.Format("ContainingNamespace:{0}",typeInfo.Type.ContainingNamespace));
                            }

                        }

                        
                    }
                }