如何通过 Roslyn 获取 class 的基础 class 名称？

Question

我正在使用 Roslyn 并且我有以下 class:

var source = @"
    using System;
    class MyClass : MyBaseClass {
      static void Main(string[] args) {
        Console.WriteLine(""Hello, World!"");
      }
    }";

// Parsing
SyntaxTree tree = CSharpSyntaxTree.ParseText(source);

// This uses an internal function (working)
// That gets the first node of type `SimpleBaseTypeSyntax`
SimpleBaseTypeSyntax simpleBaseType = GetNBaseClassNode(tree);

获取基础 class 名称

我成功访问了包含我需要的节点 SimpleBaseTypeSyntax。事实上，如果我使用语法浏览器，我会得到：

节点 IdentifierToken 有我需要的一切有它的 Text、Value 和 ValueText 属性是 "MyBaseClass"!

但是，虽然在语法资源管理器中我可以看到所有这些值，但我无法以编程方式访问它们。

所以我尝试以编程方式检索节点：

IdentifierNameSyntax identifierNode =
  simpleBaseType.ChildNodes().OfType<IdentifierNameSyntax>().First();
SyntaxToken identifier = simpleBaseType.Identifier;
string name = identifier.Text;

但是name是空字符串。与 identifier.Value 和 identifier.ValueText.

相同

我做错了什么？也许我做错了，所以 你如何检索基础 class 名称？

另一种尝试：使用语义模型

我开始考虑我需要此类信息的语义模型：

IdentifierNameSyntax identifierNode =
  simpleBaseType .ChildNodes().OfType<IdentifierNameSyntax>().First();

SemanticModel semanticModel =
  CSharpCompilation.Create("Class")
   .AddReferences(MetadataReference.CreateFromFile(
     typeof(object).Assembly.Location))
       .AddSyntaxTrees(tree).GetSemanticModel(tree);

SymbolInfo symbolInfo = this.semanticModel.GetSymbolInfo(identifierNode);
string name = symbolInfo.Symbol.Name;

这会引发异常，因为 symbolInfo.Symbol 是 null。

Answer 1

我看到您正在尝试使用 Roslyn API 构建分析器。您知道还有其他方法可以测试您的分析器逻辑吗？使用单元测试文件而不是直接在分析器中获取源代码。

使用这个想法，您完全可以使用 Visual Studio 提供的模板构建您的分析器，您必须在其中继承 DiagnosticAnalyzer 并创建您的分析代码逻辑。

对于您的情况，您应该查看 ClassDeclaration 并轻松访问 Node 中的 BaseTypes 属性。

        public bool SomeTriedDiagnosticMethod(SyntaxNodeAnalysisContext nodeContext)
    {
        var classDeclarationNode = nodeContext.Node as ClassDeclarationSyntax;
        if (classDeclarationNode == null) return false;
        var baseType = classDeclarationNode.BaseList.Types.FirstOrDefault(); //  Better use this in all situations to be sure code won't break
        var nameOfFirstBaseType = baseType.Type.ToString();  
        return nameOfFirstBaseType == "BaseType";

    }

Answer 2

我真的不知道为什么你不能通过 GetSymbolInfo() 将 BaseTypeSyntax 传递给语义模型，但它也为我返回 null 而没有错误。

无论如何，这是一种有效的方法：

var tree = CSharpSyntaxTree.ParseText(@"
using System;
class MyBaseClass
{
}
class MyClass : MyBaseClass {
  static void Main(string[] args) {
    Console.WriteLine(""Hello, World!"");
  }
}");

var Mscorlib = PortableExecutableReference.CreateFromAssembly(typeof(object).Assembly);
var compilation = CSharpCompilation.Create("MyCompilation",
    syntaxTrees: new[] { tree }, references: new[] { Mscorlib });
var model = compilation.GetSemanticModel(tree);

var myClass = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().Last();
var myClassSymbol = model.GetDeclaredSymbol(myClass) as ITypeSymbol;
var baseTypeName = myClassSymbol.BaseType.Name;

您需要在此处使用语义模型，因为您无法可靠地判断您在语法级别处理的是接口还是基类型。

Answer 3

    protected static bool IsWebPage(SyntaxNodeAnalysisContext context, ClassDeclarationSyntax classDeclaration)
    {
        INamedTypeSymbol iSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclaration) as INamedTypeSymbol;
        INamedTypeSymbol symbolBaseType = iSymbol?.BaseType;

        while (symbolBaseType != null)
        {
            if (symbolBaseType.ToString() == "System.Web.UI.Page")
                return true;
            symbolBaseType = symbolBaseType.BaseType;
        }

        return false;
    }

Answer 4

这是我的助手 class，它可以找到所有属性、class 名称、class 命名空间和基础 classes.

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

namespace MyProject
{
    public class CsharpClass
    {
        public string Name { get; set; }
        public string Namespace { get; set; }
        public List<CsharpProperty> Properties { get; set; }
        public List<string> BaseClasses { get; set; }

        public class CsharpProperty
        {
            public string Name { get; set; }
            public string Type { get; set; }

            public CsharpProperty(string name, string type)
            {
                Name = name;
                Type = type;
            }
        }

        public CsharpClass()
        {
            Properties = new List<CsharpProperty>();
            BaseClasses = new List<string>();
        }
    }

    public static class CsharpClassParser
    {
        public static CsharpClass Parse(string content)
        {
            var csharpClass = new CsharpClass();
            var tree = CSharpSyntaxTree.ParseText(content);
            var members = tree.GetRoot().DescendantNodes().OfType<MemberDeclarationSyntax>();

            foreach (var member in members)
            {
                if (member is PropertyDeclarationSyntax property)
                {
                    csharpClass.Properties.Add(new CsharpClass.CsharpProperty(
                        property.Identifier.ValueText, property.Type.ToString()));
                }

                if (member is NamespaceDeclarationSyntax namespaceDeclaration)
                {
                    csharpClass.Namespace = namespaceDeclaration.Name.ToString();
                }

                if (member is ClassDeclarationSyntax classDeclaration)
                {
                    csharpClass.Name = classDeclaration.Identifier.ValueText;

                    csharpClass.BaseClasses = GetBaseClasses(classDeclaration).ToList();
                }

                //if (member is MethodDeclarationSyntax method)
                //{
                //    Console.WriteLine("Method: " + method.Identifier.ValueText);
                //}
            }

            return csharpClass;
        }

        private static IEnumerable<string> GetBaseClasses(ClassDeclarationSyntax classDeclaration)
        {
            if (classDeclaration == null)
            {
                return null;
            }

            if (classDeclaration.BaseList == null)
            {
                return null;
            }

            return classDeclaration.BaseList.Types.Select(x => x.Type.ToString());
        }
    }
}

用法：

const string content = @"
namespace Acme.Airlines.AirCraft
{
    public class AirCraft
    {
        public virtual string Name { get; set; }

        public virtual int Code { get; set; }

        public AirCraft()
        {

        }
    }
}";

var csharpClass = CsharpClassParser.Parse(content);

Console.WriteLine(csharpClass.Name);
Console.WriteLine(csharpClass.Namespace);
Console.WriteLine(csharpClass.Properties.Count);
Console.WriteLine(csharpClass.BaseClasses.Count);

如何通过 Roslyn 获取 class 的基础 class 名称？

How to get the base class name of a class via Roslyn?

c#

roslyn

获取基础 class 名称

另一种尝试：使用语义模型