Öğretici: ASP.NET MVC uygulaması için daha karmaşık bir veri modeli oluşturma

Önceki öğreticilerde üç varlık içeren basit bir veri modeliyle çalıştınız. Bu öğreticide daha fazla varlık ve ilişki ekleyecek ve biçimlendirme, doğrulama ve veritabanı eşleme kuralları belirterek veri modelini özelleştirebilirsiniz. Bu makalede, veri modelini özelleştirmenin iki yolu gösterilmektedir: varlık sınıflarına öznitelikler ekleyerek ve veritabanı bağlam sınıfına kod ekleyerek.

İşiniz bittiğinde varlık sınıfları, aşağıdaki çizimde gösterilen tamamlanmış veri modelini oluşturur:

Bu öğreticide şunları yaptınız:

• Veri modelini özelleştirme
• Öğrenci varlığını güncelleştirme
• Eğitmen varlığı oluşturma
• OfficeAssignment varlığı oluşturma
• Course varlığını değiştirme
• Departman varlığını oluşturma
• Kayıt varlığını değiştirme
• Veritabanı bağlamı için kod ekleme
• Test verileriyle tohum veritabanı
• Geçiş ekleme
• Veritabanını güncelleştirme

Önkoşullar

• Code First geçişleri ve dağıtımı

Veri modelini özelleştirme

Bu bölümde biçimlendirme, doğrulama ve veritabanı eşleme kurallarını belirten öznitelikleri kullanarak veri modelini özelleştirmeyi öğreneceksiniz. Ardından, aşağıdaki bölümlerden birkaçında, oluşturduğunuz sınıflara öznitelikler ekleyerek ve modeldeki kalan varlık türleri için yeni sınıflar oluşturarak tam School veri modelini oluşturacaksınız.

DataType Özniteliği

Öğrenci kayıt tarihleri için, tüm web sayfaları şu anda tarihle birlikte saati de görüntüler, ancak bu alan için önemsediğiniz tek şey tarihtir. Veri ek açıklaması özniteliklerini kullanarak, verileri gösteren her görünümde görüntüleme biçimini düzeltecek bir kod değişikliği yapabilirsiniz. Bunun nasıl yapılacağını gösteren bir örnek görmek için sınıfındaki Student özelliğine EnrollmentDate bir öznitelik ekleyeceksiniz.

Models\Student.cs içinde, ad alanı için System.ComponentModel.DataAnnotations bir using deyim ekleyin ve aşağıdaki örnekte gösterildiği gibi özelliğine EnrollmentDate ve DisplayFormat öznitelikleri ekleyinDataType:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        public string LastName { get; set; }
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        public DateTime EnrollmentDate { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

DataType özniteliği, veritabanı iç türünden daha özel bir veri türü belirtmek için kullanılır. Bu durumda, tarih ve saati değil yalnızca tarihi izlemek istiyoruz. DataType NumaralandırmasıDate, Time, PhoneNumber, Currency, EmailAddress ve daha fazlası gibi birçok veri türü sağlar. özniteliği, DataType uygulamanın türe özgü özellikleri otomatik olarak sağlamasına da olanak tanıyabilir. Örneğin, DataType.EmailAddress için bir mailto: bağlantı oluşturulabilir ve HTML5'i destekleyen tarayıcılarda DataType.Date için bir tarih seçici sağlanabilir. DataType öznitelikleri, HTML 5 tarayıcılarının anlayabileceği HTML 5 veri- (belirgin veri tiresi) öznitelikleri yayar. DataType öznitelikleri herhangi bir doğrulama sağlamaz.

DataType.Date görüntülenen tarihin biçimini belirtmez. Varsayılan olarak, veri alanı sunucunun CultureInfo'sunu temel alan varsayılan biçimlere göre görüntülenir.

DisplayFormat özniteliği, tarih biçimini açıkça belirtmek için kullanılır:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

ayar, ApplyFormatInEditMode belirtilen biçimlendirmenin, değer düzenleme için bir metin kutusunda görüntülendiğinde de uygulanması gerektiğini belirtir. (Bazı alanlarda bunu istemeyebilirsiniz; örneğin, para birimi değerleri için, metin kutusunda para birimi simgesinin düzenlenmesini istemeyebilirsiniz.)

DisplayFormat özniteliğini tek başına kullanabilirsiniz, ancak DataType özniteliğini de kullanmak genellikle iyi bir fikirdir. DataType özniteliği, verilerin ekranda nasıl işlendiğinin aksine semantiğini iletir ve ile DisplayFormatelde etmediğiniz aşağıdaki avantajları sağlar:

• Tarayıcı HTML5 özelliklerini etkinleştirebilir (örneğin, bir takvim denetimi, yerel ayara uygun para birimi simgesi, e-posta bağlantıları, bazı istemci tarafı giriş doğrulaması vb.) gösterebilir.
• Varsayılan olarak, tarayıcı yerel ayarınıza göre doğru biçimi kullanarak verileri işler.
• DataType özniteliği, MVC'nin verileri işlemek için doğru alan şablonunu seçmesini sağlayabilir (DisplayFormat dize şablonunu kullanır). Daha fazla bilgi için bkz. Brad Wilson'ın ASP.NET MVC 2 Şablonları. (MVC 2 için yazılmış olsa da, bu makale ASP.NET MVC'nin geçerli sürümü için hala geçerlidir.)

özniteliğini DataType bir tarih alanıyla kullanırsanız, alanın Chrome tarayıcılarında doğru şekilde işlenmesini sağlamak için özniteliğini de belirtmeniz DisplayFormat gerekir. Daha fazla bilgi için bu StackOverflow iş parçacığına bakın.

MVC'de diğer tarih biçimlerini işleme hakkında daha fazla bilgi için MVC 5 Giriş: Düzenleme Yöntemlerini İnceleme ve Görünümü Düzenle'ye gidin ve sayfada "uluslararasılaştırma" araması yapın.

Öğrenci Dizini sayfasını yeniden çalıştırın ve kayıt tarihleri için artık saatlerin görüntülenmediğini fark edin. Modeli kullanan Student tüm görünümler için de aynı durum geçerli olacaktır.

The StringLengthAttribute

Öznitelikleri kullanarak veri doğrulama kuralları ve doğrulama hata iletileri de belirtebilirsiniz. StringLength özniteliği veritabanındaki uzunluk üst sınırını ayarlar ve ASP.NET MVC için istemci tarafı ve sunucu tarafı doğrulaması sağlar. Bu öznitelikte en düşük dize uzunluğunu da belirtebilirsiniz, ancak minimum değerin veritabanı şeması üzerinde hiçbir etkisi yoktur.

Kullanıcıların bir ad için 50'den fazla karakter girmediğinden emin olmak istediğinizi varsayalım. Bu sınırlamayı eklemek için, aşağıdaki örnekte gösterildiği gibi ve FirstMidName özelliklerine LastNameStringLength özniteliklerini ekleyin:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        [StringLength(50)]
        public string LastName { get; set; }
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        public DateTime EnrollmentDate { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

StringLength özniteliği, kullanıcının bir ad için boşluk girmesini engellemez. Girişe kısıtlamalar uygulamak için RegularExpression özniteliğini kullanabilirsiniz. Örneğin, aşağıdaki kod ilk karakterin büyük harf, kalan karakterlerin ise alfabetik olmasını gerektirir:

[RegularExpression(@"^[A-Z]+[a-zA-Z""'\s-]*$")]

MaxLength özniteliği StringLength özniteliğine benzer işlevsellik sağlar ancak istemci tarafı doğrulaması sağlamaz.

Uygulamayı çalıştırın ve Öğrenciler sekmesine tıklayın. Aşağıdaki hatayı alırsınız:

Veritabanı oluşturulduktan sonra 'SchoolContext' bağlamını arka planlayan model değişti. Veritabanını (https://go.microsoft.com/fwlink/?LinkId=238269 güncelleştirmek için Code First Migrations kullanmayı göz önünde bulundurun.

Veritabanı modeli, veritabanı şemasında değişiklik gerektirecek şekilde değişmiştir ve Entity Framework bunu algılamıştır. Kullanıcı arabirimini kullanarak veritabanına eklediğiniz verileri kaybetmeden şemayı güncelleştirmek için geçişleri kullanacaksınız. yöntemi tarafından oluşturulan verileri değiştirdiyseniz, yönteminde SeedSeed kullandığınız AddOrUpdate yöntemi nedeniyle bu işlem özgün durumuna geri döndürülecektir. (AddOrUpdate , veritabanı terminolojisinden "upsert" işlemiyle eşdeğerdir.)

Paket Yöneticisi Konsolu'nda (PMC) aşağıdaki komutları girin:

add-migration MaxLengthOnNames
update-database

komutu timeStamp>_MaxLengthOnNames.cs adlı< bir dosya oluşturur.add-migration Bu dosya yönteminde Up veritabanını geçerli veri modeliyle eşleşecek şekilde güncelleştirecek kodu içerir. Komut update-database bu kodu çalıştırmıştı.

Geçişler dosya adına eklenen zaman damgası, Entity Framework tarafından geçişleri sıralamak için kullanılır. Komutu çalıştırmadan update-database önce birden çok geçiş oluşturabilirsiniz ve sonra tüm geçişler oluşturuldukları sırayla uygulanır.

Oluştur sayfasını çalıştırın ve 50 karakterden uzun bir ad girin. Oluştur'a tıkladığınızda istemci tarafı doğrulaması bir hata iletisi gösterir: LastName alanı en fazla 50 uzunluğunda bir dize olmalıdır.

Sütun Özniteliği

Sınıflarınızın ve özelliklerinizin veritabanına nasıl eşlenmiş olduğunu denetlemek için öznitelikleri de kullanabilirsiniz. Alan ikinci ad da içerebileceğinden, ad alanı için bu adı kullandığınızı FirstMidName varsayalım. Ancak veritabanına geçici sorgular yazacak kullanıcılar bu ada alışkın olduğundan veritabanı sütununun olarak adlandırılmasını FirstNameistiyorsunuz. Bu eşlemeyi yapmak için özniteliğini Column kullanabilirsiniz.

Column özniteliği, veritabanı oluşturulduğunda, özelliğine eşleyen tablonun sütununun StudentFirstMidName olarak adlandırılacağını FirstNamebelirtir. Başka bir deyişle, kodunuz öğesine başvurduğunda Student.FirstMidNameveriler tablonun sütunundan FirstNameStudent gelir veya güncelleştirilir. Sütun adlarını belirtmezseniz, bunlara özellik adıyla aynı ad verilir.

Student.cs dosyasında, System.ComponentModel.DataAnnotations.Schema için bir using deyim ekleyin ve aşağıdaki vurgulanan kodda gösterildiği gibi sütun adı özniteliğini FirstMidName özelliğine ekleyin:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        [StringLength(50)]       
        public string LastName { get; set; }
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        [Column("FirstName")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

        public DateTime EnrollmentDate { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

Column özniteliğinin eklenmesi SchoolContext'i yedekleyerek modeli değiştirir, bu nedenle veritabanıyla eşleşmez. Başka bir geçiş oluşturmak için PMC'ye aşağıdaki komutları girin:

add-migration ColumnFirstName
update-database

Sunucu Gezgini'ndeStudent tablosuna çift tıklayarak Student tablo tasarımcısını açın.

Aşağıdaki görüntüde, ilk iki geçişi uygulamadan önceki özgün sütun adı gösterilmektedir. olarak değişen FirstMidNameFirstNamesütun adının yanı sıra, iki ad sütunu da uzunluğundan MAX 50 karaktere değiştirildi.

Bu öğreticinin ilerleyen bölümlerinde göreceğiniz gibi Fluent API'sini kullanarak veritabanı eşleme değişiklikleri de yapabilirsiniz.

Not

Aşağıdaki bölümlerdeki tüm varlık sınıflarını oluşturmayı tamamlamadan önce derlemeyi denerseniz, derleyici hataları alabilirsiniz.

Öğrenci varlığını güncelleştirme

Models\Student.cs dosyasında, daha önce eklediğiniz kodu aşağıdaki kodla değiştirin. Değişiklikler vurgulanır.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        [Required]
        [StringLength(50)]
        [Display(Name = "Last Name")]
        public string LastName { get; set; }
        [Required]
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Enrollment Date")]
        public DateTime EnrollmentDate { get; set; }

        [Display(Name = "Full Name")]
        public string FullName
        {
            get
            {
                return LastName + ", " + FirstMidName;
            }
        }

        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

Gerekli Öznitelik

Gerekli özniteliği, ad özelliklerini gerekli alanlara yapar. Required attribute DateTime, int, double ve float gibi değer türleri için gerekli değildir. Değer türlerine null değer atanamaz, bu nedenle bunlar doğal olarak gerekli alanlar olarak değerlendirilir.

özniteliğinin Required zorlanması için MinimumLength ile MinimumLength kullanılması gerekir.

[Display(Name = "Last Name")]
[Required]
[StringLength(50, MinimumLength=2)]
public string LastName { get; set; }

MinimumLength ve Required boşluğun doğrulamayı karşılamasına izin verin. RegularExpression Dize üzerinde tam denetim için özniteliğini kullanın.

Display Özniteliği

özniteliği, Display metin kutularının başlık her örnekte özellik adı yerine "Ad", "Soyadı", "Tam Ad" ve "Kayıt Tarihi" olması gerektiğini belirtir (sözcükleri bölen alan yoktur).

FullName Hesaplanan Özelliği

FullName , diğer iki özelliği birleştirerek oluşturulan bir değer döndüren hesaplanan özelliktir. Bu nedenle yalnızca bir get erişimciye sahiptir ve veritabanında hiçbir FullName sütun oluşturulmaz.

Eğitmen varlığı oluşturma

Models\Instructor.cs dosyasını oluşturup şablon kodunu aşağıdaki kodla değiştirin:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Instructor
    {
        public int ID { get; set; }

        [Required]
        [Display(Name = "Last Name")]
        [StringLength(50)]
        public string LastName { get; set; }

        [Required]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        [StringLength(50)]
        public string FirstMidName { get; set; }

        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Hire Date")]
        public DateTime HireDate { get; set; }

        [Display(Name = "Full Name")]
        public string FullName
        {
            get { return LastName + ", " + FirstMidName; }
        }

        public virtual ICollection<Course> Courses { get; set; }
        public virtual OfficeAssignment OfficeAssignment { get; set; }
    }
}

ve Instructor varlıklarında birkaç özelliğin Student aynı olduğuna dikkat edin. Bu serinin devamında yer alan Devralma Uygulama öğreticisinde, yedekliliği ortadan kaldırmak için bu kodu yeniden düzenleyeceksiniz.

Bir satıra birden çok öznitelik koyabilirsiniz, böylece eğitmen sınıfını aşağıdaki gibi de yazabilirsiniz:

public class Instructor
{
   public int ID { get; set; }

   [Display(Name = "Last Name"),StringLength(50, MinimumLength=1)]
   public string LastName { get; set; }

   [Column("FirstName"),Display(Name = "First Name"),StringLength(50, MinimumLength=1)]
   public string FirstMidName { get; set; }

   [DataType(DataType.Date),Display(Name = "Hire Date"),DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
   public DateTime HireDate { get; set; }

   [Display(Name = "Full Name")]
   public string FullName
   {
      get { return LastName + ", " + FirstMidName; }
   }

   public virtual ICollection<Course> Courses { get; set; }
   public virtual OfficeAssignment OfficeAssignment { get; set; }
}

Kurslar ve OfficeAssignment Gezinti Özellikleri

Courses ve OfficeAssignment özellikleri gezinti özellikleridir. Daha önce açıklandığı gibi, yavaş yükleme adı verilen bir Entity Framework özelliğinden yararlanabilmeleri için genellikle sanal olarak tanımlanırlar. Ayrıca, bir gezinti özelliği birden çok varlığı barındırabiliyorsa, türünün ICollection<T> Arabirimini uygulaması gerekir. Örneğin, IList<T>, Ekle'yi uygulamadığından IEnumerable<T'yi>IEnumerable<T> niteler ancak nitelemez.

Eğitmen herhangi bir sayıda ders verebilir, bu nedenle Courses varlık koleksiyonu Course olarak tanımlanır.

public virtual ICollection<Course> Courses { get; set; }

İş kurallarımız bir eğitmenin en fazla bir ofise sahip olabileceğini belirtir, bu nedenle OfficeAssignment tek OfficeAssignment bir varlık (herhangi bir ofis atanmamış olabilir null ) olarak tanımlanır.

public virtual OfficeAssignment OfficeAssignment { get; set; }

OfficeAssignment varlığı oluşturma

Models \OfficeAssignment.cs dosyasını aşağıdaki kodla oluşturun:

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

namespace ContosoUniversity.Models
{
    public class OfficeAssignment
    {
        [Key]
        [ForeignKey("Instructor")]
        public int InstructorID { get; set; }
        [StringLength(50)]
        [Display(Name = "Office Location")]
        public string Location { get; set; }

        public virtual Instructor Instructor { get; set; }
    }
}

Değişikliklerinizi kaydeden ve derleyicinin yakalayabileceği kopyalama ve yapıştırma hataları oluşturmadığınız doğrulayan projeyi derleyin.

Anahtar Özniteliği

ve OfficeAssignment varlıkları arasında Instructor bire sıfır veya bir ilişkisi vardır. Ofis ataması yalnızca atandığı eğitmenle ilişkili olarak bulunur ve bu nedenle birincil anahtarı aynı zamanda varlığın Instructor yabancı anahtarıdır. Ancak Entity Framework, adı veya sınıf adıID adlandırma kuralına uymadığından bu varlığın ID birincil anahtarı olarak otomatik olarak tanıyamazInstructorID. Bu nedenle, Key özniteliği anahtar olarak tanımlamak için kullanılır:

[Key]
[ForeignKey("Instructor")]
public int InstructorID { get; set; }

Varlığın Key kendi birincil anahtarı varsa ancak özelliğine veya IDdışında classnameID bir ad vermek istiyorsanız özniteliğini de kullanabilirsiniz. Varsayılan olarak, sütun tanımlayıcı bir ilişki için olduğundan EF anahtarı veritabanı oluşturulmamış olarak ele alır.

ForeignKey Özniteliği

İki varlık arasında (ve gibi OfficeAssignmentInstructor) bire sıfıra veya bire bir ilişki olduğunda, EF ilişkinin hangi sonunun sorumlu ve hangi ucun bağımlı olduğunu çözemez. Bire bir ilişkiler, her sınıfta diğer sınıfa bir başvuru gezinti özelliğine sahiptir. İlişkiyi oluşturmak için ForeignKey Özniteliği bağımlı sınıfa uygulanabilir. ForeignKey Özniteliğini atlarsanız, geçişi oluşturmaya çalıştığınızda aşağıdaki hatayı alırsınız:

'ContosoUniversity.Models.OfficeAssignment' ve 'ContosoUniversity.Models.Instructor' türleri arasındaki ilişkilendirmenin asıl sonu belirlenemiyor. Bu ilişkilendirmenin asıl ucu, ilişki akıcı API'si veya veri ek açıklamaları kullanılarak açıkça yapılandırılmalıdır.

Öğreticinin ilerleyen bölümlerinde akıcı API ile bu ilişkiyi yapılandırmayı öğreneceksiniz.

Eğitmen Gezinti Özelliği

Varlığın Instructor null atanabilir OfficeAssignment bir gezinti özelliği vardır (eğitmenin ofis ataması olmayabilir) ve varlığın OfficeAssignment boş değer atanamaz Instructor bir gezinti özelliği vardır (bir ofis ataması eğitmen olmadan varolmadığından) InstructorID null atanamaz. Bir Instructor varlığın ilgili OfficeAssignment bir varlığı olduğunda, her varlığın gezinti özelliğinde diğerine bir başvurusu olur.

İlgili bir eğitmenin olması gerektiğini belirtmek için Eğitmen gezinti özelliğine bir [Required] öznitelik koyabilirsiniz, ancak InstructorID yabancı anahtarı (bu tablonun da anahtarıdır) null atanamaz olduğundan bunu yapmanız gerekmez.

Course varlığını değiştirme

Models\Course.cs dosyasında, daha önce eklediğiniz kodu aşağıdaki kodla değiştirin:

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
   public class Course
   {
      [DatabaseGenerated(DatabaseGeneratedOption.None)]
      [Display(Name = "Number")]
      public int CourseID { get; set; }

      [StringLength(50, MinimumLength = 3)]
      public string Title { get; set; }

      [Range(0, 5)]
      public int Credits { get; set; }

      public int DepartmentID { get; set; }

      public virtual Department Department { get; set; }
      public virtual ICollection<Enrollment> Enrollments { get; set; }
      public virtual ICollection<Instructor> Instructors { get; set; }
   }
}

Kurs varlığı, ilgili Department varlığa işaret eden bir yabancı anahtar özelliğine DepartmentID ve bir Department gezinti özelliğine sahiptir. Entity Framework, ilgili bir varlık için gezinti özelliğine sahip olduğunuzda veri modelinize yabancı anahtar özelliği eklemenizi gerektirmez. EF, gerektiğinde veritabanında otomatik olarak yabancı anahtarlar oluşturur. Ancak veri modelinde yabancı anahtarın olması, güncelleştirmeleri daha basit ve daha verimli hale getirebilir. Örneğin, düzenlemek üzere bir kurs varlığını getirdiğinizde, Department yüklemezseniz varlık null olur, bu nedenle kurs varlığını güncelleştirdiğinizde önce varlığı getirmeniz Department gerekir. Yabancı anahtar özelliği DepartmentID veri modeline dahil edildiğinde, güncelleştirmeden önce varlığı getirmeniz Department gerekmez.

DatabaseGenerated Özniteliği

özelliğinde CourseIDNone parametresine sahip DatabaseGenerated özniteliği, birincil anahtar değerlerinin veritabanı tarafından oluşturulmak yerine kullanıcı tarafından sağlandığını belirtir.

[DatabaseGenerated(DatabaseGeneratedOption.None)]
[Display(Name = "Number")]
public int CourseID { get; set; }

Varsayılan olarak, Entity Framework birincil anahtar değerlerinin veritabanı tarafından oluşturulduğunu varsayar. Çoğu senaryoda istediğiniz budur. Ancak varlıklar için, bir departman için Course 1000 serisi, başka bir bölüm için 2000 serisi gibi kullanıcı tarafından belirtilen bir kurs numarası kullanacaksınız.

Yabancı Anahtar ve Gezinti Özellikleri

Varlıktaki Course yabancı anahtar özellikleri ve gezinti özellikleri aşağıdaki ilişkileri yansıtır:

• Kurs bir bölüme atanır, bu nedenle yukarıda belirtilen nedenlerle bir DepartmentID yabancı anahtar ve gezinti Department özelliği vardır.

  public int DepartmentID { get; set; }
  public virtual Department Department { get; set; }
  

• Bir kursa kayıtlı herhangi bir sayıda öğrenci olabilir, bu nedenle Enrollments gezinti özelliği bir koleksiyondur:

  public virtual ICollection<Enrollment> Enrollments { get; set; }
  

• Bir kurs birden çok eğitmen tarafından öğretilebilir, bu nedenle Instructors gezinti özelliği bir koleksiyondur:

  public virtual ICollection<Instructor> Instructors { get; set; }
  

Departman varlığını oluşturma

Aşağıdaki kodla Models\Department.cs dosyasını oluşturun:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
   public class Department
   {
      public int DepartmentID { get; set; }

      [StringLength(50, MinimumLength=3)]
      public string Name { get; set; }

      [DataType(DataType.Currency)]
      [Column(TypeName = "money")]
      public decimal Budget { get; set; }

      [DataType(DataType.Date)]
      [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
      [Display(Name = "Start Date")]
      public DateTime StartDate { get; set; }

      public int? InstructorID { get; set; }

      public virtual Instructor Administrator { get; set; }
      public virtual ICollection<Course> Courses { get; set; }
   }
}

Sütun Özniteliği

Daha önce sütun adı eşlemesini değiştirmek için Column özniteliğini kullandınız. Varlığın Department kodunda özniteliği SQL Column veri türü eşlemesini değiştirmek için kullanılır, böylece sütun veritabanındaki SQL Server para türü kullanılarak tanımlanır:

[Column(TypeName="money")]
public decimal Budget { get; set; }

Varlık Çerçevesi genellikle özellik için tanımladığınız CLR türüne göre uygun SQL Server veri türünü seçtiğinden sütun eşlemesi genellikle gerekli değildir. CLR decimal türü bir SQL Server decimal türüyle eşler. Ancak bu durumda sütunun para birimi tutarlarını tutacağını ve para veri türünün bunun için daha uygun olduğunu biliyorsunuz. CLR veri türleri ve bunların SQL Server veri türleriyle eşleşmeleri hakkında daha fazla bilgi için bkz. Entity FrameworkTypes için SqlClient.

Yabancı Anahtar ve Gezinti Özellikleri

Yabancı anahtar ve gezinti özellikleri aşağıdaki ilişkileri yansıtır:

• Bir bölümün yöneticisi olabilir veya olmayabilir ve yönetici her zaman eğitmendir. Bu nedenle özellik, varlığın InstructorID yabancı anahtarı Instructor olarak eklenir ve özelliği null atanabilir olarak işaretlemek için tür gösteriminden sonra int bir soru işareti eklenir. Gezinti özelliği adlandırılmıştır Administrator ancak bir Instructor varlığı barındırmaktadır:

  public int? InstructorID { get; set; }
  public virtual Instructor Administrator { get; set; }
  

• Bir bölümün birçok kursu olabilir, bu nedenle bir Courses gezinti özelliği vardır:

  public virtual ICollection<Course> Courses { get; set; }
  

  Not

  Kural gereği, Entity Framework null atanamayan yabancı anahtarlar ve çoka çok ilişkiler için art arda silmeyi etkinleştirir. Bu durum döngüsel art arda silme kurallarıyla sonuçlanabilir ve bu da geçiş eklemeye çalıştığınızda bir özel duruma neden olur. Örneğin, özelliği null atanabilir olarak tanımlamadıysanız Department.InstructorID şu özel durum iletisini alırsınız: "Başvuru ilişkisi, izin verilmeyen döngüsel başvuruyla sonuçlanır." İş kurallarınızda özelliğin null atanamaz olması gerekiyorsa InstructorID , ilişkide art arda silmeyi devre dışı bırakmak için aşağıdaki fluent API deyimini kullanmanız gerekir:

modelBuilder.Entity().HasRequired(d => d.Administrator).WithMany().WillCascadeOnDelete(false);

Kayıt varlığını değiştirme

Models\Enrollment.cs içinde, daha önce eklediğiniz kodu aşağıdaki kodla değiştirin

using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
    public enum Grade
    {
        A, B, C, D, F
    }

    public class Enrollment
    {
        public int EnrollmentID { get; set; }
        public int CourseID { get; set; }
        public int StudentID { get; set; }
        [DisplayFormat(NullDisplayText = "No grade")]
        public Grade? Grade { get; set; }

        public virtual Course Course { get; set; }
        public virtual Student Student { get; set; }
    }
}

Yabancı Anahtar ve Gezinti Özellikleri

Yabancı anahtar özellikleri ve gezinti özellikleri aşağıdaki ilişkileri yansıtır:

• Kayıt kaydı tek bir kurs içindir, bu nedenle yabancı anahtar özelliği ve Course gezinti özelliği vardırCourseID:

  public int CourseID { get; set; }
  public virtual Course Course { get; set; }
  

• Kayıt kaydı tek bir öğrenciye yöneliktir, bu nedenle yabancı anahtar özelliği ve Student gezinti özelliği vardırStudentID:

  public int StudentID { get; set; }
  public virtual Student Student { get; set; }
  

Çoka Çok İlişkiler

ve varlıkları arasında Student çoka çok ilişki vardır ve Enrollment varlık, veritabanında yükü olan çoka çok birleştirme tablosu olarak işlev görür.Course Bu, tablonun birleştirilen tablolar için yabancı anahtarların (bu örnekte birincil anahtar ve Grade özellik) yanı sıra ek veriler içerdiği anlamına gelirEnrollment.

Aşağıdaki çizimde bu ilişkilerin bir varlık diyagramında nasıl göründüğü gösterilmektedir. (Bu diyagram Entity Framework Power Tools kullanılarak oluşturulmuştur; diyagramı oluşturmak öğreticinin bir parçası değildir, yalnızca burada çizim olarak kullanılmaktadır.)

Her ilişki çizgisinin bir ucunda 1, diğer ucunda bir yıldız (*) vardır ve bu da bire çok ilişkisini gösterir.

Enrollment Tabloda not bilgileri yoksa, yalnızca ve iki yabancı anahtarı CourseIDStudentIDiçermesi gerekir. Bu durumda, veritabanında yükü ( veya saf birleştirme tablosu) olmayan çoka çok birleştirme tablosuna karşılık gelir ve bunun için bir model sınıfı oluşturmanız gerekmez. Instructor ve Course varlıkları bu tür bir çoka çok ilişkisine sahiptir ve gördüğünüz gibi aralarında varlık sınıfı yoktur:

Ancak, aşağıdaki veritabanı diyagramında gösterildiği gibi veritabanında bir birleştirme tablosu gereklidir:

Entity Framework tabloyu otomatik olarak oluşturur CourseInstructor ve ve gezinti özelliklerini okuyup güncelleştirerek dolaylı olarak okuyup güncelleştirirsiniz Instructor.CoursesCourse.Instructors .

Varlık ilişkisi diyagramı

Aşağıdaki çizimde, Tamamlanmış Okul modeli için Entity Framework Güç Araçları'nın oluşturduğu diyagram gösterilmektedir.

Çoka çok ilişki çizgilerinin (* - *) ve bire çok ilişki çizgilerinin (1 - *) yanı sıra, burada ve OfficeAssignment varlıkları arasındaki bire sıfır veya bir ilişki çizgisini (1- 0,.1) ve Eğitmen ile Bölüm varlıkları arasındaki Instructor sıfır veya bire çok ilişki çizgisini (0..1 - *) görebilirsiniz.

Veritabanı bağlamı için kod ekleme

Daha sonra sınıfına yeni varlıklar SchoolContext ekleyecek ve akıcı API çağrılarını kullanarak eşlemenin bazılarını özelleştireceksiniz. AŞAĞıDAKI örnekte olduğu gibi genellikle bir dizi yöntem çağrısının tek bir deyimde dizelenmesiyle kullanıldığından API "akıcıdır":

modelBuilder.Entity<Course>()
     .HasMany(c => c.Instructors).WithMany(i => i.Courses)
     .Map(t => t.MapLeftKey("CourseID")
         .MapRightKey("InstructorID")
         .ToTable("CourseInstructor"));

Bu öğreticide akıcı API'yi yalnızca özniteliklerle gerçekleştiremezseniz veritabanı eşlemesi için kullanacaksınız. Ancak, öznitelikleri kullanarak yapabileceğiniz biçimlendirme, doğrulama ve eşleme kurallarının çoğunu belirtmek için akıcı API'yi de kullanabilirsiniz. gibi MinimumLength bazı öznitelikler akıcı API ile uygulanamaz. Daha önce belirtildiği gibi şemayı MinimumLength değiştirmez, yalnızca istemci ve sunucu tarafı doğrulama kuralı uygular

Bazı geliştiriciler, varlık sınıflarını "temiz" tutmak için akıcı API'yi yalnızca kullanmayı tercih eder. İsterseniz öznitelikleri ve akıcı API'yi karıştırabilirsiniz ve yalnızca akıcı API kullanılarak yapılabilecek birkaç özelleştirme vardır, ancak genel olarak önerilen uygulama bu iki yaklaşımdan birini seçmek ve bunu mümkün olduğunca tutarlı bir şekilde kullanmaktır.

Yeni varlıkları veri modeline eklemek ve öznitelikleri kullanarak yapmadığınız veritabanı eşlemesini gerçekleştirmek için DAL\SchoolContext.cs dosyasındaki kodu aşağıdaki kodla değiştirin:

using ContosoUniversity.Models;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ContosoUniversity.DAL
{
   public class SchoolContext : DbContext
   {
      public DbSet<Course> Courses { get; set; }
      public DbSet<Department> Departments { get; set; }
      public DbSet<Enrollment> Enrollments { get; set; }
      public DbSet<Instructor> Instructors { get; set; }
      public DbSet<Student> Students { get; set; }
      public DbSet<OfficeAssignment> OfficeAssignments { get; set; }

      protected override void OnModelCreating(DbModelBuilder modelBuilder)
      {
         modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

         modelBuilder.Entity<Course>()
             .HasMany(c => c.Instructors).WithMany(i => i.Courses)
             .Map(t => t.MapLeftKey("CourseID")
                 .MapRightKey("InstructorID")
                 .ToTable("CourseInstructor"));
      }
   }
}

OnModelCreating yöntemindeki yeni deyim, çoka çok birleştirme tablosunu yapılandırıyor:

• ve Course varlıkları arasındaki Instructor çoka çok ilişkisi için kod birleştirme tablosunun tablo ve sütun adlarını belirtir. Code First, bu kod olmadan çoka çok ilişkisini sizin için yapılandırabilir, ancak bu ilişkiyi çağırmazsanız sütun için InstructorID gibi InstructorInstructorID varsayılan adlar alırsınız.

  modelBuilder.Entity<Course>()
      .HasMany(c => c.Instructors).WithMany(i => i.Courses)
      .Map(t => t.MapLeftKey("CourseID")
          .MapRightKey("InstructorID")
          .ToTable("CourseInstructor"));
  

Aşağıdaki kod, ve OfficeAssignment varlıkları arasındaki Instructor ilişkiyi belirtmek için öznitelikler yerine akıcı API'yi nasıl kullanabileceğinize ilişkin bir örnek sağlar:

modelBuilder.Entity<Instructor>()
    .HasOptional(p => p.OfficeAssignment).WithRequired(p => p.Instructor);

"Fluent API" deyimlerinin arka planda ne yaptığı hakkında bilgi için Fluent API blog gönderisine bakın.

Test verileriyle tohum veritabanı

Oluşturduğunuz yeni varlıklar için tohum verileri sağlamak için Migrations\Configuration.cs dosyasındaki kodu aşağıdaki kodla değiştirin.

namespace ContosoUniversity.Migrations
{
    using ContosoUniversity.Models;
    using ContosoUniversity.DAL;
    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Data.Entity.Migrations;
    using System.Linq;
    
    internal sealed class Configuration : DbMigrationsConfiguration<SchoolContext>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = false;
        }

        protected override void Seed(SchoolContext context)
        {
            var students = new List<Student>
            {
                new Student { FirstMidName = "Carson",   LastName = "Alexander", 
                    EnrollmentDate = DateTime.Parse("2010-09-01") },
                new Student { FirstMidName = "Meredith", LastName = "Alonso",    
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Arturo",   LastName = "Anand",     
                    EnrollmentDate = DateTime.Parse("2013-09-01") },
                new Student { FirstMidName = "Gytis",    LastName = "Barzdukas", 
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Yan",      LastName = "Li",        
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Peggy",    LastName = "Justice",   
                    EnrollmentDate = DateTime.Parse("2011-09-01") },
                new Student { FirstMidName = "Laura",    LastName = "Norman",    
                    EnrollmentDate = DateTime.Parse("2013-09-01") },
                new Student { FirstMidName = "Nino",     LastName = "Olivetto",  
                    EnrollmentDate = DateTime.Parse("2005-09-01") }
            };

            students.ForEach(s => context.Students.AddOrUpdate(p => p.LastName, s));
            context.SaveChanges();

            var instructors = new List<Instructor>
            {
                new Instructor { FirstMidName = "Kim",     LastName = "Abercrombie", 
                    HireDate = DateTime.Parse("1995-03-11") },
                new Instructor { FirstMidName = "Fadi",    LastName = "Fakhouri",    
                    HireDate = DateTime.Parse("2002-07-06") },
                new Instructor { FirstMidName = "Roger",   LastName = "Harui",       
                    HireDate = DateTime.Parse("1998-07-01") },
                new Instructor { FirstMidName = "Candace", LastName = "Kapoor",      
                    HireDate = DateTime.Parse("2001-01-15") },
                new Instructor { FirstMidName = "Roger",   LastName = "Zheng",      
                    HireDate = DateTime.Parse("2004-02-12") }
            };
            instructors.ForEach(s => context.Instructors.AddOrUpdate(p => p.LastName, s));
            context.SaveChanges();

            var departments = new List<Department>
            {
                new Department { Name = "English",     Budget = 350000, 
                    StartDate = DateTime.Parse("2007-09-01"), 
                    InstructorID  = instructors.Single( i => i.LastName == "Abercrombie").ID },
                new Department { Name = "Mathematics", Budget = 100000, 
                    StartDate = DateTime.Parse("2007-09-01"), 
                    InstructorID  = instructors.Single( i => i.LastName == "Fakhouri").ID },
                new Department { Name = "Engineering", Budget = 350000, 
                    StartDate = DateTime.Parse("2007-09-01"), 
                    InstructorID  = instructors.Single( i => i.LastName == "Harui").ID },
                new Department { Name = "Economics",   Budget = 100000, 
                    StartDate = DateTime.Parse("2007-09-01"), 
                    InstructorID  = instructors.Single( i => i.LastName == "Kapoor").ID }
            };
            departments.ForEach(s => context.Departments.AddOrUpdate(p => p.Name, s));
            context.SaveChanges();

            var courses = new List<Course>
            {
                new Course {CourseID = 1050, Title = "Chemistry",      Credits = 3,
                  DepartmentID = departments.Single( s => s.Name == "Engineering").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
                new Course {CourseID = 4022, Title = "Microeconomics", Credits = 3,
                  DepartmentID = departments.Single( s => s.Name == "Economics").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
                new Course {CourseID = 4041, Title = "Macroeconomics", Credits = 3,
                  DepartmentID = departments.Single( s => s.Name == "Economics").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
                new Course {CourseID = 1045, Title = "Calculus",       Credits = 4,
                  DepartmentID = departments.Single( s => s.Name == "Mathematics").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
                new Course {CourseID = 3141, Title = "Trigonometry",   Credits = 4,
                  DepartmentID = departments.Single( s => s.Name == "Mathematics").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
                new Course {CourseID = 2021, Title = "Composition",    Credits = 3,
                  DepartmentID = departments.Single( s => s.Name == "English").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
                new Course {CourseID = 2042, Title = "Literature",     Credits = 4,
                  DepartmentID = departments.Single( s => s.Name == "English").DepartmentID,
                  Instructors = new List<Instructor>() 
                },
            };
            courses.ForEach(s => context.Courses.AddOrUpdate(p => p.CourseID, s));
            context.SaveChanges();

            var officeAssignments = new List<OfficeAssignment>
            {
                new OfficeAssignment { 
                    InstructorID = instructors.Single( i => i.LastName == "Fakhouri").ID, 
                    Location = "Smith 17" },
                new OfficeAssignment { 
                    InstructorID = instructors.Single( i => i.LastName == "Harui").ID, 
                    Location = "Gowan 27" },
                new OfficeAssignment { 
                    InstructorID = instructors.Single( i => i.LastName == "Kapoor").ID, 
                    Location = "Thompson 304" },
            };
            officeAssignments.ForEach(s => context.OfficeAssignments.AddOrUpdate(p => p.InstructorID, s));
            context.SaveChanges();

            AddOrUpdateInstructor(context, "Chemistry", "Kapoor");
            AddOrUpdateInstructor(context, "Chemistry", "Harui");
            AddOrUpdateInstructor(context, "Microeconomics", "Zheng");
            AddOrUpdateInstructor(context, "Macroeconomics", "Zheng");

            AddOrUpdateInstructor(context, "Calculus", "Fakhouri");
            AddOrUpdateInstructor(context, "Trigonometry", "Harui");
            AddOrUpdateInstructor(context, "Composition", "Abercrombie");
            AddOrUpdateInstructor(context, "Literature", "Abercrombie");

            context.SaveChanges();

            var enrollments = new List<Enrollment>
            {
                new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Alexander").ID, 
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID, 
                    Grade = Grade.A 
                },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID, 
                    Grade = Grade.C 
                 },                            
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID, 
                    Grade = Grade.B
                 },
                 new Enrollment { 
                     StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID, 
                    Grade = Grade.B 
                 },
                 new Enrollment { 
                     StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID, 
                    Grade = Grade.B 
                 },
                 new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Composition" ).CourseID, 
                    Grade = Grade.B 
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Anand").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Anand").ID,
                    CourseID = courses.Single(c => c.Title == "Microeconomics").CourseID,
                    Grade = Grade.B         
                 },
                new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Barzdukas").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry").CourseID,
                    Grade = Grade.B         
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Li").ID,
                    CourseID = courses.Single(c => c.Title == "Composition").CourseID,
                    Grade = Grade.B         
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Justice").ID,
                    CourseID = courses.Single(c => c.Title == "Literature").CourseID,
                    Grade = Grade.B         
                 }
            };

            foreach (Enrollment e in enrollments)
            {
                var enrollmentInDataBase = context.Enrollments.Where(
                    s =>
                         s.Student.ID == e.StudentID &&
                         s.Course.CourseID == e.CourseID).SingleOrDefault();
                if (enrollmentInDataBase == null)
                {
                    context.Enrollments.Add(e);
                }
            }
            context.SaveChanges();
        }

        void AddOrUpdateInstructor(SchoolContext context, string courseTitle, string instructorName)
        {
            var crs = context.Courses.SingleOrDefault(c => c.Title == courseTitle);
            var inst = crs.Instructors.SingleOrDefault(i => i.LastName == instructorName);
            if (inst == null)
                crs.Instructors.Add(context.Instructors.Single(i => i.LastName == instructorName));
        }
    }
}

İlk öğreticide gördüğünüz gibi, bu kodun çoğu yalnızca yeni varlık nesnelerini güncelleştirir veya oluşturur ve test için gereken örnek verileri özelliklere yükler. Ancak varlıkla çoka çok ilişkisi olan varlığın nasıl Course işlendiğine Instructor dikkat edin:

var courses = new List<Course>
{
    new Course {CourseID = 1050, Title = "Chemistry",      Credits = 3,
      DepartmentID = departments.Single( s => s.Name == "Engineering").DepartmentID,
      Instructors = new List<Instructor>() 
    },
    ...
};
courses.ForEach(s => context.Courses.AddOrUpdate(p => p.CourseID, s));
context.SaveChanges();

Bir Course nesne oluşturduğunuzda, gezinti özelliğini kodunu Instructors = new List<Instructor>()kullanarak boş bir koleksiyon olarak başlatırsınızInstructors. Bu, yöntemi kullanılarak bununla Course ilgili varlıkların eklenmesini InstructorInstructors.Add mümkün kılar. Boş liste oluşturmadıysanız bu ilişkileri ekleyemezsiniz çünkü Instructors özelliği null olur ve bir Add yöntemi olmaz. Liste başlatmayı oluşturucuya da ekleyebilirsiniz.

Geçiş ekleme

PMC'den komutunu girin add-migration (komutu henüz yapmayın update-database ):

add-Migration ComplexDataModel

Komutu bu noktada çalıştırmayı update-database denediyseniz (henüz çalıştırmadıysanız) aşağıdaki hatayı alırsınız:

ALTER TABLE deyimi FOREIGN KEY kısıtlaması "FK_dbo ile çakışıyor. Course_dbo. Department_DepartmentID". Çakışma "ContosoUniversity" veritabanında, "dbo" tablosunda oluştu. Department", 'DepartmentID' sütunu.

Bazen var olan verilerle geçişleri yürütürken, yabancı anahtar kısıtlamalarını karşılamak için veritabanına saplama verileri eklemeniz gerekir ve şimdi yapmanız gereken budur. ComplexDataModel Up yönteminde oluşturulan kod, tabloya Course null atanamaz DepartmentID bir yabancı anahtar ekler. Kod çalıştırıldığında tabloda zaten satırlar Course olduğundan, AddColumn SQL Server sütuna null olemeyen hangi değeri koyacağını bilmediğinden işlem başarısız olur. Bu nedenle, yeni sütuna varsayılan bir değer vermek için kodu değiştirmeniz ve varsayılan bölüm olarak görev yapmak için "Temp" adlı bir saplama departmanı oluşturmanız gerekir. Sonuç olarak, mevcut Course satırların tümü yöntem çalıştırıldıktan sonra "Geçici" bölümle Up ilişkilendirilecektir. Bunları yöntemindeki doğru departmanlarla Seed ilişkilendirebilirsiniz.

<Timestamp>_ComplexDataModel.cs dosyasını düzenleyin, DepartmentID sütununu Course tablosuna ekleyen kod satırını açıklama satırı yapın ve aşağıdaki vurgulanan kodu ekleyin (açıklama satırı da vurgulanır):

CreateTable(
        "dbo.CourseInstructor",
        c => new
            {
                CourseID = c.Int(nullable: false),
                InstructorID = c.Int(nullable: false),
            })
        .PrimaryKey(t => new { t.CourseID, t.InstructorID })
        .ForeignKey("dbo.Course", t => t.CourseID, cascadeDelete: true)
        .ForeignKey("dbo.Instructor", t => t.InstructorID, cascadeDelete: true)
        .Index(t => t.CourseID)
        .Index(t => t.InstructorID);

    // Create  a department for course to point to.
    Sql("INSERT INTO dbo.Department (Name, Budget, StartDate) VALUES ('Temp', 0.00, GETDATE())");
    //  default value for FK points to department created above.
    AddColumn("dbo.Course", "DepartmentID", c => c.Int(nullable: false, defaultValue: 1)); 
    //AddColumn("dbo.Course", "DepartmentID", c => c.Int(nullable: false));

    AlterColumn("dbo.Course", "Title", c => c.String(maxLength: 50));

Seed Yöntem çalıştırıldığında tabloya Department satır ekler ve var olan Course satırları bu yeni Department satırlarla ilişkilendirir. Kullanıcı arabirimine hiç kurs eklemediyseniz artık "Geçici" bölüme veya sütundaki varsayılan değere Course.DepartmentID ihtiyacınız kalmaz. Birinin uygulamayı kullanarak kurs eklemiş olma olasılığına izin vermek için, varsayılan değeri sütundan kaldırıp "Geçici" bölümünü silmeden önce tüm Course satırların (yöntemin önceki çalıştırmaları Seed tarafından eklenenler değil) geçerli DepartmentID değerlere sahip olduğundan emin olmak için yöntem kodunu da güncelleştirmek Seed istersiniz.

Veritabanını güncelleştirme

Timestamp>_ComplexDataModel.cs dosyasını düzenlemeyi < tamamladıktan sonra, geçişi yürütmek için PMC'ye komutunu girinupdate-database.

update-database

Not

Verileri geçirirken ve şema değişiklikleri yaparken başka hatalar almak mümkündür. Çözemediğiniz geçiş hataları alırsanız, bağlantı dizesindeki veritabanı adını değiştirebilir veya veritabanını silebilirsiniz. En basit yaklaşım, veritabanınıWeb.config dosyasında yeniden adlandırmaktır. Aşağıdaki örnekte adın CU_Test olarak değiştirildiği gösterilmektedir:

<add name="SchoolContext" connectionString="Data Source=(LocalDb)\v11.0;Initial Catalog=CU_Test;Integrated Security=SSPI;" 
      providerName="System.Data.SqlClient" />

Yeni bir veritabanıyla geçirecek veri yoktur ve komutun update-database hatasız tamamlanma olasılığı çok daha yüksektir. Veritabanını silme yönergeleri için bkz. Visual Studio 2012'den Veritabanı Bırakma.

Bu başarısız olursa, deneyebileceğiniz bir diğer şey de PMC'ye aşağıdaki komutu girerek veritabanını yeniden başlatmaktır:

update-database -TargetMigration:0

Daha önce yaptığınız gibi veritabanını Sunucu Gezgini'nde açın ve tüm tabloların oluşturulduğunu görmek için Tablolar düğümünü genişletin. ( Sunucu Gezgini daha önce açık durumdaysa Yenile düğmesine tıklayın.)

Tablo için CourseInstructor model sınıfı oluşturmadınız. Daha önce açıklandığı gibi, bu, ve Course varlıkları arasındaki Instructor çoka çok ilişkisine yönelik bir birleştirme tablosudur.

Tabloya CourseInstructor sağ tıklayın ve gezinti özelliğine eklediğiniz varlıkların bir sonucu Instructor olarak içinde veri olduğunu doğrulamak için Course.InstructorsTablo Verilerini Göster'i seçin.

Kodu alma

Tamamlanan Projeyi İndir

Ek kaynaklar

Diğer Entity Framework kaynaklarına bağlantılar ASP.NET Veri Erişimi - Önerilen Kaynaklar'da bulunabilir.

Sonraki adımlar

Bu öğreticide şunları yaptınız:

• Veri modelini özelleştirme
• Güncelleştirilmiş Öğrenci varlığı
• Eğitmen varlığı oluşturuldu
• Oluşturulan OfficeAssignment varlığı
• Course varlığı değiştirildi
• Departman varlığı oluşturuldu
• Kayıt varlığı değiştirildi
• Veritabanı bağlamı için kod eklendi
• Test verileriyle dağıtılmış veritabanı
• Geçiş eklendi
• Veritabanı güncelleştirildi

Entity Framework'ün yüklendiği ilgili verilerin gezinti özelliklerine nasıl okunup görüntüleneceğini öğrenmek için sonraki makaleye ilerleyin.

İlgili verileri okuma