क्रमशः

Question

निष्पादित करने के लिए एसिंक कोड को क्यूइंग करना किसी भी समय, मुझे एक विधि कॉल प्राप्त हो सकती है जिसे संतुष्ट करने के लिए लंबे समय तक चलने वाले ऑपरेशन की आवश्यकता होगी।

इनमें से कई विधियां हैं। चूंकि वे संसाधन साझा करते हैं, इसलिए यह महत्वपूर्ण है कि वे एक साथ नहीं चलें - प्रत्येक अनुक्रम में चलना चाहिए।

आम तौर पर, मैं बस अनुक्रम में कॉल करने चाहते हैं:

var result1 = await Foo1Async(); 
var result2 = await Foo2Async(); 

हालांकि, इस मामले में, विधि मेरे लिए कॉल अतुल्यकालिक हैं:

void Bar1() 
{ 
    var result = await Foo1Async(); 
    // ... 
} 

void Bar2() 
{ 
    var result = await Foo2Async(); 
    // ... 
} 

मुझे लगता है मैं उपयोग करने की आवश्यकता Task.ContinueWith, और इस के साथ आए हैं:

readonly object syncLock = new Object(); 

private Task currentOperationTask = TaskUtilities.CompletedTask; 
public Task<TResult> EnqueueOperation<TResult>(Func<Task<TResult>> continuationFunction) 
{ 
    lock (this.syncLock) 
    { 
     var operation = this.currentOperationTask.ContinueWith(predecessor => continuationFunction()).Unwrap(); 
     this.currentOperationTask = operation; 
     return operation; 
    } 
} 

और मैं इसे इस तरह का उपयोग करें:

void Bar1() 
{ 
    var result = await EnqueueOperation(() => Foo1Async()); 
    // ... 
} 

void Bar2() 
{ 
    var result = await EnqueueOperation(() => Foo2Async()); 
    // ... 
} 

क्या यह इस समस्या से संपर्क करने का सही तरीका है? क्या कोई नुकसान है जिसके बारे में मुझे अवगत होना चाहिए?

Answer 1

आपका कोड ठीक काम करेगा, मुझे लगता है कि यह समस्या हल करने का एक उचित तरीका है।

यह करने के लिए एक सरल दृष्टिकोण का उपयोग करने AsyncLock from Nito AsyncEx होगा:

private readonly AsyncLock asyncLock = new AsyncLock(); 

public async Task<TResult> EnqueueOperation<TResult>(
    Func<Task<TResult>> continuationFunction) 
{ 
    using (await asyncLock.LockAsync()) 
    { 
     return await continuationFunction(); 
    } 
}