public override SyntaxNode Visit(SyntaxNode node) { // Check each node until we find the property's parent. When we've found it, let's add a private field to it if (_propertyParent.IsEquivalentTo(node)) { var variableDeclarator = SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier(this.PrivateFieldName)); if (_crunchedProperty.IsExpressionProperty()) { variableDeclarator = variableDeclarator.WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.Token(SyntaxKind.EqualsToken), _crunchedProperty.ExpressionBody.Expression)); } // Create the private "backing field" of the property var privateField = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration(_crunchedProperty.Type, // Property Type SyntaxFactory.SeparatedList( new[] { variableDeclarator }))) // Field Name .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); // Modifier (always private) // Insert the backing field just ahead of the original property var newParent = node.InsertNodesBefore(_crunchedProperty, new[] { privateField }); return(base.Visit(newParent)); // Return the new parent which replaces the original. } return(base.Visit(node)); }
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax property) { // Check each node until we find the property in question. When we have it, we'll replace it with a Full Property if (property.IsEquivalentTo(this._crunchedProperty)) { AccessorDeclarationSyntax getter = null; AccessorDeclarationSyntax setter = null; SyntaxTokenList getterModifiers = default(SyntaxTokenList); SyntaxTokenList setterModifiers = default(SyntaxTokenList); bool hasGetter = false; bool hasSetter = false; if (property.IsExpressionProperty()) { hasGetter = true; } else { hasGetter = property.HasGetter(); hasSetter = property.HasSetter(); if (hasGetter) { getterModifiers = property.GetGetter().Modifiers; } if (hasSetter) { setterModifiers = property.GetSetter().Modifiers; } } if (hasGetter) // Check if original Auto Property had a getter { // Create a new Getter with a body, returning a private field getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithBody( SyntaxFactory.Block( SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(this.PrivateFieldName))) // return field e.g. return _myProperty; ) .WithModifiers(getterModifiers) // Keep original modifiers .WithoutTrivia(); } if (hasSetter) // Check if original Auto Property had a setter { // Create a new Setter with a body, setter the private field setter = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithBody( SyntaxFactory.Block( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(this.PrivateFieldName), SyntaxFactory.IdentifierName("value")))) // Assignment e.g. _myProperty = value ) .WithModifiers(setterModifiers) // Keep original modifiers .WithoutTrivia(); } // Create a new property. Set the type and name var newProperty = SyntaxFactory.PropertyDeclaration(property.Type, property.Identifier.ValueText) .WithModifiers(property.Modifiers); // use the modifier(s) of the original property // Add getter and setter to accessor list var accessors = new List <AccessorDeclarationSyntax>(); if (getter != null) { accessors.Add(getter); } if (setter != null) { accessors.Add(setter); } // Put together the property with our built up accessors list newProperty = newProperty.WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List(accessors))); return(newProperty); // Returning our new property "replaces" the original } return(base.VisitPropertyDeclaration(property)); }