Is there a C# counterpart to this javascript trick for avoiding too much recursion

Question

In javascript it is possible to prevent a "too much recursion" error, when a method is calling itself, by wrapping the recursive call in setTimeout. For example, this eventhandler adds one item at a time to a knockout observable array, using array.shift() and recursion instead of a loop:

$(document).on("AddPizzaFan", function (event, data, results) {

    var item = data.shift();
    var fan =   new PizzaFan(

                     item['firstname'],
                     item['lastname'],
                     item['favoritePizzaTopping']

        )
    myObservableArray.push(fan);
    if (data.length > 0) {
        setTimeout(function () { $(document).trigger("AddPizzaFan", [data, myObservableArray]); }, 1);
    }

});

This approach allows a UI component bound to the KO observable to be updated one data row at a time, making the UI seem fast and responsive even when data contains thousands of rows and might otherwise require 5 or 10 or even 60 seconds or more to appear if the data array was simply fed all at once to the UI. When the array is fed to the UI in many small bits, the user starts to see data on the screen right away. (FWIW, the actual application is a text corpora search where many paragraphs of text are returned which contain the user's search term or search phrase.)

Can something comparable to this be done with a Stack and async await in C# ? Reading this question and answer, it seems that it can't, at least not easily. If it is possible to do something similar in C#, how is it accomplished?

What kind of UI are you using? Windows Forms? Windows Presentation Foundation? — Jesús López, May 17 '20 at 17:36
You don't need to rely on JavaScript tricks. c# has lots of capabilities to deal with threads and asynchronous programming. Just forget those tricks an embrace c# approach — Jesús López, May 17 '20 at 17:40
@JesúsLópez: That is *exactly* my question. What are the counterpart C# approaches. — Tim, May 17 '20 at 20:56
The best solution for this problem is data virtualization. I'm not sure what kind of virtualization support Blazor controls currently have. — Stephen Cleary, May 18 '20 at 09:10

Arman Ebrahimpour · Accepted Answer · 2020-05-17T17:54:19.437

0

I think your code could be implemented in c# as follow:

Recursive Implementation:

async Task RecursiveTask(Stack<object> data, Queue<object> myObservableArray)
{
    if (data.Count > 0)
    {
        myObservableArray.Enqueue(data.Pop()); // or any other logic
        await Task.Delay(1000);
        await RecursiveTask(data, myObservableArray);
    }
}

Non-recursive Implementation (Recommended):

async Task RecursiveTask(Stack<object> data, Queue<object> myObservableArray)
{
    while (data.Count > 0)
    {
        myObservableArray.Enqueue(data.Pop()); // or any other logic
        await Task.Delay(1000);
    }
}

edited May 17 '20 at 17:54

answered May 17 '20 at 17:19

Arman Ebrahimpour

4,252
1
14
46

1

only that recursion is not necessary at all – Jesús López May 17 '20 at 17:42
@JesúsLópez : You're right. I try to show Tim `recursive version` I'll update my answer with non recursive version too, thanks for your point – Arman Ebrahimpour May 17 '20 at 17:45

Is there a C# counterpart to this javascript trick for avoiding too much recursion

1 Answers1