如何在不停止.Net（c＃）中方法的情况下从异步方法返回值？

Question

Consider the following example:

public Fruit ProcessFruitBasket(List<Fruit> fruits) {
    Fruit result = null;
    foreach (var fruit in fruits) {
        ProcessFruit(fruit);
        if (fruit.MeetsSomeCondition()) result = fruit;
    }
    return fruit;
}

The method ProcessFruitBasket() needs to do something (ProcessFruit()) to every item in the list. Additionally, it needs to find one particular item that meets some condition and return it. The current version is single-threaded, and as a result, the caller will need to wait until all of the items are processed before it can get back its result, even if the one it wants is the first item in the list.

What I would like to do is run ProcessFruitBasket() asynchronously, and have it return the desired value when it finds it so the caller can continue on with the result. However, the ProcessFruitBasket() should still continue to process the rest of the list.

Alternatively, if I could somehow start a Task and have it fill a variable the caller has a reference to, the maybe there is a way that the caller can await the variable being populated (not null anymore?) but not await the whole task?

I have some ideas of how the .Net Tasks namespace might potentially have solved this, but I haven't been able to find any relevant examples. It's possible this isn't an option? I have a clunky solution in mind where the code could loop through the list until it found the right item, and then fire off a task that continues to process the rest of the list asynchronously while the original method returns the found result. It seems like there could be a cleaner mechanism already in place for this. Possibly a way of using Parallel.ForEach() that I haven't found yet?

The important part is that the caller should await the result without having to await the processing of the entire list .

Answer 1

You can pass a function

public void ProcessFruitBasket(List<Fruit> fruits, Func<Fruit> callback) {
    foreach (var fruit in fruits) {
        ProcessFruit(fruit);
        if (fruit.MeetsSomeCondition()) 
            callback(fruit);
    }
}

also on side note that if you dont await asynchronous method then .net will execute next statements until you call await on asynchronous method.

Update 1

    public async Task ProcessFruitBasket(IList<Fruit> fruits, Action<Fruit> callBack)
    {
        foreach (var fruit in fruits)
        {
            var process = ProcessFruit(fruit); // DO NOT await here

            // do something else here

            await process; // you have to await here since you have to check condition on processed fruit
            if (fruit.MeetsSomeCondition())
            {
                callBack(fruit);
            }
        }
    }
    public async Task ProcessFruit(Fruit fruit)
    {
        // do async actions here
        await Task.FromResult<int>(0);
    }

    public void Callback(Fruit fruit)
    {
        // Do something with the fruit
    }

Answer 2

Something like this might work. You will want to get back something representing the remaining processing so that you can await it at some point. I would use an object to capture both things:

public class FruitProcessingResult
{
    public bool FruitWasFound { get; set; }
    public Fruit FruitMeetingCondition { get; set; }
    public Task RemainingProcessing { get; set; }
}

    private async Task<FruitProcessingResult> ProcessFruitBasket(List<Fruit> fruits)
    {
        var result = new FruitProcessingResult();

        //Kick off all fruit processing
        var tasks = fruits.Select(f => ProcessAndTestFruit(f, result)).ToList();

        while (tasks.Any())
        {
            var completed = await Task.WhenAny(tasks);
            tasks.Remove(completed);

            lock (result)
            {
                if (result.FruitWasFound)
                {
                    result.RemainingProcessing = Task.WhenAll(tasks);
                    return result;
                }
            }
        }

        result.RemainingProcessing = Task.CompletedTask;
        return result;
    }

    private async Task ProcessAndTestFruit(Fruit fruit, FruitProcessingResult result)
    {          
        //Process each individual fruit async if you can, otherwise kick off a task
        await ProcessFruitAsync(fruit);
        //await Task.Run(() => ProcessFruitAsync(fruit));

        if (fruit.MeetsSomeCondition())
        {
            lock (result)
            {
                if (!result.FruitWasFound)
                {
                    result.FruitWasFound = true;
                    result.FruitMeetingCondition = fruit;
                }
            }
        }
    }