C# CodeFixContext.RegisterCodeFix方法代码示例

 public async override Task RegisterCodeFixesAsync(CodeFixContext context)
 {
     var document = context.Document;
     var cancellationToken = context.CancellationToken;
     var span = context.Span;
     var diagnostics = context.Diagnostics;
     var root = await document.GetSyntaxRootAsync(cancellationToken);
     var diagnostic = diagnostics.First();
     var node = root.FindNode(context.Span);
     if (node is BinaryExpressionSyntax)
     {
         var newRoot = root.ReplaceNode(node, SyntaxFactory.LiteralExpression(node.IsKind(SyntaxKind.EqualsExpression) ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression));
         context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, diagnostic.GetMessage(), document.WithSyntaxRoot(newRoot)), diagnostic);
     } 
     else if (node is InvocationExpressionSyntax)
     {
         var newRoot = root.ReplaceNode(node, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression));
         context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, diagnostic.GetMessage(), document.WithSyntaxRoot(newRoot)), diagnostic);
     } 
     else if (node is PrefixUnaryExpressionSyntax) 
     {
         var newRoot = root.ReplaceNode(node, SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
         context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, diagnostic.GetMessage(), document.WithSyntaxRoot(newRoot)), diagnostic);
     }
 }

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;

            // Find the type declaration identified by the diagnostic.
            var baseTypeDeclaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<SimpleBaseTypeSyntax>().FirstOrDefault();
            if (baseTypeDeclaration != null)
            {
                context.RegisterCodeFix(
                    CodeAction.Create(
                        title: title,
                        createChangedDocument: c => GenerateInterfaceImplementationAsync(context.Document, baseTypeDeclaration, c),
                        equivalenceKey: title),
                    diagnostic);
                return;
            }

            var methodDeclaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<MethodDeclarationSyntax>().FirstOrDefault();
            if (methodDeclaration != null)
            {
                context.RegisterCodeFix(
                    CodeAction.Create(
                        title: title,
                        createChangedDocument: c => GenerateMethodImplementationAsync(context.Document, methodDeclaration, c),
                        equivalenceKey: title),
                    diagnostic);
                return;
            }
        }

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;
            var refactorType = diagnostic.Properties[ForeachToLinqAnalyzer.RefactorType];
            var foreachStatement = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<ForEachStatementSyntax>().First();
            if (refactorType == ForeachToLinqAnalyzer.ContainingIfToWhere)
            {
                var ifStatement = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<IfStatementSyntax>().First();
                context.RegisterCodeFix(
                    CodeAction.Create("Convert if statement to LINQ method chain",
                    c => ConvertIfToLINQ(context.Document, ifStatement, foreachStatement, c)),
                    diagnostic);
            }
            else if (refactorType == ForeachToLinqAnalyzer.IfWithContinueToWhere)
            {
                var ifStatement = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<IfStatementSyntax>().First();
                context.RegisterCodeFix(
                    CodeAction.Create("Convert if statement to LINQ method chain",
                    c => ConvertIfContinueToLINQ(context.Document, ifStatement, foreachStatement, c)),
                    diagnostic);
            }
            else if (refactorType == ForeachToLinqAnalyzer.VariableToSelect)
            {
                var variableDeclarator = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<VariableDeclaratorSyntax>().First();
                context.RegisterCodeFix(
                    CodeAction.Create("Convert variable assignment to LINQ method chain",
                    c => ConvertVariableAssignmentToLINQ(context.Document, variableDeclarator, foreachStatement, c)),
                    diagnostic);
            }
        }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            var node = root.FindNode(context.Span);
            var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
            var symbol = model.GetDeclaredSymbol(node, context.CancellationToken);

            if (symbol == null)
            {
                return;
            }

            var diagnostic = context.Diagnostics.Single();

            // There was no constructor and so the diagnostic was on the type. Generate a serialization ctor.
            if (symbol.Kind == SymbolKind.NamedType)
            {
                context.RegisterCodeFix(new MyCodeAction(AnalyzerPowerPackFixersResources.ImplementSerializationConstructor,
                     async ct => await GenerateConstructor(context.Document, node, symbol, ct).ConfigureAwait(false)),
                diagnostic);
            }
            // There is a serialization constructor but with incorrect accessibility. Set that right.
            else if (symbol.Kind == SymbolKind.Method)
            {
                context.RegisterCodeFix(new MyCodeAction(AnalyzerPowerPackFixersResources.ImplementSerializationConstructor,
                     async ct => await SetAccessibility(context.Document, node, symbol, ct).ConfigureAwait(false)),
                diagnostic);
            }

            return;
        }

 public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
 {
     var diagnostic = context.Diagnostics.First();
     context.RegisterCodeFix(CodeAction.Create("Rethrow as inner exception", c => MakeThrowAsInnerAsync(context.Document, diagnostic, c)), diagnostic);
     context.RegisterCodeFix(CodeAction.Create("Throw original exception", c => MakeThrowAsync(context.Document, diagnostic, c)), diagnostic);
     return Task.FromResult(0);
 }

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;

            var declaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<ClassDeclarationSyntax>().First();

            context.RegisterCodeFix(
                CodeAction.Create(
                    title: publicTitle,
                    createChangedDocument: c => AddModifier(context.Document, declaration, SyntaxKind.PublicKeyword, c),
                    equivalenceKey: publicTitle),
                diagnostic);
            context.RegisterCodeFix(
                CodeAction.Create(
                    title: internalTitle,
                    createChangedDocument: c => AddModifier(context.Document, declaration, SyntaxKind.InternalKeyword, c),
                    equivalenceKey: internalTitle),
                diagnostic);
            context.RegisterCodeFix(
                CodeAction.Create(
                    title: privateTitle,
                    createChangedDocument: c => AddModifier(context.Document, declaration, SyntaxKind.PrivateKeyword, c),
                    equivalenceKey: privateTitle),
                diagnostic);
        }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            var node = root.FindNode(context.Span);
            var fieldNode = GetFieldDeclarationNode(node);
            if(fieldNode == null)
            {
                return;
            }

            var diagnostic = context.Diagnostics.Single();

            // Fix 1: Add a NonSerialized attribute to the field
            context.RegisterCodeFix(new MyCodeAction(AnalyzerPowerPackFixersResources.AddNonSerializedAttribute,
                                        async ct => await AddNonSerializedAttribute(context.Document, fieldNode, ct).ConfigureAwait(false)),
                                    diagnostic);


            // Fix 2: If the type of the field is defined in source, then add the serializable attribute to the type.
            var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
            var fieldSymbol = model.GetDeclaredSymbol(node, context.CancellationToken) as IFieldSymbol;
            var type = fieldSymbol?.Type;
            if (type != null && type.Locations.Any(l => l.IsInSource))
            {
                context.RegisterCodeFix(new MyCodeAction(AnalyzerPowerPackFixersResources.AddSerializableAttribute,
                            async ct => await AddSerializableAttributeToType(context.Document, type, ct).ConfigureAwait(false)),
                        diagnostic);
            }
        }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            var node = root.FindNode(context.Span);
            if (node == null)
            {
                return;
            }

            var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
            var charSetType = model.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.CharSet");
            var dllImportType = model.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.DllImportAttribute");
            var marshalAsType = model.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.MarshalAsAttribute");
            var unmanagedType = model.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.UnmanagedType");
            if (charSetType == null || dllImportType == null || marshalAsType == null || unmanagedType == null)
            {
                return;
            }

            // We cannot have multiple overlapping diagnostics of this id.
            var diagnostic = context.Diagnostics.Single();

            if (IsAttribute(node))
            {
                context.RegisterCodeFix(new MyCodeAction(SystemRuntimeInteropServicesAnalyzersResources.SpecifyMarshalingForPInvokeStringArgumentsTitle,
                                                         async ct => await FixAttributeArguments(context.Document, node, charSetType, dllImportType, marshalAsType, unmanagedType, ct).ConfigureAwait(false)),
                                        diagnostic);
            }
            else if (IsDeclareStatement(node))
            {
                context.RegisterCodeFix(new MyCodeAction(SystemRuntimeInteropServicesAnalyzersResources.SpecifyMarshalingForPInvokeStringArgumentsTitle,
                                                         async ct => await FixDeclareStatement(context.Document, node, ct).ConfigureAwait(false)),
                                        diagnostic);
            }
        }

        /// <inheritdoc/>
        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var syntaxRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            foreach (var diagnostic in context.Diagnostics)
            {
                var queryExpression = (QueryExpressionSyntax)syntaxRoot.FindNode(diagnostic.Location.SourceSpan).Parent;

                if (queryExpression.DescendantTrivia().All(AcceptableSingleLineTrivia))
                {
                    context.RegisterCodeFix(
                        CodeAction.Create(
                            ReadabilityResources.SA1103CodeFixSingleLine,
                            cancellationToken => GetTransformedDocumentFromSingleLineAsync(context.Document, diagnostic, cancellationToken),
                            nameof(SA1103CodeFixProvider) + "Single"),
                        diagnostic);
                }

                context.RegisterCodeFix(
                    CodeAction.Create(
                        ReadabilityResources.SA1103CodeFixMultipleLines,
                        cancellationToken => GetTransformedDocumentForMultipleLinesAsync(context.Document, diagnostic, cancellationToken),
                        nameof(SA1103CodeFixProvider) + "Multiple"),
                    diagnostic);
            }
        }

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;

            // Find the type declaration identified by the diagnostic.
            var declaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<MethodDeclarationSyntax>().First();

            var title = "Return void";
            context.RegisterCodeFix(
                CodeAction.Create(
                    title
                    , c => ReturnVoidAsync(context.Document, declaration, c)
                    , title)
                , diagnostic);

            var title2 = "Return self";
            context.RegisterCodeFix(
                CodeAction.Create(
                    title2
                    , c => ReturnSelfAsync(context.Document, declaration, c)
                    , title2)
                , diagnostic);
        }

		public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
		{
			var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false) as CompilationUnitSyntax;

			var diagnostic = context.Diagnostics.First();
			var diagnosticSpan = diagnostic.Location.SourceSpan;
			var classDeclaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<ClassDeclarationSyntax>().First();

			var missingInterfaces = classDeclaration.GetMissingInterfaces();
			if (missingInterfaces.Any())
			{
				var codeAction = CodeAction.Create(
					"Add Missing Interfaces",
					_ => AddInterface(context.Document, root, classDeclaration, missingInterfaces),
					$"{ExportAnalyzer.DiagnosticId} Add Missing Interfaces");
				context.RegisterCodeFix(codeAction, diagnostic);
			}

			var missingExports = classDeclaration.GetMissingExports();
			if (missingExports.Any())
			{
				var codeAction = CodeAction.Create(
					"Add Missing Exports",
					_ => AddExport(context.Document, root, classDeclaration, missingExports),
					$"{ExportAnalyzer.DiagnosticId} Add Missing Exports");
				context.RegisterCodeFix(codeAction, diagnostic);
			}
		}

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);

            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;

            var methodSyntax = root.FindNode(diagnosticSpan) as MethodDeclarationSyntax;
            var methodSymbol = model.GetDeclaredSymbol(methodSyntax);

            var xml = methodSymbol.GetDocumentationCommentXml();

            //<!-- Badly formed XML comment ignored for member "M:XX(YY)" -->
            if (xml.StartsWith("<!--"))
            {
                context.RegisterCodeFix(
                    CodeAction.Create(Resources.RepairXmlCommentTitle, c => RepairXmlCommentAsync(context.Document, methodSyntax, c), equivalenceKey: Resources.RepairXmlCommentTitle),
                    diagnostic);
            }
            else
            {
                context.RegisterCodeFix(
                    CodeAction.Create(Resources.CodeFixTitle, c => UpdateDocumentCommentAsync(context.Document, methodSyntax, c), equivalenceKey: Resources.CodeFixTitle),
                    diagnostic);
            }
        }

 public async override Task RegisterCodeFixesAsync(CodeFixContext context)
 {
     var document = context.Document;
     var cancellationToken = context.CancellationToken;
     var span = context.Span;
     var diagnostics = context.Diagnostics;
     var root = await document.GetSyntaxRootAsync(cancellationToken);
     var diagnostic = diagnostics.First();
     var constructor = root.FindToken(span.Start).Parent.AncestorsAndSelf().OfType<ConstructorDeclarationSyntax>().First();
     context.RegisterCodeFix(CodeActionFactory.Create(span, diagnostic.Severity, "Make constructor protected", delegate
     {
         var publicToken = constructor.Modifiers.First(m => m.IsKind(SyntaxKind.PublicKeyword));
         var newConstructor = constructor.WithModifiers(constructor.Modifiers.Replace(publicToken, SyntaxFactory.Token(publicToken.LeadingTrivia, SyntaxKind.ProtectedKeyword,
                                                                                                                          publicToken.TrailingTrivia)));
         var newRoot = root.ReplaceNode(constructor, newConstructor);
         return Task.FromResult(document.WithSyntaxRoot(newRoot));
     }), diagnostic);
     context.RegisterCodeFix(CodeActionFactory.Create(span, diagnostic.Severity, "Make constructor private", delegate
     {
         var publicToken = constructor.Modifiers.First(m => m.IsKind(SyntaxKind.PublicKeyword));
         var newConstructor = constructor.WithModifiers(constructor.Modifiers.Remove(publicToken));
         var newRoot = root.ReplaceNode(constructor, newConstructor);
         return Task.FromResult(document.WithSyntaxRoot(newRoot));
     }), diagnostic);
 }

 public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
 {
     var diagnostic = context.Diagnostics.First();
     context.RegisterCodeFix(CodeAction.Create("Change property to 'private set'", c => ChangePropertySetAsync(context.Document, diagnostic, c, FixType.PrivateFix), nameof(PropertyPrivateSetCodeFixProvider) + nameof(FixType.PrivateFix)), diagnostic);
     context.RegisterCodeFix(CodeAction.Create("Change property to 'protected set'", c => ChangePropertySetAsync(context.Document, diagnostic, c, FixType.ProtectedFix), nameof(PropertyPrivateSetCodeFixProvider) + nameof(FixType.ProtectedFix)), diagnostic);
     return Task.FromResult(0);
 }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            SyntaxNode node = root.FindNode(context.Span);
            SemanticModel model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
            ISymbol symbol = model.GetDeclaredSymbol(node, context.CancellationToken);

            if (symbol == null)
            {
                return;
            }

            INamedTypeSymbol notImplementedExceptionType = WellKnownTypes.NotImplementedException(model.Compilation);
            if (notImplementedExceptionType == null)
            {
                return;
            }

            Diagnostic diagnostic = context.Diagnostics.Single();

            // There was no constructor and so the diagnostic was on the type. Generate a serialization ctor.
            if (symbol.Kind == SymbolKind.NamedType)
            {
                context.RegisterCodeFix(new MyCodeAction(DesktopAnalyzersResources.ImplementSerializationConstructorsCodeActionTitle,
                     async ct => await GenerateConstructor(context.Document, node, symbol, notImplementedExceptionType, ct).ConfigureAwait(false)),
                diagnostic);
            }
            // There is a serialization constructor but with incorrect accessibility. Set that right.
            else if (symbol.Kind == SymbolKind.Method)
            {
                context.RegisterCodeFix(new MyCodeAction(DesktopAnalyzersResources.ImplementSerializationConstructorsCodeActionTitle,
                     async ct => await SetAccessibility(context.Document, symbol, ct).ConfigureAwait(false)),
                diagnostic);
            }
        }