C# SeparatedSyntaxList.AddRange方法代码示例

        public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
        {
            var typesList = new List<TypeSyntax> { _baseTypeSyntax };

            if (node.BaseList != null)
                typesList.AddRange(node.BaseList.Types);

            var types = new SeparatedSyntaxList<TypeSyntax>();
            types = types.AddRange(typesList);

            var identifier = SyntaxFactory.Identifier(FurnaceTypeIdentifier + _typeName);

            var newNode = node.Update(
                node.AttributeLists,
                node.Modifiers,
                node.Keyword,
                identifier,
                node.TypeParameterList,
                SyntaxFactory.BaseList(types),
                node.ConstraintClauses,
                node.OpenBraceToken,
                node.Members,
                node.CloseBraceToken,
                node.SemicolonToken).NormalizeWhitespace();

            return base.VisitClassDeclaration(newNode);
        }

        private static TypeArgumentListSyntax ParameterToArgumentListSyntax(TypeParameterListSyntax typeParameters)
        {
            var list = new SeparatedSyntaxList<TypeSyntax>();
            list = list.AddRange(typeParameters.Parameters.Select(p => SyntaxFactory.ParseName(p.ToString()).WithTriviaFrom(p)));

            for (int i = 0; i < list.SeparatorCount; i++)
            {
                // Make sure the parameter list looks nice
                var separator = list.GetSeparator(i);
                list = list.ReplaceSeparator(separator, separator.WithTrailingTrivia(SyntaxFactory.Space));
            }

            return SyntaxFactory.TypeArgumentList(list);
        }

        private void DoTestAddInsertRemoveOnEmptyList(SeparatedSyntaxList<SyntaxNode> list)
        {
            Assert.Equal(0, list.Count);

            SyntaxNode nodeD = SyntaxFactory.ParseExpression("D");
            SyntaxNode nodeE = SyntaxFactory.ParseExpression("E");

            var newList = list.Add(nodeD);
            Assert.Equal(1, newList.Count);
            Assert.Equal("D", newList.ToFullString());

            newList = list.AddRange(new[] { nodeD, nodeE });
            Assert.Equal(2, newList.Count);
            Assert.Equal("D,E", newList.ToFullString());

            newList = list.Insert(0, nodeD);
            Assert.Equal(1, newList.Count);
            Assert.Equal("D", newList.ToFullString());

            newList = list.InsertRange(0, new[] { nodeD, nodeE });
            Assert.Equal(2, newList.Count);
            Assert.Equal("D,E", newList.ToFullString());

            newList = list.Remove(nodeD);
            Assert.Equal(0, newList.Count);

            Assert.Equal(-1, list.IndexOf(nodeD));
            Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(0));
            Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(1, nodeD));
            Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, nodeD));
            Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { nodeD }));
            Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { nodeD }));
            Assert.Throws<ArgumentNullException>(() => list.Add(null));
            Assert.Throws<ArgumentNullException>(() => list.AddRange((IEnumerable<SyntaxNode>)null));
            Assert.Throws<ArgumentNullException>(() => list.Insert(0, null));
            Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, (IEnumerable<SyntaxNode>)null));
        }

        public void SomeTest()
        {
            var tree = CSharpSyntaxTree.ParseFile("Roslyn/FurnaceItem.cs");
            var root = tree.GetRoot();
            var node = root.DescendantNodes().OfType<ClassDeclarationSyntax>().First();

            var tt = SyntaxFactory.ParseTypeName("TestClass");

            var typesList = new List<TypeSyntax> {tt};
            typesList.AddRange(node.BaseList.Types);

            var types = new SeparatedSyntaxList<TypeSyntax>();
            types = types.AddRange(typesList);

            //SyntaxFactory.BaseList();
            var updated = node.Update(node.AttributeLists,
                node.Modifiers,
                node.Keyword,
                node.Identifier,
                node.TypeParameterList,
                SyntaxFactory.BaseList(types),
                node.ConstraintClauses,
                node.OpenBraceToken,
                node.Members,
                node.CloseBraceToken,
                node.SemicolonToken).NormalizeWhitespace();

            System.Console.WriteLine(updated.ToFullString());
        }

            public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
            {
                var tt = SyntaxFactory.ParseTypeName(_baseClass);

                var typesList = new List<TypeSyntax> { tt };
                typesList.AddRange(node.BaseList.Types);

                var types = new SeparatedSyntaxList<TypeSyntax>();
                types = types.AddRange(typesList);

                //SyntaxFactory.BaseList();
                var updated = node.Update(node.AttributeLists,
                    node.Modifiers,
                    node.Keyword,
                    node.Identifier,
                    node.TypeParameterList,
                    SyntaxFactory.BaseList(types),
                    node.ConstraintClauses,
                    node.OpenBraceToken,
                    node.Members,
                    node.CloseBraceToken,
                    node.SemicolonToken).NormalizeWhitespace();

                return updated;
            }

        private AttributeListSyntax CreateInternalVisibleToAttributeList(Project project, Project[] allProjects)
        {
            var testProjects = allProjects.Where(x => x.ProjectReferences.Any(y => y.ProjectId == project.Id)).ToArray();
            if (testProjects.Length == 0)
                return null;

            List<AttributeSyntax> attrs = testProjects.Select(CreateInternalVisibleToAttribute).ToList();

            var attributeList = new SeparatedSyntaxList<AttributeSyntax>();
            attributeList = attributeList.AddRange(attrs);

            var assemblyLevelSpecifier =
                SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword));

            return SyntaxFactory.AttributeList(assemblyLevelSpecifier, attributeList);
        }