Come posso impedire a Entity Framework di provare a salvare / inserire oggetti figlio?

Quando salvo un'entità con Entity Framework, ho naturalmente pensato che avrebbe provato a salvare solo l'entità specificata. Tuttavia, sta anche tentando di salvare le entità figlio di quell'entità. Ciò sta causando tutti i tipi di problemi di integrità. Come faccio a forzare EF a salvare solo l'entità che voglio salvare e quindi a ignorare tutti gli oggetti figlio?

Se imposto manualmente le proprietà su null, viene visualizzato un messaggio di errore "Operazione non riuscita: la relazione non può essere modificata perché una o più proprietà della chiave esterna non sono annullabili". Questo è estremamente controproducente poiché ho impostato l'oggetto figlio su null in modo specifico in modo che EF lo lasci da solo.

Perché non voglio salvare / inserire gli oggetti figlio?

Poiché questo viene discusso avanti e indietro nei commenti, fornirò alcune giustificazioni del motivo per cui voglio che gli oggetti di mio figlio vengano lasciati in pace.

Nell'applicazione che sto creando, il modello a oggetti EF non viene caricato dal database ma utilizzato come oggetti dati che sto popolando durante l'analisi di un file flat. Nel caso degli oggetti figlio, molti di questi fanno riferimento a tabelle di ricerca che definiscono varie proprietà della tabella padre. Ad esempio, la posizione geografica dell'entità principale.

Poiché ho popolato questi oggetti da solo, EF presume che si tratti di nuovi oggetti e che debbano essere inseriti insieme all'oggetto padre. Tuttavia, queste definizioni esistono già e non voglio creare duplicati nel database. Uso l'oggetto EF solo per eseguire una ricerca e popolare la chiave esterna nella mia entità di tabella principale.

Anche con gli oggetti figlio che sono dati reali, ho bisogno di salvare prima il genitore e ottenere una chiave primaria o EF sembra solo fare un pasticcio di cose. Spero che questo dia qualche spiegazione.

Per quanto ne so, hai due opzioni.

Opzione 1)

Null tutti gli oggetti figlio, questo assicurerà che EF non aggiunga nulla. Inoltre non cancellerà nulla dal tuo database.

Opzione 2)

Impostare gli oggetti figlio come scollegati dal contesto utilizzando il codice seguente

 context.Entry(yourObject).State = EntityState.Detached

Nota che non puoi scollegare un file List/ Collection. Dovrai scorrere l'elenco e staccare ogni elemento nell'elenco in questo modo

foreach (var item in properties)
{
     db.Entry(item).State = EntityState.Detached;
}

Per farla breve: usa la chiave esterna e ti salverà la giornata.

Supponi di avere un'entità Scuola e una Città , e questa è una relazione molti-a-uno in cui una città ha molte scuole e una scuola appartiene a una città. E supponi che le città siano già esistenti nella tabella di ricerca, quindi NON vuoi che vengano inserite di nuovo quando si inserisce una nuova scuola.

Inizialmente potresti definirti entità come questa:

public class City
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class School
{
    public int Id { get; set; }
    public string Name { get; set; }

    [Required]
    public City City { get; set; }
}

E potresti eseguire l' inserimento della scuola in questo modo (supponiamo che tu abbia già la proprietà City assegnata al newItem ):

public School Insert(School newItem)
{
    using (var context = new DatabaseContext())
    {
        context.Set<School>().Add(newItem);
        // use the following statement so that City won't be inserted
        context.Entry(newItem.City).State = EntityState.Unchanged;
        context.SaveChanges();
        return newItem;
    }
}

L'approccio di cui sopra può funzionare perfettamente in questo caso, tuttavia, preferisco l' approccio della chiave esterna che per me è più chiaro e flessibile. Vedi la soluzione aggiornata di seguito:

public class City
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class School
{
    public int Id { get; set; }
    public string Name { get; set; }

    [ForeignKey("City_Id")]
    public City City { get; set; }

    [Required]
    public int City_Id { get; set; }
}

In questo modo si definisce esplicitamente che la Scuola ha una chiave esterna City_Id e si riferisce all'entità City . Quindi, quando si tratta dell'inserimento di Scuola , puoi fare:

    public School Insert(School newItem, int cityId)
    {
        if(cityId <= 0)
        {
            throw new Exception("City ID no provided");
        }

        newItem.City = null;
        newItem.City_Id = cityId;

        using (var context = new DatabaseContext())
        {
            context.Set<School>().Add(newItem);
            context.SaveChanges();
            return newItem;
        }
    }

In questo caso, specifichi esplicitamente City_Id del nuovo record e rimuovi la City dal grafico in modo che EF non si preoccupi di aggiungerlo al contesto insieme a School .

Anche se alla prima impressione l'approccio della chiave straniera sembra più complicato, ma credimi questa mentalità ti farà risparmiare molto tempo quando si tratta di inserire una relazione molti-a-molti (immaginando di avere una relazione Scuola e Studente, e lo Studente ha una proprietà City) e così via.

Spero che questo ti sia utile.

Se vuoi solo memorizzare le modifiche a un oggetto padre ed evitare di memorizzare le modifiche a uno qualsiasi dei suoi oggetti figlio , perché non fare semplicemente quanto segue:

using (var ctx = new MyContext())
{
    ctx.Parents.Attach(parent);
    ctx.Entry(parent).State = EntityState.Added;  // or EntityState.Modified
    ctx.SaveChanges();
}

La prima riga collega l'oggetto genitore e l'intero grafico dei suoi oggetti figli dipendenti al contesto in Unchangedstato.

La seconda riga cambia lo stato solo per l'oggetto padre, lasciando i suoi figli nello Unchangedstato.

Si noti che utilizzo un contesto appena creato, quindi questo evita di salvare altre modifiche al database.

Una delle soluzioni suggerite è assegnare la proprietà di navigazione dallo stesso contesto di database. In questa soluzione, la proprietà di navigazione assegnata dall'esterno del contesto del database verrebbe sostituita. Si prega di vedere il seguente esempio per l'illustrazione.

class Company{
    public int Id{get;set;}
    public Virtual Department department{get; set;}
}
class Department{
    public int Id{get; set;}
    public String Name{get; set;}
}

Salvataggio nel database:

 Company company = new Company();
 company.department = new Department(){Id = 45}; 
 //an Department object with Id = 45 exists in database.    

 using(CompanyContext db = new CompanyContext()){
      Department department = db.Departments.Find(company.department.Id);
      company.department = department;
      db.Companies.Add(company);
      db.SaveChanges();
  }

Microsoft lo inserisce come funzionalità, tuttavia lo trovo fastidioso. Se l'oggetto reparto associato all'oggetto società ha un ID già esistente nel database, perché EF non associa semplicemente l'oggetto società all'oggetto database? Perché dovremmo prenderci cura dell'associazione da soli? Prendersi cura della proprietà di navigazione durante l'aggiunta di un nuovo oggetto è qualcosa come spostare le operazioni del database da SQL a C #, scomode per gli sviluppatori.

Innanzitutto è necessario sapere che esistono due modi per aggiornare l'entità in EF.

• Oggetti allegati

Quando si modifica la relazione degli oggetti collegati al contesto dell'oggetto utilizzando uno dei metodi descritti in precedenza, Entity Framework deve mantenere sincronizzati chiavi esterne, riferimenti e raccolte.

• Oggetti scollegati

Se stai lavorando con oggetti disconnessi, devi gestire manualmente la sincronizzazione.

Nell'applicazione che sto creando, il modello a oggetti EF non viene caricato dal database ma utilizzato come oggetti dati che sto popolando durante l'analisi di un file flat.

Ciò significa che stai lavorando con un oggetto disconnesso, ma non è chiaro se stai utilizzando un'associazione indipendente o un'associazione di chiave esterna .

• Inserisci

  Quando si aggiunge una nuova entità con l'oggetto figlio esistente (oggetto che esiste nel database), se l'oggetto figlio non viene tracciato da EF, l'oggetto figlio verrà reinserito. A meno che non si colleghi manualmente prima l'oggetto figlio.

    db.Entity(entity.ChildObject).State = EntityState.Modified;
    db.Entity(entity).State = EntityState.Added;

• Aggiornare

  Puoi semplicemente contrassegnare l'entità come modificata, quindi tutte le proprietà scalari verranno aggiornate e le proprietà di navigazione verranno semplicemente ignorate.

    db.Entity(entity).State = EntityState.Modified;

Grafico diff

Se vuoi semplificare il codice quando lavori con oggetti scollegati, puoi provare a rappresentare graficamente la libreria diff .

Ecco l'introduzione, Introduzione a GraphDiff per Entity Framework Code First - Consentire aggiornamenti automatici di un grafico di entità separate .

Codice di esempio

• Inserisci entità se non esiste, altrimenti aggiorna.

    db.UpdateGraph(entity);

• Inserisci entità se non esiste, altrimenti aggiorna E inserisci oggetto figlio se non esiste, altrimenti aggiorna.

    db.UpdateGraph(entity, map => map.OwnedEntity(x => x.ChildObject));

Il modo migliore per farlo è sovrascrivere la funzione SaveChanges nel tuo contesto dati.

    public override int SaveChanges()
    {
        var added = this.ChangeTracker.Entries().Where(e => e.State == System.Data.EntityState.Added);

        // Do your thing, like changing the state to detached
        return base.SaveChanges();
    }

Ho lo stesso problema quando provo a salvare il profilo, ho già il saluto della tabella e nuovo per creare il profilo. Quando inserisco il profilo lo inserisco anche nel saluto. Quindi ho provato in questo modo prima di savechanges ().

db.Entry (Profile.Salutation) .State = EntityState.Unchanged;

Questo ha funzionato per me:

// temporarily 'detach' the child entity/collection to have EF not attempting to handle them
var temp = entity.ChildCollection;
entity.ChildCollection = new HashSet<collectionType>();

.... do other stuff

context.SaveChanges();

entity.ChildCollection = temp;

Quello che abbiamo fatto è prima di aggiungere il genitore al dbset, disconnettere le raccolte figlie dal genitore, assicurandoci di spingere le raccolte esistenti su altre variabili per consentire di lavorarci successivamente, e quindi sostituire le raccolte figlie correnti con nuove raccolte vuote. L'impostazione delle raccolte figlio su null / nothing sembrava fallire per noi. Dopo averlo fatto, aggiungi il genitore al dbset. In questo modo i bambini non vengono aggiunti finché non lo desideri.

So che è un vecchio post, tuttavia se stai usando l'approccio code-first puoi ottenere il risultato desiderato usando il seguente codice nel tuo file di mappatura.

Ignore(parentObject => parentObject.ChildObjectOrCollection);

Questo fondamentalmente dirà a EF di escludere la proprietà "ChildObjectOrCollection" dal modello in modo che non venga mappata al database.

Ho avuto una sfida simile utilizzando Entity Framework Core 3.1.0, la mia logica del repository è piuttosto generica.

Questo ha funzionato per me:

builder.Entity<ChildEntity>().HasOne(c => c.ParentEntity).WithMany(l =>
       l.ChildEntity).HasForeignKey("ParentEntityId");

Tieni presente che "ParentEntityId" è il nome della colonna della chiave esterna nell'entità figlio. Ho aggiunto la riga di codice sopra menzionata su questo metodo:

protected override void OnModelCreating(ModelBuilder builder)...