यहाँ शीर्ष मतदान के जवाब के आधार पर पूरी तरह से काम किया गया उदाहरण है, जो है:
int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
// task completed within timeout
} else {
// timeout logic
}
इस उत्तर में कार्यान्वयन का मुख्य लाभ यह है कि जेनरिक जोड़े गए हैं, इसलिए फ़ंक्शन (या कार्य) एक मान लौटा सकता है। इसका मतलब है कि किसी भी मौजूदा फ़ंक्शन को टाइमआउट फ़ंक्शन में लपेटा जा सकता है, जैसे:
इससे पहले:
int x = MyFunc();
उपरांत:
// Throws a TimeoutException if MyFunc takes more than 1 second
int x = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
इस कोड के लिए .NET 4.5 की आवश्यकता है।
using System;
using System.Threading;
using System.Threading.Tasks;
namespace TaskTimeout
{
public static class Program
{
/// <summary>
/// Demo of how to wrap any function in a timeout.
/// </summary>
private static void Main(string[] args)
{
// Version without timeout.
int a = MyFunc();
Console.Write("Result: {0}\n", a);
// Version with timeout.
int b = TimeoutAfter(() => { return MyFunc(); },TimeSpan.FromSeconds(1));
Console.Write("Result: {0}\n", b);
// Version with timeout (short version that uses method groups).
int c = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
Console.Write("Result: {0}\n", c);
// Version that lets you see what happens when a timeout occurs.
try
{
int d = TimeoutAfter(
() =>
{
Thread.Sleep(TimeSpan.FromSeconds(123));
return 42;
},
TimeSpan.FromSeconds(1));
Console.Write("Result: {0}\n", d);
}
catch (TimeoutException e)
{
Console.Write("Exception: {0}\n", e.Message);
}
// Version that works on tasks.
var task = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
return 42;
});
// To use async/await, add "await" and remove "GetAwaiter().GetResult()".
var result = task.TimeoutAfterAsync(TimeSpan.FromSeconds(2)).
GetAwaiter().GetResult();
Console.Write("Result: {0}\n", result);
Console.Write("[any key to exit]");
Console.ReadKey();
}
public static int MyFunc()
{
return 42;
}
public static TResult TimeoutAfter<TResult>(
this Func<TResult> func, TimeSpan timeout)
{
var task = Task.Run(func);
return TimeoutAfterAsync(task, timeout).GetAwaiter().GetResult();
}
private static async Task<TResult> TimeoutAfterAsync<TResult>(
this Task<TResult> task, TimeSpan timeout)
{
var result = await Task.WhenAny(task, Task.Delay(timeout));
if (result == task)
{
// Task completed within timeout.
return task.GetAwaiter().GetResult();
}
else
{
// Task timed out.
throw new TimeoutException();
}
}
}
}
चेतावनियां
इस उत्तर को दिए जाने के बाद, सामान्य ऑपरेशन के दौरान आपके कोड में अपवादों को रखने के लिए इसका अच्छा अभ्यास नहीं है, जब तक कि आपको बिल्कुल ऐसा न करना पड़े:
- हर बार एक अपवाद को फेंक दिया जाता है, यह एक अत्यंत भारी ऑपरेशन है,
- अपवाद एक तंग लूप में हैं, तो अपवाद आपके कोड को 100 या अधिक के कारक से धीमा कर सकते हैं।
केवल इस कोड का उपयोग करें यदि आप बिल्कुल उस फ़ंक्शन को बदल नहीं सकते हैं जिसे आप किसी विशिष्ट के बाद इसे बाहर करते हैं TimeSpan ।
यह जवाब वास्तव में केवल तब लागू होता है जब तृतीय पक्ष पुस्तकालय पुस्तकालयों के साथ काम करता है जिसे आप केवल टाइमआउट पैरामीटर शामिल करने के लिए रिफलेक्टर नहीं कर सकते हैं।
कैसे मजबूत कोड लिखने के लिए
यदि आप मजबूत कोड लिखना चाहते हैं, तो सामान्य नियम यह है:
हर एक ऑपरेशन जो संभावित रूप से अनिश्चित काल के लिए अवरुद्ध हो सकता है, एक समयबाह्य होना चाहिए।
अगर तुम नहीं इस नियम का पालन करते हैं, तो आपका कोड अंततः एक ऑपरेशन को प्रभावित करेगा जो किसी कारण से विफल हो जाता है, तो यह अनिश्चित काल तक अवरुद्ध हो जाएगा, और आपका ऐप बस स्थायी रूप से लटका दिया गया है।
यदि कुछ समय बाद एक उचित समय समाप्त हो जाता था, तो आपका ऐप कुछ चरम समय (उदाहरण के लिए 30 सेकंड) के लिए लटका होगा, तब वह या तो एक त्रुटि प्रदर्शित करेगा और अपने मैरी रास्ते पर जारी रहेगा, या फिर से प्रयास करेगा।