我发现有两种常见的使用情形：
1.当您实作允许异步呼叫端的界面，但您的实作是同步的。
1.当您为测试而存根/模拟异步代码时。

一个例子是一个使用缓存的方法。如果结果已经计算过了，你可以返回一个完成的任务，其值为（使用Task.FromResult）。如果没有，你就继续返回一个表示正在进行的工作的任务。
缓存示例：Cache Example using Task.FromResult for Pre-computed values

当你想创建一个可等待的方法而不使用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);
    }
}

在这里，您将创建自己的IHttpActionResult接口实现，以便在Web Api操作中使用。ExecuteAsync方法应该是异步的，但您不必使用async关键字来使其异步和可等待。由于您已经有了结果，不需要等待任何东西，因此最好使用Task.FromResult。

来自MSDN：
当您执行传回Task对象的异步作业，而且该Task对象的结果已经计算出来时，这个方法会很有用。
http://msdn.microsoft.com/en-us/library/hh228607.aspx

当你想要一个异步操作，但有时结果是同步的时候，使用Task.FromResult。你可以在这里找到一个很好的例子http://msdn.microsoft.com/en-us/library/hh228607.aspx。

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

Task.Run（）创建一个lambda线程，不需要异步，并返回一个类型对象。在我的例子中，我有多个任务同时运行，等待它们的完成。一旦所有任务都完成了，我可以循环它们的结果。Task.FromResult用于推送不是由Task.Run（）生成的任务结果。
Task.FromResult在Result类中推送一个类型对象（在本例中为RecordStruct类）。我创建了任务，调用函数getData。Task.WaitAll处理每个任务，并将结果推送到RecordStruct类型的result对象数组中。然后，我访问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);
                }
            }
        }