相关疑难解决方法(0)

我想弄清楚是否应该在顶级请求上使用ConfigureAwait(false).从这个主题的某个权威读取这篇文章:http: //blog.stephencleary.com/2012/07/dont-block-on-async-code.html

......他推荐这样的东西:

public async Task<JsonResult> MyControllerAction(...)
{
    try
    {
        var report = await _adapter.GetReportAsync();
        return Json(report, JsonRequestBehavior.AllowGet);
    }
    catch (Exception ex)
    {
        return Json("myerror", JsonRequestBehavior.AllowGet);  // really slow without configure await
    }
}

public async Task<TodaysActivityRawSummary> GetReportAsync()
{           
    var data = await GetData().ConfigureAwait(false);

    return data
}

...它表示在除顶级调用之外的每个await上使用ConfigureAwait(false). 但是,在执行此操作时,我的异常需要几秒钟才能返回调用者而不是使用它并让它立即返回.

调用异步方法的MVC控制器操作的最佳实践是什么？我应该在控制器本身中使用ConfigureAwait,还是只在使用等待请求数据等的服务调用中使用？如果我不在顶级调用中使用它,等待几秒钟的异常似乎有问题.我不需要HttpContext,并且我已经看过其他帖子,如果你不需要上下文,那么总是使用ConfigureAwait(false).

更新: 我在我的调用链中某处丢失了ConfigureAwait(false),导致异常无法立即返回.但是问题仍然存在,是否应该在顶层使用ConfigureAwait(false).

更新

我问错了问题,改写(根据答案和评论的重要信息):

.net的异步操作是否是真正的异步,因此是IOCP还是异步(重叠)？有没有快速的方法来确定几个类是否正在这样做？

盲目地不信任框架开发人员的示例

创建FileStream的自然起点是静态File.Open()方法,该文档没有提及创建的FileStream的同步性!它也不允许您提供FileOptions(用于指定魔术FileOptions.Asynchronous标志).

而是使用FileOptions.None创建FileStream.任何异步操作都是由Stream基类的强制实现悄然伪造的,它只是将相应的同步方法包装在委托中,并使用BeginInvoke()方法在线程池上调用它.

这偏离了通常的"成功之坑"设计理念,即.NET中的所有内容似乎都能按照您的想法运行,而无需仔细阅读文档和/或逐渐发现模糊的捕获和陷阱.

我一直在努力寻找有关使用IO完成端口的信息.NET.

有没有什么好方法可以知道给定的.NET类是否使用IO完成端口？(每次使用新类时都不必运行一些测试.

我尝试了msdn文档的一些类和方法,我找不到任何东西.

更好的是,如果有一些列表使用IOCP的类列表.

阅读本文后指出:

设备完成其作业后(IO操作) - 它通过中断通知CPU.

...... ......

但是,"完成"状态仅存在于操作系统级别; 该进程有自己的内存空间,必须通知

...... ......

由于库/ BCL使用标准的P/Invoke重叠I/O系统,因此它已经使用I/O完成端口(IOCP)注册了句柄,IOCP是线程池的一部分.

...... ......

因此,简单地借用 I/O线程池线程来执行APC,APC通知任务它已完成.

关于大胆的部分,我很有趣:

如果我理解正确,在IO操作完成后,它必须通知执行IO操作的实际进程.

问题#1:

这是否意味着它为每个完成的IO操作抓取一个新的线程池线程？或者这是一个专门的线程数？

问题2:

看着 :

for (int i=0;i<1000;i++)
    {
      PingAsync_NOT_AWAITED(i); //notice not awaited !
    }

这是否意味着我将同时运行1000个IOCP线程池线程(某种类型),当它们全部完成时？

我已经做了很多的发展在C#/.Net和异步的故事一直存在从一开始(诚然API的已超过从开始/结束事件的年显著改变,以Task<T>用async/ await).在过去一年左右的时间里,我一直在使用Node.js进行开发,它以异步方式执行所有I/O并使用单线程事件循环模型.最近我正在开发一个我们使用Ruby的项目,对于应用程序的一部分,我觉得以异步方式制作一大堆Web请求是有意义的,并且惊讶地发现Ruby中的异步故事非常多不同.执行任何异步I/O的唯一方法是使用EventMachine.

我的问题归结为:为什么在.Net(以及我可以告诉它对Java/JVM也是如此)不需要事件循环,我可以随时触发异步请求但是在像Ruby/Python这样的语言中,我需要分别使用eventmachine/twisted？我觉得有一些关于异步I/O如何工作的基本问题,我不理解.

我想知道哪种方法通常在内存和资源使用方面会更有效。

尤其是方法1，我很难想象将如何创建任务对象和线程旋转？有人可以解释一下幕后发生的事情吗？

如果两者之间没有区别，我想使用＃1（以免引起异步气泡）。对于＃2，我知道编译器将在下面生成状态机并产生收益。OTOH，＃1在概念上似乎是递归的，但是在传统意义上会像在一个堆栈帧中等待另一个一样递归吗？

方法1：

internal static Task ExecuteAsyncWithRetry(Func<Task> methodToExecute, Func<bool> shouldRetry)
    {
        var tcs = new TaskCompletionSource<object>();

        try
        {
            return methodToExecute().ContinueWith<Task>((t) =>
            {
                if (t.IsFaulted || t.IsCanceled)
                {
                    if (shouldRetry())
                    {
                        return ExecuteAsyncWithRetry(methodToExecute, shouldRetry);
                    }
                    else
                    {
                        tcs.SetException(t.Exception);
                    }
                }
                else
                {
                    tcs.SetResult(null);

                }

                return tcs.Task;
            }, TaskContinuationOptions.ExecuteSynchronously).Unwrap();
        }
        catch(Exception ex)
        {
            tcs.SetException(ex);
        }

        return tcs.Task;
    }

方法2（忽略两者之间异常传播的差异）：

internal static async Task ExecuteWithRetry(Func<Task> methodToExecute, Func<bool> shouldRetry)
    {
        while (true)
        {
            try
            {
                await methodToExecute();
            }
            catch(Exception ex)
            {
                if(!shouldRetry())
                { …