当您想创建一个可等待的方法而不使用async关键字时使用它。 我找到了这个例子:

public class TextResult : IHttpActionResult
{
    string _value;
    HttpRequestMessage _request;

    public TextResult(string value, HttpRequestMessage request)
    {
        _value = value;
        _request = request;
    }
    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        var response = new HttpResponseMessage()
        {
            Content = new StringContent(_value),
            RequestMessage = _request
        };
        return Task.FromResult(response);
    }
}

在这里，您正在创建用于Web Api动作的IHttpActionResult接口的自己的实现。ExecuteAsync方法预期是异步的，但您不必使用async关键字来使其成为异步和可等待的。因为你已经有了结果，不需要等待任何东西，所以最好使用Task.FromResult。

一个例子就是使用缓存的方法。如果已经计算出结果，则可以返回一个已完成的任务和该值(使用task . fromresult)。如果不是，则继续执行并返回一个表示正在进行的工作的任务。

Cache示例:使用任务的Cache示例。FromResult用于预计算值

使用Task创建预计算任务。FromResult:

当您执行返回Task对象的异步操作，并且该Task对象的结果已经计算出来时，此方法非常有用。

Task.Run()创建一个lambda线程，不需要async并返回一个类型对象。在我的示例中，有多个任务同时运行，等待它们的完成。一旦所有任务都完成了，我就可以循环查看它们的结果。的任务。FromResult用于推送不是task生成的任务结果。

这个任务。FromResult在这种情况下推一个类型对象RecordStruct类的Result类。我创建的任务调用函数getData。这个任务。WaitAll处理每个任务，并将结果推入RecordStruct类型的结果对象数组。然后我访问RecordStruct类的属性元素作为结果

    public class RecordStruct
    {
        public RecordStruct(string _element) {
            element = _element;
        }
        public string element { get;set; }
    }

public class TaskCustom
    {
        public Task<RecordStruct> getData(string phrase)
        {
            if (phrase == "hello boise")
            {
                return Task.FromResult(new RecordStruct("Boise is a great place to live"));
            }

            return Task.Run(() =>
            {
                return new RecordStruct(phrase);
            });
        }
    } 

[Fact]
        public async Task TestFactory()
        {
            TaskCustom obj = new TaskCustom();
            List<Task<RecordStruct>> tasks = new List<Task<RecordStruct>>();
            tasks.Add(obj.getData("hello world"));
            tasks.Add(obj.getData("hello boise"));

            Task.WaitAll(tasks.ToArray());

            for(int ctr = 0; ctr < tasks.Count; ctr++) {
                if (tasks[ctr].Status == TaskStatus.Faulted)
                    output.WriteLine(" Task fault occurred");
                else
                {
                    output.WriteLine("test sent {0}",
                                      tasks[ctr].Result.element);
                    Assert.True(true);
                }
            }
        }

当您想创建一个可等待的方法而不使用async关键字时使用它。 我找到了这个例子:

public class TextResult : IHttpActionResult
{
    string _value;
    HttpRequestMessage _request;

    public TextResult(string value, HttpRequestMessage request)
    {
        _value = value;
        _request = request;
    }
    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        var response = new HttpResponseMessage()
        {
            Content = new StringContent(_value),
            RequestMessage = _request
        };
        return Task.FromResult(response);
    }
}

在这里，您正在创建用于Web Api动作的IHttpActionResult接口的自己的实现。ExecuteAsync方法预期是异步的，但您不必使用async关键字来使其成为异步和可等待的。因为你已经有了结果，不需要等待任何东西，所以最好使用Task.FromResult。

我认为你可以使用Task。FromResult用于同步方法，当您可以在代码中执行其他独立工作时，需要很长时间才能完成。我宁愿让这些方法异步调用。但是想象一下这样一种情况，您无法控制所调用的代码，而您想要隐式并行处理。