查找在方法

Question

中使用哪些使用指令

如何知道在给定SyntaxNode的后代中使用了哪些使用指令。

请看下面的例子： https://dotnetfiddle.net/mCzNST 在这里，我想知道哪些usings在Class1的使用，却忽略了在Class2中使用的usings。

Answer 1

您可以使用语义模型获取与语法节点相关的类型。类型信息知道可用于标识相关使用的相关名称空间。迭代所有节点时，您会收到方法的返回值以及变量，属性和字段的类型。如果限制到特定类型（例如InvocationExpressionSyntax）的节点上，您只能得到返回类型，变量类型等

private static IEnumerable<string> FindUsedUsings(SemanticModel model, SyntaxNode node) 
{ 
    var resultList = new List<string>(); 
    foreach (var identifier in node.DescendantNodesAndSelf()) 
    { 
     var typeInfo = model.GetTypeInfo(identifier); 
     if (typeInfo.Type != null) 
     { 
      resultList.Add(typeInfo.Type.ContainingNamespace.ToDisplayString()); 
     } 
    } 
    return resultList.Distinct().ToList(); 
} 

但是，如果你想获得你必须确定所有申报类型usings。我写了一个（不完全）解决方案，以确定三种需要usings的：

using System; 
using Text = System.String; 
using static System.Console; 

您可以识别每一种类型有不同的逻辑使用。

对于第一类使用，你应该考虑的：

• 变种不需要使用
• PredefinedTypes（字符串，整数）要求使用无
• 动态不需要使用
• QualifiedTypeNames不需要使用

对于第二种使用类型，您应该考虑：

• 虽然可以使用别名来解析类型，但您也可以使用原始名称。使用上面的例子，你可以写出Statement string sample = Text.Empty;

对于第三种类型的使用，您没有该类型的标识符，因此您需要使用表达式语句查找该调用。 请注意，在下面的解决方案中，使用静态MyNamespace.Classname将无法正确解析，因为我没有为该方法的IdentifierNameSyntax提供TypeSymbol，所以无法解析该类型。

这两个问题解决：

• 如果类型不解决对该类当使用静态MyNamespace.Classname可能会丢失MyNamespace.Class2
• 如果类型解析使用无效在分析类MyNamespace.Classname时可能会出现静态MyNamespace.Classname（因为类中不需要类型名称）

考虑到这一点，我想出了这个解决方案。可能还有其他特殊情况要考虑，但我认为这是一个不错的起点：

private static IEnumerable<string> FindUsedUsings(SemanticModel model, 
      SyntaxNode node, SyntaxNode root) 
{ 
    var aliasResolution = new Dictionary<string, string>(); 
    var usings = root.DescendantNodes().OfType<UsingDirectiveSyntax>(); 
    foreach (var curr in usings) 
    { 
     var nameEquals = curr.DescendantNodes(). 
      OfType<NameEqualsSyntax>().FirstOrDefault(); 
     if (nameEquals != null) 
     { 
      var qualifiedName = 
       curr.DescendantNodes().OfType<QualifiedNameSyntax>(). 
        FirstOrDefault()?.ToFullString(); 
      if (qualifiedName != null) 
      { 
       aliasResolution.Add(nameEquals.Name.Identifier.Text, qualifiedName); 
      } 
     } 
    } 
    var currentNamespace = node.Ancestors(). 
     OfType<NamespaceDeclarationSyntax>().FirstOrDefault(); 
    var namespacename = currentNamespace?.Name.ToString(); 
    if (namespacename == null) 
    { 
     // Empty namespace 
     namespacename = string.Empty; 
    } 
    var resultList = new List<string>(); 
    foreach (var identifier in node.DescendantNodesAndSelf().OfType<TypeSyntax>()) 
    { 
     if (identifier is PredefinedTypeSyntax || identifier.IsVar) 
     { 
      // No usings required for predefined types or var... 
      // [string, int, char, var, etc. do not need usings] 
      continue; 
     } 
     // If an alias is defined use it prioritized 
     if (GetUsingFromAlias(model, identifier, aliasResolution, resultList)) 
     { 
      continue; 
     } 
     // If a type is provided, try to resolve it 
     if (GetUsingFromType(model, identifier, namespacename, resultList)) 
     { 
      continue; 
     } 
     // If no type is provided check if the expression 
     // corresponds to a static member call 
     GetUsingFromStatic(model, identifier, resultList); 
    } 
    return resultList.Distinct().ToList(); 
} 

private static void GetUsingFromStatic(SemanticModel model, TypeSyntax identifier, 
      List<string> resultList) 
{ 
    var symbol = model.GetSymbolInfo(identifier).Symbol; 
    // If the symbol (field, property, method call) can be resolved, 
    // is static and has a containing type 
    if (symbol != null && symbol.IsStatic && symbol.ContainingType != null) 
    { 
     var memberAccess = identifier.Parent as ExpressionSyntax; 
     if (memberAccess != null) 
     { 
      bool hasCallingType = false; 
      var children = memberAccess.ChildNodes(); 
      foreach (var childNode in children) 
      { 
       // If the Expression has a Type 
       // (that is, if the expression is called from an identifyable source) 
       // no using static is required 
       var typeInfo = model.GetSymbolInfo(childNode).Symbol as INamedTypeSymbol; 
       if (typeInfo != null) 
       { 
        hasCallingType = true; 
        break; 
       } 
      } 
      // if the type-Info is missing a static using is required 
      if (!hasCallingType) 
      { 
       // type three using: using static [QualifiedType] 
       resultList.Add($"static {symbol.ContainingType}"); 
      } 
     } 
    } 
} 

private static bool GetUsingFromType(SemanticModel model, TypeSyntax identifier, 
      string namespacename, List<string> resultList) 
{ 
    var typeInfo = model.GetSymbolInfo(identifier).Symbol as INamedTypeSymbol; 
    // dynamic is not required and not provided as an INamedTypeSymbol 
    if (typeInfo != null) 
    { 
     if (identifier is QualifiedNameSyntax 
      || identifier.Parent is QualifiedNameSyntax) 
     { 
      // Qualified namespaces can be ignored... 
      return true; 
     } 
     var containingNamespace = typeInfo.ContainingNamespace.ToDisplayString(); 
     // The current namespace need not be referenced 
     if (namespacename == containingNamespace) 
     { 
      return true; 
     } 
     // Type one using: using [Namespace]; 
     resultList.Add(typeInfo.ContainingNamespace.ToDisplayString()); 
     return true; 
    } 
    return false; 
} 

private static bool GetUsingFromAlias(SemanticModel model, TypeSyntax identifier, 
      Dictionary<string, string> aliasResolution, List<string> resultList) 
{ 
    var aliasInfo = model.GetAliasInfo(identifier); 
    // If the identifier is an alias 
    if (aliasInfo != null) 
    { 
     // check if it can be resolved 
     if (aliasResolution.ContainsKey(aliasInfo.Name)) 
     { 
      // Type two using: using [Alias] = [QualifiedType]; 
      resultList.Add($"{aliasInfo.Name} = {aliasResolution[aliasInfo.Name]}"); 
      return true; 
     } 
    } 
    return false; 
}