C# CodeFixContext.RegisterFixes方法代码示例

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var cancellationToken = context.CancellationToken;
            var uniqueIdentities = await GetUniqueIdentitiesAsync(context).ConfigureAwait(false);

            var assemblyNames = uniqueIdentities.Select(i => i.Name).ToSet();
            var addPackageCodeActions = await GetAddPackagesCodeActionsAsync(context, assemblyNames).ConfigureAwait(false);
            var addReferenceCodeActions = await GetAddReferencesCodeActionsAsync(context, uniqueIdentities).ConfigureAwait(false);

            context.RegisterFixes(addPackageCodeActions, context.Diagnostics);
            context.RegisterFixes(addReferenceCodeActions, context.Diagnostics);
        }

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var document = context.Document;
            var span = context.Span;
            var cancellationToken = context.CancellationToken;

            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

            var token = root.FindToken(span.Start);
            if (!token.Span.IntersectsWith(span))
            {
                return;
            }

            var service = document.GetLanguageService<IImplementInterfaceService>();
            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            var actions = token.Parent.GetAncestorsOrThis<TypeSyntax>()
                                      .Where(_interfaceName)
                                      .Select(n => service.GetCodeActions(document, model, n, cancellationToken))
                                      .FirstOrDefault(_codeActionAvailable);

            if (_codeActionAvailable(actions))
            {
                context.RegisterFixes(actions, context.Diagnostics);
            }
        }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var cancellationToken = context.CancellationToken;
            var assemblyName = GetAssemblyName(context.Diagnostics[0].Id);

            if (assemblyName != null)
            {
                var assemblyNames = new HashSet<string> { assemblyName };
                var addPackageCodeActions = await GetAddPackagesCodeActionsAsync(context, assemblyNames).ConfigureAwait(false);
                context.RegisterFixes(addPackageCodeActions, context.Diagnostics);
            }
        }

        public async override Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var document = context.Document;
            var cancellationToken = context.CancellationToken;
            var span = context.Span;
            var diagnostics = context.Diagnostics;
            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var diagnostic = diagnostics.First();
            var node = root.FindToken(context.Span.Start).Parent as LiteralExpressionSyntax;
            if (node == null)
                return;
            var argumentList = node.Parent.Parent as ArgumentListSyntax;

            var objectCreateExpression = argumentList.Parent as ObjectCreationExpressionSyntax;
            var validNames = NotResolvedInTextAnalyzer.GetValidParameterNames(objectCreateExpression);
            var guessName = NotResolvedInTextAnalyzer.GuessParameterName(model, objectCreateExpression, validNames);

            ExpressionSyntax paramNode;
            ExpressionSyntax altParamNode;
            bool canAddParameterName;

            NotResolvedInTextAnalyzer.CheckExceptionType(model, objectCreateExpression, out paramNode, out altParamNode, out canAddParameterName);

            if (diagnostic.Id == CSharpDiagnosticIDs.NotResolvedInTextAnalyzer_SwapID)
            {
                context.RegisterCodeFix(
                    CodeActionFactory.Create(
                        node.Span,
                        diagnostic.Severity,
                        GettextCatalog.GetString("Swap parameter"),
                        (token) =>
                        {
                            var list = new List<ArgumentSyntax>();
                            foreach (var arg in argumentList.Arguments)
                            {
                                if (arg.Expression == paramNode)
                                {
                                    list.Add((Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax)altParamNode.Parent);
                                    continue;
                                }
                                if (arg.Expression == altParamNode)
                                {
                                    list.Add((Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax)paramNode.Parent);
                                    continue;
                                }

                                list.Add(arg);
                            }
                            var newRoot = root.ReplaceNode(argumentList, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(list)).WithAdditionalAnnotations(Formatter.Annotation));
                            return Task.FromResult(document.WithSyntaxRoot(newRoot));
                        }
                    ),
                    diagnostic
                );
            }
            else if (diagnostic.Id == CSharpDiagnosticIDs.NotResolvedInTextAnalyzerID)
            {
                var fixes = new List<CodeAction>();
                if (canAddParameterName)
                {
                    fixes.Add(
                        CodeActionFactory.Create(
                            node.Span,
                            diagnostic.Severity,
                            string.Format(GettextCatalog.GetString("Add '\"{0}\"' parameter."), guessName),
                            (token) =>
                            {
                                var newArgument = SyntaxFactory.ParseExpression('"' + guessName + '"');
                                var newRoot = root.ReplaceNode(argumentList, argumentList.WithArguments(argumentList.Arguments.Insert(0, SyntaxFactory.Argument(newArgument))).WithAdditionalAnnotations(Formatter.Annotation));
                                return Task.FromResult(document.WithSyntaxRoot(newRoot));
                            }
                        )
                    );
                }

                fixes.Add(CodeActionFactory.Create(
                    node.Span,
                    diagnostic.Severity,
                    string.Format(GettextCatalog.GetString("Replace with '\"{0}\"'."), guessName),
                    (token) =>
                    {
                        var newArgument = SyntaxFactory.ParseExpression('"' + guessName + '"');
                        var newRoot = root.ReplaceNode(node, newArgument.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia()));
                        return Task.FromResult(document.WithSyntaxRoot(newRoot));
                    }
                ));

                context.RegisterFixes(
                    fixes,
                    diagnostic
                );
            }
        }

        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var document = context.Document;
            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
                return;
            var span = context.Span;
            var cancellationToken = context.CancellationToken;
            if (cancellationToken.IsCancellationRequested)
                return;
            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
            if (model.IsFromGeneratedCode(cancellationToken))
                return;
            var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
            var diagnostic = context.Diagnostics.First();
            var syntaxNode = root.FindNode(span);
            var node = syntaxNode as MethodDeclarationSyntax;
            if (node != null && node.Identifier.Span.Contains(span))
            {
                context.RegisterFixes(
                    new[] {
                        CodeActionFactory.Create (
                            node.Span,
                            DiagnosticSeverity.Error,
                            GettextCatalog.GetString ("This is a constructor"),
                            t => Task.FromResult (
                                document.WithSyntaxRoot (
                                    root.ReplaceNode (
                                        (SyntaxNode)node,
                                        node.WithIdentifier (node.AncestorsAndSelf ().OfType<BaseTypeDeclarationSyntax> ().First ().Identifier.WithoutTrivia ()).WithAdditionalAnnotations (Formatter.Annotation)
                                    )
                                )
                            )
                        ),
                        CodeActionFactory.Create (
                            node.Span,
                            DiagnosticSeverity.Error,
                            GettextCatalog.GetString ("This is a void method"),
                            t => Task.FromResult (
                                document.WithSyntaxRoot (
                                    root.ReplaceNode (
                                        (SyntaxNode)node,
                                        node.WithReturnType (SyntaxFactory.ParseTypeName ("void")).WithAdditionalAnnotations (Formatter.Annotation)
                                    )
                                )
                            )
                        )
                    },
                    diagnostic
                );
            }
            var constructor = syntaxNode as MethodDeclarationSyntax;
            if (constructor != null)
            {
                context.RegisterFixes(
                    new[] {
                        CodeActionFactory.Create (
                            node.Span,
                            DiagnosticSeverity.Error,
                            GettextCatalog.GetString ("Fix constructor"),
                            t => Task.FromResult (
                                document.WithSyntaxRoot (
                                    root.ReplaceNode (
                                        (SyntaxNode)node,
                                        node.WithIdentifier (node.AncestorsAndSelf ().OfType<BaseTypeDeclarationSyntax> ().First ().Identifier.WithoutTrivia ()).WithAdditionalAnnotations (Formatter.Annotation)
                                    )
                                )
                            )
                        )
                    },
                    diagnostic
                );
            }


        }