How do you set up some function to run in a background thread but keep the normal return type instead of the Task?

Question

I have a function from the one service to that will get the count of all files inside a directory. And another service will get that int number to do some stuff with it.

public int GetNumberOfAvatarsInFile()
{
    try
    {
        var path = GetAvatarsFilePath();
        var numberOfAvatars = Directory.GetFiles(path, "*.*", SearchOption.TopDirectoryOnly).Length;
        return numberOfAvatars;
    }
    catch (Exception exception)
    {
        var message = $"Error While Getting Total Numbers Of Avatars at {DateTime.Now}\n\t" +
            $"Error: {JsonConvert.SerializeObject(exception)}";
        sentryClient.CaptureMessage(message, SentryLevel.Error);
        return 1;
    }
}

private string GetAvatarsFilePath()
{
    var webRootPath = webHostEnvironment.WebRootPath;
    var path = Path.Combine(webRootPath, "path");
    return path;
}

The other service will use this function like this

private int GetMaximumAvatarId() => avatarService.GetNumberOfAvatarsInFile();

How do I set up so that all these file getting logic and string combine will be separated to a background thread/another thread by either Task.Run or something similar?

When I try to set up the GetNumberOfAvatarsInFile() by implementing await Task.Run(async () => LOGIC+Return int); I have to return a Task rather than the int from the other service that is calling it as well, which is not desirable since those are other people code and I should not change them. Also as far as I know all the Path.Combine and Directory functions do not employ any awaiter.

Is there a way to implement this?

Answer 1

As mentioned in the comments, the best practice is to provide async methods to the caller and use async all the way (see this article). However there are 2 things that can already be done:

1. Make your I/O method run asynchronously in a separate thread.
2. Have callers call your method asynchronously even if the implementation is synchronous.

The implementations on client side and on service side are independent. Here is a commented example that I hope shows how to do this. Most of the code below is unnecessary and is there only to illustrate what happens when multiple callers call your method and what is executed when. You may change the Thread.Sleep() values to simulate different execution time.

I also added a side note regarding the value you return in the Exception, that does not look ok to me.

public class Program
{
    public static void Main()
    {
        // These simulate 3 callers calling your service at different times.
        var t1 = Task.Run(() => GetMaximumAvatarId(1));
        Thread.Sleep(100);
        var t2 = Task.Run(() => GetMaximumAvatarId(2));
        Thread.Sleep(2000);
        var t3 = Task.Run(() => GetMaximumAvatarId(3));

        // Example purposes.
        Task.WaitAll(t1, t2, t3);
        Console.WriteLine("MAIN: Done.");
        Console.ReadKey();
    }

    // This is a synchronous call on the client side. This could very well be implemented
    // as an asynchronous call, even if the service method is synchronous, by using a
    // Task and having the caller await for it (GetMaximumAvatarIdAsync).
    public static int GetMaximumAvatarId(int callerId)
    {
        Console.WriteLine($"CALLER {callerId}: Calling...");
        var i = GetNumberOfAvatarsInFile(callerId);
        Console.WriteLine($"CALLER {callerId}: Done -> there are {i} files.");
        return i;
    }

    // This method has the same signature as yours. It's synchronous in the sense that it
    // does not return an awaitable. However it now uses `Task.Run` in order to execute
    // `Directory.GetFiles` in a threadpool thread, which allows to run other code in
    // parallel (in this example `Sleep` calls, in real life useful code). It finally 
    // blocks waiting for the result of the task, then returns it to the caller as an int.
    // The "callerId" is for the example only, you may remove this everywhere.
    public static int GetNumberOfAvatarsInFile(int callerId)
    {
        Console.WriteLine($"    SERVICE: Called by {callerId}...");

        var path = GetAvatarsFilePath();
        var t = Task.Run(() => Directory.GetFiles(path, "*.*", SearchOption.TopDirectoryOnly).Length);

        // Simulate long work for a caller, showing the caller.
        Console.WriteLine($"    SERVICE: Working for {callerId}...");
        Thread.Sleep(500);
        Console.WriteLine($"    SERVICE: Working for {callerId}...");
        Thread.Sleep(500);
        Console.WriteLine($"    SERVICE: Working for {callerId}...");
        Thread.Sleep(500);
        
        Console.WriteLine($"    SERVICE: Blocking for {callerId} until task completes.");

        return t.Result; // Returns an int.

        // --------------------------------------------------------
        // Side note: you should return `-1` in the `Exception`.
        // Otherwise it is impossible for the caller to know if there was an error or
        // if there is 1 avatar in the file.
        // --------------------------------------------------------
    }

    // Unchanged.
    private string GetAvatarsFilePath()
    {
        var webRootPath = webHostEnvironment.WebRootPath;
        var path = Path.Combine(webRootPath, "path");
        return path;
    }
}