none
Visual Studio 2013 going into 'Not responding' state when opening a .cs file with nested async methods defined.

    Question

  • When code file with nested async methods are opened for further editing , Visual studio goes into 'Not responding' state. The entire solution can be opened and edited without any trouble if that particualr file is closed. 

    private async Task NestedFunc()
            {
                

                Task tc0 = SampleClass.Func1Async().ContinueWith(t0 =>
                {
                    Task tc1 = SampleClass.Func2Async().ContinueWith(t1 =>
                    {
                        Task tc2 = SampleClass.Func3Async().ContinueWith(t2 =>
                        {
                            Task tc3 = SampleClass.Func4Async().ContinueWith(t3 =>
                            {
                                Task tc4 = SampleClass.Func5Async().ContinueWith(t4 =>
                                {
                                    Task tc5 = SampleClass.Func6Async().ContinueWith(t5 =>
                                    {
                                        Task tc6 = SampleClass.Func7Async().ContinueWith(t6 =>
                                        {
                                            Task tc7 = SampleClass.Func8Async().ContinueWith(t7 =>
                                            {
                                                Task tc8 = SampleClass.Func9Async().ContinueWith(t8 =>
                                                {
                                                    Task tc9 = SampleClass.Func10Async().ContinueWith(t9 =>
                                                    {
                                                        Task tc10 = SampleClass.Func11Async().ContinueWith(t10 =>
                                                        {
                                                            Task tc11 = SampleClass.Func12Async().ContinueWith(t11 =>
                                                            {
                                                                Task tc12 = SampleClass.Func13Async().ContinueWith(t12 =>
                                                                {
                                                                    Task tc13 = SampleClass.Func14Async().ContinueWith(t13 =>
                                                                    {
                                                                        Task tc14 = SampleClass.Func15Async().ContinueWith(t14 =>
                                                                                                                                                                                                                                                                          tc15.Wait();
                                                                                                                                                                                                                                                                                    });
                                                                        tc14.Wait();
                                                                    });
                                                                    tc13.Wait();
                                                                });
                                                                tc12.Wait();
                                                            });
                                                            tc11.Wait();
                                                        });
                                                        tc10.Wait();
                                                    });
                                                    tc9.Wait();
                                                });
                                                tc8.Wait();
                                            });
                                            tc7.Wait();
                                        });
                                        tc6.Wait();
                                    });
                                    tc5.Wait();
                                });
                                tc4.Wait();
                            });
                            tc3.Wait();
                        });
                        tc2.Wait();
                    });
                    tc1.Wait();
                });
                
                await tc0;
            }

    The level of nesting is 15. Please explain this behaviour. 

    Is there any limitation to the nesting levels?

    Friday, February 05, 2016 12:36 PM

Answers

  • Hi,

    Before declare that a bug, you need to test without extensions, because it could be an extension not VS.

    After I don't know where to find information about this kind of limits. Perhaps on Connect : https://connect.microsoft.com/VisualStudio you can find information about this.

    If there is Nothing and you can reproduce the behavior without extensions, you can request a bug.

    Regards,


    Yan Grenier

    Merci de bien vouloir "Marquer comme réponse", les réponses qui ont répondues à votre question, et de noter les réponses que vous avez trouvé utiles.

    Tuesday, February 09, 2016 10:34 AM

All replies

  • Hi,

    First your code is not valid (no { before your tc15.wait();).

    Second because VS create lot of metadata about the code, probably you reach a limit with so many anonymous methods nested call. Your sample run in my VS (when corrected) but it's very slow to edit.

    Third (not about VS) I don't understand your code: it's not good pratice.

    - If you use continious task, dont wait the only child task, it's useless. Prefere a sequence of wait() in the first continuation.

    Task tc0 = SampleClass.Func1Async().ContinueWith(t0 =>
    {
        SampleClass.Func2Async().Wait();
        SampleClass.Func3Async().Wait();
        ...
        SampleClass.Func15Async().Wait();
    });
    

    - Having lot of nested Anonymous methods, make your code difficult to read.

    - If you use async/await why use continious Task+.Wait() ?? And it's very dangerous, never mix TPL async methods and await/async patterns, you may cause deadlock. With await/async you just need write a sequence of await and you code is better. await/async was created for that.

    await SampleClass.Func2Async();
    await SampleClass.Func3Async();
    ...
    await SampleClass.Func15Async();
    

    Regards,


    Yan Grenier

    Merci de bien vouloir "Marquer comme réponse", les réponses qui ont répondues à votre question, et de noter les réponses que vous avez trouvé utiles.

    Friday, February 05, 2016 2:04 PM
  • Thanks for the reply. Sorry for the syntax error i made while copy pasting.

    With respect to the second point, is it clear to assume to that if nested async anonymous method can take a hit on the perfromance of the Visual Studio editor?

    From where can we find if there is any such limit(if i had reached) ?

    Isnt that thing should be explained by the VS support team? Is this a bug in visual studio ? 

     


    Tuesday, February 09, 2016 9:33 AM
  • Hi,

    Before declare that a bug, you need to test without extensions, because it could be an extension not VS.

    After I don't know where to find information about this kind of limits. Perhaps on Connect : https://connect.microsoft.com/VisualStudio you can find information about this.

    If there is Nothing and you can reproduce the behavior without extensions, you can request a bug.

    Regards,


    Yan Grenier

    Merci de bien vouloir "Marquer comme réponse", les réponses qui ont répondues à votre question, et de noter les réponses que vous avez trouvé utiles.

    Tuesday, February 09, 2016 10:34 AM