آموزش دسترسی به داده‌ها در .NET

در آموزش .NET، یکی از مهم‌ترین مباحثی که توسعه‌دهندگان با آن سروکار دارند، دسترسی به داده‌ها در .NET است. این موضوع به شما امکان می‌دهد تا با پایگاه‌های داده تعامل داشته باشید، اطلاعات را ذخیره کنید، بازیابی کنید و مدیریت کنید. چه بخواهید یک برنامه ساده بسازید یا یک سیستم پیچیده سازمانی، دانستن نحوه کار با داده‌ها امری ضروری است. در این مقاله، ما از مفاهیم ابتدایی شروع می‌کنیم و به تدریج به مباحث پیشرفته‌تر می‌پردازیم. هدف این است که با زبانی ساده و قابل فهم، شما را با ابزارها و تکنیک‌های دسترسی به داده‌ها در .NET آشنا کنیم. در ادامه، به معرفی ابزارهای مدرن مانند Entity Framework Core، نحوه پیکربندی مدل‌ها، عملیات CRUD و اتصال به پایگاه‌های داده مختلف خواهیم پرداخت.

معرفی Entity Framework Core

Entity Framework Core یا به اختصار EF Core، نسخه‌ای مدرن، سبک و انعطاف‌پذیر از فریم‌ورک محبوب Entity Framework است که توسط مایکروسافت برای اکوسیستم .NET توسعه داده شده است. این ابزار به عنوان یک ORM (مخفف Object-Relational Mapping یا نگاشت شیء-رابطه‌ای) عمل می‌کند و به توسعه‌دهندگان این امکان را می‌دهد که به جای درگیر شدن با پیچیدگی‌های دستورات SQL و مدیریت مستقیم پایگاه داده، با استفاده از کلاس‌ها و اشیاء آشنا در زبان برنامه‌نویسی C# با داده‌ها تعامل داشته باشند. به عبارت ساده‌تر، EF Core مانند یک مترجم هوشمند عمل می‌کند که داده‌های ذخیره‌شده در جداول پایگاه داده را به اشیاء قابل استفاده در کد شما تبدیل می‌کند و برعکس.

EF Core به‌گونه‌ای طراحی شده که با نیازهای امروزی توسعه‌دهندگان همگام باشد. این فریم‌ورک نه تنها عملکرد بالایی ارائه می‌دهد، بلکه با پشتیبانی از معماری‌های مدرن و پلتفرم‌های مختلف، به ابزاری کلیدی برای پروژه‌های کوچک و بزرگ تبدیل شده است.

چرا EF Core؟

استفاده از EF Core مزایای متعددی دارد که آن را از سایر روش‌های دسترسی به داده متمایز می‌کند:

ساده‌سازی کدها و افزایش خوانایی: به جای نوشتن کوئری‌های پیچیده و طولانی SQL که گاهی نگهداری و دیباگ کردن آن‌ها دشوار است، EF Core به شما اجازه می‌دهد از LINQ (Language Integrated Query) استفاده کنید. LINQ یک زبان پرس‌وجوی قدرتمند و یکپارچه در C# است که با синтакس آشنا و شیءگرا، کار با داده‌ها را بسیار ساده‌تر می‌کند.
پشتیبانی چندپلتفرمی: EF Core به صورت کاملاً Cross-Platform طراحی شده است. این یعنی شما می‌توانید برنامه‌های خود را روی سیستم‌عامل‌های مختلف مثل ویندوز، لینوکس و مک توسعه داده و اجرا کنید، بدون اینکه نگران سازگاری باشید.
پشتیبانی از پایگاه‌های داده متنوع: یکی از نقاط قوت EF Core این است که با انواع پایگاه‌های داده کار می‌کند؛ از SQL Server مایکروسافت گرفته تا گزینه‌های متن‌باز مثل PostgreSQL، MySQL، SQLite و حتی پایگاه‌های داده ابری مانند Azure Cosmos DB. این انعطاف‌پذیری به شما اجازه می‌دهد که بسته به نیاز پروژه‌تان، بهترین گزینه را انتخاب کنید.
مدیریت آسان مدل‌ها و مهاجرت‌ها (Migrations): EF Core ابزارهایی برای تعریف مدل‌های داده به صورت کد (Code-First) یا استفاده از پایگاه داده موجود (Database-First) ارائه می‌دهد. همچنین با قابلیت Migrations، به‌روزرسانی ساختار پایگاه داده با تغییرات مدل‌ها بسیار ساده و خودکار انجام می‌شود.
بهینه‌سازی عملکرد: EF Core با قابلیت‌هایی مثل بارگذاری تنبل (Lazy Loading)، ردیابی تغییرات (Change Tracking) و کش (Caching)، به شما کمک می‌کند تا عملکرد برنامه‌تان را بهینه کنید.

مثال ساده و کاربردی

برای درک بهتر، فرض کنید یک جدول به نام “کاربران” در پایگاه داده دارید که شامل ستون‌های Id (شناسه) و Name (نام) است. با EF Core می‌توانید به سادگی یک کلاس در C# تعریف کنید که نمایانگر این جدول باشد:

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

سپس، با استفاده از یک DbContext (کلاسی که ارتباط بین کد و پایگاه داده را مدیریت می‌کند)، می‌توانید بدون نوشتن حتی یک خط SQL، داده‌ها را بخوانید یا ویرایش کنید:

using (var context = new MyDbContext())
{
    var users = context.Users.Where(u => u.Name == "علی").ToList();
    foreach (var user in users)
    {
        Console.WriteLine($"شناسه: {user.Id}، نام: {user.Name}");
    }
}

در این کد، به جای کوئری SQL مثل SELECT * FROM Users WHERE Name = ‘علی’، از LINQ استفاده شده که هم خواناتر است و هم با ابزارهای توسعه مثل IntelliSense سازگار است.

رویکردهای مختلف در EF Core

EF Core از دو رویکرد اصلی پشتیبانی می‌کند:

Code-First: ابتدا مدل‌ها را در کد تعریف می‌کنید و سپس EF Core پایگاه داده و جداول را بر اساس آن‌ها می‌سازد.
Database-First: اگر پایگاه داده‌ای از قبل دارید، می‌توانید مدل‌ها را از روی آن تولید کنید.
این انعطاف‌پذیری باعث می‌شود که EF Core برای پروژه‌های جدید یا پروژه‌هایی با زیرساخت موجود، گزینه‌ای ایده‌آل باشد.
در یک کلام، EF Core ابزاری است که پیچیدگی کار با پایگاه داده را به حداقل می‌رساند و به توسعه‌دهندگان اجازه می‌دهد روی منطق برنامه تمرکز کنند، نه روی جزئیات فنی دسترسی به داده‌ها. در بخش‌های بعدی، با جزئیات بیشتری به نحوه پیکربندی، استفاده از DbContext، کار با مهاجرت‌ها و بهینه‌سازی کوئری‌ها در EF Core خواهیم پرداخت.

ایجاد و پیکربندی مدل‌های داده‌ای

در Entity Framework Core (EF Core)، مدل‌های داده‌ای اساس کار شما برای تعامل با پایگاه داده هستند. این مدل‌ها در واقع کلاس‌هایی در زبان C# هستند که به طور مستقیم نمایانگر ساختار جداول پایگاه داده‌اند. هر کلاس معمولاً به یک جدول و هر پراپرتی درون آن به یک ستون در آن جدول نگاشت می‌شود. برای ایجاد و پیکربندی این مدل‌ها، EF Core دو رویکرد اصلی ارائه می‌دهد: Code-First و Database-First. در ادامه هر دو روش را با جزئیات بیشتری بررسی کرده و نحوه پیکربندی آن‌ها را توضیح می‌دهم.

روش Code-First: از کد به پایگاه داده

در رویکرد Code-First، شما به عنوان توسعه‌دهنده ابتدا مدل‌های خود را به صورت کلاس‌های C# تعریف می‌کنید و سپس EF Core بر اساس این مدل‌ها، پایگاه داده و جداول مورد نیاز را به صورت خودکار ایجاد می‌کند. این روش برای پروژه‌های جدید یا زمانی که می‌خواهید کنترل کاملی روی ساختار داده‌ها داشته باشید، بسیار مناسب است.

تعریف مدل‌ها

فرض کنید یک سیستم وبلاگ‌نویسی ساده دارید که شامل وبلاگ‌ها (Blogs) و پست‌ها (Posts) است. مدل‌ها به شکل زیر تعریف می‌شوند:

public class Blog
{
    public int BlogId { get; set; }      // کلید اصلی (Primary Key)
    public string Title { get; set; }    // عنوان وبلاگ
    public List<Post> Posts { get; set; } // رابطه یک‌به‌چند با پست‌ها
}

public class Post
{
    public int PostId { get; set; }      // کلید اصلی
    public string Content { get; set; }  // محتوای پست
    public int BlogId { get; set; }      // کلید خارجی (Foreign Key)
    public Blog Blog { get; set; }       // رابطه ناوبری به وبلاگ
}

در اینجا:

BlogId و PostId به عنوان کلیدهای اصلی (Primary Keys) عمل می‌کنند.
Posts در کلاس Blog یک لیست است که رابطه یک‌به‌چند را نشان می‌دهد (یک وبلاگ می‌تواند چندین پست داشته باشد).
BlogId در کلاس Post یک کلید خارجی است که به وبلاگ مرتبط اشاره می‌کند.

ایجاد DbContext

بعد از تعریف مدل‌ها، باید یک کلاس به نام DbContext بسازید که نقش رابط بین کد شما و پایگاه داده را بازی می‌کند. این کلاس مشخص می‌کند که کدام مدل‌ها در پایگاه داده حضور دارند و چگونه به آن متصل شویم:

using Microsoft.EntityFrameworkCore;

public class BlogContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }  // مجموعه‌ای از وبلاگ‌ها
    public DbSet<Post> Posts { get; set; }  // مجموعه‌ای از پست‌ها

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // تنظیم اتصال به پایگاه داده (مثلاً SQL Server)
        optionsBuilder.UseSqlServer("Server=.;Database=BlogDb;Trusted_Connection=True;TrustServerCertificate=True;");
    }
}

DbSet<TEntity>: هر DbSet نمایانگر یک جدول در پایگاه داده است و به EF Core می‌گوید که این کلاس‌ها باید نگاشت شوند.
OnConfiguring: این متد مشخص می‌کند که از چه نوع پایگاه داده‌ای (مثلاً SQL Server) استفاده می‌کنیم و چگونه به آن متصل شویم (رشته اتصال یا Connection String).

ایجاد پایگاه داده

پس از تعریف مدل‌ها و DbContext، می‌توانید با ابزار Migrations پایگاه داده را بسازید. کافی است در کنسول مدیریت بسته‌ها (Package Manager Console) دستورات زیر را اجرا کنید:

Add-Migration InitialCreate (ایجاد یک مهاجرت اولیه)
Update-Database (اعمال مهاجرت و ساخت پایگاه داده)
EF Core به طور خودکار جداول Blogs و Posts را با روابط مناسب ایجاد می‌کند.

روش Database-First: از پایگاه داده به کد

اگر پایگاه داده‌ای از قبل دارید (مثلاً توسط یک تیم دیگر یا در یک پروژه قدیمی ساخته شده)، می‌توانید از رویکرد Database-First استفاده کنید. در این روش، EF Core مدل‌ها و کلاس DbContext را بر اساس ساختار پایگاه داده موجود تولید می‌کند.

تولید مدل‌ها با ابزار Scaffold-DbContext

برای این کار، از دستور زیر در کنسول مدیریت بسته‌ها استفاده می‌کنید:

Scaffold-DbContext "Server=.;Database=BlogDb;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

پارامتر اول: رشته اتصال به پایگاه داده.
پارامتر دوم: ارائه‌دهنده پایگاه داده (مثلاً SQL Server).
OutputDir: پوشه‌ای که مدل‌ها و DbContext در آن تولید می‌شوند.
بعد از اجرای این دستور، EF Core کلاس‌هایی مثل Blog و Post و همچنین یک BlogContext را به صورت خودکار ایجاد می‌کند. این مدل‌ها دقیقاً با ساختار جداول پایگاه داده هم‌راستا خواهند بود.

پیکربندی دقیق‌تر مدل‌ها

گاهی نیاز دارید که روابط، محدودیت‌ها یا تنظیمات خاصی را به صورت دستی مشخص کنید. EF Core دو ابزار اصلی برای این کار ارائه می‌دهد: Data Annotations و Fluent API.

1. Data Annotations

با استفاده از Attributeها می‌توانید تنظیمات را مستقیماً در کلاس‌ها اعمال کنید:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

public class Blog
{
    [Key]                         // مشخص کردن کلید اصلی
    public int BlogId { get; set; }
    
    [Required]                    // اجباری بودن فیلد
    [MaxLength(100)]             // حداکثر طول 100 کاراکتر
    public string Title { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Content { get; set; }
    
    [ForeignKey("Blog")]         // مشخص کردن کلید خارجی
    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

2. Fluent API

برای کنترل بیشتر، می‌توانید از متد OnModelCreating در DbContext استفاده کنید:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(b => b.Posts)          // رابطه یک‌به‌چند
        .WithOne(p => p.Blog)           // طرف مقابل رابطه
        .HasForeignKey(p => p.BlogId);  // کلید خارجی

    modelBuilder.Entity<Blog>()
        .Property(b => b.Title)
        .IsRequired()                   // اجباری بودن
        .HasMaxLength(100);            // حداکثر طول
}

Fluent API انعطاف‌پذیری بیشتری دارد و برای تنظیمات پیچیده‌تر توصیه می‌شود.

نکات تکمیلی

کنوانسیون‌ها (Conventions): EF Core به صورت پیش‌فرض از نام‌گذاری‌های استاندارد پشتیبانی می‌کند (مثلاً تشخیص Id یا EntityId به عنوان کلید اصلی).
روابط: می‌توانید روابط یک‌به‌یک، یک‌به‌چند و چندبه‌چند را با ترکیب پراپرتی‌های ناوبری و کلیدهای خارجی تعریف کنید.
انعطاف‌پذیری: هر دو روش Code-First و Database-First قابل ترکیب هستند؛ مثلاً می‌توانید از Database-First شروع کنید و سپس با Code-First تغییرات را اعمال کنید.

ایجاد و پیکربندی مدل‌های داده‌ای در EF Core، چه با رویکرد Code-First و چه Database-First، فرآیندی ساده و قدرتمند است که به شما اجازه می‌دهد ساختار داده‌ها را به شکلی منسجم و متناسب با نیاز پروژه‌تان تعریف کنید. با استفاده از ابزارهایی مثل Data Annotations و Fluent API، می‌توانید این مدل‌ها را تا حد زیادی سفارشی‌سازی کنید. در بخش‌های بعدی، به کار با داده‌ها (مثل درج، به‌روزرسانی و حذف) و بهینه‌سازی عملکرد خواهیم پرداخت.

انجام عملیات CRUD

در Entity Framework Core (EF Core)، عملیات CRUD (مخفف Create، Read، Update، Delete) قلب تعامل با داده‌ها هستند. این عملیات به شما امکان می‌دهند که داده‌ها را در پایگاه داده ایجاد، بازیابی، به‌روزرسانی یا حذف کنید. EF Core این فرآیندها را با استفاده از مدل‌های شیءگرا و متدهای ساده‌ای که نیاز به نوشتن کوئری‌های SQL پیچیده را از بین می‌برند، بسیار آسان کرده است. در ادامه هر یک از این عملیات را به طور مفصل بررسی می‌کنیم و نکات کلیدی را توضیح می‌دهم.

1. Create (ایجاد)

عملیات Create برای افزودن رکوردهای جدید به پایگاه داده استفاده می‌شود. در EF Core، شما یک نمونه از کلاس مدل خود می‌سازید، آن را به DbContext اضافه می‌کنید و سپس تغییرات را ذخیره می‌کنید.

مثال ساده:

using (var context = new BlogContext())
{
    var blog = new Blog { Title = "آموزش .NET" }; // ایجاد یک شیء جدید
    context.Blogs.Add(blog);                      // افزودن به مجموعه Blogs
    context.SaveChanges();                        // اعمال تغییرات در پایگاه داده
}

توضیحات:
new Blog: یک شیء جدید از کلاس Blog ایجاد می‌شود و پراپرتی Title مقداردهی می‌شود. پراپرتی BlogId (کلید اصلی) به صورت خودکار توسط پایگاه داده تولید می‌شود (اگر Auto-Increment باشد).
Add: این متد، شیء را به وضعیت Added در ردیابی تغییرات EF Core اضافه می‌کند.
SaveChanges: تغییرات ردیابی‌شده (در اینجا افزودن رکورد) به پایگاه داده اعمال می‌شود و یک کوئری INSERT در پشت صحنه اجرا می‌شود.

افزودن با روابط:

اگر بخواهید یک وبلاگ همراه با پست‌هایش اضافه کنید:

using (var context = new BlogContext())
{
    var blog = new Blog 
    { 
        Title = "آموزش .NET",
        Posts = new List<Post> 
        { 
            new Post { Content = "مقدمه‌ای بر EF Core" },
            new Post { Content = "کار با مهاجرت‌ها" }
        }
    };
    context.Blogs.Add(blog);
    context.SaveChanges();
}

در این حالت، EF Core به طور خودکار کلید خارجی (BlogId) را برای پست‌ها تنظیم می‌کند.

2. Read (خواندن)

عملیات Read برای بازیابی داده‌ها از پایگاه داده است. EF Core این کار را با استفاده از LINQ به شکلی ساده و انعطاف‌پذیر انجام می‌دهد.

مثال ساده:

using (var context = new BlogContext())
{
    var blogs = context.Blogs.ToList(); // دریافت همه وبلاگ‌ها
    foreach (var blog in blogs)
    {
        Console.WriteLine(blog.Title);
    }
}

فیلتر کردن داده‌ها:

برای جستجوی خاص‌تر:

using (var context = new BlogContext())
{
    var specificBlog = context.Blogs
        .Where(b => b.Title.Contains("NET"))
        .FirstOrDefault(); // اولین وبلاگی که شامل "NET" باشد
    if (specificBlog != null)
    {
        Console.WriteLine(specificBlog.Title);
    }
}

بازیابی با روابط:
برای بارگذاری داده‌های مرتبط (مثلاً پست‌های یک وبلاگ):

using (var context = new BlogContext())
{
    var blogWithPosts = context.Blogs
        .Include(b => b.Posts) // بارگذاری پست‌ها همراه وبلاگ
        .First(b => b.BlogId == 1);
    foreach (var post in blogWithPosts.Posts)
    {
        Console.WriteLine(post.Content);
    }
}

Include: برای بارگذاری تنبل (Eager Loading) داده‌های مرتبط استفاده می‌شود.

نکات:

متدهای مثل Find، First، Single و ToList برای سناریوهای مختلف قابل استفاده‌اند.
برای عملکرد بهتر، از پروجکشن (Projection) با Select استفاده کنید تا فقط ستون‌های مورد نیاز را بارگذاری کنید:

var titles = context.Blogs.Select(b => b.Title).ToList();

3. Update (به‌روزرسانی)

عملیات Update برای ویرایش داده‌های موجود است. ابتدا رکورد مورد نظر را پیدا می‌کنید، تغییرات را اعمال می‌کنید و سپس آن‌ها را ذخیره می‌کنید.

مثال ساده:

using (var context = new BlogContext())
{
    var blog = context.Blogs.First(b => b.BlogId == 1); // پیدا کردن رکورد
    blog.Title = "آموزش پیشرفته .NET";                 // تغییر مقدار
    context.SaveChanges();                              // ذخیره تغییرات
}

توضیحات:
EF Core به طور خودکار تغییرات اعمال‌شده به اشیاء ردیابی‌شده را تشخیص می‌دهد.
SaveChanges: یک کوئری UPDATE برای به‌روزرسانی رکورد در پایگاه داده اجرا می‌کند.

به‌روزرسانی بدون بارگذاری کامل:

اگر فقط می‌خواهید یک مقدار خاص را تغییر دهید بدون بارگذاری کل شیء:

using (var context = new BlogContext())
{
    var blog = new Blog { BlogId = 1, Title = "آموزش جدید" };
    context.Entry(blog).State = EntityState.Modified; // مشخص کردن حالت تغییر
    context.SaveChanges();
}

این روش زمانی مفید است که شناسه رکورد را از قبل می‌دانید و نیازی به بارگذاری داده‌ها ندارید.

4. Delete (حذف)

عملیات Delete برای حذف رکوردهای موجود استفاده می‌شود. مشابه به‌روزرسانی، ابتدا رکورد را پیدا کرده و سپس آن را حذف می‌کنید.

مثال ساده:

using (var context = new BlogContext())
{
    var blog = context.Blogs.First(b => b.BlogId == 1); // پیدا کردن رکورد
    context.Blogs.Remove(blog);                         // حذف از مجموعه
    context.SaveChanges();                              // اعمال تغییرات
}

حذف بدون بارگذاری:
اگر فقط شناسه را دارید:

using (var context = new BlogContext())
{
    var blog = new Blog { BlogId = 1 };
    context.Entry(blog).State = EntityState.Deleted; // مشخص کردن حالت حذف
    context.SaveChanges();
}

نکات:
اگر رکوردی با روابط (مثلاً پست‌ها) را حذف کنید، باید مطمئن شوید که پایگاه داده یا مدل‌ها برای حذف آبشاری (Cascade Delete) پیکربندی شده‌اند، وگرنه خطا دریافت می‌کنید.

نکات کلیدی در عملیات CRUD

SaveChanges و ردیابی تغییرات: این متد تغییرات را به پایگاه داده اعمال می‌کند. EF Core به صورت خودکار وضعیت اشیاء (Added، Modified، Deleted) را ردیابی می‌کند.
تراکنش‌ها: اگر چندین عملیات را با هم انجام می‌دهید، می‌توانید از تراکنش استفاده کنید:

using (var context = new BlogContext())
{
    using (var transaction = context.Database.BeginTransaction())
    {
        context.Blogs.Add(new Blog { Title = "وبلاگ 1" });
        context.Blogs.Add(new Blog { Title = "وبلاگ 2" });
        context.SaveChanges();
        transaction.Commit();
    }
}

عملکرد: برای عملیات سنگین، از AddRange، RemoveRange یا اجرای مستقیم SQL با ExecuteSqlRaw استفاده کنید.
مدیریت منابع: همیشه DbContext را در بلوک using قرار دهید تا منابع به درستی آزاد شوند.

عملیات CRUD در EF Core با استفاده از مدل‌های شیءگرا و متدهای ساده، فرآیندی روان و کارآمد است. این ابزار نه تنها کدنویسی را ساده‌تر می‌کند، بلکه با قابلیت‌هایی مثل LINQ، ردیابی تغییرات و پشتیبانی از روابط، انعطاف‌پذیری بالایی ارائه می‌دهد.

اتصال به پایگاه‌های داده مختلف

یکی از بزرگ‌ترین مزایای Entity Framework Core (EF Core)، توانایی آن در پشتیبانی از طیف گسترده‌ای از پایگاه‌های داده است. این انعطاف‌پذیری به توسعه‌دهندگان اجازه می‌دهد که بسته به نیاز پروژه—چه یک برنامه کوچک محلی باشد و چه یک سیستم توزیع‌شده بزرگ—پایگاه داده مناسب را انتخاب کنند. EF Core این امکان را با استفاده از Providerها (ارائه‌دهندگان) فراهم می‌کند که به عنوان واسطه‌ای بین فریم‌ورک و پایگاه داده عمل می‌کنند. در ادامه، نحوه اتصال به برخی از پایگاه‌های داده محبوب را بررسی می‌کنیم و نکات کلیدی را توضیح می‌دهم.

1. SQL Server

Microsoft SQL Server یکی از پرکاربردترین پایگاه‌های داده برای پروژه‌های .NET است و EF Core به صورت پیش‌فرض از آن پشتیبانی می‌کند.

تنظیمات اتصال:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseSqlServer("Server=.;Database=MyDb;Trusted_Connection=True;TrustServerCertificate=True;");
}

توضیحات:
رشته اتصال (Connection String):
Server=. : به سرور محلی اشاره دارد (می‌توانید آدرس IP یا نام سرور را جایگزین کنید).
Database=MyDb : نام پایگاه داده‌ای که می‌خواهید به آن متصل شوید.
Trusted_Connection=True : از احراز هویت ویندوزی استفاده می‌کند (بدون نیاز به نام کاربری و رمز عبور).
TrustServerCertificate=True : برای دور زدن خطاهای مربوط به گواهی SSL در محیط‌های تست یا محلی.
پکیج مورد نیاز: پکیج Microsoft.EntityFrameworkCore.SqlServer باید از NuGet نصب شود.
کاربرد: مناسب برای پروژه‌های سازمانی، برنامه‌های ویندوزی یا سرویس‌های ابری مثل Azure SQL.

2. SQLite

SQLite یک پایگاه داده سبک و بدون سرور است که برای برنامه‌های کوچک، تست یا پروژه‌های محلی بسیار مناسب است.

تنظیمات اتصال:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseSqlite("Data Source=mydb.db");
}

توضیحات:
رشته اتصال:
Data Source=mydb.db : مسیر فایل پایگاه داده را مشخص می‌کند (می‌تواند نسبی یا مطلق باشد).
پکیج مورد نیاز: پکیج Microsoft.EntityFrameworkCore.Sqlite باید نصب شود.
مزایا: نیازی به نصب سرور جداگانه ندارد و فایل پایگاه داده به راحتی قابل انتقال است.
کاربرد: ایده‌آل برای برنامه‌های موبایل، دسکتاپ یا تست واحد (Unit Testing).

3. PostgreSQL

PostgreSQL یک پایگاه داده متن‌باز و قدرتمند است که به دلیل عملکرد بالا و قابلیت‌های پیشرفته، طرفداران زیادی دارد.

تنظیمات اتصال:
ابتدا پکیج Npgsql.EntityFrameworkCore.PostgreSQL را از NuGet نصب کنید، سپس:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseNpgsql("Host=localhost;Database=MyDb;Username=user;Password=pass");
}

توضیحات:
رشته اتصال:
Host=localhost : آدرس سرور PostgreSQL (می‌تواند IP یا دامنه باشد).
Database=MyDb : نام پایگاه داده.
Username=user و Password=pass : اطلاعات ورود به سرور.
مزایا: پشتیبانی از انواع داده‌های پیچیده (مثل JSON) و قابلیت‌های مقیاس‌پذیری.
کاربرد: مناسب برای برنامه‌های وب مدرن، سیستم‌های توزیع‌شده یا پروژه‌هایی که نیاز به انعطاف‌پذیری بالا دارند.

4. MySQL

MySQL یکی دیگر از پایگاه‌های داده متن‌باز محبوب است که با EF Core به خوبی کار می‌کند.

تنظیمات اتصال:
ابتدا پکیج Pomelo.EntityFrameworkCore.MySql را نصب کنید، سپس:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseMySql(
        "Server=localhost;Database=MyDb;User=root;Password=pass",
        new MySqlServerVersion(new Version(8, 0, 21))
    );
}

توضیحات:
رشته اتصال:
Server=localhost : آدرس سرور MySQL.
Database=MyDb : نام پایگاه داده.
User=root و Password=pass : اطلاعات احراز هویت.
نسخه سرور: باید نسخه MySQL سرور (مثلاً 8.0.21) را مشخص کنید تا EF Core به درستی با آن ارتباط برقرار کند.
پکیج مورد نیاز: Pomelo.EntityFrameworkCore.MySql به دلیل سازگاری بهتر با EF Core توصیه می‌شود.
کاربرد: مناسب برای برنامه‌های وب، پروژه‌های کوچک تا متوسط و سیستم‌هایی که از قبل با MySQL کار می‌کنند.

5. سایر پایگاه‌های داده

EF Core از پایگاه‌های داده دیگری نیز پشتیبانی می‌کند، از جمله:

Oracle: با پکیج Oracle.EntityFrameworkCore.
Cosmos DB: با Microsoft.EntityFrameworkCore.Cosmos برای پایگاه‌های داده NoSQL در Azure.
In-Memory: با Microsoft.EntityFrameworkCore.InMemory برای تست بدون نیاز به پایگاه داده واقعی:

optionsBuilder.UseInMemoryDatabase("TestDb");

پیکربندی متمرکز و بهترین روش‌ها

به جای hard-code کردن رشته‌های اتصال در متد OnConfiguring， بهتر است از Dependency Injection و فایل تنظیمات (مثل appsettings.json) استفاده کنید:

مثال با appsettings.json:

{
  "ConnectionStrings": {
    "SqlServerConnection": "Server=.;Database=MyDb;Trusted_Connection=True;",
    "SqliteConnection": "Data Source=mydb.db"
  }
}

استفاده در کد:

public class BlogContext : DbContext
{
    private readonly IConfiguration _config;

    public BlogContext(IConfiguration config)
    {
        _config = config;
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(_config.GetConnectionString("SqlServerConnection"));
    }

    public DbSet<Blog> Blogs { get; set; }
}

مزایا: جداسازی تنظیمات از کد، امکان تغییر آسان‌تر و امنیت بیشتر (مثلاً با استفاده از متغیرهای محیطی).

نکات مهم

نصب پکیج‌ها: برای هر پایگاه داده، پکیج مربوطه را از NuGet نصب کنید. بدون Provider مناسب، EF Core نمی‌تواند به پایگاه داده متصل شود.
رشته‌های اتصال: همیشه رشته اتصال را با دقت تنظیم کنید و از منابع امن (مثل متغیرهای محیطی) برای ذخیره اطلاعات حساس استفاده کنید.
تست سازگاری: هر Provider ممکن است محدودیت‌ها یا قابلیت‌های خاصی داشته باشد (مثلاً پشتیبانی از انواع داده‌ها)، پس قبل از استفاده در محیط تولید، تست کنید.
مهاجرت‌ها (Migrations): هنگام تغییر پایگاه داده، ممکن است نیاز به بازنگری در کد مهاجرت‌ها داشته باشید، چون برخی دستورات (مثل IDENTITY) بین پایگاه‌ها متفاوت‌اند.

اتصال به پایگاه‌های داده مختلف در EF Core به لطف معماری ماژولار و Providerهای متنوع، فرآیندی ساده و انعطاف‌پذیر است. چه بخواهید از یک پایگاه داده سازمانی مثل SQL Server استفاده کنید، چه یک گزینه سبک مثل SQLite یا یک سیستم متن‌باز مثل PostgreSQL، EF Core با چند خط کد شما را به هدف‌تان می‌رساند. این قابلیت، EF Core را به ابزاری ایده‌آل برای پروژه‌های متنوع در .NET تبدیل کرده است.

نتیجه‌گیری

دسترسی به داده‌ها در .NET با ابزارهایی مثل Entity Framework Core به یک تجربه ساده و لذت‌بخش تبدیل شده است. از تعریف مدل‌ها گرفته تا انجام عملیات CRUD و اتصال به پایگاه‌های داده مختلف، این فریم‌ورک به شما کمک می‌کند تا تمرکز خود را روی منطق برنامه‌نویسی بگذارید، نه پیچیدگی‌های مدیریت داده. چه مبتدی باشید و چه حرفه‌ای، یادگیری این ابزارها می‌تواند مهارت‌های شما را به سطح بالاتری برساند. با تمرین مثال‌های این مقاله و استفاده از منابع تکمیلی، می‌توانید به راحتی پروژه‌های خود را با داده‌های پویا توسعه دهید.