我正在写一个地铁应用程序.
这有效:
HttpClient client = new HttpClient();
var bytes = await client.GetByteArrayAsync(new Uri("www.microsoft.com"));
这不是:
var folder = Windows.Storage.ApplicationData.Current.LocalFolder;
var file = await folder.GetFileAsync("text.txt");
第一个返回Task <>,第二个返回IAsyncOperation <>
有什么不同？为什么有两种不同的类型？我该如何修复第二个样本？
我有一个庞大的集合,我想以平行的方式处理每个对象.同步地执行相同操作通常涉及简单的"foreach".
只是想知道在我的场景中使用什么,即Parallel.ForEach或MyCollection.AsParallel().ForAll().
你能否解释一下使用一对一的好处.
是否有建议的自我取消和重启任务模式？
例如,我正在研究背景拼写检查程序的API.拼写检查会话被包装为Task.每个新会话都应该取消之前的会话并等待其终止(以正确地重新使用拼写检查服务提供商等资源).
我想出了这样的事情:
class Spellchecker
{
Task pendingTask = null; // pending session
CancellationTokenSource cts = null; // CTS for pending session
// SpellcheckAsync is called by the client app
public async Task<bool> SpellcheckAsync(CancellationToken token)
{
// SpellcheckAsync can be re-entered
var previousCts = this.cts;
var newCts = CancellationTokenSource.CreateLinkedTokenSource(token);
this.cts = newCts;
if (IsPendingSession())
{
// cancel the previous session and wait for its termination
if (!previousCts.IsCancellationRequested)
previousCts.Cancel();
// this is not expected to throw
// as the …我正在实施IAsyncDisposable这要求我返回 a ValueTask，但有时我的 dispose 方法无关。在这种情况下我应该如何返回？
目前我正在返回new ValueTask(Task.CompletedTask)这似乎有效，但由于 valueTasks 的目的是避免创建不必要的堆对象，我相信应该有一种更简单、更有效的方法。
我正在使用.NET 4.0构建Windows服务.
我在任务中抛出了各种未处理的异常,但它们不会像MSDN文档所述那样终止我的进程(并行任务 - 请参阅未观察到的任务异常).
"如果您没有给故障任务提供传播其异常的机会(例如,通过调用Wait方法),那么当任务被垃圾收集时,运行时将根据当前的.NET异常策略升级任务的未观察异常. ".
即使我使用最简单的任务调用,它的行为也是如此:
Task.Factory.StartNew(() => { throw new Exception(); }
调用该服务时,该服务保持正常运行.
根据文档,任务的终结器将在任务为GC后重新抛出异常,但这似乎不会发生.MSDN反复声明,正常的".NET异常策略"会导致进程终止.
为什么不终止我的应用程序？我能想到的唯一一件事就是以某种方式提到某个地方的任务(是lambda ??)
var tasks = new List<Task>();
foreach (var guid in guids)
{
var task = new Task( ...);
tasks.Add(task);
}
foreach (var task in tasks)
{
task.Start();
Task.WaitAll(task);
}
这是UI线程的运行.我需要一个接一个地执行任务变量中的所有任务.问题是如果我调用Task.WaitAll(任务),UI冻结.如何在不冻结UI的情况下执行以下逻辑？
我的应用程序需要将插件加载到单独的应用程序域中,然后异步执行其中的一些代码.我编写了一些代码来包装可Task编组类型:
static class RemoteTask
{
public static async Task<T> ClientComplete<T>(RemoteTask<T> remoteTask,
CancellationToken cancellationToken)
{
T result;
using (cancellationToken.Register(remoteTask.Cancel))
{
RemoteTaskCompletionSource<T> tcs = new RemoteTaskCompletionSource<T>();
remoteTask.Complete(tcs);
result = await tcs.Task;
}
await Task.Yield(); // HACK!!
return result;
}
public static RemoteTask<T> ServerStart<T>(Func<CancellationToken, Task<T>> func)
{
return new RemoteTask<T>(func);
}
}
class RemoteTask<T> : MarshalByRefObject
{
readonly CancellationTokenSource cts = new CancellationTokenSource();
readonly Task<T> task;
internal RemoteTask(Func<CancellationToken, Task<T>> starter)
{
this.task = starter(cts.Token);
}
internal void Complete(RemoteTaskCompletionSource<T> tcs)
{
task.ContinueWith(t …说我有以下课程:
class SomeClass
{
private TaskCompletionSource<string> _someTask;
public Task<string> WaitForThing()
{
_someTask = new TaskCompletionSource<string>();
return _someTask.Task;
}
//Other code which calls _someTask.SetResult(..);
}
然后别的,我打电话
//Some code..
await someClassInstance.WaitForThing();
//Some more code
在//Some more code被调用之前不会被_someTask.SetResult(..)调用.调用上下文在内存中等待.
但是,假设SetResult(..)从未被调用过,并且someClassInstance停止被引用并被垃圾收集.这会造成内存泄漏吗？或.Net自动神奇地知道需要处理调用上下文？
我正在尝试使用几个ASP.NET Web API 2.0端点进行基准测试(使用Apache工作台).其中一个是同步和一个异步.
[Route("user/{userId}/feeds")]
[HttpGet]
public IEnumerable<NewsFeedItem> GetNewsFeedItemsForUser(string userId)
{
return _newsFeedService.GetNewsFeedItemsForUser(userId);
}
[Route("user/{userId}/feeds/async")]
[HttpGet]
public async Task<IEnumerable<NewsFeedItem>> GetNewsFeedItemsForUserAsync(string userId)
{
return await Task.Run(() => _newsFeedService.GetNewsFeedItemsForUser(userId));
}
在观看了Steve Sanderson的演讲之后,我ab -n 100 -c 10 http://localhost....向每个端点发出了以下命令.
我很惊讶,因为每个端点的基准似乎大致相同.
关闭史蒂夫解释说我期待异步端点更高效,因为它会立即将线程池线程释放回线程池,从而使它们可用于其他请求并提高吞吐量.但数字看起来完全一样.
我在这里误解了什么？
c# asp.net task-parallel-library async-await asp.net-web-api
在试图找出新的(现在可能不是那么新,但对我而言是新的)TaskC#中的异步编程时,我遇到了一个问题,让我有点想弄清楚,我不知道为什么.
我已经解决了这个问题,但我仍然不确定为什么这是一个问题.我只是觉得我会分享我的经验,以防任何人遇到同样的情况.
如果有任何大师想告诉我这个问题的原因,那就太棒了,非常感激.我总是喜欢知道为什么有些东西不起作用!
我做了一个测试任务,如下:
Random rng = new Random((int)DateTime.UtcNow.Ticks);
int delay = rng.Next(1500, 15000);
Task<Task<object>> testTask = Task.Factory.StartNew<Task<object>>(
async (obj) =>
{
DateTime startTime = DateTime.Now;
Console.WriteLine("{0} - Starting test task with delay of {1}ms.", DateTime.Now.ToString("h:mm:ss.ffff"), (int)obj);
await Task.Delay((int)obj);
Console.WriteLine("{0} - Test task finished after {1}ms.", DateTime.Now.ToString("h:mm:ss.ffff"), (DateTime.Now - startTime).TotalMilliseconds);
return obj;
},
delay
);
Task<Task<object>>[] tasks = new Task<Task<object>>[] { testTask };
Task.WaitAll(tasks);
Console.WriteLine("{0} - Finished waiting.", DateTime.Now.ToString("h:mm:ss.ffff"));
// make console stay open till user …