Automapper. Карта списка записей объединенных таблиц

Question

У меня есть хранимая процедура, которая возвращает записи объединенных таблиц.

Зависимости следующие:

class Result
{
    public int Id { get; set; }
    ...
    public IEnumerable<Request> Requests { get; set; }
    public IEnumerable<Field> Fields { get; set; }
}
class Request
{
    public int Id { get; set; }
    ...
}
class Field
{
    public int Id { get; set; }
    ...
    public Template Template { get; set; }
}
class Template
{
    public int Id { get; set; }
    ...
}

И то, что я получаю из БД, это:

result_id | ... | request_id | ... | field_id | ... | template_id | ...
----------+-----+------------+-----+----------+-----+-------------+----
1         | ... | null       | ... | 10       | ... | 100         | ...
1         | ... | null       | ... | 11       | ... | 101         | ...
2         | ... | null       | ... | 12       | ... | 102         | ...

Итак

class ProcResult
{
    public int result_id { get; set; }
    ...
    public Nullable<int> request_id { get; set; }
    ...
    public Nullable<int> field_id { get; set; }
    ...
    public Nullable<int> template_id { get; set; }
    ...
}

Я хочу знать, есть ли способ сопоставить их со списком сущностей через Automapper.

var procResults = context.Proc();
var mappedResults = mapper.Map<IEnumerable<ProcResult>, IEnumerable<Result>>(procResults);

В настоящее время я делаю это сам.

private IEnumerable<Result> Map(IEnumerable<ProcResult> procResults)
            {
                var results = new Dictionary<int, Result>();

                foreach (var record in procResults)
                {
                    Result result;

                    if (!results.TryGetValue(record.result_id, out result))
                    {
                        result = new Result
                        {
                            Id = record.result_id,
                            ...,
                            Requests = new List<Request>(),
                            Fields = new List<Field>()
                        };

                        results.Add(record.result_id, result);
                    }

                    if (record.request_id.HasValue)
                    {
                        Request request = result.Requests.FirstOrDefault(r => r.Id == record.request_id);

                        if (request is null)
                        {
                            request = new Request
                            {
                                Id = record.request_id.Value,
                                ...
                            };

                            result.Requests.Add(request);
                        }
                    }

                    if (record.field_id.HasValue)
                    {
                        Field field = result.Fields.FirstOrDefault(f => f.Id == record.field_id.Value);

                        if (field is null)
                        {
                            field = new Field
                            {
                                Id = record.field_id.Value,
                                ...
                            };

                            result.Fields.Add(field);
                        }

                        if (record.template_id.HasValue)
                        {
                            field.Template = new Template
                            {
                                Id = record.template_id.Value,
                                ...
                            };
                        }
                    }
                }

                return results.Values;
            }

Как видите, сущности Result и Request не являются уникальными и повторяются. Вот почему я использую словарь и все эти проверки.