Az Entity Framework Code First -öt a projektben főleg a rugalmasabb adatbázis létrehozására, alakítására, optimalizálására fogom használni. Az EFCF feladata elsősorban az lesz, hogy a C# -ban létrehozott osztályok, kontextus osztályok alapján adatbázisokat hozzon létre. Így nagyobb hangsúlyt lehet fektetni magára az oldal designra, ahelyett, hogy a régi módszer szerint felépített adatbázis köré tervezett oldalt fejlesztenénk.
Az alap munkamenet a következő:
- Megírjuk az applikáció tartomány, és kontextus osztályait.
- Beállítjuk a tartomány, és kontextus osztályokat a további feltérképezés miatt.
- Futtatjuk az applikációnkat.
- A Code First API létrehozza az új adatbázisokat, vagy feltérképezi a már létezőket a tartomány osztályokkal.
- Alap teszt adatokkal tölti fel az adatbázisokat.
- elindítja az applikációt.
Miután felraktam a szükséges programokat, csomagokat, neki is láttam egy alap kis osztály szerkezet megvalósításának, amely alapján majd felépíthetem az app adatbázisát. Kezdésnek definiáltam egy alap Person osztályt, amelyből majd a szociális API-knak megfelelően különböző formái lesznek, de egyenlőre egy sima is elég lesz.
public class Person
{
}
public Person()
{
}
public int personID { get; set; }
public string personName { get; set; }
public DateTime? DateOfBirth { get; set; }
public byte[] photo { get; set; }}
public PData PData { get; set; }
}
Ezt követően létrehozok egy PData nevű osztályt, amiben a személyek gyűjteményének definícióját adom meg.
public class PData
{
public PData()
{
}
public int PDataId { get; set; }
public string PDataName { get; set; }
public ICollection<Person> Persons { get; set; }
}
Ekkor meg is vagyunk a kezdetleges tartományokkal. A továbbiakban egy Kontextus osztályra lesz szükségünk, amelyet a DbContext\Dbset használatával valósíthatunk meg a következő képpen.
public class PersonContext : DbContext
{
public PersonContext() : base()
{
}
public DbSet<Person> Persons { get; set; }
public DbSet<PData> PDatas { get; set; }
}
Ezzel meg is lenne a Code-First megközelítésünk, vagyis a továbbiakban a kontextuson keresztül tudunk adatot hozzáadni az adatbázisunkhoz. Amennyiben ezt a programot lefuttatjuk lehet látni, hogy az adatbázishoz új adatot adtunk hozzá. Az SQL Server explorer-ben meg is lehet nézni, hogy a kód futtatásával az új adatbázis, és bizonyos adat mezők, kulcsok, idegen kulcsok lettek létrehozva, anélkül, hogy ahhoz hozzányúltunk volna külön.
Amennyiben kiegészítem a kódot, egy további FBPerson osztállyal, és azt a Person osztályon belül megadom ugyanúgy, mint a sima Person -t, de a kontextus osztályban nem lesz definiálva, akkor is létrehozza a Code-First a neki megfelelő osztályt, és kulcsot. Ezzel láthatjuk, hogy a Code-First nem csak a kontextusban megadott egyedeket készíti el, hanem az egyéb referencia egyedeket is.
A Code-First bizonyos alap szabályok szerint működik. Például az elsődleges kulcs generálásánál azt a változót adja meg, amelynek a nevében Id található( <ClassName>Id ). Amennyiben ettől a formától eltérő kulcsot akarunk megadni a DataAnnotation-t, vagy Fluent API-t kell használnunk hozzá.
A kapcsolatokat a két egyed között navigációs property-vel lehet megadni. Az egyik osztályban létrehozzuk az annak megfelelő navigációs property -t, majd a másik osztályban pedig az annak megfelelő kolekciót. Esetünkben ez itt a Person osztályban:
public PData PData { get; set; }
, a PData osztályban pedig a:
public ICollection<Person> Persons { get; set; }
kollekció definiálásával történt meg. Így a Code-First automatikusan létrehozott egy egy-több -es kapcsolatot úgy, hogy egy idegen kulcsot illesztett be a Person táblába. Idegen kulcsot megadhatunk a következő formával is :
public int PDataId { get; set; }
A táblák, és egyedek alapértelmezett esetben a EntityFramework által generálódnak, de van lehetőség megadni neki, hogy egy általunk használni kívánt adatbázist használjon. Egyik ilyen lehetőség, ha a kontextus osztályban a base() konstruktornak paraméterben megadjuk a használni kívánt adatbázis nevét pl.:
public PersonContext() : base("DEV") { … }
Másik lehetőség, egy ConnectionString név string megadása az App.config, vagy Web.config segítségével:
<connectionStrings>
<add name="PersonDBConnectionString" connectionString="Data Source=.;Initial Catalog=PersonDB-ByConnectionString;Integrated Security=true" providerName="System.Data.SqlClient"/>
</connectionStrings>
Ilyenkor a base() konstruktornak a paramétere a következő lenne:
public PersonContext() : base("name=PersonDBConnectionString") { … }
Amennyiben nem írjuk oda a „name=” részt, az adatbázis nevének tekinti a stringet.
A korábban említett DataAnnotation, és FluentAPI az adatbázis modellezésének specifikusabb meghatározására alkalmazható. A DataAnnotation a System.ComponentModel.DataAnnotations útvonalon érhető el, ilyenkor az adatbázis tábláit a következő módon adhatjuk meg:
[Table("PersonInfo")]
public class Person
{
public Person()
{
}
[Key]
public int personID { get; set; }
[Column("Name", TypeName = "ntext")]
[MaxLength(20)]
public string personName { get; set; }
[NotMapped]
public DateTime? DateOfBirth { get; set; }
[NotMapped]
public byte[] photo { get; set; }
public FBPerson { get; set; }
[ForeignKey("StdId")]
public virtual PData PData { get; set; }
}
A FluentAPI -t a kontextus osztályban kell megvalósítani a következő képpen:
protectedoverridevoid OnModelCreating(DbModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); }