زمانی که از یک ORM (Object-Relational Mapper) مانند Entity Framework Core استفاده می‌کنیم، یکی از قدرتمندترین ابزارهایی که در اختیار داریم، Navigation Properties یا همان ویژگی‌های ناوبری هستند. این ویژگی‌ها به ما اجازه می‌دهند تا به جای فکر کردن به "کلیدهای خارجی" (Foreign Keys) و دستورات پیچیده SQL، با "اشیاء" (Objects) و روابط بین آن‌ها فکر کنیم.

در این مقاله، بررسی خواهیم کرد که چگونه می‌توان با استفاده از Navigation Propertyها، داده‌ها را به صورت همزمان در چندین جدول مرتبط ذخیره کرد، بدون اینکه نگران مدیریت دستی روابط باشیم.

ویژگی ناوبری (Navigation Property) چیست؟

به زبان ساده، Navigation Property خاصیتی در کلاس Entity شماست که به شما اجازه می‌دهد از یک رکورد به رکورد(های) مرتبط با آن حرکت کنید.

دو نوع کلی وجود دارد:

1. Reference Navigation Property: اشاره به یک موجودیت واحد (مثلاً Order.Customer).

2. Collection Navigation Property: اشاره به لیستی از موجودیت‌ها (مثلاً Customer.Orders).

سناریوی ۱: رابطه یک‌به‌چند (One-to-Many)

مثال: وبلاگ و پست‌ها

فرض کنید دو کلاس داریم: Blog (وبلاگ) و Post (پست). هر وبلاگ می‌تواند چندین پست داشته باشد.

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    
    // Collection Navigation Property
    public List<Post> Posts { get; set; } = new List<Post>();
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    
    public int BlogId { get; set; }
    // Reference Navigation Property
    public Blog Blog { get; set; }
}

ذخیره یک گراف کامل از داده‌ها (Insert همزمان)

قدرت اصلی Navigation Property زمانی مشخص می‌شود که می‌خواهید یک وبلاگ جدید را به همراه پست‌های اولیه آن ذخیره کنید. در روش سنتی SQL، شما باید ابتدا وبلاگ را Insert کنید، ID آن را بگیرید و سپس پست‌ها را Insert کنید. اما با ORM:

using (var context = new BloggingContext())
{
    // 1. ایجاد شیء والد
    var newBlog = new Blog
    {
        Url = "http://blogs.msdn.com/adonet",
        // 2. مقداردهی فرزندان از طریق Navigation Property
        Posts = new List<Post>
        {
            new Post { Title = "Intro to EF Core", Content = "Content 1..." },
            new Post { Title = "Working with Relationships", Content = "Content 2..." }
        }
    };

    // 3. فقط والد را به کانتکست اضافه کنید
    context.Blogs.Add(newBlog);
    
    // 4. ذخیره تغییرات
    context.SaveChanges();
}

چه اتفاقی در پشت صحنه می‌افتد؟

وقتی شما newBlog را به کانتکست اضافه می‌کنید، EF Core به صورت خودکار گراف اشیاء را پیمایش می‌کند. متوجه می‌شود که این وبلاگ دارای دو پست است که آن‌ها نیز جدید هستند. هنگام فراخوانی SaveChanges، ابزار به طور هوشمند:

1. ابتدا Blog را در دیتابیس درج می‌کند.

2. ID تولید شده برای Blog را دریافت می‌کند.

3. این ID را در فیلد BlogId پست‌ها قرار می‌دهد.

4. پست‌ها را در دیتابیس درج می‌کند.

   همه این‌ها در یک تراکنش (Transaction) واحد انجام می‌شود.

سناریوی ۲: افزودن فرزند به والد موجود

مثال: افزودن پست جدید به وبلاگی که از قبل وجود دارد

گاهی والد (Parent) از قبل در دیتابیس هست و ما فقط می‌خواهیم یک فرزند جدید (Child) را از طریق رابطه به آن اضافه کنیم.

using (var context = new BloggingContext())
{
    // 1. بازیابی وبلاگ موجود (Include کردن پست‌ها الزامی نیست مگر اینکه بخواهید با آن‌ها کار کنید)
    var blog = context.Blogs.Single(b => b.Url == "http://blogs.msdn.com/adonet");

    // 2. ساخت پست جدید
    var newPost = new Post { Title = "New Advanced Post", Content = "..." };

    // 3. افزودن به کالکشن Navigation Property
    blog.Posts.Add(newPost);

    // 4. تشخیص تغییرات توسط Change Tracker
    context.SaveChanges();
}

در اینجا، نیازی نیست صریحاً بگوییم context.Posts.Add(newPost). همین که شیء جدید را به Posts (که متعلق به یک موجودیت تحت نظر کانتکست است) اضافه کردیم، EF Core می‌فهمد که این یک رکورد جدید است که باید به دیتابیس اضافه شود و کلید خارجی آن را نیز خودکار تنظیم می‌کند.

سناریوی ۳: رابطه چندبه‌چند (Many-to-Many)

مثال: دانش‌آموزان و دوره‌های آموزشی

در نسخه‌های جدید EF Core (نسخه 5 به بعد)، مدیریت روابط چندبه‌چند بسیار ساده شده است و نیازی به تعریف کلاس واسط (Join Entity) به صورت دستی نیست (مگر اینکه جدول واسط دارای دیتای اضافه باشد).

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Course> Courses { get; set; } = new List<Course>();
}

public class Course
{
    public int Id { get; set; }
    public string Title { get; set; }
    public List<Student> Students { get; set; } = new List<Student>();
}

ذخیره رابطه جدید

فرض کنید می‌خواهیم یک دانش‌آموز جدید را در یک دوره موجود ثبت‌نام کنیم:

using (var context = new SchoolContext())
{
    // 1. یافتن دوره موجود از دیتابیس
    var existingCourse = context.Courses.Single(c => c.Title == "Math 101");

    // 2. ایجاد دانش‌آموز جدید
    var newStudent = new Student { Name = "Ali Rezaei" };

    // 3. ایجاد رابطه از طریق Navigation Property
    newStudent.Courses.Add(existingCourse);

    // 4. اضافه کردن دانش‌آموز به کانتکست
    context.Students.Add(newStudent);

    // 5. ذخیره
    context.SaveChanges();
}

نکته کلیدی: در اینجا existingCourse از قبل در دیتابیس وجود دارد و newStudent جدید است. EF Core هوشمند است؛ رکورد جدیدی برای Course ایجاد نمی‌کند، بلکه:

1. دانش‌آموز را در جدول Students ذخیره می‌کند.

2. یک رکورد در جدول واسط (Join Table) مخفی ایجاد می‌کند که ID دانش‌آموز جدید و ID دوره موجود را به هم متصل می‌کند.

مکانیسم‌های پشت صحنه (Deep Dive)

درک اینکه ORM چگونه این کار را انجام می‌دهد، برای دیباگ کردن و بهینه‌سازی حیاتی است.

1. Change Tracker (ردیاب تغییرات)

قلب تپنده EF Core، کلاسی به نام ChangeTracker است. وقتی شما context.Add(blog) را صدا می‌زنید، ردیاب تغییرات نه تنها blog را بررسی می‌کند، بلکه تمام اشیایی که از طریق Navigation Property به آن متصل هستند (Reachable objects) را پیمایش می‌کند.

• اگر شیء ID نداشته باشد (یا صفر باشد)، وضعیت آن را Added در نظر می‌گیرد.

• اگر شیء ID داشته باشد و ردیابی شده باشد، وضعیت آن ممکن است Unchanged یا Modified باشد.

2. اصلاح روابط (Relationship Fixup)

زمانی که داده‌ها را لود می‌کنید یا اضافه می‌کنید، EF Core به طور خودکار ارجاعات حافظه را اصلاح می‌کند. اگر شما post.Blog = blog را ست کنید، به صورت خودکار آن پست به لیست blog.Posts نیز اضافه می‌شود (اگر آن لیست در حافظه لود شده باشد). این ویژگی باعث یکپارچگی داده‌ها در سمت اپلیکیشن می‌شود.

3. تراکنش‌ها (Transactions)

متد SaveChanges به صورت پیش‌فرض تمام عملیات (Insert/Update/Delete) را در یک تراکنش دیتابیس می‌پیچد. این یعنی یا همه داده‌ها (والد و تمام فرزندان) ذخیره می‌شوند، یا هیچکدام. این رفتار، اصل Atomicity در پایگاه داده را تضمین می‌کند و از بروز داده‌های یتیم (Orphaned data) یا ناقص جلوگیری می‌کند.

چالش‌ها و نکات مهم

با وجود راحتی کار، بی‌توجهی به برخی نکات می‌تواند باعث باگ‌های خطرناک شود.

1. مشکل داده‌های تکراری (Duplicate Data)

یکی از رایج‌ترین اشتباهات، ساختن نمونه جدید از یک موجودیت موجود است.

اشتباه:

var blog = new Blog { BlogId = 1, Url = "..." }; // ما فکر می‌کنیم این همان بلاگ قبلی است
var post = new Post { Title = "News", Blog = blog };
context.Add(post); 
// نتیجه: EF ممکن است سعی کند بلاگ با ID=1 را دوباره Insert کند که منجر به خطا می‌شود.

راه حل: برای اتصال به موجودیت موجود، یا باید آن را از دیتابیس Fetch کنید یا از روش Attach استفاده کنید تا کانتکست بفهمد این شیء Unchanged است.

2. مدیریت نال (NullReferenceException)

همیشه مطمئن شوید که لیست‌های Navigation Property در سازنده (Constructor) کلاس، نمونه‌سازی (Initialize) شده‌اند.

// در سازنده کلاس
public Blog()
{
    Posts = new List<Post>(); // جلوگیری از خطای Null هنگام Add کردن
}

3. عملکرد (Performance)

هنگامی که فقط می‌خواهید یک فرزند اضافه کنید، نیازی نیست کل فرزندان قبلی را لود کنید.

به جای:

var blog = context.Blogs.Include(b => b.Posts).First(...); // لود کردن هزاران پست!
blog.Posts.Add(newPost);

از انتساب مستقیم کلید خارجی استفاده کنید (اگر فقط هدف Insert است):

var newPost = new Post 
{ 
    Title = "New Post", 
    BlogId = existingBlogId // استفاده مستقیم از FK بدون لود کردن والد
};
context.Posts.Add(newPost);

جدول مقایسه روش‌ها

نتیجه‌گیری

استفاده از Navigation Properties برای ذخیره داده‌ها در جداول مرتبط، فاصله بین کد شیءگرا و پایگاه داده رابطه‌ای را به حداقل می‌رساند. این روش نه تنها کد شما را تمیزتر و خواناتر می‌کند، بلکه با استفاده از مکانیسم‌های داخلی ORM مانند تراکنش‌های خودکار، یکپارچگی داده‌های شما را تضمین می‌کند.

با درک نحوه عملکرد ChangeTracker و تفاوت بین موجودیت‌های Added و Unchanged، می‌توانید پیچیده‌ترین سناریوهای ذخیره‌سازی داده (مانند فرم‌های تو‌در‌تو، سبدهای خرید، و ثبت‌نام‌ها) را با چند خط کد ساده مدیریت کنید.