Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
LINQ naar SQL-objecten nemen altijd deel aan een bepaalde toestand. Bijvoorbeeld, wanneer LINQ naar SQL een nieuw object maakt, bevindt het object zich in de toestand Unchanged. Een nieuw object dat u zelf maakt, is onbekend voor de DataContext en bevindt zich in de Untracked status. Na een geslaagde uitvoering van SubmitChanges bevinden alle objecten die bekend zijn bij LINQ to SQL zich in Unchanged status. (De enige uitzondering wordt gevormd door degenen die succesvol uit de database zijn verwijderd, die zich in de Deleted staat bevinden en onbruikbaar zijn in dat DataContext exemplaar.)
Objectstatussen
De volgende tabel bevat de mogelijke statussen voor LINQ naar SQL-objecten.
| Staat | Beschrijving |
|---|---|
Untracked |
Een object dat niet wordt bijgehouden door LINQ naar SQL. Voorbeelden hiervan zijn: - Een object dat niet wordt opgevraagd via de huidige DataContext query (zoals een nieuw gemaakt object). - Een object dat is gemaakt via deserialisatie - Een object dat wordt opgevraagd via een andere DataContext. |
Unchanged |
Een object dat is opgehaald met behulp van de huidige DataContext en waarvan niet bekend is dat het gewijzigd is sinds de creatie. |
PossiblyModified |
Een object dat is gekoppeld aan een DataContext. Zie Gegevens ophalen en CUD-bewerkingen in N-tier-toepassingen (LINQ naar SQL) voor meer informatie. |
ToBeInserted |
Een object dat niet wordt opgehaald met behulp van de huidige DataContext. Dit leidt tot een database INSERT gedurende SubmitChanges. |
ToBeUpdated |
Een object waarvan bekend is dat het is gewijzigd sinds het is opgehaald. Dit leidt tot een database UPDATE gedurende SubmitChanges. |
ToBeDeleted |
Een object dat is gemarkeerd voor verwijdering, waardoor er een probleem met de database ontstaat tijdens DELETESubmitChanges. |
Deleted |
Een object dat in de database is verwijderd. Deze status is definitief en staat geen extra overgangen toe. |
Objecten invoegen
U kunt expliciet aanvragen Inserts met behulp van InsertOnSubmit. LinQ naar SQL kan ook afleiden Inserts door objecten te vinden die zijn verbonden met een van de bekende objecten die moeten worden bijgewerkt. Als u bijvoorbeeld een Untracked object toevoegt aan een EntitySet<TEntity> of een EntityRef<TEntity> object instelt op een Untracked object, maakt u het Untracked object bereikbaar via bijgehouden objecten in de grafiek. Tijdens de verwerking SubmitChanges doorkruist LINQ naar SQL de bijgehouden objecten en ontdekt eventuele bereikbare permanente objecten die niet worden bijgehouden. Dergelijke objecten zijn kandidaten voor invoeging in de database.
Voor klassen in een overnamehiërarchie InsertOnSubmitstelt (o) ook de waarde in van het lid dat is aangewezen als de discriminator die overeenkomt met het type van het object o. In het geval van een type dat overeenkomt met de standaarddiscriminatorwaarde, zorgt deze actie ervoor dat de discriminatorwaarde wordt overschreven met de standaardwaarde. Zie Overnameondersteuning voor meer informatie.
Belangrijk
Een object dat aan een Table object is toegevoegd, bevindt zich niet in de identiteitscache. De identiteitscache geeft alleen weer wat uit de database wordt opgehaald. Na een aanroep naar InsertOnSubmit, wordt de toegevoegde entiteit pas weergegeven in query's voor de database wanneer het proces rond SubmitChanges succesvol is voltooid.
Objecten verwijderen
Je markeert een bijgehouden object o voor verwijdering door DeleteOnSubmit(o) aan te roepen op de betreffende Table<TEntity>. LINQ naar SQL beschouwt het verwijderen van een object uit een EntitySet<TEntity> als een updatebewerking, en de bijbehorende vreemde-sleutelwaarde wordt ingesteld op null. Het doel van de bewerking (o) wordt niet verwijderd uit de tabel. Geeft bijvoorbeeld cust.Orders.DeleteOnSubmit(ord) een update aan waarbij de relatie tussen cust en ord wordt verbroken door de refererende sleutel ord.CustomerID in te stellen op null. Dit veroorzaakt geen verwijdering van de rij die overeenkomt met ord.
LINQ naar SQL voert de volgende verwerking uit wanneer een object wordt verwijderd (DeleteOnSubmit) uit de tabel:
Wanneer SubmitChanges wordt aangeroepen, wordt een
DELETEbewerking voor dat object uitgevoerd.De verwijdering wordt niet doorgegeven aan gerelateerde objecten, ongeacht of ze worden geladen. Gerelateerde objecten worden niet geladen voor het bijwerken van de relatie-eigenschap.
Nadat de succesvolle uitvoering van SubmitChanges is voltooid, worden de objecten in de
Deletedstatus gebracht. Als gevolg hiervan kunt u het object of deidervan niet gebruiken in die DataContext. De interne cache die door een DataContext exemplaar wordt onderhouden, elimineert geen objecten die als nieuw worden opgehaald of toegevoegd, zelfs nadat de objecten in de database zijn verwijderd.
U kunt DeleteOnSubmit alleen aanroepen op een object dat wordt bijgehouden door de DataContext. Voor een Untracked object moet u aanroepen Attach voordat u aanroept DeleteOnSubmit. Het aanroepen van DeleteOnSubmit op een Untracked object werpt een uitzondering op.
Opmerking
Als u een object uit een tabel verwijdert, wordt aan LINQ aan SQL gevraagd om een overeenkomstige SQL-opdracht DELETE te genereren tijdens SubmitChanges. Met deze actie wordt het object niet uit de cache verwijderd of wordt de verwijdering doorgegeven aan gerelateerde objecten.
Om het id van een verwijderd object terug te vorderen, gebruikt u een nieuw DataContext exemplaar. Voor het opschonen van gerelateerde objecten kunt u de functie trapsgewijs verwijderen van de database gebruiken of de gerelateerde objecten handmatig verwijderen.
De gerelateerde objecten hoeven niet in een speciale volgorde te worden verwijderd (in tegenstelling tot in de database).
Objecten bijwerken
U kunt Updates detecteren door meldingen van wijzigingen te bekijken. Meldingen worden verstrekt via de PropertyChanging gebeurtenis in eigenschapssetters. Wanneer LINQ naar SQL wordt geïnformeerd over de eerste wijziging in een object, wordt er een kopie van het object gemaakt en wordt het object beschouwd als een kandidaat voor het genereren van een Update instructie.
Voor objecten die niet worden geïmplementeerd INotifyPropertyChanging, onderhoudt LINQ naar SQL een kopie van de waarden die objecten hadden toen ze voor het eerst werden gerealiseerd. Wanneer u LINQ aanroept SubmitChanges, vergelijkt LINQ met SQL de huidige en oorspronkelijke waarden om te bepalen of het object is gewijzigd.
Voor updates van relaties wordt de verwijzing van het kind naar de bovenliggende entiteit (oftewel de verwijzing die overeenkomt met de vreemde sleutel) beschouwd als de autoriteit. De verwijzing in omgekeerde richting (dat wil zeggen, van ouder naar kind) is optioneel. Relatieklassen (EntitySet<TEntity> en EntityRef<TEntity>) garanderen dat de bidirectionele verwijzingen consistent zijn voor een-op-veel- en een-op-een-relaties. Als het objectmodel geen gebruik maakt van EntitySet<TEntity> of EntityRef<TEntity>, en de omgekeerde verwijzing is aanwezig, dan is het uw verantwoordelijkheid om deze consistent te houden met de doorstuurverwijzing wanneer de relatie wordt bijgewerkt.
Als u zowel de vereiste verwijzing als de bijbehorende foreign key bijwerkt, moet u ervoor zorgen dat ze met elkaar overeenkomen. Er wordt een InvalidOperationException uitzondering gegenereerd als de twee niet gesynchroniseerd zijn op het moment dat u SubmitChanges aanroept. Hoewel wijzigingen in de refererende sleutelwaarde voldoende zijn om een update van de onderliggende rij te beïnvloeden, moet u de verwijzing wijzigen om de connectiviteit van de objectgrafiek en bidirectionele consistentie van relaties te behouden.