Ist es möglich zu überprüfen, ob ein Objekt bereits in Entity Framework an einen Datenkontext angehängt ist?

Beim Versuch, ein Objekt anzuhängen, das bereits an einen bestimmten Kontext angehängt ist, wird folgende Fehlermeldung angezeigt context.AttachTo(...):

Im ObjectStateManager ist bereits ein Objekt mit demselben Schlüssel vorhanden. Der ObjectStateManager kann nicht mehrere Objekte mit demselben Schlüssel verfolgen.

Gibt es eine Möglichkeit, etwas in der Art zu erreichen:

context.IsAttachedTo(...)

Prost!

Bearbeiten:

Die von Jason beschriebene Erweiterungsmethode ist nah, funktioniert aber in meiner Situation nicht.

Ich versuche, mit der in der Antwort auf eine andere Frage beschriebenen Methode zu arbeiten:

Wie lösche ich eine oder mehrere Zeilen mit Linq to Entities * aus meiner Tabelle, ohne * zuerst die Zeilen abzurufen?

Mein Code sieht ein bisschen so aus:

var user = new User() { Id = 1 };
context.AttachTo("Users", user);
comment.User = user;
context.SaveChanges();

Dies funktioniert einwandfrei, außer wenn ich etwas anderes für diesen Benutzer mache, bei dem ich dieselbe Methode verwende und versuche, ein Dummy- UserObjekt anzuhängen . Dies schlägt fehl, weil ich dieses Dummy-Benutzerobjekt zuvor angehängt habe. Wie kann ich das überprüfen?

Folgendes habe ich erreicht, was sehr gut funktioniert:

public static void AttachToOrGet<T>(this ObjectContext context, string entitySetName, ref T entity)
    where T : IEntityWithKey
{
    ObjectStateEntry entry;
    // Track whether we need to perform an attach
    bool attach = false;
    if (
        context.ObjectStateManager.TryGetObjectStateEntry
            (
                context.CreateEntityKey(entitySetName, entity),
                out entry
            )
        )
    {
        // Re-attach if necessary
        attach = entry.State == EntityState.Detached;
        // Get the discovered entity to the ref
        entity = (T)entry.Entity;
    }
    else
    {
        // Attach for the first time
        attach = true;
    }
    if (attach)
        context.AttachTo(entitySetName, entity);
}

Sie können es wie folgt nennen:

User user = new User() { Id = 1 };
II.AttachToOrGet<Users>("Users", ref user);

Dies funktioniert sehr gut, da es nur so ist, als ob context.AttachTo(...)Sie den oben genannten ID-Trick jedes Mal verwenden können. Am Ende wird entweder das zuvor angehängte Objekt oder Ihr eigenes Objekt angehängt. Das Aufrufen CreateEntityKeydes Kontexts stellt sicher, dass er nett und allgemein ist und auch mit zusammengesetzten Schlüsseln ohne weitere Codierung funktioniert (da EF dies bereits für uns tun kann!).

Ein einfacherer Ansatz ist:

 bool isDetached = context.Entry(user).State == EntityState.Detached;
 if (isDetached)
     context.Users.Attach(user);

Probieren Sie diese Erweiterungsmethode aus (dies ist ungetestet und ohne Manschette):

public static bool IsAttachedTo(this ObjectContext context, object entity) {
    if(entity == null) {
        throw new ArgumentNullException("entity");
    }
    ObjectStateEntry entry;
    if(context.ObjectStateManager.TryGetObjectStateEntry(entity, out entry)) {
        return (entry.State != EntityState.Detached);
    }
    return false;
}

In Anbetracht der Situation, die Sie in Ihrer Bearbeitung beschreiben, müssen Sie möglicherweise die folgende Überladung verwenden, die EntityKeyein Objekt anstelle eines Objekts akzeptiert :

public static bool IsAttachedTo(this ObjectContext, EntityKey key) {
    if(key == null) {
        throw new ArgumentNullException("key");
    }
    ObjectStateEntry entry;
    if(context.ObjectStateManager.TryGetObjectStateEntry(key, out entry)) {
        return (entry.State != EntityState.Detached);
    }
    return false;
}

EntityKeyVerwenden Sie Folgendes als Richtlinie, um eine in Ihrer Situation zu erstellen :

EntityKey key = new EntityKey("MyEntities.User", "Id", 1);

Sie können das EntityKeyvon einer vorhandenen Instanz von Userabrufen, indem Sie die Eigenschaft User.EntityKey(von der Schnittstelle IEntityWithKey) verwenden.

Verwenden Sie den Entitätsschlüssel des Objekts, das Sie überprüfen möchten:

var entry = context.ObjectStateManager.GetObjectStateEntry("EntityKey");
if (entry.State == EntityState.Detached)
{
  // Do Something
}

Freundlichkeit,

Dan

Dies beantwortet die Frage des OP nicht direkt, aber so habe ich meine gelöst.

Dies ist für diejenigen, die DbContextanstelle von verwenden ObjectContext.

    public TEntity Retrieve(object primaryKey)
    {
        return DbSet.Find(primaryKey);
    }

DbSet.Find-Methode :

Findet eine Entität mit den angegebenen Primärschlüsselwerten. Wenn eine Entität mit den angegebenen Primärschlüsselwerten im Kontext vorhanden ist, wird sie sofort zurückgegeben, ohne eine Anforderung an das Geschäft zu senden. Andernfalls wird eine Anforderung an den Speicher für eine Entität mit den angegebenen Primärschlüsselwerten gestellt, und diese Entität wird, falls gefunden, an den Kontext angehängt und zurückgegeben. Wenn im Kontext oder im Speicher keine Entität gefunden wird, wird null zurückgegeben.

Grundsätzlich wird das angehängte Objekt des angegebenen Objekts zurückgegeben, primaryKeysodass Sie nur die Änderungen auf das zurückgegebene Objekt anwenden müssen, um die richtige Instanz beizubehalten.