我在C#中有一个应用程序列表.我希望尽可能多地同时完成这项工作.但是我需要能够控制并行任务的最大数量.
根据我的理解,这可以通过ThreadPool或任务来实现.我使用哪一个有区别吗?我主要担心的是能够一次控制多少个线程处于活动状态.
我正在阅读有关使用4.0进行异步编程的首选方法.我只是想知道是否有任何用例不应该优先使用任务而不是普通的c#线程?
我试图使用AsyncTargetingPack异步将一些信息记录到针对.NET 4.0的MVC 4控制器操作中的SQL Server.我会直接跳到.NET 4.5,但我的应用程序存在于Azure中,我们仍在等待更新 ...
此代码按预期工作(一行写入我的数据库,没有抛出异常):
public class SystemActionLogger : ISystemActionLogger
{
private readonly ActionBlock<Tuple<SystemAction, object>> actionBlock;
public SystemActionLogger(ISystemActionLogEntryRepository repository)
{
actionBlock = new ActionBlock<Tuple<SystemAction, object>>(
entry => TaskEx.Run(async () =>
{
string data = await JsonConvert.SerializeObjectAsync(entry.Item2);
await repository.PersistAsync(new SystemActionLogEntry(entry.Item1, data));
}));
}
public void Log(SystemAction systemAction, object data)
{
actionBlock.Post(new Tuple<SystemAction, object>(systemAction, data));
}
}
Run Code Online (Sandbox Code Playgroud)
并且此代码抛出NullReferenceException:
public class SystemActionLogger : ISystemActionLogger
{
private readonly ActionBlock<Tuple<SystemAction, object>> actionBlock;
public SystemActionLogger(ISystemActionLogEntryRepository repository)
{
actionBlock = new ActionBlock<Tuple<SystemAction, object>>(async entry …Run Code Online (Sandbox Code Playgroud) 使用TPL/Tasks我可以使用内部try/catch语句执行异常处理:
Task.Factory.StartNew(
()=>
{
try
{
// Do stuff
}
catch
{
// Handle exception
}
});
Run Code Online (Sandbox Code Playgroud)
或使用ContinueWith,如下所示:
Task.Factory.StartNew(
()=>
{
// Do stuff
}).ContinueWith(
task =>
{
if(task.Exception != null)
// Handle exception
});
Run Code Online (Sandbox Code Playgroud)
更推荐使用哪种方法?每个人的缺点和优点是什么?
我正在使用异步I/O与HID设备进行通信,并且我希望在超时时抛出一个可捕获的异常.我有以下读取方法:
public async Task<int> Read( byte[] buffer, int? size=null )
{
size = size ?? buffer.Length;
using( var cts = new CancellationTokenSource() )
{
cts.CancelAfter( 1000 );
cts.Token.Register( () => { throw new TimeoutException( "read timeout" ); }, true );
try
{
var t = stream.ReadAsync( buffer, 0, size.Value, cts.Token );
await t;
return t.Result;
}
catch( Exception ex )
{
Debug.WriteLine( "exception" );
return 0;
}
}
}
Run Code Online (Sandbox Code Playgroud)
从Token的回调抛出的异常不会被任何try/catch块捕获,我不知道为什么.我以为它会被等待,但事实并非如此.有没有办法捕获这个异常(或让它由Read()的调用者捕获)?
编辑: 所以我重新阅读msdn上的文档,它说:"委托生成的任何异常都将从此方法调用中传播出来."
我不确定"传播出这个方法调用"是什么意思,因为即使我将.Register()调用移到try块中,异常仍然没有被捕获.
我有一个不返回任何东西的任务.你不能在这样的Task上做Async.AwaitTask,所以你需要做一个Async.AwaitIAsyncTask.不幸的是,这似乎只是吞下了底层任务抛出的任何异常: -
TaskFactory().StartNew(Action(fun _ -> failwith "oops"))
|> Async.AwaitIAsyncResult
|> Async.Ignore
|> Async.RunSynchronously
// val it : unit = ()
Run Code Online (Sandbox Code Playgroud)
另一方面,AwaitTask正确级联异常: -
TaskFactory().StartNew(fun _ -> failwith "oops"
5)
|> Async.AwaitTask
|> Async.Ignore
|> Async.RunSynchronously
// POP!
Run Code Online (Sandbox Code Playgroud)
将常规(非泛型)任务视为异步但仍然可以传播异常的最佳方法是什么?
我正在使用async-await方法创建一个应用程序.但是使用它们对我来说存在很大问题.在阅读了一些文章之后,我仍然不知道将重同步操作包装到异步方法的最佳方法是什么.
我有2个想法.哪一个是最好的?
1)目前的实现.
private Task<List<UploadedTestModel>> ParseTestFiles(List<string> filesContent)
{
var tcs = new TaskCompletionSource<List<UploadedTestModel>>();
Task.Run(() =>
{
var resultList = new List<UploadedTestModel>();
foreach (var testBody in filesContent)
{
try
{
var currentCulture = Thread.CurrentThread.CurrentCulture;
var serializerSettings = new JsonSerializerSettings
{
Culture = currentCulture
};
var parsedData = JsonConvert.DeserializeObject<UploadedTestModel>(testBody, serializerSettings);
resultList.Add(parsedData);
}
catch(Exception exception)
{
tcs.SetException(exception);
}
}
tcs.SetResult(resultList);
});
return tcs.Task;
}
Run Code Online (Sandbox Code Playgroud)
我正在使用Task.Run和TaskCompletionSource
2)仅使用Task.Run而不使用TaskCompletionSource
private Task<List<UploadedTestModel>> ParseTestFiles(List<string> filesContent)
{
return Task.Run(() =>
{
. . . .
return resultList;
});
}
Run Code Online (Sandbox Code Playgroud) 该async关键字也导致CIL改变(即使有方法内部没有的await),但它主要是允许await存在.
但我没想到会发生以下情况:
static void Main(string[] args)
{
Task t = Go();
t.Wait();
}
static async Task Go()
{
Console.WriteLine(1);
await AAA(3000);
Console.WriteLine(2);
}
static Task<object> AAA(int a) // <--- No `async`
{
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
Task.Delay(a).ContinueWith(b => tcs.SetResult(null));
return tcs.Task;
}
Run Code Online (Sandbox Code Playgroud)
这个印刷品:
1
(wait)
2
Run Code Online (Sandbox Code Playgroud)
但如果我改变
static Task<object> AAA(int a)
Run Code Online (Sandbox Code Playgroud)
至
static async Task<object> AAA(int a)
Run Code Online (Sandbox Code Playgroud)
它打印:
1
2
(no wait)
Run Code Online (Sandbox Code Playgroud)
题
为什么我没有看到延迟?TCS仅在三秒后解决.同时,任务没有得到解决,应该等待.
.net c# task-parallel-library async-await taskcompletionsource
我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
我有以下代码:
var factory = new TaskFactory();
for (int i = 0; i < 100; i++)
{
var i1 = i;
factory.StartNew(() => foo(i1));
}
static void foo(int i)
{
Thread.Sleep(1000);
Console.WriteLine($"foo{i} - on thread {Thread.CurrentThread.ManagedThreadId}");
}
Run Code Online (Sandbox Code Playgroud)
我可以看到它一次只做4个线程(基于观察).我的问题:
PS我的盒子有4个核心.
PPS我需要具有特定数量的任务(并且不再需要)由TPL同时处理并最终得到以下代码:
private static int count = 0; // keep track of how many concurrent tasks are running
private static void SemaphoreImplementation()
{
var s = new Semaphore(20, 20); // allow 20 tasks at a time
for (int i = …Run Code Online (Sandbox Code Playgroud) c# ×9
.net ×3
.net-4.0 ×1
async-await ×1
asynchronous ×1
f# ×1
f#-async ×1
httpclient ×1
tpl-dataflow ×1