C# SyntaxList.OfType方法代码示例

 /// <summary>
 /// Retourne les conditions sur les paramètres dans une listes d'expressions.
 /// </summary>
 /// <param name="expressions">Liste d'expressions.</param>
 /// <param name="paramètres">Les paramètres du constructeur.</param>
 /// <param name="modèleSémantique">Modèle sémantique.</param>
 /// <returns>La liste d'assignations.</returns>
 public static IEnumerable<IfStatementSyntax> TrouveConditionsParametres(SyntaxList<StatementSyntax> expressions, ParameterListSyntax paramètres, SemanticModel modèleSémantique) =>
     expressions
         .OfType<IfStatementSyntax>()
         .Where(e =>
             (e.Condition
                 ?.DescendantNodes()?.OfType<IdentifierNameSyntax>()
                 ?.Any(identifiant => modèleSémantique.GetSymbolInfo(identifiant).Symbol?.Kind == SymbolKind.Parameter)
             ?? false)
         && (e.Statement
                 ?.DescendantNodes()?.OfType<IdentifierNameSyntax>()
                 ?.All(identifiant => modèleSémantique.GetSymbolInfo(identifiant).Symbol?.Kind != SymbolKind.Field)
             ?? false));

 private void ProcessMembers(SyntaxList<MemberDeclarationSyntax> members)
 {
     foreach (var namespaceDeclaration in members.OfType<NamespaceDeclarationSyntax>())
     {
         this.ProcessUsingDirectives(namespaceDeclaration.Usings);
         this.ProcessMembers(namespaceDeclaration.Members);
     }
 }

        private static int CountNamespaces(SyntaxList<MemberDeclarationSyntax> members)
        {
            var result = 0;

            foreach (var namespaceDeclaration in members.OfType<NamespaceDeclarationSyntax>())
            {
                result += 1 + CountNamespaces(namespaceDeclaration.Members);
            }

            return result;
        }

        private static SyntaxList<XmlNodeSyntax> RemoveMalformattedStandardText(SyntaxList<XmlNodeSyntax> content, SyntaxToken identifier, string preText, string postText, ref string trailingString)
        {
            var regex = new Regex(@"^\s*" + Regex.Escape(preText) + "[^ ]+" + Regex.Escape(postText));
            var item = content.OfType<XmlTextSyntax>().FirstOrDefault();

            if (item == null)
            {
                return content;
            }

            int index = -1;
            foreach (var token in item.TextTokens)
            {
                index++;

                if (token.IsKind(SyntaxKind.XmlTextLiteralNewLineToken))
                {
                    continue;
                }
                else if (token.IsKind(SyntaxKind.XmlTextLiteralToken))
                {
                    string value = token.ValueText.Trim(null);

                    Match match = regex.Match(value);

                    if (!match.Success)
                    {
                        return content;
                    }
                    else if (match.Length == value.Length)
                    {
                        // Remove the token
                        var tokens = item.TextTokens;

                        while (index >= 0)
                        {
                            tokens = tokens.RemoveAt(0);
                            index--;
                        }

                        var newContent = item.WithTextTokens(tokens);

                        return content.Replace(item, newContent);
                    }
                    else
                    {
                        // Remove the tokens before
                        var tokens = item.TextTokens;

                        while (index >= 0)
                        {
                            tokens = tokens.RemoveAt(0);
                            index--;
                        }

                        trailingString = value.Substring(match.Length);

                        var newContent = item.WithTextTokens(tokens);

                        return content.Replace(item, newContent);
                    }
                }
                else
                {
                    return content;
                }
            }

            return content;
        }

        ExpressionSyntax CollectCondition(ExpressionSyntax expressionSyntax, SyntaxList<SwitchLabelSyntax> labels)
        {
            //default
            if (labels.Count == 0 || labels.OfType<DefaultSwitchLabelSyntax>().Any())
                return null;

            var conditionList =
                labels
                    .OfType<CaseSwitchLabelSyntax>()
                    .Select(l => SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, expressionSyntax, l.Value)).ToList();

            //attempt to add parentheses
            //TODO: port InsertParentheses in-full rather than a make-do (but I didn't think I had the time to do a full-port)
            for (int i = 0; i < conditionList.Count; ++i)
            {
                var cond = conditionList[i];
                if (NeedsParentheses((cond.Right)))
                {
                    conditionList[i] = cond.WithRight(SyntaxFactory.ParenthesizedExpression(cond.Right));
                }
            }

            if (conditionList.Count == 1)
                return conditionList.First();

            //combine case labels
            BinaryExpressionSyntax condition = conditionList[0];
            for (int i = 1; i < conditionList.Count; ++i)
            {
                condition = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, condition, conditionList[i]);
            }
            return condition;
        }