标签: async-ctp

我有各种任务的令牌,我需要更好地管理他们的取消,以获得我可以使用的取消通知:

token.Register(RegisterMethod);

如何删除此"订阅"？有没有办法"UnRegister"？

我想过用TaskCompletionSource做一个解决方法.但我不知道它是否会运作良好.解决这种方法的最佳方法是什么？

我一直在阅读关于新的异步await关键字,它听起来很棒,但有一个关键问题我到目前为止看过的任何一个介绍视频都找不到答案(我也读过白皮书)一会儿回来).

假设我await在主UI线程上的嵌套函数中有一个调用.此时线程会发生什么？控件是否返回消息循环,UI线程可以自由处理其他输入？

当等待的任务完成时,整个堆栈是否被推送到消息队列,这样控制将通过每个嵌套函数返回,或者其他完全发生在这里？

其次(虽然我引起了你的注意),我真的不明白为什么需要标记异步方法async.不能异步执行任何方法吗？如果我想异步执行一个方法但它没有async关键字怎么办？有没有办法简单地做到这一点？

干杯.:)

编辑: 不可否认,如果我能得到示例代码编译,我可能只是想出自己,但由于某种原因,我遇到了一个块.我真正想知道的是,延续的持续程度是多久...是否会冻结整个调用堆栈,在任务完成时恢复它,还是只返回到目前为止？是否需要将函数本身标记为异步以支持延续,或者(正如我最初所说)它是否继续整个调用堆栈？

如果它没有冻结整个调用堆栈,那么当异步等待命中非异步调用函数时会发生什么？它阻止了吗？这不会打败等待点吗？我希望你能看到我在这里缺少一些理解我希望有人可以填写,所以我可以继续学习这个.

在C#with async ctp或vs.net 2011 beta中,我们可以编写如下的递归代码:

public async void AwaitSocket()
{
    var socket = await this.AcceptSocketAsync(); //await socket and >>return<< to caller
    AwaitSocket(); //recurse, note that the stack will never be deeper than 1 step since await returns..
    Handle(socket); // this will get called since "await" returns
}

在此特定示例中,代码异步等待tcp套接字,一旦被接受,它将递归并且异步等待另一个.

这似乎工作正常,因为await部分将使代码返回到调用者,因此,不会导致堆栈溢出.

这里有两个问题:

1. 如果我们忽略了我们在这个样本中处理套接字的事实.以这种方式进行堆栈自由递归是否可以？还是有缺点我不见了？

2. 从IO的角度来看,上面的代码是否足以处理所有传入的请求？我的意思是只等一个,一旦被接受就开始等待另一个.某些请求会因某种原因而失败吗？

这是代码:

static class AsyncFinally
{
    static async Task<int> Func( int n )
    {
        try
        {
            Console.WriteLine( "    Func: Begin #{0}", n );
            await TaskEx.Delay( 100 );
            Console.WriteLine( "    Func: End #{0}", n );
            return 0;
        }
        finally
        {
            Console.WriteLine( "    Func: Finally #{0}", n );
        }
    }

    static async Task Consumer()
    {
        for ( int i = 1; i <= 2; i++ )
        {
            Console.WriteLine( "Consumer: before await #{0}", i );
            int u = await Func( i );
            Console.WriteLine( "Consumer: …

我正在评估Async CTP.

如何在另一个线程池的线程上开始执行异步函数？

static async Task Test()
{
    // Do something, await something
}

static void Main( string[] args )
{
    // Is there more elegant way to write the line below?
    var t = TaskEx.Run( () => Test().Wait() );

    // Doing much more in this same thread
    t.Wait(); // Waiting for much more then just this single task, this is just an example
}

使用最新的CTP5和async/await关键字,我写了一些代码,显然无法编译:

 class Program
    {
        public class MyClass
        {
            async public Task<int> Test()
            {
                var result = await TaskEx.Run(() =>
                    {
                        Thread.Sleep(3000);
                        return 3;
                    });
                return result;
            }
        }

        static void Main(string[] args)
        {
            var myClass = new MyClass();

            //The 'await' operator can only be used in a method or lambda marked with the 'async' modifier error ??!!
            int result = await myClass.Test();

            Console.ReadLine();
        }
    }

"'await'运算符的原因是什么只能用于标有'async'修饰符错误的方法或lambda？" (我选择了Visual Studio指向的行)

将后置条件添加到返回的异步方法的推荐方法是什么Task<T>？

我已经阅读了以下建议:

http://social.msdn.microsoft.com/Forums/hu-HU/async/thread/52fc521c-473e-4bb2-a666-6c97a4dd3a39

帖子建议将每个方法实现为同步,签约,然后将异步对应实现为简单的包装器.不幸的是,我不认为这是一个可行的解决方案(也许是通过我自己的误解):

1. 异步方法虽然被假定为同步方法的包装器,但没有任何真正的代码契约,因此可以按照自己的意愿进行.
2. 致力于异步的代码库不太可能为所有内容实现同步对应.因此,实现包含await其他异步方法的新方法因此被强制为异步.这些方法本质上是异步的,不能轻易转换为同步.它们不仅仅是包装纸.

即使我们通过说我们可以使用.Result或.Wait()代替await(这实际上会导致某些SyncContexts死锁,并且无论如何都必须在异步方法中重写)来使后一点无效,我仍然相信第一点.

有没有其他想法,或者有什么我错过的代码合同和TPL？

在.NET 4中,是否有任何功能等同于.NET 4.5的System.Threading.Tasks.Task.WhenAll()？

目标是将多个异步任务包装成一个在完成所有组成任务时完成的异步任务.

我试图看看新的C#5.0异步(CTP)功能将如何工作.我也使用ReSharper.但由于它只是一个CTP,ReSharper 不支持新关键字(async/await)并将其突出显示为错误.

这是它的外观(来自CTP样本的代码)

现在可以让ReSharper跳过这些词吗？

UPDATE

我试过早期访问计划ReSharper build 6.0.2151.53(2011年5月10日)但没有运气.问题仍然存在,所以如果你想解决它,请在这里投票(遵循彼得的回答).

我有一个异步方法:

public async Task<BitmapSource> GetBitmapAsync(double[] pixels);

假设我也有这个课程:

public class PixelData
{
    public double[] Pixels { get; }
}

我现在想要创建一个生成BitmapSource输出的方便方法,使用上面的异步方法来完成工作.我可以提出至少三种方法来做到这一点,但对于我来说,从效率和可靠性的角度来看,我应该选择哪一种方法.

有人可以建议; 以下每种方法的优点和缺点是什么？

选项A创建一个返回以下内容Result的同步方法Task:

public BitmapSource GetBitmap(PixelData pixelData)
{
    return GetBitmapAsync(pixelData.Pixels).Result;
}

选项B创建一个返回Task<BitmapSource>以下内容的同步(或它是异步？)方法:

public Task<BitmapSource> GetBitmap(PixelData pixelData)
{
    return GetBitmapAsync(pixelData.Pixels);
}

选项C创建一个显式使用的异步方法await:

public async Task<BitmapSource> GetBitmapAsync(PixelData pixelData)
{
    return await GetBitmapAsync(pixelData.Pixels);
}