Samtidig håndtering kan bruges til at opretholde dataintegritet og datakonsistens, når flere brugere får adgang til den samme ressource samtidigt. Samtidige overtrædelser kan forekomme, når du har indbyrdes afhængige transaktioner, dvs. transaktioner, der er afhængige af hinanden og forsøger at få adgang til den samme ressource.
Håndtering af samtidighedskonflikter i Entity Framework
Lad os nu forstå, hvordan hver af disse strategier fungerer i Entity Framework. I den pessimistiske samtidighed, når en bestemt post opdateres, vil alle andre samtidige opdateringer på den samme post blive sat i bero, indtil den aktuelle operation er afsluttet, og kontrollen opgives tilbage, så andre samtidige operationer kan fortsætte. I den optimistiske samtidighedstilstand vinder den sidst gemte post "." I denne tilstand antages det, at ressourcekonflikter på grund af samtidig adgang til en delt ressource er usandsynlige, men ikke umulige.
I øvrigt understøtter Entity Framework som standard optimistisk samtidighed. Entity Framework yder ikke support til pessimistisk samtidighed uden for boksen. Lad os nu forstå, hvordan Entity Framework løser samtidighedskonflikter, når vi arbejder i den optimistiske samtidighed (standardtilstand).
Når du arbejder med optimistisk samtidig håndteringstilstand, vil du typisk gemme data i din database, forudsat at dataene ikke er ændret, siden de blev indlæst i hukommelsen. Bemærk, at når dit forsøg på at gemme ændringer i databasen ved hjælp af SaveChanges-metoden i din datakontekstforekomst, kastes en DbUpdateConcurrencyException. Lad os nu forstå, hvordan vi kan løse dette.
For at kontrollere for overtrædelse af samtidighed kan du medtage et felt i din enhedsklasse og markere det ved hjælp af tidsstempelattributten. Se enhedsklassen nedenfor.
offentlig klasse Forfatter
{
offentlig Int32 Id {get; sæt; }
offentlig streng Fornavn {get; sæt; }
public string LastName {get; sæt; }
public string Address {get; sæt; }
[Tidsstempel]
offentlig byte [] RowVersion {get; sæt; }
}
Nu understøtter Entity Framework to samtidige tilstande: Ingen og Fast. Mens førstnævnte indebærer, at der ikke udføres nogen samtidighedskontrol, når enheden opdateres, antyder sidstnævnte, at den oprindelige værdi af ejendommen vil blive taget i betragtning under udførelsen af WHERE-klausuler på det tidspunkt, hvor opdateringer eller sletninger af data udføres. Hvis du har en egenskab, der er markeret ved hjælp af tidsstempel, betragtes samtidighedstilstanden som fast, hvilket igen indebærer, at ejendommens oprindelige værdi vil blive betragtet i WHERE-klausulen om eventuelle opdateringer eller sletninger af data for den pågældende enhed.
For at løse optimistiske samtidighedskonflikter kan du udnytte metoden Reload til at opdatere de aktuelle værdier i din enhed, der er i hukommelsen, med de seneste værdier i databasen. Når de er blevet genindlæst med de opdaterede data, kan du forsøge at fastholde din enhed igen i databasen. Følgende kodestykke illustrerer, hvordan dette kan opnås.
ved hjælp af (var dbContext = ny IDBDataContext ())
{
Forfatterforfatter = dbContext.Authors.Find (12);
author.Address = "Hyderabad, Telengana, INDIEN";
prøve
{
dbContext.SaveChanges ();
}
fangst (DbUpdateConcurrencyException ex)
{
ex.Entries.Single (). Genindlæs ();
dbContext.SaveChanges ();
}
}
Bemærk, at du kan udnytte metoden Entries i DbUpdateConcurrencyException-forekomsten for at hente listen over DbEntityEntry-forekomster, der svarer til de enheder, der ikke kunne opdateres, når en SaveChanges-metode blev kaldt for at fastholde enhederne til databasen.
Nu kaldes den tilgang, vi lige har diskuteret, ofte "lagrede gevinster" eller "database vinder", da dataene i enheden overskrives af de tilgængelige data i databasen. Du kan også følge en anden tilgang kaldet "klient vinder". I denne strategi hentes dataene fra databasen for at udfylde enheden. I det væsentlige indstilles de data, der hentes fra den underliggende database, som de oprindelige værdier for enheden. Følgende kodestykke illustrerer, hvordan dette kan opnås.
prøve
{
dbContext.SaveChanges ();
}
fangst (DbUpdateConcurrencyException ex)
{
var data = ex.Entries.Single ();
data.OriginalValues.SetValues (data.GetDatabaseValues ());
}
Du kan også kontrollere, om den enhed, du prøver at opdatere, allerede er slettet af en anden bruger eller allerede er blevet opdateret af en anden bruger. Følgende kodestykke illustrerer, hvordan du kan gøre dette.
fangst (DbUpdateConcurrencyException ex)
{
var entity = ex.Entries.Single (). GetDatabaseValues ();
hvis (enhed == null)
{
Console.WriteLine ("Enheden, der opdateres, er allerede slettet af en anden bruger ...");
}
andet
{
Console.WriteLine ("Den enhed, der opdateres, er allerede blevet opdateret af en anden bruger ...");
}
}
Hvis din databasetabel ikke har en tidsstempelkolonne eller rækkeversion, kan du drage fordel af attributten ConcurrencyCheck til at opdage samtidige konflikter, når du bruger Entity Framework. Sådan bruges denne egenskab.
[Tabel ("Forfattere"]
offentlig klasse Forfatter
{
offentlig forfatter () {}
[Nøgle]
public int Id {get; sæt; }
[ConcurrencyCheck]
offentlig streng Fornavn {get; sæt; }
public string LastName {get; sæt; }
public string Address {get; sæt; }
}
Ved at gøre det vil SQL Server automatisk inkludere AuthorName, når de udfører opdatering eller sletning af udsagn i databasen.
