‫Domain-Driven Design (DDD)؛ بخش دهم: DDD با EF Core؛ قسمت دوم

public class Order
{
    public int Id { get; set; }
    public decimal TotalAmount { get; set; }
    public List<OrderItem> Items { get; set; } = new();

    public Order() { }
}

• هیچ منطق خاصی درون آن وجود ندارد.
• تمام اعضا public set دارند.
• هر کسی از بیرون می‌تواند TotalAmount یا حتی Items را دستکاری کند.

• به جای این‌که همه‌چیز public باشد، مقادیر حساس را پشت فیلدهای خصوصی نگه می‌داریم.
• EF-Core همچنان می‌تواند داده‌ها را از پایگاه داده بارگذاری کند، ولی از بیرون کسی به سادگی به آن‌ها دسترسی ندارد.

public class Order
{
    private readonly List<OrderItem> _items = new();
    private decimal _totalAmount;

    public int Id { get; private set; }

    // فقط خواندنی برای بیرون
    public IReadOnlyCollection<OrderItem> Items => _items.AsReadOnly();
    public decimal TotalAmount => _totalAmount;

    // سازنده برای ایجاد موجودیت معتبر
    public Order(IEnumerable<OrderItem> items)
    {
        if (items == null || !items.Any())
            throw new InvalidOperationException("سفارش نمی‌تواند بدون آیتم باشد.");

        _items.AddRange(items);
        _totalAmount = _items.Sum(i => i.Price * i.Quantity);
    }

    // منطق دامنه برای افزودن آیتم
    public void AddItem(OrderItem item)
    {
        if (item == null) throw new ArgumentNullException(nameof(item));

        _items.Add(item);
        _totalAmount += item.Price * item.Quantity;
    }
}

• اطلاعات حساس محافظت شده‌اند
• دیگر کسی نمی‌تواند TotalAmount را مستقیم تغییر دهد.
• تنها راه تغییر آن، عبور از متدهای دامنه است.
• معنا و قوانین درون موجودیت آمده‌اند
• «سفارش بدون آیتم» دیگر غیرممکن است.
• هر افزودن آیتم، به‌طور خودکار مبلغ کل را به‌روزرسانی می‌کند.
• EF-Core همچنان پشتیبانی می‌کند
• EF-Core می‌تواند از طریق Field-only Mapping به فیلدهای خصوصی دسترسی داشته باشد.

modelBuilder.Entity<Order>()
    .Property<decimal>("_totalAmount") // field-only property
    .HasColumnName("TotalAmount");

modelBuilder.Entity<Order>()
    .Navigation(o => o.Items)
    .UsePropertyAccessMode(PropertyAccessMode.Field);

• مدل آنمیک: موجودیتی شبیه یک DTO، ساده اما آسیب‌پذیر.
• مدل غنی: موجودیتی که قوانین دامنه را در خود جای داده است.
• Field-only Properties در EF-Core به ما اجازه می‌دهد همین غنای دامنه را پیاده کنیم، بدون این‌که EF-Core دچار مشکل شود.

using Xunit;

public class OrderTests
{
    [Fact]
    public void Cannot_Create_Order_Without_Items()
    {
        // Arrange
        var emptyItems = new List<OrderItem>();

        // Act & Assert
        Assert.Throws<InvalidOperationException>(() => new Order(emptyItems));
    }

    [Fact]
    public void Creating_Order_Should_Calculate_TotalAmount()
    {
        // Arrange
        var items = new List<OrderItem>
        {
            new OrderItem("Book", 2, 50m),
            new OrderItem("Pen", 5, 10m)
        };

        // Act
        var order = new Order(items);

        // Assert
        Assert.Equal(2 * 50m + 5 * 10m, order.TotalAmount);
    }

    [Fact]
    public void Adding_Item_Should_Update_TotalAmount()
    {
        // Arrange
        var order = new Order(new List<OrderItem>
        {
            new OrderItem("Notebook", 1, 100m)
        });

        var newItem = new OrderItem("Eraser", 3, 5m);

        // Act
        order.AddItem(newItem);

        // Assert
        Assert.Equal(100m + (3 * 5m), order.TotalAmount);
        Assert.Contains(order.Items, i => i.Name == "Eraser");
    }
}

public class OrderItem
{
    public string Name { get; }
    public int Quantity { get; }
    public decimal Price { get; }

    public OrderItem(string name, int quantity, decimal price)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("نام آیتم نمی‌تواند خالی باشد.");

        if (quantity <= 0)
            throw new ArgumentException("تعداد باید بیشتر از صفر باشد.");

        if (price <= 0)
            throw new ArgumentException("قیمت باید بیشتر از صفر باشد.");

        Name = name;
        Quantity = quantity;
        Price = price;
    }
}

• تست اول: نشان می‌دهد که سفارش بدون آیتم ممنوع است.
• تست دوم: نشان می‌دهد که مبلغ کل در زمان ساخت به‌طور خودکار محاسبه می‌شود.
• تست سوم: نشان می‌دهد که هر افزودن آیتم، قوانین دامنه را فعال می‌کند (یعنی فقط از طریق متد AddItem می‌توان مقدار کل را تغییر داد).

• دیگر مثل مدل آنمیک نمی‌شود با set کردن پراپرتی‌ها همه‌چیز را دور زد.
• تست‌ها به‌وضوح نشان می‌دهند که قوانین دامنه در خود مدل نهادینه شده‌اند.

• پیکربندی EF-Core با Field-only Properties
• استفاده از دیتابیس InMemory برای تست انتها‌به‌انتها (Integration Test)

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> builder)
    {
        builder.ToTable("Orders");

        builder.HasKey(o => o.Id);

        // Mapping به فیلد خصوصی
        builder.Property<decimal>("_totalAmount")
               .HasColumnName("TotalAmount");

        // تنظیم رفتار دسترسی به مجموعه آیتم‌ها
        builder.Metadata
               .FindNavigation(nameof(Order.Items))!
               .SetPropertyAccessMode(PropertyAccessMode.Field);

        // رابطه یک به چند با OrderItem
        builder.HasMany<OrderItem>()
               .WithOne()
               .HasForeignKey("OrderId");
    }
}

using Microsoft.EntityFrameworkCore;

public class OrderingContext : DbContext
{
    public OrderingContext(DbContextOptions<OrderingContext> options)
        : base(options) { }

    public DbSet<Order> Orders { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.ApplyConfiguration(new OrderConfiguration());

        modelBuilder.Entity<OrderItem>(builder =>
        {
            builder.ToTable("OrderItems");
            builder.HasKey(i => i.Id);

            builder.Property(i => i.Name).IsRequired();
            builder.Property(i => i.Quantity).IsRequired();
            builder.Property(i => i.Price).IsRequired();
        });
    }
}

public class OrderItem
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public int Quantity { get; private set; }
    public decimal Price { get; private set; }

    private OrderItem() { } // برای EF-Core

    public OrderItem(string name, int quantity, decimal price)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("نام آیتم نمی‌تواند خالی باشد.");

        if (quantity <= 0)
            throw new ArgumentException("تعداد باید بیشتر از صفر باشد.");

        if (price <= 0)
            throw new ArgumentException("قیمت باید بیشتر از صفر باشد.");

        Name = name;
        Quantity = quantity;
        Price = price;
    }
}

using Microsoft.EntityFrameworkCore;
using Xunit;

public class OrderIntegrationTests
{
    private OrderingContext CreateContext()
    {
        var options = new DbContextOptionsBuilder<OrderingContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString())
            .Options;

        return new OrderingContext(options);
    }

    [Fact]
    public void Can_Save_And_Load_Order_With_Items()
    {
        using (var context = CreateContext())
        {
            // Arrange
            var order = new Order(new List<OrderItem>
            {
                new OrderItem("Book", 2, 50m),
                new OrderItem("Pen", 5, 10m)
            });

            context.Orders.Add(order);
            context.SaveChanges();
        }

        using (var context = CreateContext())
        {
            // Act
            var order = context.Orders
                               .Include(o => o.Items)
                               .First();

            // Assert
            Assert.Equal(2 * 50m + 5 * 10m, order.TotalAmount);
            Assert.Equal(2, order.Items.Count);
        }
    }
}

• Field-only Properties در EF-Core واقعاً کار می‌کنند؛ TotalAmount در جدول ذخیره شد، بدون این‌که set عمومی داشته باشد.
• مجموعه آیتم‌ها با PropertyAccessMode.Field به فیلد خصوصی _items نگاشت شد.
• تست InMemory نشان داد که قوانین دامنه، حتی بعد از ذخیره و بازیابی از دیتابیس، پابرجا می‌مانند.

public string Name { get; private set; }

• کد ساده‌تر و خواناتر است.
• EF-Core بدون پیکربندی خاصی به‌راحتی آن‌ها را نگاشت می‌کند.
• برای بیشتر سناریوهای روزمره (مثل Name, Email, CreatedAt) کفایت می‌کند.

• همچنان از بیرون قابل دسترسی خواندن هستند.
• اگر یک Property مجموعه‌ای (Collection) باشد، حتی با private set، خود لیست قابل دستکاری است:

public List<OrderItem> Items { get; private set; } = new();
// بیرون می‌تواند Items.Add(...) کند، بدون اینکه قوانین دامنه اجرا شود

private readonly List<OrderItem> _items = new();
private decimal _totalAmount;

public IReadOnlyCollection<OrderItem> Items => _items.AsReadOnly();
public decimal TotalAmount => _totalAmount;

• دسترسی بیرونی کاملاً کنترل‌شده است.
• EF-Core می‌تواند مقداردهی و نگاشت را به فیلد انجام دهد.
• برای سناریوهایی که قوانین دامنه حساس‌اند (مثل محاسبه‌ی مبلغ کل سفارش، یا مدیریت وضعیت‌ها) بسیار مفید است.

• نیازمند پیکربندی بیشتر در EF-Core (PropertyAccessMode.Field).
• کد کمی پیچیده‌تر و پرجزئیات‌تر می‌شود.
• برای ویژگی‌های ساده ممکن است استفاده از آن بیش‌ازحد مهندسی (Overengineering) باشد.

• ویژگی‌های ساده و بدون منطق خاص (نام، کد ملی، تاریخ ایجاد)
• ➝ private set کافی است.
• ویژگی‌های مشتق‌شده یا محاسباتی که نباید بیرون دستی تغییر کنند (مثل TotalAmount)
• ➝ Field-only بهتر است.
• مجموعه‌ها (Collections)
• ➝ تقریباً همیشه Field-only (چون اگر List یا HashSet را مستقیم بیرون بدهی، قوانین دامنه دور زده می‌شوند).
• موجودیت‌هایی که قوانین پیچیده یا Invariantهای حساس دارند
• ➝ Field-only توصیه می‌شود.

• اگر فقط می‌خواهی یک پنجره شیشه‌ای داشته باشی که بیرون بتواند داخل را ببیند اما نه دستکاری کند → private set.
• اگر می‌خواهی پرده‌های کنترلی داشته باشی که فقط بخش‌هایی از داخل دیده شوند و فقط خودت تصمیم بگیری چه چیزی قابل تغییر باشد → Field-only.