C# ConstructorDeclarationSyntax.WithBody方法代码示例

        public static SyntaxNode IntroduceFieldFromConstructor(SyntaxNode root, ConstructorDeclarationSyntax constructorStatement, ParameterSyntax parameter)
        {
            var oldClass = constructorStatement.FirstAncestorOrSelf<ClassDeclarationSyntax>();
            var newClass = oldClass;
            var fieldName = parameter.Identifier.ValueText;
            var fieldType = parameter.Type;
            var members = ExtractMembersFromClass(oldClass.Members);

            var addMember = false;
            if (!members.Any(p => p.Key == fieldName && p.Value == fieldType.ToString()))
            {
                var identifierPostFix = 0;
                while (members.Any(p => p.Key == fieldName))
                    fieldName = parameter.Identifier.ValueText + ++identifierPostFix;

                addMember = true;
            }

            var assignmentField = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                               SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(),
                                               SyntaxFactory.IdentifierName(fieldName)), SyntaxFactory.IdentifierName(parameter.Identifier.ValueText)));
            var newConstructor = constructorStatement.WithBody(constructorStatement.Body.AddStatements(assignmentField));
            newClass = newClass.ReplaceNode(constructorStatement, newConstructor);

            if (addMember)
            {
                var newField = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(parameter.Type)
                                    .WithVariables(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(fieldName)))))
                                    .WithModifiers(SyntaxFactory.TokenList(new[] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword) }))
                                    .WithAdditionalAnnotations(Formatter.Annotation);
                newClass = newClass.WithMembers(newClass.Members.Insert(0, newField)).WithoutAnnotations(Formatter.Annotation);
            }
            var newRoot = root.ReplaceNode(oldClass, newClass);
            return newRoot;
        }

        public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
        {
            if(this._targetConstructor == null || node.ParameterList.ToString() == this._targetConstructor.ParameterList.ToString())
            {
                var fieldName = this._relatedField.Declaration.Variables
                    .Select(p => p.Identifier.Text)
                    .FirstOrDefault();

                var paramName = fieldName.TrimStart('_');

                if (this._rewriteParams)
                {
                    var newParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier(paramName))
                                .WithType(this._relatedField.Declaration.Type);

                    var newConstructorParams = node.ParameterList.AddParameters(newParam);

                    node = node.WithParameterList(newConstructorParams);
                }

                var newStatement = SyntaxExtenders.AssignmentStatement("this." + fieldName, paramName);
                var newStatements = node.Body.Statements.Insert(0, newStatement);

                node = node.WithBody(node.Body.WithStatements(newStatements));
            }

            return base.VisitConstructorDeclaration(node);
        }

        internal static SyntaxNode AddStatementToConstructorBody(SyntaxNode root, ConstructorDeclarationSyntax constructor, StatementSyntax statement)
        {
            var body = constructor.Body ?? SyntaxFactory.Block();

            return root.ReplaceNode(root.GetCurrentNode(constructor), constructor.WithBody(
                    body.WithStatements(SyntaxFactory.List(new[] { statement }.Concat(body.Statements)))
                ));
        }

 public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
 {
     if (node.ParameterList.Parameters.Count == 0)
         return node
             .WithBody(
                 SyntaxFactory.Block(
                     statements: SyntaxFactory.List(node.Body.Statements.Union(new [] { SyntaxFactory.ParseStatement("DataContext = vm;") }))))
             .WithParameterList(
                 SyntaxFactory.ParameterList(
                     SyntaxFactory.SeparatedList(
                         new[] { SyntaxFactory.Parameter(SyntaxFactory.Identifier("vm")).WithType(SyntaxFactory.ParseTypeName(_viewModelTypeName)) })));
     return base.VisitConstructorDeclaration(node);
 }

        private static ConstructorDeclarationSyntax UseExpressionBodyIfDesired(
            Workspace workspace, ConstructorDeclarationSyntax declaration, ParseOptions options)
        {
            if (declaration.ExpressionBody == null)
            {
                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors).Value;
                if (preferExpressionBody)
                {
                    var expressionBody = declaration.Body.TryConvertToExpressionBody(options);
                    if (expressionBody != null)
                    {
                        return declaration.WithBody(null)
                                          .WithExpressionBody(expressionBody)
                                          .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
                    }
                }
            }

            return declaration;
        }

 public SyntaxNode StaticConstructorPrefixerDeclaration(ConstructorDeclarationSyntax node)
 {
     node = node.WithBody(node.Body.WithStatements(node.Body.Statements.Insert(0, SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(".precctor"))))));
     return node;
 }