标签: task-parallel-library

任务与ThreadPool

我在C#中有一个应用程序列表.我希望尽可能多地同时完成这项工作.但是我需要能够控制并行任务的最大数量.

根据我的理解,这可以通过ThreadPool或任务来实现.我使用哪一个有区别吗?我主要担心的是能够一次控制多少个线程处于活动状态.

c# parallel-processing multithreading task-parallel-library

9
推荐指数
2
解决办法
1万
查看次数

是否存在不应使用任务的情况?

我正在阅读有关使用4.0进行异步编程的首选方法.我只是想知道是否有任何用例不应该优先使用任务而不是普通的c#线程?

.net c# multithreading task-parallel-library

9
推荐指数
2
解决办法
261
查看次数

异步日志记录抛出NullReferenceException

我试图使用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)

c# .net-4.0 task-parallel-library tpl-dataflow

9
推荐指数
2
解决办法
6133
查看次数

使用TPL进行异常处理

使用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)

更推荐使用哪种方法?每个人的缺点和优点是什么?

c# task-parallel-library

9
推荐指数
1
解决办法
1375
查看次数

你如何捕获CancellationToken.Register回调异常?

我正在使用异步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块中,异常仍然没有被捕获.

c# task-parallel-library cancellationtokensource

9
推荐指数
3
解决办法
6281
查看次数

Async.Await没有捕获任务异常

我有一个不返回任何东西的任务.你不能在这样的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)

将常规(非泛型)任务视为异步但仍然可以传播异常的最佳方法是什么?

f# exception-handling task-parallel-library f#-async

9
推荐指数
2
解决办法
615
查看次数

将同步代码包装到异步方法中的最佳方法是什么

我正在使用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)

c# asynchronous task-parallel-library

9
推荐指数
1
解决办法
6705
查看次数

为什么我的TCS没有等待?

该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

9
推荐指数
2
解决办法
756
查看次数

使用语句中的HttpClient导致任务被取消

我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

9
推荐指数
2
解决办法
1万
查看次数

什么决定了TaskFactory衍生作业的线程数?

我有以下代码:

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个线程(基于观察).我的问题:

  1. 什么决定了一次使用的线程数?
  2. 我该如何找回这个号码?
  3. 我该如何更改此号码?

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)

.net c# multithreading task-parallel-library

9
推荐指数
2
解决办法
7021
查看次数