Thread safety when mutating an object

public class Result
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public record NameResult(string Id, string Name);
public record AgeResult(string Id, int Age);

public class Service
{
    public async Task<IDictionary<string, Result>> ProcessAsync(
        IAsyncEnumerable<NameResult> namesSource, 
        IAsyncEnumerable<AgeResult> agesSource)
    {
        var results = new ConcurrentDictionary<string, Result>();

        async Task ConsumeNamesSource()
        {
            await foreach (NameResult nameResult in namesSource)
            {
                var result = results.GetOrAdd(nameResult.Id, _ => new Result { Name = nameResult.Name });
                result.Name = nameResult.Name;
            }
        }

        async Task ConsumeAgesSource()
        {
            await foreach (AgeResult ageResult in agesSource)
            {
                var result = results.GetOrAdd(ageResult.Id, _ => new Result { Age = ageResult.Age });
                result.Age = ageResult.Age;
            }
        }

        Task namesConsumer = ConsumeNamesSource();
        Task agesConsumer = ConsumeAgesSource();

        await namesConsumer;
        await agesConsumer;

        return results;
    }
}