很明显，我在Execute方法中在此处创建了一个死锁，该方法基本上可以包装 异步实现。

 public IEnumerable<IDataPoint> Execute(Guid batchId,Guid parameterId,DateTime startDateTime,DateTime endDateTime,int maxNumberOfDataPoints)
        {
            return this.ExecuteAsync(batchId,parameterId,startDateTime,endDateTime,maxNumberOfDataPoints)
                .ConfigureAwait(false)
                .Getawaiter()
                .GetResult();
        }


public async Task<IEnumerable<IDataPoint>> ExecuteAsync(Guid batchId,int maxNumberOfDataPoints)
{
    var foundDataPoints = new List<DataPoint>();

    startDateTime = startDateTime.WithoutMilliseconds();
    var firstdataPoint = await this.GetfirstdataPointBeforeDateTimeAsync(batchId,startDateTime).ConfigureAwait(false);
    var lastDataPoint = await this.GetfirstdataPointAfterDateTimeAsync(batchId,endDateTime).ConfigureAwait(false);
    var numberOfDatapointsToSubstract = firstdataPoint == null ? 0 : 1;
    numberOfDatapointsToSubstract += lastDataPoint == null ? 0 : 1;
    var dataPoints = await this.GetDataPointsBetweenDateTimesAsync(batchId,maxNumberOfDataPoints - numberOfDatapointsToSubstract).ConfigureAwait(false);

    if (firstdataPoint != null)
    {
        foundDataPoints.Add(firstdataPoint);
    }

    foundDataPoints.AddRange(dataPoints);

    if (lastDataPoint != null)
    {
        foundDataPoints.Add(lastDataPoint);
    }

    return foundDataPoints.OrderBy(x => x.Timestamp);
}

ExecuteAsync工作正常时，Execute不会终止。 我没问题。这似乎是一个僵局，但我看不出原因。

包裹ExecuteAsync就像这样工作，

return Task.Run(
                    async () =>
                        await this.ExecuteAsync(batchId,maxNumberOfDataPoints)
                            .ConfigureAwait(false))
                .ConfigureAwait(false)
                .Getawaiter()
                .GetResult();

主要区别当然是ExecuteAsync被包装在一个Task中。

更新： 我认为ExecuteAsync将始终在与调用方不同的线程上执行，并且通过显式禁用上下文同步，我会很好，但显然我错了。