L’utilisation de LINQPad pour insérer des données dans une firebase database SQL CE, Linq-to-sql, ralentit avec le temps, que puis-je faire à ce sujet?

J’ai une firebase database SQL CE 4.0 sur le disque et un programme LINQPad que je voulais utiliser pour remplir cette firebase database.

J’utilise le système linq2sql intégré (à LINQPad). Je remarque qu’au fil du temps, le temps nécessaire pour insérer un lot de lignes prend de plus en plus de temps et que, finalement, il semble que le programme ait ralenti.

Y at-il une sorte de cache ou similaire qui le ralentit? Que puis-je faire pour éviter ce ralentissement?

Voici mon tableau de test simple avec lequel j’ai utilisé ceci:

CREATE TABLE dummy ( id int not null primary key identity (1, 1), value nvarchar(20) not null ) 

et mon programme de test:

 void Main() { for (int iteration = 1; iteration <= 1000; iteration++) { Stopwatch sw = Stopwatch.StartNew(); for (int row = 0; row < 100; row++) dummy.InsertOnSubmit(new dummy { value = "row#" + row }); var create = sw.ElapsedMilliseconds; SubmitChanges(); sw.Stop(); var total = sw.ElapsedMilliseconds; Debug.WriteLine("iteration " + iteration + ", create=" + create + ", total=" + total); } } 

voici un exemple de sortie:

 iteration 1, create=1, total=52 iteration 2, create=0, total=41 iteration 3, create=0, total=53 iteration 4, create=0, total=45 ... iteration 86, create=0, total=181 iteration 87, create=0, total=218 iteration 88, create=0, total=172 iteration 89, create=4, total=192 ... iteration 167, create=0, total=387 iteration 168, create=0, total=427 iteration 169, create=0, total=496 iteration 170, create=0, total=425 

Comme vous pouvez le constater, le temps nécessaire pour appeler SubmitChanges prend de plus en plus de temps. Pourtant, SubmitChanges le même nombre d’entités à chaque itération.

Veuillez noter que je suis tout à fait conscient que je n’obtiendrai pas de vitesses telles que l’insertion en bloc ou autre, mais je voudrais tout de même éviter si possible ce ralentissement.

Notez également que si je relance le programme maintenant, avec beaucoup de lignes déjà dans la firebase database, le temps commence à nouveau:

 iteration 1, create=1, total=51 iteration 2, create=0, total=50 iteration 3, create=0, total=45 iteration 4, create=0, total=45 

Il me semble donc que quelque chose continue de grandir dans la mémoire.

Y a-t-il quelque chose que je puisse éteindre, réinitialiser, dump, peu importe, pour résoudre ce problème, si ce n’est d’arrêter le programme périodiquement et de le redémarrer (ce que je peux réellement faire peut être fait, mais j’aimerais l’éviter) .

Il semble que vous souhaitiez copier en bloc des données vers SQL Server à partir de LINQPad. Voici une méthode que j’utilise pour le faire:

 void BCP (IEnumerable rows) { if (rows.Count() == 0) return; var dt = new DataTable (); var metaTable = _db.Mapping.GetTable (typeof (TRow)); var columns = metaTable.RowType.DataMembers.Where (dm => dm.Association == null); var transformers = new List>(); foreach (var columnX in columns) { var column = columnX; dt.Columns.Add (column.Name, L2sToDataTable (column.Type)); transformers.Add (row => L2sToDataTable (row.GetType().GetField (column.Name).GetValue (row))); } foreach (var row in rows) dt.Rows.Add (transformers.Select (t => t (row)).ToArray()); _db.Connection.Open(); Console.Write ("Bulk copying " + metaTable.TableName + "... "); var bcp = new SqlBulkCopy ((SqlConnection)_db.Connection) { DestinationTableName = metaTable.TableName, BulkCopyTimeout = 300 }; bcp.BatchSize = 20; bcp.NotifyAfter = 20; bcp.SqlRowsCopied += (sender, args) => Console.Write (args.RowsCopied + " rows... "); bcp.WriteToServer (dt); _db.Connection.Close(); Console.WriteLine ("Done"); } Type L2sToDataTable (Type l2sType) { if (l2sType == typeof (Binary)) return typeof (byte[]); if (l2sType.IsGenericType && l2sType.GetGenericTypeDefinition() == typeof (Nullable<>)) return l2sType.GetGenericArguments()[0]; return l2sType; } object L2sToDataTable (object l2sValue) { if (l2sValue == null) return DBNull.Value; if (l2sValue is Binary) return ((Binary) l2sValue).ToArray(); return l2sValue; } 

Cela évite la surcharge de mémoire cache d’un mappeur relationnel-object, tel que LINQ-to-SQL, tout en utilisant les métadonnées de ce dernier.