Utilisez linq pour générer une mise à jour directe sans sélectionner

Question

Tous les jours.

Je suis encore à apprendre LINQ alors pardonnez-moi si cela est naïf. Lorsque vous traitez directement avec SQL, vous pouvez générer des commandes de mise à jour avec conditions, sans exécuter d'instruction select.

Quand je travaille avec LINQ je semble suivre le modèle de:

1. entités Sélectionnez
2. Modifier les entités
3. Soumettre les modifications

Ce que je veux faire est une mise à jour directe en utilisant linq et l'exécution différée. Est-il possible que l'exécution réelle se produise directement au SQL sans qu'aucune donnée ne soit transmise au client?

DataContext dc = new DataContext 

var q = from product in dc.Products 
     where product.Type = 1 
     set product.Count = 0 

dc.SubmitChanges 

Donc, en substance LINQ a toutes les informations dont il a besoin sans utiliser de sélection pour générer une commande de mise à jour. Il exécuterait le code SQL:

Update Products Set Count = 0 Where Type = 1 

Existe-t-il un mot clé tel que "set" dans LINQ?

Answer 1

Non, ni LINQ, ni LINQ to SQL a des capacités de mise à jour mise en base.

Dans LINQ to SQL, vous devez interroger pour l'objet que vous souhaitez mettre à jour, mettre à jour les champs/propriétés au besoin, puis appelez SubmitChanges(). Par exemple:

var qry = from product in dc.Products where Product.Name=='Foobar' select product; 
var item = qry.Single(); 
item.Count = 0; 
dc.SubmitChanges(); 

Si vous souhaitez faire batching:

var qry = from product in dc.Products where Product.Type==1 select product; 
foreach(var item in qry) 
{ 
    item.Count = 0; 
} 
dc.SubmitChanges(); 

Sinon, vous pouvez écrire la requête vous:

dc.ExecuteCommand("update Product set Count=0 where Type=1", null); 

Answer 2

Linq 2 SQL n'a pas insertion directe/mise à jour/supprimer les équivalents de SQL. Dans V1, les seules mises à jour que vous pouvez faire en utilisant linq sont des SubmmitChanges sur le contexte ou si vous revenez sur sql.

Toutefois, certaines personnes ont tenté de contourner cette limitation de LINQ utilisant des implémentations personnalisées.

Linq batch update.

Answer 3

Le cadre PLINQO (http://plinqo.com) utilise le LINQ mise à jour batch pour effectuer des mises à jour

context.Task.Update(t => t.Id == 1, t2 => new Task {StatusId = 2});

Ceci effectuera une Update Task Set StatusId = 2 Where Id = 1

Answer 4

Vous pouvez effectivement laisser LINQ to SQL générer des instructions de mise à jour:

Foo foo=new Foo { FooId=fooId }; // create obj and set keys 
context.Foos.Attach(foo); 
foo.Name="test"; 
context.SubmitChanges(); 

Dans votre DBML réglé UpdateCheck = "Jamais" pour toutes les propriétés.

Cela génère une seule instruction de mise à jour sans avoir à sélectionner d'abord.

Une mise en garde: si vous voulez être en mesure de définir Nom à null vous devez initialiser votre objet foo à une valeur différente si Linq peut détecter le changement:

Foo foo=new Foo { FooId=fooId, Name="###" }; 
... 
foo.Name=null; 

Si vous voulez vérifier un horodatage alors que la mise à jour, vous pouvez le faire ainsi:

Foo foo=new Foo { FooId=fooId, Modified=... }; 
// Modified needs to be set to UpdateCheck="Always" in the dbml 

Answer 5

Essayez ceci:

dbEntities.tblSearchItems 
    .Where(t => t.SearchItemId == SearchItemId) 
    .ToList() 
    .ForEach(t => t.isNew = false); 
dbEntities.SaveChanges(); 

Answer 6

-nous e cette méthode d'extension: EntityExtensionMethods.cs

public static void UpdateOnSubmit<TEntity>(this Table<TEntity> table, TEntity entity, TEntity original = null) 
    where TEntity : class, new() 
{ 
    if (original == null) 
    { 
     // Create original object with only primary keys set 
     original = new TEntity(); 
     var entityType = typeof(TEntity); 
     var dataMembers = table.Context.Mapping.GetMetaType(entityType).DataMembers; 
     foreach (var member in dataMembers.Where(m => m.IsPrimaryKey)) 
     { 
      var propValue = entityType.GetProperty(member.Name).GetValue(entity, null); 
      entityType.InvokeMember(member.Name, BindingFlags.SetProperty, Type.DefaultBinder, 
       original, new[] { propValue }); 
     } 
    } 

    // This will update all columns that are not set in 'original' object. For 
    // this to work, entity has to have UpdateCheck=Never for all properties except 
    // for primary keys. This will update the record without querying it first. 
    table.Attach(entity, original); 
} 

Pour l'utiliser, assurez-vous que l'objet entity que vous passez à la méthode UpdateOnSubmit a toutes les propriétés clés primaires définies pour l'enregistrement que vous souhaitez mettre à jour. Cette méthode met alors à jour l'enregistrement avec les propriétés restantes de l'objet entity sans tirer l'enregistrement en premier.

Après avoir appelé UpdateOnSubmit, veillez à appeler SubmitChanges() pour les modifications à appliquer.