Task<IEnumerable<T>> thread safety issues

I am creating all the variables within a task and I don't see any shared state. One of the MyData value (eg: myData.Chocolate) was null in one of the instances where I made a call. I didn't have logs when I made the call and I am unable to replicate it. I wasn't sure if the external call returned a null or if there was any threading issue which caused the field to be null during the specific instance.

Do you see any thread safety issues in the program below?

public async Task<IEnumerable<MyData>> MyMethodAsync(IEnumerable<string> data)
{
    var tasks = data.Select(async d =>
    {
        MyData myData = new MyData();

        //API call
        CandyData candyData = // await async API call to Graph Client

        myData.Chocolate = candyData.Chocolate;
        myData.Toffee = candyData.Toffee;
        // more similar setters

        return myData;
    });
    var results = await Task.WhenAll(tasks);
    return results;
}

Your code looks fine.

I tested it with the following:

async Task Main()
{
	var results = await MyMethodAsync(new [] { "A", "B", "C", });
	foreach (var result in results)
		Console.WriteLine(result.Chocolate);
}

public async Task<IEnumerable<MyData>> MyMethodAsync(IEnumerable<string> data)
{
	var tasks = data.Select(async d =>
	{
		MyData myData = new MyData();

		CandyData candyData = await GetCandyDataAsync(d);

		myData.Chocolate = candyData.Chocolate;
		myData.Toffee = candyData.Toffee;

		return myData;
	});
	var results = await Task.WhenAll(tasks);
	return results;
}

public Task<CandyData> GetCandyDataAsync(string data) =>
	Task.Run(() =>
	{
		Thread.Sleep(TimeSpan.FromSeconds(10.0));
		return new CandyData()
		{
			Chocolate = data,
			Toffee = data
		};
	});

That produced A, B, C to the console after 10 seconds as expected.

This means that any issue could be in your implementation of GetCandyDataAsync.

My next thought was to try to clean up the code to make it more maintainable and testable.

So, I wrote this extension method based on your MyMethodAsync:

public static async Task<IEnumerable<R>> SelectMany<T, U, R>(
		this IEnumerable<T> source,
		Func<T, Task<U>> taskSelector,
		Func<T, U, R> resultSelector) =>
	await Task.WhenAll(
		source
			.Select(async t =>
			{
				U u = await taskSelector(t);
				R r = resultSelector(t, u);
				return r;
			}));

Yes, that effectively your code wrapped in a SelectMany that can now be used to write a simple LINQ query implementation of your MyMethodAsync method.

Here it is:

public async Task<IEnumerable<MyData>> MyMethodAsync(IEnumerable<string> data) =>
	await
		from d in data
		from candyData in GetCandyDataAsync(d)
		select new MyData()
		{
			Chocolate = candyData.Chocolate,
			Toffee = candyData.Toffee,
		};

Again, that produces the same result as above, but it's encapsulated the hard work in a handy extension method.

I fully tested before posting.