जब मैं ConfigureAwait(false) का उपयोग करता हूं तो मेरे कस्टम वर्तमान शेड्यूलर को डिफ़ॉल्ट से क्यों बदल दिया जाता है?

मैंने एक कस्टम TaskScheduler लिखा है जो एक ही थ्रेड पर दिए गए कार्यों को निष्पादित करने वाला है। इस कार्य शेड्यूलर का उपयोग कस्टम कार्य फ़ैक्टरी के साथ किया जाता है। यह कार्य कारखाना एक एसिंक विधि ReadFileAsync निष्पादित करता है जो StreamReader की एक अन्य एसिंक विधि ReadToEndAsync कहता है।

मैंने देखा है कि ReadToEndAsync().ConfigureAwait(false) का उपयोग करने के बाद, वर्तमान कार्य अनुसूचक को वापस डिफ़ॉल्ट एक, ThreadPoolTaskScheduler पर वापस कर दिया जाता है। अगर मैं ConfigureAwait(false) को हटा देता हूं, तो कस्टम टास्क शेड्यूलर SameThreadTaskScheduler रखा जाता है। क्यों? क्या इसके निष्पादन के बाद उसी कस्टम शेड्यूलर के साथ ConfigureAwait(false) का उपयोग करने का कोई तरीका है?

मैंने कई चीजों की कोशिश की है, लेकिन नतीजा वही है:

• कस्टम TaskFactory के एनम झंडे बदलें
• एक कस्टम सिंक्रोनाइज़ेशन संदर्भ का उपयोग करना जो Posts कॉलबैक को थ्रेड पूल के बजाय सिंक्रोनाइज़ करता है
• कार्य फ़ैक्टरी पर निष्पादित कार्य फ़ंक्शन के अंदर सिंक्रनाइज़ेशन को बदलें और वापस लाएं
• कार्य फ़ैक्टरी पर निष्पादित कार्य फ़ंक्शन के बाहर सिंक्रनाइज़ेशन को बदलें और वापस लाएं

public static class Program
{
    private static readonly string DesktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

    public static void Main()
    {
        _ = AsyncHelper.RunSynchronously(ReadFileAsync);
    }

    private static async Task<string> ReadFileAsync()
    {
        // Prints "SameThreadTaskScheduler"
        Console.WriteLine(TaskScheduler.Current.GetType().Name);

        using var fs = File.OpenText(Path.Combine(DesktopPath, "hello.txt"));
        var content = await fs.ReadToEndAsync().ConfigureAwait(false); // <-------- HERE

        // With ReadToEndAsync().ConfigureAwait(false), prints "ThreadPoolTaskScheduler"
        // With ReadToEndAsync() only, prints "SameThreadTaskScheduler"
        Console.WriteLine(TaskScheduler.Current.GetType().Name);

        return content;
    }
}

public static class AsyncHelper
{
    private static readonly TaskFactory SameThreadTaskFactory = new TaskFactory(
        CancellationToken.None,
        TaskCreationOptions.None,
        TaskContinuationOptions.None,
        new SameThreadTaskScheduler());

    public static TResult RunSynchronously<TResult>(Func<Task<TResult>> func)
    {
        var oldContext = SynchronizationContext.Current;

        try
        {
            SynchronizationContext.SetSynchronizationContext(null);
            return SameThreadTaskFactory.StartNew(func).Unwrap().GetAwaiter().GetResult();
        }
        finally
        {
            SynchronizationContext.SetSynchronizationContext(oldContext);
        }
    }
}

public sealed class SameThreadTaskScheduler : TaskScheduler
{
    public override int MaximumConcurrencyLevel => 1;

    protected override void QueueTask(Task task)
    {
        this.TryExecuteTask(task);
    }

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        this.TryExecuteTask(task);
        return true;
    }

    protected override IEnumerable<Task> GetScheduledTasks()
    {
        return Enumerable.Empty<Task>();
    }
}