Entity Framework: Überprüfen Sie alle Beziehungen, die ein entity für foreign key verwenden

Ich habe eine Entität, nennen wir es CommonEntity hat einen primary key als foreign key eingesetzt in vielen anderen Einrichtungen. Wie die Anwendung entwickelt wird, diese verbindungen weiterhin zu wachsen.

Ich würde gerne einen Weg, um zu sehen, ob CommonEntity sicher gelöscht werden können (D. H. es ist nicht von einer anderen Entitäten).

Ich begreife, dass ich tun kann,

if(!ce.EntityA.Any() && !ce.EntityB.Any() ... && !ce.EntityN.Any())
{
   //Delete
}

aber ich bin der Hoffnung, für ein Weg, um einfach überprüfen Sie alle Beziehungen automatisch, da ich nicht Liebe die Idee, wieder zu kommen und ändern Sie diesen code manuell jedes mal, wenn wir eine neue Beziehung. Vielleicht gibt es etwas in EF4+ ich bin mir nicht bewusst?

Dachte ich, es wäre möglich, einen Transaktionsbereich, um nur versuchen, und entfernen Sie das Objekt und Rollen Sie es zurück, wenn es fehlschlägt, war mir aber nicht sicher, ob es irgendwelche negativen Nebenwirkungen, die mit diesem Ansatz.

Gibt es einen besseren Ansatz?

EDIT: Sieht aus wie VS2012 verwendet hat, EF5, obwohl das Projekt ist .Net 4, so hat er erstellt das Modell mit POCOs obwohl es generiert aus einer DB.

InformationsquelleAutor BenC3 | 2012-10-12
  1. 11

    Lass es einfach ausfallen. Wenn das Unternehmen hat viele Beziehungen, eine überprüfung könnte wirklich schwer sein.

    public bool TryDelete(int id)
{
    try
    {
        //Delete
        return true;
    }
    catch (SqlException ex)
    {
        if (ex.Number == 547) return false; //The {...} statement conflicted with the {...} constraint {...}
        throw; //other error
    }
}
    • Wenn lass ich es ausfallen, wird es automatisch zurück eine erfolgreiche Kaskadierung ohne Transaktionsbereich?
    • Die Antwort fand - SaveChanges() verwendet eine Transaktion, also jeden Fehler wird ein Rollback ausgeführt: msdn.microsoft.com/en-us/library/bb336792.aspx
    • Überhaupt nicht gut, wenn Sie halten Ihre Entitäten öffnen!
    • Leting es fail ist für mich die beste Lösung. Wenn Sie Prüfungen für alle Beziehungen, die Sie erzeugen können zirkuläre Abhängigkeiten zu anderen Teilsystemen. Es gibt einen Nachteil, es ist schwer zu zeigen, um den Benutzer, welche relation den Fehler verursacht.
    • was ist, wenn ondeletecascade eingeschaltet ist. es wird nicht fehlschlagen, dann wäre es?
    InformationsquelleAutor y34h
  2. 5

    Können Sie versuchen, diese:

    var allrelatedEnds = ((IEntityWithRelationships)ce).RelationshipManager.GetAllRelatedEnds();
bool hasRelation = false;
foreach (var relatedEnd in allrelatedEnds)
{
    if (relatedEnd.GetEnumerator().MoveNext())
    {
        hasRelation = true;
        break;
    }
}

if (!hasRelation)
{
    //Delete
}
    • Nach einigen Forschung scheint es, dass VS2012 verwendet eine version von EF5 auch bei der Ausrichtung .Net 4, also lange Geschichte kurz, es ist POCOs generiert für mich, obwohl ich generiert das Modell aus der DB, also kann ich nicht werfen, um IEntityWithRelationships. Meine schlecht für nicht es zu erwähnen!
    InformationsquelleAutor
  3. 2

    Können Sie mithilfe von Reflektion für diese (wenn Sie nicht möchten, verwenden Sie "Nicht Löschen" Auf "SQL")
    Ich Schreibe dies, weil ich nicht wollen, zu LÖSCHEN Entität, die wollen nur wissen, ob Ihr mit oder nicht !

     public static object GetEntityFieldValue(this object entityObj, string propertyName)
        {
            var pro = entityObj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).First(x => x.Name == propertyName);
            return pro.GetValue(entityObj, null);

        }

 public static IEnumerable<PropertyInfo> GetManyRelatedEntityNavigatorProperties(object entityObj)
        {
            var props = entityObj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.CanWrite && x.GetGetMethod().IsVirtual && x.PropertyType.IsGenericType == true);
            return props;
        }

public static bool HasAnyRelation(object entityObj)
        {

                var collectionProps= GetManyRelatedEntityNavigatorProperties(entityObj);


                foreach (var item in collectionProps)
                {
                    var collectionValue = GetEntityFieldValue(entityObj,item.Name);
                    if (collectionValue != null && collectionValue is IEnumerable)
                    {
                        var col = collectionValue as IEnumerable;
                        if (col.GetEnumerator().MoveNext())
                        {
                            return true;
                        }

                    }
                }
               return false;
}

    BEACHTEN Sie, dass : Kontext muss nicht Entsorgt werden und der Proxy Muss Aktiviert Sein
    UND WISSEN, DASS ES ERHALTEN ALLE ZUGEHÖRIGEN DATENSATZ ZU SPEICHER (ES IST Zu Schwer)

    • Dies ist eine wirklich gute Art, wie ich denke, anstatt das zu tun MyClass.Any() || MyOtherClass.Any() etc etc. Das einzige, was ich Hinzugefügt wurde ein Attribut Ignorieren, um Ihnen zu erlauben, zu entscheiden, um Nicht die Property im HasAnyRelation() Die GetManyRelatedEntityNavigatorProperties() sieht so aus... var props = entityObj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.CanWrite && x.GetGetMethod().IsVirtual && x.PropertyType.IsGenericType && (x.GetCustomAttribute(typeof (IgnoreIsDeletableAttribute)) == null) );
    InformationsquelleAutor mX64
  4. -1

    Zuerst die Einheit, die Sie löschen möchten mit Finden im EF pass die Person zu unter-Funktion.., Wenn die Funktion true zurückgibt, bedeutet es nicht gelöscht werden kann und außen-Daten vorhanden sind.. Wenn-Funktion gibt false zurück, es bedeutet keine über-oder untergeordnete Datensätze und kann gelöscht werden..

     public static bool DeleteCheckOnEntity(object entity)
   {
     var propertiesList = entity.GetType().GetProperties();
     return (from prop in propertiesList where prop.PropertyType.IsGenericType select prop.GetValue(entity) into propValue select propValue as IList).All(propList => propList == null || propList.Count <= 0);
   }
    • Es werde nur überprüfen, ob es irgendwelche navigation Eigenschaft oder nicht, es wird nicht überprüfen, ob es abhängige Daten handelt oder nicht.
    InformationsquelleAutor Pramod Singh
Schreibe einen Kommentar