Tôi biết rằng với .net 4.5 có các từ khóa chờ đợi, không đồng bộ cho phép dễ dàng gọi các phương thức không đồng bộ. Tôi hiện đang nghiên cứu cách thực hiện cuộc gọi không đồng bộ trong C# 4.0. Một ví dụ tôi muốn là thực hiện một cuộc gọi async nơi datagrid đang được databind.Làm cách nào để gọi các phương thức không đồng bộ trong asp.net C# 4.0?
Nếu bạn có thể cung cấp cho tôi một số liên kết, tôi thực sự sẽ đánh giá cao nó.
Hãy xem xét việc sử dụng Công việc, tính năng này có sẵn trong .Net 4 và sẽ giúp bạn. Một ví dụ đơn giản có thể trông như thế này:
public void MainFlow()
{
Task taskWork = Task.Factory.StartNew(new Action(DoWork));
//Do other work
//Then wait for thread finish
taskWork.Wait();
}
private void DoWork()
{
//Do work
}
Để biết thêm, có một cái nhìn ở đây
http://msdn.microsoft.com/en-us/library/system.threading.tasks.task(v=vs.100).aspx
Sử dụng Task.ContinueWith mà về cơ bản thực hiện hành động của bạn một khi nhiệm vụ hoàn thành.
Một số ví dụ có thể hữu ích:
Chúng tôi thực hiện một số lớp công cụ để thực hiện các hoạt động async.
Những phương pháp này thực sự thực hiện: thực hiện hành động không đồng bộ và sau đó đăng tải việc thực thi hoàn thành phù hợp với bối cảnh đồng bộ hóa.
Chúng tôi đã thực hiện điều này như là trình bao bọc của TPL để dễ dàng sử dụng nó nằm trong WPF khi chúng ta gọi các hoạt động chạy dài. Lớp này cũng có tương tự cho các hành động có thể bị hủy bỏ, không chỉ bị bỏ rơi.
public static class AsyncExecutor
{
public static CancellationTokenSource ExecuteBlockingOperation(Action action, Action completition, Action<AggregateException> onException)
{
if (action == null)
throw new ArgumentNullException("action");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task(action, TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition();
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn>(Action<TIn> action, TIn parameter, Action<TIn> completition, Action<AggregateException, TIn> onException)
{
if (action == null)
throw new ArgumentNullException("action");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task(() => action(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TOut>(Func<TOut> func, Action<TOut> completition, Action<AggregateException> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(func, TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(asyncPart.Result);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut, TIn> completition, Action<AggregateException, TIn> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(asyncPart.Result, parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut> completition, Action<AggregateException, TIn> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(asyncPart.Result);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TIn> completition, Action<AggregateException, TIn> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action completition, Action<AggregateException, TIn> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition();
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TIn> completition, Action<AggregateException> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut, TIn> completition, Action<AggregateException> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(asyncPart.Result, parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut> completition, Action<AggregateException> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition(asyncPart.Result);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action completition, Action<AggregateException> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var cts = new CancellationTokenSource();
var token = cts.Token;
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (!token.IsCancellationRequested)
completition();
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
return cts;
}
public static void ExecuteBlockingOperation(Action action, Action completition, Func<bool> shouldComplete, Action<AggregateException> onException)
{
if (action == null)
throw new ArgumentNullException("action");
if (completition == null)
throw new ArgumentNullException("completition");
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task(action, TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (shouldComplete == null || shouldComplete())
completition();
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
}
public static void ExecuteBlockingOperation<TIn>(Action<TIn> action, TIn parameter, Action<TIn> completition, Predicate<TIn> shouldComplete, Action<AggregateException, TIn> onException)
{
if (action == null)
throw new ArgumentNullException("action");
if (completition == null)
throw new ArgumentNullException("completition");
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task(() => action(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPart =>
{
if (shouldComplete == null || shouldComplete(parameter))
completition(parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
}
public static void ExecuteBlockingOperation<TOut>(Func<TOut> func, Action<TOut> completition, Predicate<TOut> shoudComplete, Action<AggregateException> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(func, TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler);
task.ContinueWith(asyncPartTask =>
{
if (shoudComplete == null || shoudComplete(asyncPartTask.Result))
completition(asyncPartTask.Result);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
}
public static void ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut, TIn> completition, Func<TOut, TIn, bool> shouldComplete, Action<AggregateException, TIn> onException)
{
if (func == null)
throw new ArgumentNullException("func");
if (completition == null)
throw new ArgumentNullException("completition");
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning);
task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); // on Exception
task.ContinueWith(asyncPart =>
{
if (shouldComplete == null || shouldComplete(asyncPart.Result, parameter))
completition(asyncPart.Result, parameter);
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler);
task.Start();
}
}
Tác vụ.Run không tồn tại trong .Net 4.0. – JPProgrammer
Sử dụng Task.Factory.StartMới cho .Net 4 –