Exemplo n.º 1
0
        public static void Do(Db db)
        {
            try
            {
                var sw = new Stopwatch();
                sw.Start();
                int next = JobTrans.NextNumber();
                if (next % 4 == 0)
                {
                    var d = new SomeData()
                    {
                        Id         = next,
                        NameSearch = next + " " + next,
                        Normalized = Convert.ToDouble("0," + next),
                        ObjectId   = next,
                        PeriodId   = next,
                        PersonId   = next,
                        Value      = next
                    };

                    using (var trans = new LinqdbTransaction())
                    {
                        db.Table <SomeData>(trans).Save(d);
                        trans.Commit();
                    }
                    sw.Stop();
                    lock (_lock)
                    {
                        numbers.Add(next);
                        totalms_save += sw.ElapsedMilliseconds;
                        total_save++;
                    }
                }
                else if (next % 4 == 1)
                {
                    int to_read = 0;
                    lock (_lock)
                    {
                        if (!numbers.Any())
                        {
                            return;
                        }
                        to_read = numbers[rg.Next() % numbers.Count];
                    }
                    var entity = db.Table <SomeData>().Where(f => f.Id == to_read).SelectEntity().FirstOrDefault();
                    if (entity == null)
                    {
                        lock (_lock)
                        {
                            if (numbers.Contains(to_read))
                            {
                                throw new Exception("Assert failure 1");
                            }
                            else
                            {
                                return;
                            }
                        }
                    }
                    if (entity.Id != to_read || entity.NameSearch != to_read + " " + to_read || entity.Normalized != Convert.ToDouble("0," + to_read) || entity.ObjectId != to_read ||
                        entity.PersonId != to_read || entity.PersonId != to_read || entity.Value != to_read || !(entity.PeriodId == to_read || entity.PeriodId == -1 * to_read))
                    {
                        throw new Exception("Assert failure 2");
                    }

                    var search_res = db.Table <SomeData>().Search(f => f.NameSearch, to_read + "").Select(f => new { Id = f.Id }).Select(f => f.Id).ToList();
                    if (!search_res.Contains(to_read))
                    {
                        lock (_lock)
                        {
                            if (numbers.Contains(to_read))
                            {
                                throw new Exception("Assert failure 3");
                            }
                            else
                            {
                                return;
                            }
                        }
                    }

                    sw.Stop();
                    lock (_lock)
                    {
                        totalms_select += sw.ElapsedMilliseconds;
                        total_select++;
                    }
                }
                else if (next % 4 == 2)
                {
                    int to_delete = 0;
                    lock (_lock)
                    {
                        if (!numbers.Any())
                        {
                            return;
                        }

                        to_delete = numbers[rg.Next() % numbers.Count];
                        while (numbers.Contains(to_delete))
                        {
                            numbers.Remove(to_delete);
                        }
                    }
                    using (var trans = new LinqdbTransaction())
                    {
                        db.Table <SomeData>(trans).Delete(to_delete);
                        trans.Commit();
                    }

                    sw.Stop();
                    lock (_lock)
                    {
                        totalms_delete += sw.ElapsedMilliseconds;
                        total_delete++;
                    }
                }
                else
                {
                    int to_update = 0;
                    lock (_lock)
                    {
                        if (!numbers.Any())
                        {
                            return;
                        }

                        to_update = numbers[rg.Next() % numbers.Count];
                    }
                    var val = db.Table <SomeData>().Where(f => f.Id == to_update).Select(f => new { PeriodId = f.PeriodId }).FirstOrDefault();
                    if (val == null)
                    {
                        lock (_lock)
                        {
                            if (numbers.Contains(to_update))
                            {
                                throw new Exception("Assert failure 4");
                            }
                            else
                            {
                                return;
                            }
                        }
                    }
                    using (var trans = new LinqdbTransaction())
                    {
                        db.Table <SomeData>(trans).Update(f => f.PeriodId, to_update, -1 * val.PeriodId);
                        trans.Commit();
                    }

                    sw.Stop();
                    lock (_lock)
                    {
                        totalms_update += sw.ElapsedMilliseconds;
                        total_update++;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Trans Parallel: " + ex.Message);
                lock (_lock)
                {
                    errors++;
                }
            }
        }