C# CodeAction.GetOperationsAsync方法代码示例

 private async Task ExecuteCodeAction(CodeAction codeAction)
 {
     var operations = await codeAction.GetOperationsAsync(CancellationToken.None).ConfigureAwait(true);
     foreach (var operation in operations)
     {
         operation.Apply(_roslynHost.GetDocument(_documentId).Project.Solution.Workspace, CancellationToken.None);
     }
 }

        public static void CodeAction(CodeAction codeAction, Document document, string expectedCode)
        {
            var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;

            Assert.That(operations.Count(), Is.EqualTo(1));

            var operation = operations.Single();
            var workspace = document.Project.Solution.Workspace;
            operation.Apply(workspace, CancellationToken.None);

            var newDocument = workspace.CurrentSolution.GetDocument(document.Id);

            var sourceText = newDocument.GetTextAsync(CancellationToken.None).Result;
            var text = sourceText.ToString();

            Assert.That(text, Is.EqualTo(expectedCode));
        }

        public static void CodeAction(CodeAction codeAction, Document document, string expectedCode)
        {
            var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;

            Assert.That(operations.Count(), Is.EqualTo(1));

            var operation = operations.Single();
            var workspace = document.Project.Solution.Workspace;
            operation.Apply(workspace, CancellationToken.None);

            var newDocument = workspace.CurrentSolution.GetDocument(document.Id);

            var sourceText = newDocument.GetTextAsync(CancellationToken.None).Result;
            var text = sourceText.ToString();
            Console.WriteLine($"New code:\r\n{text}");

            // Need to replace win-style line ending to unix-style to avoid build breaks on AppVeyor
            text = text.Replace("\r\n", "\n");
            expectedCode = expectedCode.Replace("\r\n", "\n");

            Assert.That(text, Is.EqualTo(expectedCode));
        }

 /// <summary>
 ///     Apply the inputted CodeAction to the inputted document.
 ///     Meant to be used to apply codefixes.
 /// </summary>
 /// <param name="document">The Document to apply the fix on</param>
 /// <param name="codeAction">A CodeAction that will be applied to the Document.</param>
 /// <returns>A Document with the changes from the CodeAction</returns>
 private static Document ApplyFix(Document document, CodeAction codeAction)
 {
     var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;
     var solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
     return solution.GetDocument(document.Id);
 }

		private static Document ApplyFix(Document document, CodeAction codeAction) => codeAction.GetOperationsAsync(CancellationToken.None).Result.OfType<ApplyChangesOperation>().Single().ChangedSolution.GetDocument(document.Id);

 /// <summary>
 /// Apply the inputted CodeAction to the inputted document.
 /// Meant to be used to apply codefixes.
 /// </summary>
 /// <param name="document">The Document to apply the fix on</param>
 /// <param name="codeAction">A CodeAction that will be applied to the Document.</param>
 /// <returns>A Document with the changes from the CodeAction</returns>
 private static Document ApplyFix(Document document, CodeAction codeAction)
 {
     System.Collections.Immutable.ImmutableArray<CodeActionOperation> operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;
     Solution solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
     return solution.GetDocument(document.Id);
 }

        private async Task<IEnumerable<CodeActionOperation>> GetFixAllOperationsAsync(CodeAction codeAction, FixAllContext fixAllContext, bool showPreviewChangesDialog)
        {
            // We have computed the fix all occurrences code fix.
            // Now fetch the new solution with applied fix and bring up the Preview changes dialog.

            var cancellationToken = fixAllContext.CancellationToken;
            var workspace = fixAllContext.Project.Solution.Workspace;

            cancellationToken.ThrowIfCancellationRequested();
            var operations = await codeAction.GetOperationsAsync(cancellationToken).ConfigureAwait(false);
            if (operations == null)
            {
                return null;
            }

            cancellationToken.ThrowIfCancellationRequested();
            var newSolution = await codeAction.GetChangedSolutionInternalAsync(cancellationToken: cancellationToken).ConfigureAwait(false);

            if (showPreviewChangesDialog)
            {
                newSolution = PreviewChanges(
                    fixAllContext.Project.Solution,
                    newSolution,
                    FeaturesResources.FixAllOccurrences,
                    codeAction.Title,
                    fixAllContext.Project.Language,
                    workspace,
                    cancellationToken);
                if (newSolution == null)
                {
                    return null;
                }
            }

            // Get a code action, with apply changes operation replaced with the newSolution.
            return GetNewFixAllOperations(operations, newSolution, cancellationToken);
        }

 /// <summary>
 /// Apply the inputted <see cref="CodeAction"/> to the inputted document.
 /// Meant to be used to apply code fixes.
 /// </summary>
 /// <param name="document">The <see cref="Document"/> to apply the fix on</param>
 /// <param name="codeAction">A <see cref="CodeAction"/> that will be applied to the
 /// <paramref name="document"/>.</param>
 /// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
 /// <returns>A <see cref="Document"/> with the changes from the <see cref="CodeAction"/>.</returns>
 private static async Task<Document> ApplyFixAsync(Document document, CodeAction codeAction, CancellationToken cancellationToken)
 {
     var operations = await codeAction.GetOperationsAsync(cancellationToken).ConfigureAwait(false);
     var solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
     return solution.GetDocument(document.Id);
 }

		internal static async void RunAction (DocumentContext context, CodeAction action, CancellationToken cancellationToken)
		{
			var operations = await action.GetOperationsAsync (cancellationToken).ConfigureAwait (false);
			if (operations == null)
				return;
			foreach (var op in operations) {
				if (op == null)
					continue;
				try {
					op.Apply (context.RoslynWorkspace, cancellationToken);
				} catch (Exception e) {
					LoggingService.LogError ("Error while appyling operation : " + op, e);
				}
			}

			if ((bool)hasCodeActionsProperty.GetValue (action)) {
				var result = (ImmutableArray<CodeAction>)getCodeActionsMethod.Invoke (action, null);
				foreach (var nested in result) {
					RunAction (context, nested, cancellationToken);
				}
			}
		}

 private static Solution ApplyFix(CodeAction codeAction)
 {
     var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;
     var solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
     return solution;
 }

        private async Task<IEnumerable<CodeActionOperation>> GetFixAllOperationsAsync(CodeAction codeAction, FixAllContext fixAllContext, string fixAllPreviewChangesTitle, bool showPreviewChangesDialog)
        {
            // We have computed the fix all occurrences code fix.
            // Now fetch the new solution with applied fix and bring up the Preview changes dialog.

            var cancellationToken = fixAllContext.CancellationToken;
            var workspace = fixAllContext.Project.Solution.Workspace;

            cancellationToken.ThrowIfCancellationRequested();
            var operations = await codeAction.GetOperationsAsync(cancellationToken).ConfigureAwait(false);
            if (operations == null)
            {
                return null;
            }

            cancellationToken.ThrowIfCancellationRequested();
            var newSolution = await codeAction.GetChangedSolutionInternalAsync(cancellationToken).ConfigureAwait(false);

            if (showPreviewChangesDialog)
            {
                cancellationToken.ThrowIfCancellationRequested();
                using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesPreviewChanges, cancellationToken))
                {
                    var previewService = workspace.Services.GetService<IPreviewDialogService>();
                    var glyph = fixAllContext.Project.Language == LanguageNames.CSharp ?
                        Glyph.CSharpProject :
                        Glyph.BasicProject;

                    var changedSolution = previewService.PreviewChanges(
                    string.Format(EditorFeaturesResources.PreviewChangesOf, fixAllPreviewChangesTitle),
                    "vs.codefix.fixall",
                    codeAction.Title,
                    fixAllPreviewChangesTitle,
                    glyph,
                    newSolution,
                    fixAllContext.Project.Solution);

                    if (changedSolution == null)
                    {
                        // User clicked cancel.
                        FixAllLogger.LogPreviewChangesResult(applied: false);
                        return null;
                    }

                    FixAllLogger.LogPreviewChangesResult(applied: true, allChangesApplied: changedSolution == newSolution);
                    newSolution = changedSolution;
                }
            }

            // Get a code action, with apply changes operation replaced with the newSolution.
            return GetNewFixAllOperations(operations, newSolution, cancellationToken);
        }

 private static async Task<Project> ApplyFixAsync(Project project, CodeAction codeAction)
 {
     var operations = await codeAction.GetOperationsAsync(CancellationToken.None).ConfigureAwait(true);
     var solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
     return solution.GetProject(project.Id);
 }