Is there any point in using async api

I have data in memory (json strings):

List<string> data = new List<string>();
using (StreamReader sr = new StreamReader("file.txt"))
{
   while (sr.Peek() >= 0)
   {
      data.Add(sr.ReadLine());
   }
}

and I want to filter these objects using System.Linq.Async:

var filteredData = data.WhereAwait(async x =>
    await filters.ToAsyncEnumerable().AllAwaitAsync(async filter =>
        (await JsonSerializer.DeserializeAsync<RootDto>(new MemoryStream(Encoding.UTF8.GetBytes(x))))
        .Child.Id == filter));

I know this example is stupid, but this is just a general example of whether or not to use an async api in places where it links to a synchronous one. In this example I have List<string> data which is not async by nature. I understand that it makes more sense in a case when data is obtained from an object also asynchronously.
Is it better than the one above?

var filters = new[] {"U45TC0Y7KLLD", "ELXE5X1IXHZV", "KHI3NXKEN1PE", "A7R5LDD4O0NK", "1TIICSXMH7FJ"};
var filteredData = data.Where(filters.All(filter =>
                JsonSerializer.DeserializeAsync<RootDto>(new MemoryStream(Encoding.UTF8.GetBytes(x))).GetAwaiter()
                    .GetResult().Child.Id == filter));

I want to get explanation

> I know this example is stupid

The problem is that stupid examples make talking about a specific problem's solution difficult when there are multiple solutions for different variations of said problem. Also it doesn't help that you don't seem to understand async at all (GetAwaiter().GetResult() is so incredibly bad that there's a name for it, the async-over-sync anti-pattern).

As far as the stupid example goes though, the answer is no. You gain nothing by making the portion you did "async" (note that it's not actually async, as I mentioned above, you just like how the keyword looks so you added it).

There are two theoretical places in the stupid example where async would be of use however:

• the part where you actually read the file. I/O of any kind is exactly what async is made for, making it so your process' threads aren't just sitting around picking their nose as other system components (the DMA transfer chips and the OS scheduler) do the actual work.

• If you got rid of that terrible async-over-sync code and instead created individual tasks that deserialize the code in parallel, then awaited that. Think Task.WhenAll. Depending on how many items you're deserializing and how complex they are, that could actually provide a throughput benefit.