C# - How to break an async/await chain when calling something that is not asynchronous

I have sometimes found myself - at the end of a long chain of using async/await - calling something that is not using async. Sometimes at the end of your call stack you have a mapper or another synchroneous operation. Here for a lack of better solution I have used Task.FromResult.

Let us say that you have a method like the below one:

public async Task<PersonDTO> MapPersonDTO(PersonEntity personEntity)
{
   return await _personMapper.Map(personEntity);
}

Often you find a mapper class (personMapper) like the above has synchroneous operations - as it is usually about moving some properties from one object to another. The class could look like something like the below:

public PersonDTO Map(PersonEntity personEntity)
{
    return new PersonDTO
    {
        Name = personEntity.Name,
        LastName = personEntity.LastName
    };
}

A simple mapping from an entity object to a DTO. However the above is not synchroneous in any way. So the two code pieces above would cause a compilation error. The only work around that I have found for this is by using Task.FromResult to wrap the returned DTO in a completed task. This is seen below:

public static async Task<PersonDTO> MapPersonDTO(PersonEntity personEntity)
{
    return await Task.FromResult(_personMapper.Map(personEntity));
}

The above code works, but it feels dirty. There is also the issue that this wraps exceptions in aggregated exceptions which you need to unwrap.

But when should the Task.FromResult method be used? MSDN states that "his method is useful when you perform an asynchronous operation that returns a Task<TResult> object, and the result of that Task<TResult> object is already computed.". So it is somewhat relevant for this scenario. There are also several people over at stack overflow who mentions some scenarios for this method.

So for now I use Task.FromResult for this. Let me know if you have a better solution :)