2009-10-04 5 views
77

Pour supprimer toutes les lignes d'une table, je suis actuellement ce qui suit:LINQ to SQL: Comment effacer rapidement une table

context.Entities.DeleteAllOnSubmit(context.Entities); 
context.SubmitChanges(); 

Cependant, cela semble prendre les âges. Y at-il un moyen plus rapide?

+0

Pour quelle raison n'utilisez-vous pas un proc stocké pour une suppression plus rapide et plus sûre? Vous pouvez avoir le proc assigné sur dbml – Perpetualcoder

+1

N'auriez-vous pas à en faire un pour chaque table alors? Ou? – Svish

Répondre

108

Vous pouvez faire une troncature SQL normale ou supprimer la commande, en utilisant la méthode DataContext.ExecuteCommand:

context.ExecuteCommand("DELETE FROM Entity"); 

Ou

context.ExecuteCommand("TRUNCATE TABLE Entity"); 

La façon dont vous supprimez prend longtemps parce que LINQ to SQL génère un SUPPRIMER déclaration pour chaque entité, il existe d'autres de type sécurité approches pour faire des suppressions/mises à jour par lots, consultez les articles suivants:

+0

assurez-vous de réparer le mot "DELETE" – David

+9

J'ai de même attribué +1 à ce produit. Voici une référence expliquant la différence entre Truncate (que je pense que vous voulez faire), et Delete: http://www.mssqltips.com/tip.asp?tip=1080 – David

+1

+1 sur le commentaire de David: truncate may be * beaucoup * plus rapide que de supprimer –

20

Malheureusement LINQ to SQL n'a pas exécuter des requêtes basées sur des ensembles très bien.

Vous supposer que

context.Entities.DeleteAllOnSubmit(context.Entities); 
context.SubmitChanges(); 

se traduira par quelque chose comme

DELETE FROM [Entities] 

, mais malheureusement, il est plus comme

DELETE FROM [dbo].[Entities] WHERE ([EntitiesId] = @p0) AND ([Column1] = @p1) ... 
DELETE FROM [dbo].[Entities] WHERE ([EntitiesId] = @p0) AND ([Column1] = @p1) ... 
DELETE FROM [dbo].[Entities] WHERE ([EntitiesId] = @p0) AND ([Column1] = @p1) ... 

Vous trouverez la même chose quand vous essayez de faire mise à jour en bloc dans LINQ-to-SQL. Pas plus de quelques centaines de lignes à la fois et ça va simplement être trop lent.

Si vous devez effectuer des opérations par lots & vous utilisez LINQ-to-SQL, vous devez écrire des procédures stockées.

11

J'aime utiliser une méthode d'extension, par les éléments suivants:

public static class LinqExtension 
{ 
    public static void Truncate<TEntity>(this Table<TEntity> table) where TEntity : class 
    { 
    var rowType = table.GetType().GetGenericArguments()[0]; 
    var tableName = table.Context.Mapping.GetTable(rowType).TableName; 
    var sqlCommand = String.Format("TRUNCATE TABLE {0}", tableName); 
    table.Context.ExecuteCommand(sqlCommand); 
    } 
} 
0

Le dessous du code C# est utilisé pour insérer/Mise à jour/Supprimer/DeleteAll sur une table de base de données en utilisant LINQ to SQL

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Text.RegularExpressions; 

namespace PracticeApp 
{ 
    class PracticeApp 
    {   
     public void InsertRecord(string Name, string Dept) { 
      LinqToSQLDataContext LTDT = new LinqToSQLDataContext(); 
      LINQTOSQL0 L0 = new LINQTOSQL0 { NAME = Name, DEPARTMENT = Dept }; 
      LTDT.LINQTOSQL0s.InsertOnSubmit(L0); 
      LTDT.SubmitChanges(); 
     } 

     public void UpdateRecord(int ID, string Name, string Dept) 
     { 
      LinqToSQLDataContext LTDT = new LinqToSQLDataContext(); 
      LINQTOSQL0 L0 = (from item in LTDT.LINQTOSQL0s where item.ID == ID select item).FirstOrDefault(); 
      L0.NAME = Name; 
      L0.DEPARTMENT = Dept; 
      LTDT.SubmitChanges(); 
     } 

     public void DeleteRecord(int ID) 
     { 
      LinqToSQLDataContext LTDT = new LinqToSQLDataContext(); 
      LINQTOSQL0 L0; 
      if (ID != 0) 
      { 
       L0 = (from item in LTDT.LINQTOSQL0s where item.ID == ID select item).FirstOrDefault(); 
       LTDT.LINQTOSQL0s.DeleteOnSubmit(L0); 
      } 
      else 
      { 
       IEnumerable<LINQTOSQL0> Data = from item in LTDT.LINQTOSQL0s where item.ID !=0 select item; 
       LTDT.LINQTOSQL0s.DeleteAllOnSubmit(Data); 
      }   
      LTDT.SubmitChanges(); 
     } 

     static void Main(string[] args) { 
      Console.Write("* Enter Comma Separated Values to Insert Records\n* To Delete a Record Enter 'Delete' or To Update the Record Enter 'Update' Then Enter the Values\n* Dont Pass ID While Inserting Record.\n* To Delete All Records Pass 0 as Parameter for Delete.\n"); 
      var message = "Successfully Completed"; 
      try 
      { 
       PracticeApp pa = new PracticeApp(); 
       var enteredValue = Console.ReadLine();     
       if (Regex.Split(enteredValue, ",")[0] == "Delete") 
       { 
        Console.Write("Delete Operation in Progress...\n"); 
        pa.DeleteRecord(Int32.Parse(Regex.Split(enteredValue, ",")[1])); 
       } 
       else if (Regex.Split(enteredValue, ",")[0] == "Update") 
       { 
        Console.Write("Update Operation in Progress...\n"); 
        pa.UpdateRecord(Int32.Parse(Regex.Split(enteredValue, ",")[1]), Regex.Split(enteredValue, ",")[2], Regex.Split(enteredValue, ",")[3]); 
       } 
       else 
       { 
        Console.Write("Insert Operation in Progress...\n"); 
        pa.InsertRecord(Regex.Split(enteredValue, ",")[0], Regex.Split(enteredValue, ",")[1]); 
       }         
      } 
      catch (Exception ex) 
      { 
       message = ex.ToString(); 
      } 
      Console.Write(message);    
      Console.ReadLine();       
     } 
    } 
} 
+0

ajouter quelques explications –