如果等待时间结束,我需要取消一项任务.例如
var t = Task.Factory.StartNew(() =>
{
Thread.Sleep(5000) // some long running task
"do something"
});
Task.WaitAll(new[] {t}, 1000);
Run Code Online (Sandbox Code Playgroud)
但似乎任务仍在继续.我尝试使用CancellationTokenSource,但似乎也没有用.
我使用以下代码段确认了这一点
static void Main(string[] args)
{
var cancellationTokenSource = new CancellationTokenSource();
var t = Task.Factory.StartNew(() => {
Thread.Sleep(5000);
Console.WriteLine("Still working");
}, cancellationTokenSource.Token);
Task.WaitAll(new[] {t}, 1000);
cancellationTokenSource.Cancel();
Console.ReadLine();
}
Run Code Online (Sandbox Code Playgroud)
控制台显示"仍在工作".我以为任务会被取消.
我相信我错过了一些东西.我错过了什么?谢谢.
任何人都可以解释为什么,如果一个C++应用程序运行一个.NET UI组件(所有在主线程上),它反过来产生一个模态.NET对话框,然后尝试TaskScheduler.FromCurrentSynchronizationContext();在一个Task.Factory.StartNew调用中使用该任务在一个工作线程上运行?如果我没有显示对话框或者在显示对话框之前存储了上下文,则不会发生这种情况.
我试图创建一个虚拟程序来显示它但失败了,我认为它可能与一个主进程是COM有关.
有任何想法吗?
好的,我的代码看起来像这样
private void RunStateMachine(IQ4UpgraderState State)
{
_State = State;
Task.Factory.StartNew(() => StateMachine(), _TokenSource.Token, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
}
private void StateMachine()
{
switch (_State)
{
//Some Code
}
}
Run Code Online (Sandbox Code Playgroud)
当任务启动时,当前上下文是主线程,但是当StateMachine调用运行时,它在工作线程上,当且仅当 我在运行此代码之前打开了模式对话框时.TaskScheduler.FromCurrentSynchronizationContext()返回的上下文在启动任务时似乎是正确的.我甚至比较了两种情况下返回的内容,似乎没有区别.
我需要ThreadPool每晚运行大约1,000个任务(这个数字可能会在未来增长).每个任务都执行长时间运行的操作(从Web服务读取数据),并且不是CPU密集型的.Async I/O不是这个特定用例的选项.
给定一个IList<string>参数,我需要DoSomething(string x).我试图在以下两个选项之间进行选择:
IList<Task> tasks = new List<Task>();
foreach (var p in parameters)
{
tasks.Add(Task.Factory.StartNew(() => DoSomething(p), TaskCreationOptions.LongRunning));
}
Task.WaitAll(tasks.ToArray());
Run Code Online (Sandbox Code Playgroud)
要么
Parallel.ForEach(parameters, new ParallelOptions {MaxDegreeOfParallelism = Environment.ProcessorCount*32}, DoSomething);
Run Code Online (Sandbox Code Playgroud)
哪个选项更好,为什么?
注意 :
答案应包括使用TaskCreationOptions.LongRunning和的比较MaxDegreeOfParallelism = Environment.ProcessorCount * SomeConstant.
在.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更改的情况下实现它,那将是很棒的
涉及实现这种远程工作执行的其他项目的答案也会很棒!
我正在尝试制作像IDM这样的程序,它可以同时下载部分文件.
我用来实现这个的工具是C#.Net4.5中的TPL
但是我在使用Tasks并行操作时遇到了问题.
序列功能运行良好,正在正确下载文件.
使用Tasks的并行功能正在工作,直到发生奇怪的事情:
我创建了4个任务,Factory.StartNew()在每个任务中给出了起始位置和结束位置,任务将下载这些文件,然后它将以字节[ ],一切进展顺利,任务工作正常,但在某些时候,执行冻结,就是这样,程序停止,没有其他事情发生.
并行功能的实现:
static void DownloadPartsParallel()
{
string uriPath = "http://mschnlnine.vo.llnwd.net/d1/pdc08/PPTX/BB01.pptx";
Uri uri = new Uri(uriPath);
long l = GetFileSize(uri);
Console.WriteLine("Size={0}", l);
int granularity = 4;
byte[][] arr = new byte[granularity][];
Task<byte[]>[] tasks = new Task<byte[]>[granularity];
tasks[0] = Task<byte[]>.Factory.StartNew(() => DownloadPartOfFile(uri, 0, l / granularity));
tasks[1] = Task<byte[]>.Factory.StartNew(() => DownloadPartOfFile(uri, l / granularity + 1, l / granularity + l / granularity));
tasks[2] = Task<byte[]>.Factory.StartNew(() => DownloadPartOfFile(uri, l / granularity + …Run Code Online (Sandbox Code Playgroud) 在await内部异步ASP.NET Web API控制器方法之后,我注意到一个意外的(我会说,一个冗余的)线程切换.
例如,下面我希望ManagedThreadId在#2和3#的位置看到相同的内容,但最常见的是我在#3看到一个不同的主题:
public class TestController : ApiController
{
public async Task<string> GetData()
{
Debug.WriteLine(new
{
where = "1) before await",
thread = Thread.CurrentThread.ManagedThreadId,
context = SynchronizationContext.Current
});
await Task.Delay(100).ContinueWith(t =>
{
Debug.WriteLine(new
{
where = "2) inside ContinueWith",
thread = Thread.CurrentThread.ManagedThreadId,
context = SynchronizationContext.Current
});
}, TaskContinuationOptions.ExecuteSynchronously); //.ConfigureAwait(false);
Debug.WriteLine(new
{
where = "3) after await",
thread = Thread.CurrentThread.ManagedThreadId,
context = SynchronizationContext.Current
});
return "OK";
}
}
Run Code Online (Sandbox Code Playgroud)
我已经看过了实现AspNetSynchronizationContext.Post,基本上归结为:
Task newTask = _lastScheduledTask.ContinueWith(_ => …Run Code Online (Sandbox Code Playgroud) 以下面的界面为例:
interface IOracle
{
Task<string> GetAnswerAsync(string question);
}
Run Code Online (Sandbox Code Playgroud)
此接口的某些实现可能使用async/ await.其他人可能不需要.例如,考虑这个简单的玩具实现.
class SimpleOracle
{
public Dictionary<string, string> Lookup { get; set; }
// Warning CS1998: This async method lacks 'await' operators
// and will run synchonously.
public async Task<string> GetAnswerAsync(string question)
{
string answer = Lookup[question];
return answer;
}
}
Run Code Online (Sandbox Code Playgroud)
编译器警告CS1998当然是有道理的.通常的建议是删除async关键字并使用Task.FromResult,但它错过了一个微妙的问题.如果代码抛出异常怎么办?然后该代码转换改变了方法的行为:async版本将包装任何异常Task; 非async版本不会,没有明确的try- catch.
让async关键字完全按照我的意愿工作,但它会产生编译器警告,我不认为压制这些是明智的.
我应该如何重构我的方法实现以不产生编译器警告,同时用Task任何其他async方法包装所有异常?
我经常看到建议用于异步库代码,我们应该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
.net ×4
async-await ×4
c#-4.0 ×2
asp.net ×1
asp.net-mvc ×1
asynchronous ×1
c#-5.0 ×1
c++ ×1
com ×1
dispatcher ×1
parallel-for ×1
signalr ×1
task ×1