C# PropertyDeclarationSyntax.WithAccessorList方法代码示例

 private static PropertyDeclarationSyntax GetSimpleProperty(PropertyDeclarationSyntax property, VariableDeclaratorSyntax variableDeclarator)
 {
     var simpleGetSetPropetie = property.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] {
             SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
             SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
         })));
     return variableDeclarator.Initializer == null ?
         simpleGetSetPropetie :
         simpleGetSetPropetie.WithInitializer(variableDeclarator.Initializer)
             .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
 }

        private PropertyDeclarationSyntax ConvertToAutoProperty(PropertyDeclarationSyntax propertyDeclaration)
        {
            var newProperty = propertyDeclaration
                .WithAccessorList(
                    SyntaxFactory.AccessorList(
                        SyntaxFactory.List(new[]
                            {
                                SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithAdditionalAnnotations(Formatter.Annotation),
                                SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
                            })));

            return newProperty;
        }

        private static PropertyDeclarationSyntax ExpandProperty(PropertyDeclarationSyntax original, PropertyDeclarationSyntax updated, string backingFieldName)
        {

            AccessorDeclarationSyntax getter = original.AccessorList.Accessors.FirstOrDefault(ad => ad.Kind() == SyntaxKind.GetAccessorDeclaration);
            var returnFieldStatement = SyntaxFactory.ParseStatement($"return {backingFieldName};");
            getter = getter
                .WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(returnFieldStatement)))
                .WithSemicolonToken(default(SyntaxToken));

            AccessorDeclarationSyntax setter = original.AccessorList.Accessors.FirstOrDefault(ad => ad.Kind() == SyntaxKind.SetAccessorDeclaration);

            var setPropertyStatement = SyntaxFactory.ParseStatement($"{backingFieldName} = value;");
            setter = setter
                .WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(setPropertyStatement)))
                .WithSemicolonToken(default(SyntaxToken));

            updated = updated
                .WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getter, setter })))
                .WithAdditionalAnnotations(Formatter.Annotation)
                .WithAdditionalAnnotations(UpdatedPropertyAnnotation);
            return updated;
        }

		/// <summary>
		///   Normalizes the <paramref name="declaration" />.
		/// </summary>
		public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax declaration)
		{
			// Nothing to do here for properties with expression bodies
			if (declaration.ExpressionBody != null)
				return declaration;

			// Nothing to do here for properties not defined in fault effects or for properties that are no overrides of some port
			var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
			if (!propertySymbol.ContainingType.IsFaultEffect(SemanticModel) || !propertySymbol.IsOverride)
				return declaration;

			// Nothing to do here for required ports
			if (propertySymbol.IsExtern)
				return declaration;

			var getter = (AccessorDeclarationSyntax)Syntax.GetAccessor(declaration, DeclarationKind.GetAccessor);
			var setter = (AccessorDeclarationSyntax)Syntax.GetAccessor(declaration, DeclarationKind.SetAccessor);

			// Nothing to do here for properties with accessors that have a body
			if (getter == null || getter.Body != null || setter?.Body != null)
				return declaration;

			var fieldName = GetBackingFieldName(propertySymbol);
			var fieldIdentifier = (ExpressionSyntax)Syntax.IdentifierName(fieldName);
			var fieldModifiers = setter == null
				? DeclarationModifiers.Unsafe | DeclarationModifiers.ReadOnly
				: DeclarationModifiers.Unsafe;
			var fieldDeclaration = Syntax.FieldDeclaration(
				name: fieldName,
				type: Syntax.TypeExpression(propertySymbol.Type),
				accessibility: Accessibility.Private,
				modifiers: fieldModifiers,
				initializer: declaration.Initializer?.Value);

			fieldDeclaration = Syntax.AddAttribute<CompilerGeneratedAttribute>(fieldDeclaration);
			fieldDeclaration = Syntax.MarkAsNonDebuggerBrowsable(fieldDeclaration);
			AddMembers(propertySymbol.ContainingType, (FieldDeclarationSyntax)fieldDeclaration);

			var getterBody = (StatementSyntax)Syntax.ReturnStatement(fieldIdentifier).NormalizeWhitespace();
			getterBody = getterBody.AppendLineDirective(-1).PrependLineDirective(-1);
			var getterBlock = SyntaxFactory.Block(getterBody).EnsureIndentation(getter).PrependLineDirective(getter.GetLineNumber());
			getter = getter.WithStatementBody(getterBlock);

			AccessorListSyntax accessors;
			if (setter == null)
				accessors = declaration.AccessorList.WithAccessors(SyntaxFactory.List(new[] { getter }));
			else
			{
				var assignment = Syntax.AssignmentStatement(fieldIdentifier, Syntax.IdentifierName("value"));
				var setterBody = (StatementSyntax)Syntax.ExpressionStatement(assignment);
				setterBody = setterBody.AppendLineDirective(-1).PrependLineDirective(-1);
				var setterBlock = SyntaxFactory.Block(setterBody).EnsureIndentation(setter).PrependLineDirective(setter.GetLineNumber());
				setter = setter.WithStatementBody(setterBlock);

				accessors = declaration.AccessorList.WithAccessors(SyntaxFactory.List(new[] { getter, setter }));
			}

			var originalDeclaration = declaration;
			declaration = declaration.WithInitializer(null).WithSemicolonToken(default(SyntaxToken));
			return declaration.WithAccessorList(accessors).EnsureLineCount(originalDeclaration);
		}

        private async Task<Document> TooManyAccessorsAsync(Document document, PropertyDeclarationSyntax declaration, CancellationToken c)
        {
            SyntaxGenerator generator = SyntaxGenerator.GetGenerator(document);

            var allAccessors = declaration.AccessorList.Accessors.OfType<AccessorDeclarationSyntax>();
            bool foundGetAccessor = false;
            AccessorDeclarationSyntax accessorToKeep = null;
            var accessorList = declaration.AccessorList;

            foreach (AccessorDeclarationSyntax accessor in allAccessors)
            {
                var keyword = accessor.Keyword;
                if (keyword.IsKind(SyntaxKind.GetKeyword) && !foundGetAccessor)
                {
                    accessorToKeep = accessor;
                    foundGetAccessor = true;
                }
                else
                {
                    accessorList = accessorList.RemoveNode(accessor, 0);
                }
            }

            var block = SyntaxFactory.Block(new StatementSyntax[0]);
            if (accessorToKeep == null)
            {
                accessorToKeep = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, block);
            }
            
            SyntaxList<SyntaxNode> accessorsToAdd = new SyntaxList<SyntaxNode>();
            accessorsToAdd = accessorsToAdd.Add(accessorToKeep);
            var newPropertyDeclaration = declaration.WithAccessorList(null);
            newPropertyDeclaration = generator.AddAccessors(newPropertyDeclaration, accessorsToAdd) as PropertyDeclarationSyntax;

            return await ReplaceNode(declaration, newPropertyDeclaration, document);
        }

		/// <summary>
		///   Normalizes the <paramref name="declaration" />.
		/// </summary>
		public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax declaration)
		{
			// Nothing to do here for properties without expression bodies
			if (declaration.ExpressionBody == null)
				return declaration;

			// Nothing to do here for properties not defined in fault effects or for properties that are no overrides of some port
			var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
			if (!propertySymbol.ContainingType.IsFaultEffect(SemanticModel) || !propertySymbol.IsOverride)
				return declaration;

			var originalDeclaration = declaration;
			var statements = AsStatementBody(propertySymbol.GetMethod, declaration.ExpressionBody.Expression);

			var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, statements);
			var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(getter));
			declaration = declaration.WithAccessorList(accessorList);

			declaration = declaration.WithExpressionBody(null).WithSemicolonToken(default(SyntaxToken));
			return declaration.EnsureLineCount(originalDeclaration);
		}

 static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
 {
     // create new auto property
     var accessorDeclList = new SyntaxList<AccessorDeclarationSyntax>().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))).Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
     var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
     return newProperty;
 }

        static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
		{
			var getter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.GetAccessorDeclaration));
			var setter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.SetAccessorDeclaration));

			// create new auto property
			var accessorDeclList = new SyntaxList<AccessorDeclarationSyntax>().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithModifiers (getter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
			                                                                  .Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithModifiers (setter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
            var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
            return newProperty;
        }

        private static PropertyDeclarationSyntax ExpandProperty(PropertyDeclarationSyntax property, string backingFieldName)
        {
            AccessorDeclarationSyntax getter, setter;
            if (!ExpansionChecker.TryGetAccessors(property, out getter, out setter))
            {
                throw new ArgumentException();
            }

            if (getter.Body == null)
            {
                var returnFieldStatement = SyntaxFactory.ParseStatement(string.Format("return {0};", backingFieldName));
                getter = getter
                    .WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(returnFieldStatement)));
            }

            getter = getter
                .WithSemicolonToken(default(SyntaxToken));

            var setPropertyStatement = SyntaxFactory.ParseStatement(string.Format("SetProperty(ref {0}, value, \"{1}\");", backingFieldName, property.Identifier.ValueText));
            setter = setter
                .WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(setPropertyStatement)))
                .WithSemicolonToken(default(SyntaxToken));

            var newProperty = property
                .WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getter, setter })))
                .WithAdditionalAnnotations(Formatter.Annotation);

            return newProperty;
        }

        private static PropertyDeclarationSyntax UseExpressionBodyIfDesired(
            Workspace workspace, PropertyDeclarationSyntax declaration, ParseOptions options)
        {
            if (declaration.ExpressionBody == null)
            {
                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
                if (preferExpressionBody)
                {
                    if (declaration.Initializer == null)
                    {
                        var expressionBody = TryGetExpressionBody(declaration.AccessorList, options);
                        if (expressionBody != null)
                        {
                            declaration = declaration.WithAccessorList(null)
                                                     .WithExpressionBody(expressionBody)
                                                     .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
                        }
                    }
                }
            }

            return declaration;
        }

        private async Task<Document> HandlePropertyDeclaration(PropertyDeclarationSyntax declaration, Document document, CancellationToken cancellationToken)
        {
            var returnStatement = SyntaxFactory.ReturnStatement(
                returnKeyword: SyntaxFactory.Token(SyntaxKind.ReturnKeyword),
                expression: declaration.ExpressionBody.Expression,
                semicolonToken: declaration.SemicolonToken);

            var accessorDeclaration = SyntaxFactory.AccessorDeclaration(
                kind: SyntaxKind.GetAccessorDeclaration,
                body: SyntaxFactory.Block(returnStatement));

            var newDeclaration = declaration
                .WithAccessorList(
                    SyntaxFactory.AccessorList(
                        SyntaxFactory.SingletonList(accessorDeclaration)))
                .WithExpressionBody(null)
                .WithSemicolonToken(default(SyntaxToken))
                .WithAdditionalAnnotations(Formatter.Annotation);

            var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = oldRoot.ReplaceNode(declaration, newDeclaration);

            return document.WithSyntaxRoot(newRoot);
        }

 public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
 {
     return base.VisitPropertyDeclaration(
         node.WithAccessorList(
                 SyntaxFactory.AccessorList(
                 SyntaxFactory.List<AccessorDeclarationSyntax>(
                     new[]
                     {
                         SyntaxFactory
                             .AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
                             .WithBody(SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(
                                 new[]
                                 {
                                     SyntaxFactory.ReturnStatement(
                                         SyntaxFactory.MemberAccessExpression(
                                             kind: SyntaxKind.SimpleMemberAccessExpression,
                                             expression: SyntaxFactory.IdentifierName("global::"+_symbol.ContainingType.ToDisplayString()),
                                             name: SyntaxFactory.IdentifierName(_symbol.Name))
                                     )
                                 }
                             )
                         )),
                         SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
                             .WithBody(SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(
                                 new[]
                                 {
                                     SyntaxFactory.ParseStatement("global::"+_symbol.ContainingType.ToDisplayString()+"."+_symbol.Name+" = value;")
                                 }
                             )
                         ))
                     }.Where(ad =>
                         (_symbol.GetMethod != null && ad.IsKind(SyntaxKind.GetAccessorDeclaration)) ||
                         (_symbol.SetMethod != null && ad.IsKind(SyntaxKind.SetAccessorDeclaration)))
                 )
             )));
 }

 private static PropertyDeclarationSyntax CreateAutoProperty(PropertyDeclarationSyntax property, VariableDeclaratorSyntax variableDeclarator,
     IFieldSymbol fieldSymbol, IPropertySymbol propertySymbol)
 {
     var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List(new[] {
             SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
             SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
         })));
     newProperty = variableDeclarator.Initializer == null ?
         newProperty :
         newProperty.WithInitializer(variableDeclarator.Initializer)
             .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
     newProperty = CreatePropertyWithCorrectAccessibility(newProperty, fieldSymbol, propertySymbol);
     newProperty = newProperty
         .WithTriviaFrom(property)
         .WithAdditionalAnnotations(Formatter.Annotation);
     return newProperty;
 }

        Document PerformAction(Document document, SemanticModel model, SyntaxNode root, PropertyDeclarationSyntax propertyDeclaration, bool needsSetter)
        {
            AccessorDeclarationSyntax accessor = null;
            PropertyDeclarationSyntax newProp = null;
            if (needsSetter)
            {
                accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration);

                var getter = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.GetAccessorDeclaration));
                if (getter == null)
                {
                    //get;
                    accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
                }
                else
                {
                    var getField = ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.ScanGetter(model, getter);
                    if (getField == null && getter.Body == null)
                    {
                        //get;
                        accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(getter.GetTrailingTrivia());
                    }
                    else if (getField == null || getField.IsReadOnly)
                    {
                        //readonly or no field can be found
                        accessor = accessor.WithBody(GetNotImplementedBlock());
                    }
                    else
                    {
                        //now we add a 'field = value'.
                        accessor = accessor.WithBody(SyntaxFactory.Block(
                            SyntaxFactory.ExpressionStatement(
                                SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(getField.Name), SyntaxFactory.IdentifierName("value")))));
                    }
                }
                newProp = propertyDeclaration.WithAccessorList(propertyDeclaration.AccessorList.AddAccessors(accessor));
            }
            else
            {
                accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration);

                var setter = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.SetAccessorDeclaration));
                var accessorDeclList = new SyntaxList<AccessorDeclarationSyntax>();
                if (setter == null)
                {
                    //set;
                    accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
                }
                else
                {
                    var setField = ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.ScanSetter(model, setter);
                    if (setField == null && setter.Body == null)
                    {
                        //set;
                        accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(setter.GetTrailingTrivia());
                    }
                    else if (setField == null)
                    {
                        //no field can be found
                        accessor = accessor.WithBody(GetNotImplementedBlock());
                    }
                    else
                    {
                        //now we add a 'return field;'.
                        accessor = accessor.WithBody(SyntaxFactory.Block(
                            SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(setField.Name))));
                    }
                    accessorDeclList = accessorDeclList.Add(propertyDeclaration.AccessorList.Accessors.First(m => m.IsKind(SyntaxKind.SetAccessorDeclaration)));
                }
                accessorDeclList = accessorDeclList.Insert(0, accessor);
                var accessorList = SyntaxFactory.AccessorList(accessorDeclList);
                newProp = propertyDeclaration.WithAccessorList(accessorList);
            }
            var newRoot = root.ReplaceNode((SyntaxNode)propertyDeclaration, newProp).WithAdditionalAnnotations(Formatter.Annotation);
            return document.WithSyntaxRoot(newRoot);
        }

		/// <summary>
		///   Normalizes the <paramref name="declaration" />.
		/// </summary>
		public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax declaration)
		{
			var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
			if (!propertySymbol.ContainingType.IsComponent(SemanticModel) || !propertySymbol.IsExtern)
				return declaration;

			var originalDeclaration = declaration;
			var index = declaration.Modifiers.IndexOf(SyntaxKind.ExternKeyword);
			declaration = declaration.WithModifiers(declaration.Modifiers.RemoveAt(index)).WithSemicolonToken(default(SyntaxToken));

			var accessors = SyntaxFactory.List(NormalizerAccessors(originalDeclaration.AccessorList.Accessors));
			return declaration.WithAccessorList(declaration.AccessorList.WithAccessors(accessors)).EnsureLineCount(originalDeclaration);
		}