如何在 dapper 中映射值对象

Question

我有以下实体

using MedRaise.Domain.Enums;

namespace MedRaise.Domain.Entities;

public class Appointment : Entity
{
    private Guid _clinicId;
    private DateTime _date;
    private Guid _doctorId;
    private Guid _patientId;

    public Appointment()
    {
    }

    public Appointment(Guid id, DateTime date, Guid patientId, Guid doctorId, Guid clinicId,
        AppointmentStatus appointmentStatus)
    {
        _date = date;
        _patientId = patientId;
        _doctorId = doctorId;
        _clinicId = clinicId;
        AppointmentStatus = appointmentStatus;
    }

    public DateTime Date
    {
        get => _date;
        set
        {
            _date = value;
        }
    }

    public Guid PatientId
    {
        get => _patientId;
        set
        {
            if (value == Guid.Empty) throw new ArgumentException($"The {nameof(PatientId)} is required");

            _patientId = value;
        }
    }

    public Patient? Patient { get; set; }

    public Guid DoctorId
    {
        get => _doctorId;
        set
        {
            if (value == Guid.Empty) throw new ArgumentException($"The {nameof(DoctorId)} is required");

            _doctorId = value;
        }
    }

    public Doctor? Doctor { get; set; }

    public Guid ClinicId
    {
        get => _clinicId;
        set
        {
            if (value == Guid.Empty) throw new ArgumentException($"The {nameof(ClinicId)} is required");

            _clinicId = value;
        }
    }

    public Clinic? Clinic { get; set; }
    public AppointmentStatus AppointmentStatus { get; set; }
}

还有 3 个值对象

namespace MedRaise.Domain.ValueObjects;
public class Address : ValueObject
{
    public string Country { get; set; }
    public string City { get; set; }
    public string Street { get; set; }
    public string Apartments { get; set; }
    public string PostalCode { get; set; }

    public Address() {}
    public Address(string country, string city, string street, string apartments, string postalCode)
    {
        if (string.IsNullOrWhiteSpace(country))
        {
            throw new ArgumentException("Country cannot be empty", nameof(country));
        } 
        if (string.IsNullOrWhiteSpace(city))
        {
            throw new ArgumentException("City cannot be empty", nameof(city));
        } 
        if (string.IsNullOrWhiteSpace(street))
        {
            throw new ArgumentException("Street cannot be empty", nameof(street));
        } 
        if (string.IsNullOrWhiteSpace(apartments))
        {
            throw new ArgumentException("Apartments cannot be empty", nameof(apartments));
        }
        if (string.IsNullOrWhiteSpace(postalCode))
        {
            throw new ArgumentException("Postal code cannot be empty", nameof(postalCode));
        }

        Country = country;
        City = city;
        Street = street;
        Apartments = apartments;
        PostalCode = postalCode;
    }

    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return Country;
        yield return City;
        yield return Street;
        yield return Apartments;
        yield return PostalCode;
    }
}

namespace MedRaise.Domain.ValueObjects;

public class FullName : ValueObject
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Patronymic { get; set; }

    public FullName() {}
    public FullName(string firstname, string lastname, string patronymic)
    {
        FirstName = firstname;
        LastName = lastname;
        Patronymic = patronymic;
    }
    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return FirstName;
        yield return LastName;
        yield return Patronymic;
    }
}

using MedRaise.Domain.Enums;

namespace MedRaise.Domain.ValueObjects;

public class ContactInformation : ValueObject
{
    public string? Email { get; set; }
    public string? Phone { get; set; }

    public ContactInformation() {}
    public ContactInformation(string? email, string? phone)
    {
        Email = email;
        Phone = phone;
    }
    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return Email;
        yield return Phone;
    }
}

我需要与患者进行选择预约...我有以下方法，但它不起作用，我会在患者财产中获得空字段的预约，我不明白，为什么...聊天 GPT 没有'别帮我

    public async Task<Appointment?> GetByIdWithPatientDoctorClinic(Guid id)
    {
        await using var connection = new NpgsqlConnection(connectionString);
        await connection.OpenAsync();
        const string query = """
                                 SELECT 
                                 a.*, 
                                 p.id AS PatientId, p.dob as Dob, 
                             p.address_country AS Country,
                             p.address_city AS City, 
                             p.address_street AS Street,
                             p.address_apartments AS Apartments, 
                             p.sex
                             FROM 
                                 appointments a
                             INNER JOIN 
                                 patients p ON a.patientid = p.id
                             WHERE 
                                 a.id = @Id
                             """;

        var appointments =
            await connection.QueryAsync<Appointment, Patient, Appointment>(
                query,
                (appointment, patient) =>
                {
                    appointment.Patient = patient;
                    return appointment;
                },
                new { Id = id },
                splitOn: "PatientId");

        return appointments.FirstOrDefault();
    }

我尝试自己做，但没有成功....有人可以帮我解决这个问题吗，我正在第二次与 dapper 合作

Answer 1

您忘记包含最重要类型的代码：

Patient

。没有它，没有人会告诉你出了什么问题。

除此之外，还有一些规则：

1. 如果您的类型有一个公共无参数构造函数，Dapper 将使用该构造函数，然后为属性赋值。
2. 仅当无参数构造函数不存在或不可访问（例如是私有的）时，Dapper 才会使用另一个构造函数。
3. 当 Dapper 使用非无参数构造函数时，参数的顺序和名称必须与查询中字段的顺序和名称匹配。
4. 有一个例外：如果您使用

   [ExplicitConstructor]

   属性标记构造函数之一，则规则 1-3 不适用。 Dapper 将使用该构造函数。
5. 顶级查询中允许重复的列名称（在您的情况下，无需将

   p.id

   重命名为

   PatientId

   ）。
6. 对于像

   .QueryAsync<Appointment, Patient, ...>

   这样的多重映射，Dapper 使用列名和列顺序来映射类型。

因此，要使其工作，您的类型

Patient

必须具有公共无参数构造函数和可写属性...

或者您的类型

Patient

应该有一个按顺序接受以下参数的构造函数：

patientId

（如果从查询中删除

id

，则为

AS PatientId

）、

dob

、

country

、

city

、

street 

、

apartments

和

sex

。该构造函数应标有

[ExplicitConstructor]

属性。