Ignorieren Sie doppelte Schlüssel einfügen mit Entity Framework

Question

Ich benutze ASP.NET MVC4 mit Entity Framework Code zuerst. Ich habe eine Tabelle namens "Benutzer" mit Primärschlüssel "UserId". Diese Tabelle kann 200.000 Einträge enthalten.

Ich muss noch 50 Benutzer einfügen. Ich könnte dies wie

foreach(User user in NewUsers){ 
    context.Add(user); 
} 
dbcontext.SaveChanges(); 

Das Problem ist, einer oder mehrere dieser neuen Benutzer möglicherweise bereits in der DB vorhanden. Wenn ich sie hinzufüge und dann versuche zu speichern, wird ein Fehler ausgegeben und keine der gültigen hinzugefügt. Ich könnte den Code ändern, um dies zu tun:

was funktionieren würde. Das Problem ist, dass es 50 Mal eine Abfrage in einer 200.000+ Eintragstabelle ausführen muss. Also meine Frage ist, was ist die leistungsfähigste Methode zum Einfügen dieser Benutzer, ignorieren alle Duplikate?

Answer 1

Sie können dies tun:

var newUserIDs = NewUsers.Select(u => u.UserId).Distinct().ToArray(); 
var usersInDb = dbcontext.Users.Where(u => newUserIDs.Contains(u.UserId)) 
           .Select(u => u.UserId).ToArray(); 
var usersNotInDb = NewUsers.Where(u => !usersInDb.Contains(u.UserId)); 
foreach(User user in usersNotInDb){ 
    context.Add(user); 
} 

dbcontext.SaveChanges(); 

Dies wird eine einzelne Abfrage in der Datenbank ausführen Benutzer zu finden, die bereits vorhanden ist, dann filtert sie aus Ihrem NewUsers Set.

Answer 2

Da dies Ihr Primärschlüssel ist, sind Ihre Möglichkeiten begrenzt. Wenn dies nicht Ihr primärer Schlüssel und nur ein eindeutiger Index wäre, könnten Sie unter der Annahme von SQL Server Ihren eindeutigen Schlüssel einrichten, um Duplikate zu ignorieren.

Was ich vorschlagen könnte ist, einfach ein try/catch um das Hinzufügen und essen die Ausnahme, wenn die Ausnahme eine doppelte Schlüsselfehler ist.

Sie können auch sehen, ob Ihr Objekt die AddOrUpdate() Methode unterstützt. Ich weiß, dass dies in Code First-Implementierungen unterstützt wird. Ich glaube in diesem Fall wird es ein neues hinzufügen oder aktualisieren, wenn die Zeile existiert. Dies kann jedoch immer noch eine Reise in die DB beinhalten, um festzustellen, ob der Benutzer bereits existiert, um zu wissen, ob ein Hinzufügen oder Aktualisieren durchgeführt werden soll. In einigen Fällen möchten Sie möglicherweise kein Update durchführen.

Ich denke, wenn ich ich wäre, würde ich die Try/Catch-Route gehen.

Answer 3

Sie können

foreach(User user in NewUsers.Where(us => !dbcontext.Users.Any(u => u.userId == us.userId))) 
{ 
    dbcontext.Users.Add(user); 
} 
dbcontext.SaveChanges(); 

EDIT die bestehenden Benutzer mit einer Abfrage filtern:

Wie in den Kommentaren über den Vorschlag darauf hingewiesen wird für jedes Element in der newusers Sammlung in einem SQL-Aufruf kommen. Ich konnte das mit SQL Server Profiler bestätigen.

Ein intresting Ergebnis der Profilierung ist die etwas wierd SQL erzeugt von EF für jedes Element (Modellnamen sind anders als in dem OP, aber die Abfrage ist gleich):

exec sp_executesql N'SELECT 
CASE WHEN (EXISTS (SELECT 
    1 AS [C1] 
    FROM [dbo].[EventGroup] AS [Extent1] 
    WHERE [Extent1].[EventGroupID] = @p__linq__0 
)) THEN cast(1 as bit) WHEN (NOT EXISTS (SELECT 
    1 AS [C1] 
    FROM [dbo].[EventGroup] AS [Extent2] 
    WHERE [Extent2].[EventGroupID] = @p__linq__0 
)) THEN cast(0 as bit) END AS [C1] 
FROM (SELECT 1 AS X) AS [SingleRowTable1]',N'@p__linq__0 int',@p__linq__0=10 

ein recht schönes Stück von Code, um die Arbeit eines einfachen Einzeilers zu erledigen.

Meine Sicht ist, dass das Schreiben von schönen und lesbaren deklarativen Code und lassen Sie den Compiler und Optimierer machen den schmutzigen Job ist eine gute Einstellung. Dies ist einer der Fälle, wenn das Ergebnis eines solchen Stils überraschend ist und Sie schmutzig gehen müssen.

Answer 4

Die folgende Erweiterung Methode, die Sie Aufzeichnungen jeder Art einfügen können, während Duplikate zu ignorieren:

vielleicht

public static void AddRangeIgnore(this DbSet dbSet, IEnumerable<object> entities) 
    { 
     var entitiesList = entities.ToList(); 
     var firstEntity = entitiesList.FirstOrDefault(); 

     if (firstEntity == null || !firstEntity.HasKey() || firstEntity.HasIdentityKey()) 
     { 
      dbSet.AddRange(entitiesList); 
      return; 
     } 

     var uniqueEntities = new List<object>(); 

     using (var dbContext = _dataService.CreateDbContext()) 
     { 
      var uniqueDbSet = dbContext.Set(entitiesList.First().GetType()); 

      foreach (object entity in entitiesList) 
      { 
       var keyValues = entity.GetKeyValues(); 
       var existingEntity = uniqueDbSet.Find(keyValues); 

       if (existingEntity == null) 
       { 
        uniqueEntities.Add(entity); 
        uniqueDbSet.Attach(entity); 
       } 
      } 
     } 

     dbSet.AddRange(uniqueEntities); 
    } 

    public static object[] GetKeyValues(this object entity) 
    { 
     using (var dbContext = _dataService.CreateDbContext()) 
     { 
      var entityType = entity.GetType(); 
      dbContext.Set(entityType).Attach(entity); 
      var objectStateEntry = ((IObjectContextAdapter)dbContext).ObjectContext.ObjectStateManager.GetObjectStateEntry(entity); 
      var value = objectStateEntry.EntityKey 
             .EntityKeyValues 
             .Select(kv => kv.Value) 
             .ToArray(); 
      return value; 
     } 
    } 

    public static bool HasKey(this object entity) 
    { 
     using (var dbContext = _dataService.CreateDbContext()) 
     { 
      var entityType = entity.GetType(); 
      dbContext.Set(entityType).Attach(entity); 
      var objectStateEntry = ((IObjectContextAdapter)dbContext).ObjectContext.ObjectStateManager.GetObjectStateEntry(entity); 
      return objectStateEntry.EntityKey != null; 
     } 
    } 

    public static bool HasIdentityKey(this object entity) 
    { 
     using (var dbContext = _dataService.CreateDbContext()) 
     { 
      var entityType = entity.GetType(); 
      dbContext.Set(entityType).Attach(entity); 
      var objectStateEntry = ((IObjectContextAdapter)dbContext).ObjectContext.ObjectStateManager.GetObjectStateEntry(entity); 
      var keyPropertyName = objectStateEntry.EntityKey 
             .EntityKeyValues 
             .Select(kv => kv.Key) 
             .FirstOrDefault(); 

      if (keyPropertyName == null) 
      { 
       return false; 
      } 

      var keyProperty = entityType.GetProperty(keyPropertyName); 
      var attribute = (DatabaseGeneratedAttribute)Attribute.GetCustomAttribute(keyProperty, typeof(DatabaseGeneratedAttribute)); 
      return attribute != null && attribute.DatabaseGeneratedOption == DatabaseGeneratedOption.Identity; 
     } 
    }