Hubungan satu ke satu

Hubungan satu-ke-satu digunakan ketika satu entitas dikaitkan dengan paling banyak satu entitas lain. Misalnya, memiliki Blog satu BlogHeader, dan itu BlogHeader milik satu Blog.

Dokumen ini disusun di sekitar banyak contoh. Contoh dimulai dengan kasus umum, yang juga memperkenalkan konsep. Contoh selanjutnya mencakup jenis konfigurasi yang kurang umum. Pendekatan yang baik di sini adalah memahami beberapa contoh dan konsep pertama, lalu pergi ke contoh selanjutnya berdasarkan kebutuhan spesifik Anda. Berdasarkan pendekatan ini, kita akan mulai dengan hubungan satu-ke-satu "wajib" dan "opsional" sederhana.

Diperlukan satu-ke-satu

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId { get; set; } // Required foreign key property
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Hubungan satu-ke-satu terdiri dari:

• Satu atau beberapa properti kunci utama atau alternatif pada entitas utama. Contohnya, Blog.Id.
• Satu atau beberapa properti kunci asing pada entitas dependen. Contohnya, BlogHeader.BlogId.
• Secara opsional, navigasi referensi pada entitas utama yang mereferensikan entitas dependen. Contohnya, Blog.Header.
• Secara opsional, navigasi referensi pada entitas dependen yang mereferensikan entitas utama. Contohnya, BlogHeader.Blog.

Jadi, untuk hubungan dalam contoh ini:

• Properti BlogHeader.BlogId kunci asing tidak dapat diubah ke null. Ini membuat hubungan "diperlukan" karena setiap dependen (BlogHeader) harus terkait dengan beberapa prinsipal (Blog), karena properti kunci asingnya harus diatur ke beberapa nilai.
• Kedua entitas memiliki navigasi yang menunjuk ke entitas terkait di sisi lain hubungan.

Hubungan ini ditemukan oleh konvensi. Yaitu:

• Blog ditemukan sebagai utama dalam hubungan, dan BlogHeader ditemukan sebagai dependen.
• BlogHeader.BlogId ditemukan sebagai kunci asing dari dependen yang merujuk kunci Blog.Id utama prinsipal. Hubungan ditemukan sesuai kebutuhan karena BlogHeader.BlogId tidak dapat diubah ke null.
• Blog.BlogHeader ditemukan sebagai navigasi referensi.
• BlogHeader.Blog ditemukan sebagai navigasi referensi.

Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Dalam contoh di atas, konfigurasi hubungan memulai jenis entitas utama (Blog). Seperti semua hubungan, sama persis dengan dimulai dengan jenis entitas dependen (BlogHeader) sebagai gantinya. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<BlogHeader>()
        .HasOne(e => e.Blog)
        .WithOne(e => e.Header)
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Tidak satu pun dari opsi ini lebih baik daripada yang lain; keduanya menghasilkan konfigurasi yang sama persis.

Opsional satu-ke-satu

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int? BlogId { get; set; } // Optional foreign key property
    public Blog? Blog { get; set; } // Optional reference navigation to principal
}

Ini sama dengan contoh sebelumnya, kecuali bahwa properti kunci asing dan navigasi ke prinsipal sekarang dapat diubah ke null. Ini membuat hubungan "opsional" karena dependen (BlogHeader) tidak dapat terkait dengan prinsipal apa pun (Blog) dengan mengatur properti kunci asing dan navigasinya ke null.

Seperti sebelumnya, hubungan ini ditemukan oleh konvensi. Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired(false);
}

Diperlukan satu-ke-satu dengan kunci primer ke hubungan kunci primer

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Tidak seperti hubungan satu-ke-banyak, akhir dependen dari hubungan satu-ke-satu dapat menggunakan properti kunci utama atau propertinya sebagai properti atau properti kunci asing. Ini sering disebut hubungan PK-ke-PK. Ini hanya dimungkinkan ketika jenis utama dan dependen memiliki jenis kunci utama yang sama, dan hubungan yang dihasilkan selalu diperlukan, karena kunci utama dependen tidak dapat diubah ke null.

Setiap hubungan satu-ke-satu di mana kunci asing tidak ditemukan oleh konvensi harus dikonfigurasi untuk menunjukkan ujung utama dan dependen dari hubungan. Ini biasanya dilakukan dengan panggilan ke HasForeignKey. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>();
}

Ketika tidak ada properti yang ditentukan dalam panggilan ke HasForeignKey, dan kunci primer cocok, maka properti tersebut digunakan sebagai kunci asing. Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>(e => e.Id)
        .IsRequired();
}

Diperlukan satu-ke-satu dengan kunci asing bayangan

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Dalam beberapa kasus, Anda mungkin tidak menginginkan properti kunci asing dalam model Anda, karena kunci asing adalah detail tentang bagaimana hubungan diwakili dalam database, yang tidak diperlukan saat menggunakan hubungan dengan cara yang berorientasi objek murni. Namun, jika entitas akan diserialisasikan, misalnya untuk mengirim melalui kawat, maka nilai kunci asing dapat menjadi cara yang berguna untuk menjaga informasi hubungan tetap utuh ketika entitas tidak dalam bentuk objek. Oleh karena itu sering kali pragmatis untuk menyimpan properti kunci asing dalam jenis .NET untuk tujuan ini. Properti kunci asing dapat bersifat pribadi, yang sering menjadi kompromi yang baik untuk menghindari mengekspos kunci asing sambil memungkinkan nilainya untuk bepergian dengan entitas.

Mengikuti dari contoh sebelumnya, contoh ini menghapus properti kunci asing dari jenis entitas dependen. Namun, alih-alih menggunakan kunci primer, EF malah diinstruksikan untuk membuat properti kunci asing bayangan yang disebut BlogId jenis int.

Poin penting yang perlu diperhatikan di sini adalah bahwa jenis referensi C# nullable sedang digunakan, sehingga nullability navigasi dari dependen ke prinsipal digunakan untuk menentukan apakah properti kunci asing nullable atau tidak, dan oleh karena itu apakah hubungan bersifat opsional atau diperlukan. Jika jenis referensi nullable tidak digunakan, maka properti kunci asing bayangan akan dapat diubah ke null secara default membuat hubungan opsional secara default. Dalam hal ini, gunakan IsRequired untuk memaksa properti kunci asing bayangan menjadi tidak dapat diubah ke null dan membuat hubungan diperlukan.

Hubungan ini lagi-lagi memerlukan beberapa konfigurasi untuk menunjukkan ujung utama dan dependen:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>("BlogId");
}

Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>("BlogId")
        .IsRequired();
}

Opsional satu-ke-satu dengan kunci asing bayangan

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public Blog? Blog { get; set; } // Optional reference navigation to principal
}

Seperti contoh sebelumnya, properti kunci asing telah dihapus dari jenis entitas dependen. Namun, tidak seperti contoh sebelumnya, kali ini properti kunci asing dibuat sebagai nullable karena jenis referensi C# nullable sedang digunakan dan navigasi pada jenis entitas dependen dapat diubah ke null. Hal ini membuat hubungan menjadi opsional.

Ketika jenis referensi C# nullable tidak digunakan, maka properti kunci asing akan, secara default, dibuat sebagai nullable. Ini berarti hubungan dengan properti bayangan yang dibuat secara otomatis bersifat opsional secara default.

Seperti sebelumnya, hubungan ini memerlukan beberapa konfigurasi untuk menunjukkan prinsipal dan dependen berakhir:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>("BlogId");
}

Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>("BlogId")
        .IsRequired(false);
}

Satu-ke-satu tanpa navigasi ke prinsipal

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId { get; set; } // Required foreign key property
}

Untuk contoh ini, properti kunci asing telah diperkenalkan kembali, tetapi navigasi pada dependen telah dihapus.

Hubungan ini ditemukan oleh konvensi, karena kunci asing ditemukan, sehingga menunjukkan sisi dependen. Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne()
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Perhatikan bahwa panggilan untuk WithOne tidak memiliki argumen. Ini adalah cara untuk memberi tahu EF bahwa tidak ada navigasi dari BlogHeader ke Blog.

Jika konfigurasi dimulai dari entitas tanpa navigasi, maka jenis entitas di akhir hubungan lainnya harus ditentukan secara eksplisit menggunakan panggilan generik HasOne<>() . Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<BlogHeader>()
        .HasOne<Blog>()
        .WithOne(e => e.Header)
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Satu-ke-satu tanpa navigasi ke utama dan dengan kunci asing bayangan

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
}

Contoh ini menggabungkan dua contoh sebelumnya dengan menghapus properti kunci asing dan navigasi pada dependen.

Seperti sebelumnya, hubungan ini memerlukan beberapa konfigurasi untuk menunjukkan prinsipal dan dependen berakhir:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne()
        .HasForeignKey<BlogHeader>("BlogId")
        .IsRequired();
}

Konfigurasi yang lebih lengkap dapat digunakan untuk mengonfigurasi navigasi dan nama kunci asing secara eksplisit, dengan panggilan yang sesuai ke IsRequired() atau IsRequired(false) sesuai kebutuhan. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne()
        .HasForeignKey<BlogHeader>("BlogId")
        .IsRequired();
}

Satu-ke-satu tanpa navigasi ke dependen

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId { get; set; } // Required foreign key property
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Dua contoh sebelumnya memiliki navigasi dari perwakilan ke dependen, tetapi tidak ada navigasi dari dependen ke utama. Untuk beberapa contoh berikutnya, navigasi pada dependen diperkenalkan kembali, sementara navigasi pada prinsipal dihapus sebagai gantinya.

Berdasarkan konvensi, EF akan memperlakukan ini sebagai hubungan satu-ke-banyak. Beberapa konfigurasi minimal diperlukan untuk membuatnya satu-ke-satu:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<BlogHeader>()
        .HasOne(e => e.Blog)
        .WithOne();
}

Perhatikan lagi yang WithOne() dipanggil tanpa argumen untuk menunjukkan bahwa tidak ada navigasi ke arah ini.

Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<BlogHeader>()
        .HasOne(e => e.Blog)
        .WithOne()
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Jika konfigurasi dimulai dari entitas tanpa navigasi, maka jenis entitas di akhir hubungan lainnya harus ditentukan secara eksplisit menggunakan panggilan generik HasOne<>() . Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne<BlogHeader>()
        .WithOne(e => e.Blog)
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Satu-ke-satu tanpa navigasi

Terkadang, dapat berguna untuk mengonfigurasi hubungan tanpa navigasi. Hubungan seperti itu hanya dapat dimanipulasi dengan mengubah nilai kunci asing secara langsung.

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId { get; set; } // Required foreign key property
}

Hubungan ini tidak ditemukan oleh konvensi, karena tidak ada navigasi yang menunjukkan bahwa kedua jenis tersebut terkait. Ini dapat dikonfigurasi secara eksplisit di OnModelCreating. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne<BlogHeader>()
        .WithOne();
}

Dengan konfigurasi ini, BlogHeader.BlogId properti masih terdeteksi sebagai kunci asing berdasarkan konvensi, dan hubungan "diperlukan" karena properti kunci asing tidak dapat diubah ke null. Hubungan dapat dibuat "opsional" dengan membuat properti kunci asing nullable.

Konfigurasi eksplisit hubungan ini yang lebih lengkap adalah::

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne<BlogHeader>()
        .WithOne()
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Satu-ke-satu dengan kunci alternatif

Dalam semua contoh sejauh ini, properti kunci asing pada dependen dibatasi ke properti kunci utama pada prinsipal. Kunci asing dapat dibatasi ke properti yang berbeda, yang kemudian menjadi kunci alternatif untuk jenis entitas utama. Misalnya:

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public int AlternateId { get; set; } // Alternate key as target of the BlogHeader.BlogId foreign key
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId { get; set; } // Required foreign key property
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Hubungan ini tidak ditemukan oleh konvensi, karena EF akan selalu, berdasarkan konvensi, membuat hubungan dengan kunci utama. Ini dapat dikonfigurasi secara eksplisit dalam OnModelCreating menggunakan panggilan ke HasPrincipalKey. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasPrincipalKey<Blog>(e => e.AlternateId);
}

HasPrincipalKey dapat dikombinasikan dengan panggilan lain untuk secara eksplisit mengonfigurasi navigasi, properti kunci asing, dan sifat yang diperlukan/opsional. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .HasPrincipalKey<Blog>(e => e.AlternateId)
        .HasForeignKey<BlogHeader>(e => e.BlogId)
        .IsRequired();
}

Satu-ke-satu dengan kunci asing komposit

Dalam semua contoh sejauh ini, properti kunci utama atau alternatif dari prinsipal yang terdiri dari satu properti. Kunci primer atau alternatif juga dapat dibentuk membentuk lebih dari satu properti --ini dikenal sebagai "kunci komposit". Ketika prinsip hubungan memiliki kunci komposit, maka kunci asing dependen juga harus menjadi kunci komposit dengan jumlah properti yang sama. Misalnya:

// Principal (parent)
public class Blog
{
    public int Id1 { get; set; } // Composite key part 1
    public int Id2 { get; set; } // Composite key part 2
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId1 { get; set; } // Required foreign key property part 1
    public int BlogId2 { get; set; } // Required foreign key property part 2
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Hubungan ini ditemukan oleh konvensi. Namun, itu hanya akan ditemukan jika kunci komposit telah dikonfigurasi secara eksplisit, karena kunci komposit tidak ditemukan secara otomatis. Contohnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasKey(e => new { e.Id1, e.Id2 });
}

Baik HasForeignKey dan HasPrincipalKey dapat digunakan untuk secara eksplisit menentukan kunci dengan beberapa properti. Misalnya:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>(
        nestedBuilder =>
        {
            nestedBuilder.HasKey(e => new { e.Id1, e.Id2 });

            nestedBuilder.HasOne(e => e.Header)
                .WithOne(e => e.Blog)
                .HasPrincipalKey<Blog>(e => new { e.Id1, e.Id2 })
                .HasForeignKey<BlogHeader>(e => new { e.BlogId1, e.BlogId2 })
                .IsRequired();
        });
}

Diperlukan satu-ke-satu tanpa penghapusan kaskade

// Principal (parent)
public class Blog
{
    public int Id { get; set; }
    public BlogHeader? Header { get; set; } // Reference navigation to dependent
}

// Dependent (child)
public class BlogHeader
{
    public int Id { get; set; }
    public int BlogId { get; set; } // Required foreign key property
    public Blog Blog { get; set; } = null!; // Required reference navigation to principal
}

Menurut konvensi, hubungan yang diperlukan dikonfigurasi untuk menghapus kaskade. Ini karena dependen tidak dapat ada dalam database setelah prinsipal dihapus. Database dapat dikonfigurasi untuk menghasilkan kesalahan, biasanya crash aplikasi, alih-alih secara otomatis menghapus baris dependen yang tidak dapat lagi ada. Ini memerlukan beberapa konfigurasi:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasOne(e => e.Header)
        .WithOne(e => e.Blog)
        .OnDelete(DeleteBehavior.Restrict);
}

Mereferensikan sendiri satu-ke-satu

Dalam semua contoh sebelumnya, jenis entitas utama berbeda dari jenis entitas dependen. Ini tidak harus terjadi. Misalnya, dalam jenis di bawah ini, masing-masing Person secara opsional terkait dengan yang lain Person.

public class Person
{
    public int Id { get; set; }

    public int? HusbandId { get; set; } // Optional foreign key property
    public Person? Husband { get; set; } // Optional reference navigation to principal
    public Person? Wife { get; set; } // Reference navigation to dependent
}

Hubungan ini ditemukan oleh konvensi. Untuk kasus di mana navigasi, kunci asing, atau sifat hubungan yang diperlukan/opsional tidak ditemukan oleh konvensi, hal-hal ini dapat dikonfigurasi secara eksplisit. Contoh:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Person>()
        .HasOne(e => e.Husband)
        .WithOne(e => e.Wife)
        .HasForeignKey<Person>(e => e.HusbandId)
        .IsRequired(false);
}