msdn文档Task.ContinueWith只有一个代码示例,其中一个任务(dTask)在后台运行,后跟(使用ContinueWith)第二个任务(dTask2).样品的本质如下所示;
Task dTask = Task.Factory.StartNew( () => {
... first task code here ...
} );
Task dTask2 = dTask.ContinueWith( (continuation) => {
... second task code here ...
} );
Task.WaitAll( new Task[] {dTask, dTask2} );
Run Code Online (Sandbox Code Playgroud)
我的问题很简单; 使用.ContinueWith调用第二个代码块的优点是什么,而不是简单地将它附加到第一个代码块,后者已经在后台运行并将代码更改为这样的代码?
Task dTask = Task.Factory.StartNew( () => {
... first task code here ...
if (!cancelled) //and,or other exception checking wrapping etc
{
... second task code here ...
}
} );
Task.Wait(dTask);
Run Code Online (Sandbox Code Playgroud)
在建议的修订版中,ContinueWith完全避免调用,第二个代码块仍然在后台运行,加上没有上下文切换代码来访问闭包的状态......我不明白?感觉有点愚蠢,我做了一些谷歌搜索,也许只是没有找到正确的短语来搜索.
更新: Hans Passant发布了更多MSDN …
我尝试使用系统资源的最佳使用来创建设计良好的TPL数据流管道.我的项目是一个HTML解析器,它将解析后的值添加到SQL Server DB中.我已经拥有了我未来管道的所有方法,现在我的问题是将它们放在Dataflow块中的最佳方法是什么,以及我应该使用多少块?一些方法是CPU绑定的,其中一些方法 - I/O绑定(从Internet加载,SQL Server数据库查询).现在我认为将每个I/O操作放在单独的块中就像这个方案一样正确:

在这种情况下设计管道的基本规则是什么?
我有一些使用的代码Task<T>推迟从串行读取操作返回结果很短的时间,如下所示:
void ReturnResponseAfterAShortDelay()
{
if (delayedResponseCancellationTokenSource != null)
delayedResponseCancellationTokenSource.Cancel(); // Cancel any pending operations and start a new one.
delayedResponseCancellationTokenSource = new CancellationTokenSource();
log.InfoFormat("Deferring response for {0} ms", Settings.Default.TimeoutMs);
Task.Delay(Properties.Settings.Default.TimeoutMs, delayedResponseCancellationTokenSource.Token)
.ContinueWith((continuation) => ReturnWhateverHasArrived(), TaskContinuationOptions.NotOnCanceled)
.Start();
}
Run Code Online (Sandbox Code Playgroud)
此代码背后的想法是在没有新字符到达指定间隔时返回结果.
但是,由于我无法控制的因素,我必须使用.NET 3.5,这会阻止我使用Task<T>,因此我必须以某种方式重构此代码.
如何在不使用的情况下实现相同的结果Task<T>?
虽然我展示的具体代码恰好是一个定时延迟,但我的用法并不仅限于延迟.可能还有其他情况我想立即开始一些"长时间运行"的轮询任务.典型的情况是I/O绑定操作,例如,定期查询连接到串行端口的设备,然后在满足某些条件时引发事件.
我知道这是一个常见的问题,但我读过一篇文章并感到困惑.而现在我认为最好不要阅读它们)).
那么,ASP.NET如何工作(仅关于线程):
这描述的行为是对的吗?
当我在ASP.NET MVC控制器中启动新任务时真正发生了什么?
public ActionResult Index()
{
var task1 = Task.Factory.StartNew(() => DoSomeHeavyWork());
return View();
}
private static async Task DoSomeHeavyWork()
{
await Task.Delay(5000);
}
Run Code Online (Sandbox Code Playgroud)
这是对的吗 ?
现在让我们看看异步操作
public async Task<ActionResult> Index()
{
await DoSomeHeavyWork();
return View();
}
Run Code Online (Sandbox Code Playgroud)
,我理解与以前的代码示例的区别,但不是过程,在此示例中,行为如下:
请解释第2点和第5点之间发生的事情,问题是:
几乎每个SO关于这个主题的答案都表明:
另外:
但在斯蒂芬的书中有一个样本:
问题:您有一组要处理的任务,并且您希望在完成后对每个任务执行一些处理.但是,您希望在完成后立即对每个进行处理,而不是等待任何其他任务.
推荐的解决方案之一是:
static async Task<int> DelayAndReturnAsync(int val)
{
await Task.Delay(TimeSpan.FromSeconds(val));
return val;
}
// This method now prints "1", "2", and "3".
static async Task ProcessTasksAsync()
{
// Create a sequence of tasks.
Task<int> taskA = DelayAndReturnAsync(2);
Task<int> taskB = DelayAndReturnAsync(3);
Task<int> taskC = DelayAndReturnAsync(1);
var tasks = new[] { taskA, taskB, taskC };
var processingTasks = tasks.Select(async t =>
{
var result = await t;
Trace.WriteLine(result);
}).ToArray();
// Await …Run Code Online (Sandbox Code Playgroud) 假设我有这两种方法:
public BigInteger PFactorial(int n)
{
return Enumerable.Range(1, n)
.AsParallel()
.Select(i => (BigInteger)i)
.Aggregate(BigInteger.One, BigInteger.Multiply);
}
public BigInteger Factorial(int n)
{
BigInteger result = BigInteger.One;
for(int i = 1; i <= n; i++)
result *= i;
return result;
}
Run Code Online (Sandbox Code Playgroud)
以下是我得到的结果:
PFactorial(25000) -> 0,9897 seconds
Factorial(25000) -> 0,9252 seconds
Run Code Online (Sandbox Code Playgroud)
我知道PLINQ由于线程设置而有一些开销,但是如此大的n我期待PLINQ更快.
这是另一个结果:
PFactorial(50000) -> 4,91035 seconds
Factorial(50000) -> 4,40056 seconds
Run Code Online (Sandbox Code Playgroud) 我有一个Employee对象,我正在尝试使用单个数据库实体上下文使用多任务(并行执行)更新记录(即更新/删除).但我得到以下例外
Message ="对象引用未设置为对象的实例."
考虑以下DTO
public class Employee
{
public int EmployeeId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public List<ContactPhone> ContactPhoneNumbers { get; set; }
public List<ContactEmail> ContactEmailAddress { get; set; }
}
public class ContactPhone
{
public int ContactId { get; set; }
public string Type { get; set; }
public string Number { get; set; }
}
public class ContactEmail
{
public int ContactId { …Run Code Online (Sandbox Code Playgroud) c# entity-framework task object-reference task-parallel-library
现在我有
class MyParamClass
{
all the parameters I need to pass to the task
}
MyParamClass myParamObj = new MyParamClass();
myParamObj.FirstParam = xyz;
myParamObj.SecondParam = abc;
mytask = new Task<bool>(myMethod, myParamObj,_cancelToken);
mytask.Start()
bool myMethod(object passedMyParamObj)
{
MyParamClass myParamObj = passedMyParamObj as MyParamClass;
//phew! finally access to passed parameters
}
Run Code Online (Sandbox Code Playgroud)
无论如何,我可以做到这一点,而无需创建类MyParamClass?如何在没有这种麻烦的情况下将多个参数传递给任务?这是标准做法吗?谢谢
我想知道为什么我应该在控制器上使用异步任务,当IIS已经为我处理并发时?
我FileResult : IHttpActionResult为api调用创建了一个webapi返回类型.FileResult从另一个URL下载文件,然后将流返回给客户端.
最初我的代码有using如下声明:
public async Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
try
{
HttpResponseMessage response;
using (var httpClient = new HttpClient())
{
response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new System.Net.Http.StreamContent(
await httpClient.GetStreamAsync(this.filePath))
};
}
return response;
}
catch (WebException exception)
{...}
}
Run Code Online (Sandbox Code Playgroud)
然而,这会间歇性地导致TaskCanceledException.我知道如果在异步调用完成之前处理了HttpClient,Task的状态将变为取消.但是因为我使用了await:Content = new System.Net.Http.StreamContent(await httpClient.GetStreamAsync(this.filePath))这应该可以防止HttpClient在任务完成过程中被丢弃.
为什么该任务被取消?这不是因为超时,因为这发生在最小的请求上,并不总是发生在大请求上.
当我删除using语句时代码正常工作:
public async Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
try
{
HttpResponseMessage response;
var httpClient = new HttpClient();
response = new …Run Code Online (Sandbox Code Playgroud) c# using-statement httpclient task-parallel-library asp.net-web-api
c# ×7
task ×4
.net ×3
asynchronous ×3
asp.net ×2
asp.net-mvc ×2
async-await ×2
.net-3.5 ×1
httpclient ×1
iis ×1
linq ×1
pfx ×1
pipeline ×1
tpl-dataflow ×1