Aggiunta, modifica ed eliminazione di oggetti (Entity Framework)

Gli oggetti presenti in un contesto dell'oggetto sono istanze dei tipi di entità che rappresentano i dati nell'origine dati. È possibile modificare, creare ed eliminare gli oggetti in un contesto dell'oggetto. Object Services consente di rilevare le modifiche apportate a tali oggetti. Quando viene chiamato il metodo SaveChanges, tramite Object Services vengono generati e avviati comandi che eseguono le istruzioni INSERT, UPDATE o DELETE equivalenti sull'origine dati. Per ulteriori informazioni, vedere Salvataggio delle modifiche e gestione della concorrenza (Entity Framework).

Si supponga ad esempio di eseguire una query che restituisce un oggetto SalesOrderHeader e un insieme di oggetti SalesOrderDetail correlati. È possibile enumerare l'insieme ed effettuare le operazioni seguenti:

  • Modificare la proprietà ShipDate di un ordine.

  • Eliminare un elemento specifico chiamando il metodo DeleteObject.

  • Aggiungere una voce all'ordine chiamando il metodo Add.

  • Chiamare il metodo SaveChanges sul contesto dell'oggetto per salvare di nuovo le modifiche all'oggetto nell'origine dati.

Nell'esempio seguente sono illustrate diverse modifiche agli oggetti in un contesto dell'oggetto:

Dim order As SalesOrderHeader = _
context.SalesOrderHeader.Where( _
        "it.SalesOrderID = @id", New ObjectParameter( _
         "id", orderId)).First()

' Change the status and ship date of an existing order.
order.Status = 1
order.ShipDate = DateAndTime.Today

' Load items for the order, if not already loaded.
If Not order.SalesOrderDetail.IsLoaded Then
    order.SalesOrderDetail.Load()
End If

' Delete the first item in the order.
context.DeleteObject(order.SalesOrderDetail.First())

' Create a new item using the static Create method
' and add it to the order.
order.SalesOrderDetail.Add( _
    SalesOrderDetail.CreateSalesOrderDetail( _
    1, 0, 2, 750, 1, CDec(2171.2942), 0, 0, Guid.NewGuid(), _
    DateAndTime.Today))

' Save changes in the object context to the database.
Dim changes As Integer = context.SaveChanges()

SalesOrderHeader order =
    context.SalesOrderHeader.Where
    ("it.SalesOrderID = @id", new ObjectParameter(
     "id", orderId)).First();

// Change the status and ship date of an existing order.
order.Status = 1;
order.ShipDate = DateTime.Today;

// Load items for the order, if not already loaded.
if (!order.SalesOrderDetail.IsLoaded)
{
    order.SalesOrderDetail.Load();
}

// Delete the first item in the order.
context.DeleteObject(order.SalesOrderDetail.First());

// Create a new item using the static Create method 
// and add it to the order.
order.SalesOrderDetail.Add(
    SalesOrderDetail.CreateSalesOrderDetail(0,
    0, 2, 750, 1, (decimal)2171.2942, 0, 0,
    Guid.NewGuid(), DateTime.Today));

// Save changes in the object context to the database.
int changes = context.SaveChanges();

Aggiunta di oggetti

Quando si desidera inserire dati nell'origine dati, è necessario creare un'istanza di un tipo di entità e aggiungere l'oggetto a un contesto dell'oggetto. Prima che sia possibile aggiungere un nuovo oggetto, è necessario impostare tutte le proprietà che non supportano valori null. Utilizzare il metodo statico CreateNomeOggetto del tipo di entità per creare una nuova istanza di quest'ultima. Gli strumenti Entity Data Model prevedono l'inclusione di tale metodo in ogni classe quando vengono generati i tipi di entità. Il metodo Create in questione viene utilizzato per creare un'istanza di un oggetto e impostare tutte le proprietà della classe che non possono essere null. Il metodo include un parametro per ogni proprietà per cui sia stato applicato l'attributo Nullable="false" nel file CSDL.

Nell'esempio seguente viene utilizzato il metodo statico CreateSalesOrderHeader per creare una nuova istanza della classe SalesOrderHeader.

' Create a new SalesOrderHeader using the static 
' CreateSalesOrderHeader method.
Dim order As SalesOrderHeader = _
    SalesOrderHeader.CreateSalesOrderHeader( _
    1, Convert.ToByte(1), DateTime.Now, DateTime.Today.AddMonths(2), _
    Convert.ToByte(1), False, String.Empty, customer.ContactID, shipMethod, _
    0, 0, 0, 0, Guid.NewGuid(), DateTime.Now)

// Create a new SalesOrderHeader using the static 
// CreateSalesOrderHeader method.
SalesOrderHeader order = SalesOrderHeader.CreateSalesOrderHeader(0,
    Convert.ToByte(1), DateTime.Now, DateTime.Today.AddMonths(2),
    Convert.ToByte(1), false, string.Empty, customer.ContactID, shipMethod, 
    0, 0, 0, 0, Guid.NewGuid(), DateTime.Now);

Per ulteriori informazioni, vedere Procedura: creare un oggetto utilizzando il metodo di creazione statico (Entity Framework).

È possibile aggiungere nuovi oggetti a un contesto dell'oggetto chiamando il metodo AddObject o chiamando uno dei metodi AddToNomeEntitySet sull'oggetto ObjectContext tipizzato. È anche possibile aggiungere un oggetto a un contesto inserendolo in un oggetto EntityCollection esistente. Quando si chiama il metodo Add su un oggetto EntityCollection collegato a un contesto dell'oggetto, l'oggetto aggiunto viene inserito nello stesso ObjectContext. Analogamente, è possibile aggiungere un oggetto impostandone l'istanza sulla proprietà Value di un oggetto EntityReference.

Le proprietà di navigazione definiscono le relazioni tra gli oggetti. È consigliabile impostare queste proprietà quando l'oggetto è correlato ad altri nel contesto dell'oggetto. Impostare, ad esempio, la proprietà della relazione SalesOrderHeader di un nuovo oggetto SalesOrderDetail sull'istanza dell'ordine a cui appartiene la voce. Quando si crea un nuovo oggetto correlato a un altro oggetto nel contesto dell'oggetto, aggiungere l'oggetto utilizzando uno dei metodi seguenti:

  • Per una relazione uno-a-molti o molti-a-molti, chiamare il metodo Add su EntityCollection e specificare l'oggetto correlato.

  • Per una relazione uno-a-uno o molti-a-uno, impostare la proprietà Value di EntityReference sull'oggetto correlato.

  • Chiamare il metodo AddObject per aggiungere il nuovo oggetto al contesto dell'oggetto, quindi definire la relazione utilizzando uno dei due metodi precedenti.

Le considerazioni seguenti riguardano l'aggiunta di nuovi oggetti:

  • Prima della chiamata a SaveChanges, tramite Object Services viene generato un valore di chiave temporanea per ogni nuovo oggetto aggiunto utilizzando il metodo AddObject. Dopo la chiamata a SaveChanges, il valore di chiave viene sostituito dal valore Identity assegnato dall'origine dati quando viene inserita una nuova riga.

  • Se il valore di chiave di un'entità non viene generato dall'origine dati, è necessario assegnare un valore univoco. Se due oggetti hanno lo stesso valore di chiave specificato dall'utente, quando viene chiamato SaveChanges viene generata un'eccezione InvalidOperationException. In questo caso, assegnare valori univoci e riprovare a eseguire l'operazione.

  • Entity Framework imposta automaticamente i valori di chiave esterna nell'origine dati quando si definisce una relazione tra oggetti e si chiama il metodo SaveChanges. Quando invece un'entità è mappata a stored procedure che eseguono inserimenti, aggiornamenti ed eliminazioni, i valori di chiave esterna non vengono impostati automaticamente. In tal caso, è necessario impostare le proprietà corrispondenti alla chiave esterna sui valori corretti per l'oggetto correlato. Per ulteriori informazioni, vedere Supporto delle stored procedure (Entity Framework).

Modifica di oggetti

Quando si modifica una proprietà scalare, complessa o di navigazione di un oggetto e si chiama il metodo SaveChanges, gli aggiornamenti vengono inviati all'origine dati. Per modificare le relazioni tra oggetti è necessario cambiare le proprietà di navigazione, ad esempio modificando il valore di un oggetto EntityReference o rimuovendo un oggetto da un EntityCollection. Per ulteriori informazioni, vedere Procedura: modificare le relazioni tra gli oggetti (Entity Framework).

Object Services consente di rilevare le modifiche apportate agli oggetti collegati a un oggetto ObjectContext utilizzando un'istanza di IEntityChangeTracker. Esiste una sola istanza di IEntityChangeTracker per ogni oggetto rilevato. Le query restituiscono gli oggetti in uno stato Unchanged, a meno che la query non stia utilizzando un'enumerazione MergeOption impostata su NoTracking. Gli strumenti Entity Data Model generano chiamate ai metodi di rilevamento delle modifiche nel metodo per l'impostazione della proprietà di ogni proprietà di un tipo di entità, come nell'esempio seguente nel metodo per l'impostazione della proprietà Status nella classe SalesOrderHeader.

Set(ByVal value As Byte)
    Me.OnStatusChanging(value)
    Me.ReportPropertyChanging("Status")
    Me._Status = Global.System.Data.Objects.DataClasses.StructuralObject.SetValidValue(value)
    Me.ReportPropertyChanged("Status")
    Me.OnStatusChanged()
End Set

set
{
    this.OnStatusChanging(value);
    this.ReportPropertyChanging("Status");
    this._Status = global::System.Data.Objects.DataClasses.StructuralObject.SetValidValue(value);
    this.ReportPropertyChanged("Status");
    this.OnStatusChanged();
}

I metodi ReportPropertyChanging e ReportPropertyChanged segnalano le modifiche alle proprietà a IEntityChangeTracker. Quando si utilizzano classi di dati personalizzate con Entity Data Model (EDM), è necessario segnalare anche le modifiche alle proprietà per attivare il rilevamento mediante Object Services. Per ulteriori informazioni, vedere Segnalazione delle modifiche nelle classi di dati personalizzate (Entity Framework).

Lo stato di un oggetto viene passato da Unchanged in Modified ogni volta che viene chiamato un metodo per l'impostazione di una proprietà. Ciò si verifica anche se il valore impostato corrisponde a quello corrente. Dopo la chiamata al metodo AcceptAllChanges, lo stato viene reimpostato su Unchanged. Per impostazione predefinita, il metodo AcceptAllChanges viene chiamato durante l'operazione SaveChanges.

Gli strumenti Entity Data Model generano anche una coppia di metodi parziali denominati OnProprietàChanging e OnProprietàChanged. Questi metodi vengono chiamati nel metodo per l'impostazione della proprietà. Estenderli nelle classi parziali per inserire la logica di business personalizzata durante le modifiche alle proprietà. Per ulteriori informazioni, vedere Procedura: eseguire la logica di business quando vengono modificate le proprietà (Entity Framework).

Le considerazioni seguenti riguardano la modifica di oggetti:

  • Quando si modifica una proprietà scalare o complessa di un oggetto complesso, lo stato dell'oggetto entità di livello superiore viene impostato su Modified.

  • Le modifiche non vengono rilevate quando lo stato degli oggetti è Detached. Lo stato degli oggetti è tale quando vengono restituiti da una query che utilizza l'opzione di unione NoTracking o dopo la disconnessione da un ObjectContext mediante la chiamata al metodo Detach.

  • È possibile modificare una relazione tra due oggetti assegnando il valore EntityReference a un nuovo oggetto. In tal caso, Entity Framework aggiorna automaticamente i valori di chiave esterna nell'origine dati quando si chiama il metodo SaveChanges. Quando invece un'entità è mappata a stored procedure che eseguono inserimenti, aggiornamenti ed eliminazioni, i valori di chiave esterna non vengono aggiornati automaticamente. In tal caso, è necessario impostare le proprietà corrispondenti alla chiave esterna sui valori corretti per la nuova relazione. Per ulteriori informazioni, vedere Supporto delle stored procedure (Entity Framework).

Eliminazione di oggetti

Se si chiama il metodo DeleteObject sulla classe ObjectContext, questa viene contrassegnata per l'eliminazione. La riga viene eliminata dall'origine dati solo dopo la chiamata al metodo SaveChanges.

Le considerazioni seguenti riguardano l'eliminazione di oggetti:

  • L'eliminazione di un oggetto determina anche l'eliminazione di qualsiasi relazione con altri oggetti.

  • Quando due oggetti fanno parte di una relazione vincolata, l'eliminazione dell'oggetto padre comporta anche l'eliminazione di tutti gli oggetti figlio. Il risultato è identico a quello prodotto dall'attivazione della proprietà CascadeDelete nell'associazione per la relazione. Per ulteriori informazioni, vedere Vincoli referenziali (Entity Framework).

  • Quando un oggetto restituito da una query è correlato a uno o più oggetti, la query restituisce sempre informazioni sugli oggetti correlati in modo da semplificarne l'eliminazione. In alcuni casi, queste informazioni esistenti possono determinare la creazione di un'eccezione UpdateException quando si tenta di eliminare un oggetto. Questa eccezione viene ad esempio generata quando per l'associazione che definisce la relazione viene specificato l'elemento <OnDelete Action="Cascade" /> nell'oggetto End padre dell'oggetto Association. Se si verifica ciò, caricare in modo esplicito l'oggetto correlato prima di chiamare il metodo DeleteObject.

  • È possibile chiamare nuovamente il metodo DeleteObject per un oggetto già eliminato.

Per ulteriori informazioni, vedere Procedura: aggiungere, modificare ed eliminare oggetti (Entity Framework).

Creazione di oggetti in un elemento EntitySet specifico

In alcune situazioni un tipo di entità può appartenere a più set di entità. Si consideri, ad esempio, una situazione in cui un database include due tabelle con schemi identici. Questo potrebbe verificarsi si desidera partizionare i dati per migliorare l'efficacia del processo di backup. Si potrebbe ad esempio disporre di dati dei clienti partizionati tra le tabelle Customer e CustomerArchive, dove la tabella CustomerArchive ha lo stesso schema di Customer, ma viene utilizzata per i clienti che non hanno effettuato ordini per più dei sei mesi. È possibile eseguire il backup di Customer ogni notte, mentre quello di CustomerArchive solo ogni settimana. Dal punto di vista del mapping, Customer e CustomerArchive devono appartenere a set di entità diversi. Entity Framework supporta questo scenario consentendo la presenza di un tipo di entità in uno o più set di entità. Per ulteriori informazioni, vedere Set di entità (EDM).

Quando un tipo di entità è presente in più set di entità, Object Services consente di aggiungere nuove istanze del tipo a un set di entità specifico. A tale scopo, è necessario specificare il valore di entitySetName quando si chiama il metodo AddObject per aggiungere l'oggetto al contesto dell'oggetto. Per ulteriori informazioni, vedere Procedura: aggiungere un oggetto a un set di entità specifico (Entity Framework).

Gli strumenti Entity Data Model generano anche i metodi AddToNomeEntitySet su ObjectContext, con un metodo per ogni set di entità definito nel modello concettuale. Tali metodi chiamano AddObject e passano il valore NomeEntitySet del metodo specifico. Utilizzare questi metodi per aggiungere oggetti a set di entità specifici.

Vedere anche

Attività

Procedura: definire un modello con più set di entità per tipo (Entity Framework)

  • Last updated on