如果我在检查取消时仍有一个仍在范围内的CancellationTokenSource - 例如,如果我刚刚进行了数据库查询并且尚未将CancellationToken传递给Tasks以处理结果 - 我是否应该访问IsCancellationRequested来自源或其令牌?
换句话说,如果两个选项都可用,这是首选,为什么?
1:
myCancellationTokenSource.IsCancellationRequested
Run Code Online (Sandbox Code Playgroud)
2:
myCancellationTokenSource.Token.IsCancellationRequested
Run Code Online (Sandbox Code Playgroud) 在.NET,Windows 8和Windows Phone 7中,我的代码与此类似:
public static void InvokeIfRequired(this Dispatcher dispatcher, Action action)
{
if (dispatcher.CheckAccess())
{
action();
}
else
{
dispatcher.Invoke(action);
}
}
Run Code Online (Sandbox Code Playgroud)
我如何在便携式类库中做一些事情?有一个平台无关的实现这将是很好的.我的想法是使用WP7中没有的TPL,但肯定会很快.
// PortableDispatcher must be created on the UI thread and then made accessible
// maybe as a property in my ViewModel base class.
public class PortableDispatcher
{
private TaskScheduler taskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
public void Invoke(Action action)
{
if (Alread on UI thread. How would I do this.)
{
action();
}
Task.Factory.StartNew(
action,
CancellationToken.None,
TaskCreationOptions.None,
taskScheduler);
} …Run Code Online (Sandbox Code Playgroud) .net c# dispatcher task-parallel-library portable-class-library
我使用ASP.Net MVC 5,我有一个长期运行的动作,它必须轮询webservices,处理数据并将它们存储在数据库中.
为此,我想使用TPL库来启动任务异步.
但我想知道如何做三件事:
我对所涉及的所有技术了解不少.但我不确定实现这一目标的最佳方法.
有人可以帮我解决最佳解决方案吗?
我有一个方法
public Task<Task> DoSomeWorkOnARemoteMachine()
Run Code Online (Sandbox Code Playgroud)
这非常具有描述性,通过以下方式在远程计算机上执行某些工作:
我使用的原因Task<Task>是因为第一个Task<>是排队消息; 当在Task远程机器上完成工作时(即,当收到来自代理的消息时),内部完成.远程代理在执行工作期间捕获的任何异常都将与完成消息一起传递,并在内部Task完成时重新抛出.
要调用此方法,我使用:
await await DoSomeWorkOnARemoteMachine();
Run Code Online (Sandbox Code Playgroud)
等待消息排队等待执行作业,以及完成作业并接收任何异常.但是,如果我对是否在远程代理上完成作业不感兴趣,我可以将其称为如下:
await DoSomeWorkOnARemoteMachine();
Run Code Online (Sandbox Code Playgroud)
这不是await内心的Task.但是,内部Task(从远程代理接收消息,并重新抛出异常)仍然会在某个时刻执行.我觉得这有点浪费,我不想在没有await结果时执行它.
因此我的问题是:是否有可能Task"知道"它是否被await编辑而不是执行,如果不是,或执行一些其他代码路径(例如空Task体).
我确实意识到我可以实现的替代方案,例如传递"fire and forget"标志,或者为"fire and forget"添加重载.如果我可以在没有客户端API更改的情况下实现它,那将是很棒的
涉及实现这种远程工作执行的其他项目的答案也会很棒!
我正在寻找创建一个接受任何产生一个任务的函数IEnumerable<T>.为了说明,请考虑以下函数签名.
void DoWork<TElement>(Task<IEnumerable<TElement>> task)
{ }
Run Code Online (Sandbox Code Playgroud)
现在,我想将此方法称为如下:
Task<int[]> task = Task.FromResult(new[] { 1, 2, 3 });
DoWork(task);
Run Code Online (Sandbox Code Playgroud)
显然,这不起作用,因为两种Task类型不相同,并且任务不存在协方差.但是,我想知道是否有一些聪明的技巧可以让它工作,受以下例子的启发.
async Task<IEnumerable<int>> GetTask()
{
return await Task.FromResult(new int[] { 1, 2, 3 });
}
Run Code Online (Sandbox Code Playgroud)
这里,await有效地创建了一个带有内联任务结果的新任务,因此产生了类型转换的错觉.
为了给出更详细的示例,我想允许用户DoWork在转换时没有太多负担来打电话:
// Service proxy method
Task<int[]> GetInts()
{
// simplified for brevity
return Task.FromResult(new[] { 1, 2, 3 });
}
// Service proxy method
Task<long[]> GetLongs()
{
// simplified for brevity
return Task.FromResult(new[] { 100L, 200L, 300L });
} …Run Code Online (Sandbox Code Playgroud) 我正在开发一个Web API项目,该项目使用Azure的托管缓存服务将数据库结果缓存到内存中,以缩短响应时间并减轻数据库的重复流量.尝试在缓存中放入新项时,有时会抛出特定于缓存的异常,代码为DataCacheErrorCode.RetryLater.当然,为了以后重试而不需要阻止这种方法,我做了它async并await Task.Delay在稍后再试一次.以前,开发人员已经Thread.Sleep在那里硬编码,这确实会损害应用程序性能.
方法签名看起来与此类似:
public static async Task Put(string cacheKey, object obj)
Run Code Online (Sandbox Code Playgroud)
在此更改之后,我从应用程序中的所有其他位置获得~75个编译器警告,这些警告调用以前的同步版本Put指示:
因为不等待该调用,所以在调用完成之前继续执行当前方法.考虑将'await'运算符应用于调用的结果.
在这种情况下,由于Put没有返回任何内容,因此我有理由让这个操作发生故障,因为我没有看到任何理由阻止执行调用它的方法.我只是想知道是否存在任何危险或陷阱,Task因为Put可以经常调用在后台运行许多这些即发即弃的操作.或者我应该等待,因为99%的时间我不会得到重试错误,并且Task几乎立即完成.我只是想确保我没有因为有太多线程(或类似的东西)而受到任何处罚.
我遇到了单元测试失败的问题,因为TPL任务从未执行过它ContinueWith(x, TaskScheduler.FromCurrentSynchronizationContext()).
问题原因是因为在启动任务之前意外创建了Winforms UI控件.
这是一个再现它的例子.您将看到,如果您按原样运行测试,它将通过.如果在未取消注释表单行的情况下运行测试,则会失败.
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
// Create new sync context for unit test
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var waitHandle = new ManualResetEvent(false);
var doer = new DoSomethinger();
//Uncommenting this line causes the ContinueWith part of the Task
//below never to execute.
//var f = new Form();
doer.DoSomethingAsync(() => waitHandle.Set());
Assert.IsTrue(waitHandle.WaitOne(10000), "Wait timeout exceeded.");
}
}
public class DoSomethinger
{
public void DoSomethingAsync(Action onCompleted)
{
var task = Task.Factory.StartNew(() => Thread.Sleep(1000)); …Run Code Online (Sandbox Code Playgroud) 使用时SendMailAsync我收到以下错误:
在异步操作仍处于挂起状态时完成异步模块或处理程序
我的代码:
public static async Task SendEmail(MessageContent messageContent, string emailBody)
{
SmtpClient smtpClientNoSend = new SmtpClient();
await smtpClientNoSend.SendMailAsync(mailMessage);
}
Run Code Online (Sandbox Code Playgroud)
从控制器呼叫:
public async System.Threading.Tasks.Task<ActionResult> Register()
{
await SendEmail();
}
private void SendEmail()
{
SMTPEmail.SendEmail(msg, output.ToString());
return null;
}
Run Code Online (Sandbox Code Playgroud) 除了最常见的调用TaskFactory.StartNew的形式,只有"action"参数(1)https://msdn.microsoft.com/en-us/library/dd321439 ( v= vs.110).aspx
我们还有一种方法可以接受额外的参数作为"取消令牌"(2)https://msdn.microsoft.com/en-us/library/dd988458.aspx
我的问题是,我们为什么要使用call(2)而不是call(1)?
我的意思是,如果我没有将取消令牌作为参数传递(因为可以从委托函数访问变量令牌),页面(2)的MSDN中的示例也可以工作.例如:
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var files = new List<Tuple<string, string, long, DateTime>>();
var t = Task.Factory.StartNew( () => { string dir = "C:\\Windows\\System32\\";
object obj = new Object();
if (Directory.Exists(dir)) {
Parallel.ForEach(Directory.GetFiles(dir),
f => {
if (token.IsCancellationRequested)
token.ThrowIfCancellationRequested();
var fi = new FileInfo(f);
lock(obj) {
files.Add(Tuple.Create(fi.Name, fi.DirectoryName, fi.Length, fi.LastWriteTimeUtc));
}
});
}
}
); //note that I removed the ", token" from here
tokenSource.Cancel();
Run Code Online (Sandbox Code Playgroud)
当我将取消令牌传递给Task.Factory.StartNew时,下面是否发生了什么?
谢谢
我经常看到建议用于异步库代码,我们应该ConfigureAwait(false)在所有异步调用上使用,以避免我们的调用返回将在UI线程或Web请求同步上下文上调度导致死锁等问题.
使用的一个问题ConfigureAwait(false)是,您不能在库调用的入口点上执行此操作.为了使其有效,必须在整个库代码中一直向下完成.
在我看来,一个可行的替代方案是在库的顶层面向公众的入口点简单地将当前同步上下文设置为null,然后忘掉ConfigureAwait(false).但是,我没有看到很多人采取或推荐这种方法.
简单地在库入口点上将当前同步上下文设置为null有什么问题吗?这种方法是否存在任何潜在的问题(除了将等待发布到默认同步上下文可能无关紧要的性能影响)?
(编辑#1)添加一些我的意思的示例代码:
public class Program
{
public static void Main(string[] args)
{
SynchronizationContext.SetSynchronizationContext(new LoggingSynchronizationContext(1));
Console.WriteLine("Executing library code that internally clears synchronization context");
//First try with clearing the context INSIDE the lib
RunTest(true).Wait();
//Here we again have the context intact
Console.WriteLine($"After First Call Context in Main Method is {SynchronizationContext.Current?.ToString()}");
Console.WriteLine("\nExecuting library code that does NOT internally clear the synchronization context");
RunTest(false).Wait();
//Here we again have the context intact
Console.WriteLine($"After Second Call Context …Run Code Online (Sandbox Code Playgroud) c# ×9
async-await ×5
.net ×3
asp.net-mvc ×2
.net-4.0 ×1
asynchronous ×1
c#-5.0 ×1
dispatcher ×1
signalr ×1
smtpclient ×1
unit-testing ×1
winforms ×1