SqlException from Entity Framework - nowa transakcja nie jest dozwolona, ponieważ w sesji działają inne wątki

Jak już zidentyfikowałeś, nie możesz zapisać z foreach, który nadal rysuje się z bazy danych za pomocą aktywnego czytnika.

Wywołanie ToList() lub ToArray() jest dobre dla małych zestawów danych, ale gdy masz tysiące wierszy, będziesz zużywał dużą ilość pamięci.

Lepiej załadować wiersze w kawałkach.

public static class EntityFrameworkUtil
{
    public static IEnumerable<T> QueryInChunksOf<T>(this IQueryable<T> queryable, int chunkSize)
    {
        return queryable.QueryChunksOfSize(chunkSize).SelectMany(chunk => chunk);
    }

    public static IEnumerable<T[]> QueryChunksOfSize<T>(this IQueryable<T> queryable, int chunkSize)
    {
        int chunkNumber = 0;
        while (true)
        {
            var query = (chunkNumber == 0)
                ? queryable 
                : queryable.Skip(chunkNumber * chunkSize);
            var chunk = query.Take(chunkSize).ToArray();
            if (chunk.Length == 0)
                yield break;
            yield return chunk;
            chunkNumber++;
        }
    }
}

Biorąc pod uwagę powyższe metody rozszerzenia, możesz napisać zapytanie w następujący sposób:

foreach (var client in clientList.OrderBy(c => c.Id).QueryInChunksOf(100))
{
    // do stuff
    context.SaveChanges();
}

Obiekt, który wywołujesz tą metodą na dzieje się tak, ponieważ Entity Framework obsługuje tylko IQueryable<T>.Skip(int) w zapytaniach uporządkowanych, co ma sens, gdy weźmiemy pod uwagę, że wiele zapytań dla różnych zakresów wymaga, aby kolejność była stabilna. Jeśli zamówienie nie jest dla Ciebie ważne, po prostu zamów według klucza podstawowego, ponieważ prawdopodobnie będzie miał klastrowy indeks.

Ta wersja zapyta bazę danych w partiach po 100. Zauważ, że SaveChanges() jest wywoływana dla każdej jednostki.

Jeśli chcesz poprawić przepustowość dramatycznie, powinieneś dzwonić SaveChanges() rzadziej. Zamiast tego użyj kodu w ten sposób:

foreach (var chunk in clientList.OrderBy(c => c.Id).QueryChunksOfSize(100))
{
    foreach (var client in chunk)
    {
        // do stuff
    }
    context.SaveChanges();
}

Powoduje to 100 razy mniej wywołań aktualizacji bazy danych. Oczywiście każde z tych połączeń trwa dłużej, ale i tak w końcu wychodzi się daleko do przodu. Twój przebieg może być różny, ale to było dla mnie szybsze.

EDIT powtórzyłem to pytanie po uruchomieniu SQL profilera i zaktualizowałem kilka rzeczy do popraw wydajność. Dla każdego, kto jest zainteresowany, oto przykładowy SQL, który pokazuje, co jest tworzone przez DB.

Pierwsza pętla nie musi niczego pomijać, więc jest prostsza.

SELECT TOP (100)                     -- the chunk size 
[Extent1].[Id] AS [Id], 
[Extent1].[Name] AS [Name], 
FROM [dbo].[Clients] AS [Extent1]
ORDER BY [Extent1].[Id] ASC

Kolejne wywołania muszą pominąć poprzednie fragmenty wyników, więc wprowadza użycie row_number:

SELECT TOP (100)                     -- the chunk size
[Extent1].[Id] AS [Id], 
[Extent1].[Name] AS [Name], 
FROM (
    SELECT [Extent1].[Id] AS [Id], [Extent1].[Name] AS [Name], row_number()
    OVER (ORDER BY [Extent1].[Id] ASC) AS [row_number]
    FROM [dbo].[Clients] AS [Extent1]
) AS [Extent1]
WHERE [Extent1].[row_number] > 100   -- the number of rows to skip
ORDER BY [Extent1].[Id] ASC

Opublikowaliśmy oficjalną odpowiedź na Błąd otwarty na Connect . Zalecane obejścia są następujące:

Ten błąd jest spowodowany przez strukturę encji tworzącą transakcję ukrytą podczas wywołania SaveChanges (). Najlepszym sposobem obejścia błędu jest użycie innego wzorca (tzn. nie zapisywanie podczas odczytu) lub jawne deklarowanie transakcji. Oto trzy możliwe rozwiązania:

// 1: Save after iteration (recommended approach in most cases)
using (var context = new MyContext())
{
    foreach (var person in context.People)
    {
        // Change to person
    }
    context.SaveChanges();
}

// 2: Declare an explicit transaction
using (var transaction = new TransactionScope())
{
    using (var context = new MyContext())
    {
        foreach (var person in context.People)
        {
            // Change to person
            context.SaveChanges();
        }
    }
    transaction.Complete();
}

// 3: Read rows ahead (Dangerous!)
using (var context = new MyContext())
{
    var people = context.People.ToList(); // Note that this forces the database
                                          // to evaluate the query immediately
                                          // and could be very bad for large tables.

    foreach (var person in people)
    {
        // Change to person
        context.SaveChanges();
    }
} 

Po prostu umieść context.SaveChanges() po końcu foreach (pętla).

Rzeczywiście, nie można zapisać zmian wewnątrz foreach pętli w C# przy użyciu encji Framework.

context.SaveChanges() metoda działa jak commit w zwykłym systemie bazodanowym (RDMS).

Po prostu wprowadź wszystkie zmiany (które encje będą buforowane), a następnie zapisz je wszystkie jednocześnie wywołując SaveChanges() po pętli (poza nią), jak polecenie commit bazy danych.

To działa, jeśli możesz zapisać wszystkie zmiany na raz.

Miałem ten sam problem, ale w innej sytuacji. Miałem listę przedmiotów w skrzynce na listy. Użytkownik może kliknąć element i wybrać Usuń, ale używam zapisanego proc, aby usunąć element, ponieważ usunięcie elementu jest dużo logiki. Gdy wywo3am zapisany proc, delete dzia3a dobrze, ale wszelkie przysz3e wywo3anie SaveChanges spowoduje b3êd. Moim rozwiązaniem było wywołanie zapisanego proc poza EF i to działało dobrze. Z jakiegoś powodu kiedy wywołuję zapisany proc używając EF sposób robienia rzeczy pozostawia coś otwartego.

FYI: z książki i kilku linijek poprawionych, bo jej stil poprawny:

Wywołanie metody SaveChanges () rozpoczyna transakcję, która automatycznie wycofuje wszystkie zmiany wprowadzone do bazy danych, jeśli wyjątek wystąpi przed zakończeniem iteracji; w przeciwnym razie transakcja zostanie zatwierdzona. Możesz ulec pokusie zastosowania tej metody po każdej aktualizacji lub usunięciu encji, a nie po zakończeniu iteracji, zwłaszcza gdy aktualizujesz lub usuwasz ogromną liczbę encji.

Jeśli spróbuj wywołać metodę SaveChanges () zanim wszystkie dane zostaną przetworzone, pojawi się wyjątek "nowa transakcja nie jest dozwolona, ponieważ w sesji działają inne wątki". Wyjątek występuje, ponieważ SQL Server nie pozwala na rozpoczęcie nowej transakcji na połączeniu, które ma otwarty SqlDataReader, nawet z wieloma zestawami aktywnych rekordów (MARS) włączonymi przez łańcuch połączenia (domyślny łańcuch połączenia EF włącza MARS)

Czasami lepiej zrozumieć, dlaczego coś się dzieje ;-)

Oto kolejne 2 opcje, które pozwalają na wywołanie SaveChanges () w każdej pętli.

Pierwszą opcją jest użycie jednego DBContext do generowania obiektów listy do iteracji, a następnie utworzenie drugiego DBContext do wywołania SaveChanges (). Oto przykład:

//Get your IQueryable list of objects from your main DBContext(db)    
IQueryable<Object> objects = db.Object.Where(whatever where clause you desire);

//Create a new DBContext outside of the foreach loop    
using (DBContext dbMod = new DBContext())
{   
    //Loop through the IQueryable       
    foreach (Object object in objects)
    {
        //Get the same object you are operating on in the foreach loop from the new DBContext(dbMod) using the objects id           
        Object objectMod = dbMod.Object.Find(object.id);

        //Make whatever changes you need on objectMod
        objectMod.RightNow = DateTime.Now;

        //Invoke SaveChanges() on the dbMod context         
        dbMod.SaveChanges()
    }
}

Drugą opcją jest pobranie listy obiektów bazy danych z DBContext, ale wybranie tylko identyfikatorów. a następnie iteracja przez listę identyfikatorów (prawdopodobnie int) i uzyskanie obiektu odpowiadającego każdemu int, i wywoływać SaveChanges () w ten sposób. Ideą tej metody jest pobranie dużej listy liczb całkowitych, jest o wiele bardziej efektywne niż uzyskanie dużej listy obiektów db i wywołanie .ToList () na całym obiekcie. Oto przykład tej metody:

//Get the list of objects you want from your DBContext, and select just the Id's and create a list
List<int> Ids = db.Object.Where(enter where clause here)Select(m => m.Id).ToList();

var objects = Ids.Select(id => db.Objects.Find(id));

foreach (var object in objects)
{
    object.RightNow = DateTime.Now;
    db.SaveChanges()
}

Zawsze używaj wyboru jako listy

Eg:

var tempGroupOfFiles = Entities.Submited_Files.Where(r => r.FileStatusID == 10 && r.EventID == EventId).ToList();

Następnie Pętla przez kolekcję podczas zapisywania zmian

 foreach (var item in tempGroupOfFiles)
             {
                 var itemToUpdate = item;
                 if (itemToUpdate != null)
                 {
                     itemToUpdate.FileStatusID = 8;
                     itemToUpdate.LastModifiedDate = DateTime.Now;
                 }
                 Entities.SaveChanges();

             }

Więc w projekcie miałem dokładnie ten sam problem, problem nie był w foreach lub {[3] } to był w konfiguracji AutoFac użyliśmy. To stworzyło dziwne sytuacje, w których powyższy błąd został wyrzucony, ale także wyrzucono kilka innych równoważnych błędów.

To było nasze rozwiązanie: Zmieniono to:

container.RegisterType<DataContext>().As<DbContext>().InstancePerLifetimeScope();
container.RegisterType<DbFactory>().As<IDbFactory>().SingleInstance();
container.RegisterType<UnitOfWork>().As<IUnitOfWork>().InstancePerRequest();

Do:

container.RegisterType<DataContext>().As<DbContext>().As<DbContext>();
container.RegisterType<DbFactory>().As<IDbFactory>().As<IDbFactory>().InstancePerLifetimeScope();
container.RegisterType<UnitOfWork>().As<IUnitOfWork>().As<IUnitOfWork>();//.InstancePerRequest();

Też miałem do czynienia z tym samym problemem.

Oto przyczyna i rozwiązanie.

Http://blogs.msdn.com/b/cbiyikoglu/archive/2006/11/21/mars-transactions-and-sql-error-3997-3988-or-3983.aspx

Upewnij się, że przed uruchomieniem poleceń manipulacji danymi, takich jak wstawki, aktualizacje, zamknąłeś wszystkie poprzednie aktywne czytniki SQL.

Najczęstszym błędem są funkcje, które odczytują dane z db i zwracają wartości. Dla np. funkcji jak isRecordExist.

W tym przypadku my natychmiast wróć z funkcji, jeśli znajdziemy rekord i zapomnimy zamknąć czytnik.

W moim przypadku problem pojawił się, gdy wywołałem procedurę składowaną przez EF, a następnie SaveChanges rzucają ten wyjątek. Problem polegał na wywołaniu procedury, wyliczenie nie zostało usunięte. Poprawiłem kod w następujący sposób:

public bool IsUserInRole(string username, string roleName, DataContext context)
{          
   var result = context.aspnet_UsersInRoles_IsUserInRoleEF("/", username, roleName);

   //using here solved the issue
   using (var en = result.GetEnumerator()) 
   {
     if (!en.MoveNext())
       throw new Exception("emty result of aspnet_UsersInRoles_IsUserInRoleEF");
     int? resultData = en.Current;

     return resultData == 1;//1 = success, see T-SQL for return codes
   }
}

Musiałem przeczytać ogromny ResultSet i zaktualizować kilka rekordów w tabeli. Próbowałem użyć kawałków zgodnie z sugestią w Drew Noakes 'S odpowiedz .

Niestety po 50000 płyt mam OutofMemoryException. Odpowiedź Entity framework large data set, out of memory exception wyjaśnia, że

EF tworzy drugą kopię danych, która wykorzystuje do wykrywania zmian (tak że może utrzymywać zmiany w bazie danych). EF trzyma ten drugi zestaw na żywotność kontekstu i jego Ten zestaw, który cię uruchamia pamięci.

Zaleca się odnowienie kontekstu każdej partii.

Więc pobrałem minimalne i maksymalne wartości klucza podstawowego-tabele mają klucze podstawowe jako auto incremental integers.Następnie pobrałem z bazy danych fragmenty rekordów, otwierając kontekst dla każdego kawałka. Po przetworzeniu kontekstu fragmentu zamyka się i zwalnia pamięć. Zapewnia, że użycie pamięci nie jest rośnie.

Poniżej fragment mojego kodu:

  public void ProcessContextByChunks ()
  {
        var tableName = "MyTable";
         var startTime = DateTime.Now;
        int i = 0;
         var minMaxIds = GetMinMaxIds();
        for (int fromKeyID= minMaxIds.From; fromKeyID <= minMaxIds.To; fromKeyID = fromKeyID+_chunkSize)
        {
            try
            {
                using (var context = InitContext())
                {   
                    var chunk = GetMyTableQuery(context).Where(r => (r.KeyID >= fromKeyID) && (r.KeyID < fromKeyID+ _chunkSize));
                    try
                    {
                        foreach (var row in chunk)
                        {
                            foundCount = UpdateRowIfNeeded(++i, row);
                        }
                        context.SaveChanges();
                    }
                    catch (Exception exc)
                    {
                        LogChunkException(i, exc);
                    }
                }
            }
            catch (Exception exc)
            {
                LogChunkException(i, exc);
            }
        }
        LogSummaryLine(tableName, i, foundCount, startTime);
    }

    private FromToRange<int> GetminMaxIds()
    {
        var minMaxIds = new FromToRange<int>();
        using (var context = InitContext())
        {
            var allRows = GetMyTableQuery(context);
            minMaxIds.From = allRows.Min(n => (int?)n.KeyID ?? 0);  
            minMaxIds.To = allRows.Max(n => (int?)n.KeyID ?? 0);
        }
        return minMaxIds;
    }

    private IQueryable<MyTable> GetMyTableQuery(MyEFContext context)
    {
        return context.MyTable;
    }

    private  MyEFContext InitContext()
    {
        var context = new MyEFContext();
        context.Database.Connection.ConnectionString = _connectionString;
        //context.Database.Log = SqlLog;
        return context;
    }

FromToRange jest prostą strukturą o właściwościach From I To.

Poniższy kod działa dla mnie:

private pricecheckEntities _context = new pricecheckEntities();

...

private void resetpcheckedtoFalse()
{
    try
    {
        foreach (var product in _context.products)
        {
            product.pchecked = false;
            _context.products.Attach(product);
            _context.Entry(product).State = EntityState.Modified;
        }
        _context.SaveChanges();
    }
    catch (Exception extofException)
    {
        MessageBox.Show(extofException.ToString());

    }
    productsDataGrid.Items.Refresh();
}

Jestem dużo spóźniony na imprezę, ale dziś spotkałem się z tym samym błędem, a sposób, w jaki go rozwiązałem, był prosty. Mój scenariusz był podobny do tego podanego kodu, w którym dokonywałem transakcji DB wewnątrz zagnieżdżonych pętli for-each.

Problem polega na tym, że pojedyncza transakcja DB zajmuje trochę czasu dłużej niż for-each loop, więc gdy wcześniejsza transakcja nie zostanie zakończona, Nowa trakcja rzuca wyjątek, więc rozwiązaniem jest utworzenie nowego obiektu w for-each loop, w którym tworzysz db transakcja.

Dla wyżej wymienionych scenariuszy rozwiązanie będzie wyglądało następująco:

foreach (RivWorks.Model.Negotiation.AutoNegotiationDetails companyFeedDetail in companyFeedDetailList)
                {
private RivWorks.Model.Negotiation.RIV_Entities _dbRiv = RivWorks.Model.Stores.RivEntities(AppSettings.RivWorkEntities_connString);
                    if (companyFeedDetail.FeedSourceTable.ToUpper() == "AUTO")
                    {
                        var company = (from a in _dbRiv.Company.Include("Product") where a.CompanyId == companyFeedDetail.CompanyId select a).First();
                        foreach (RivWorks.Model.NegotiationAutos.Auto sourceProduct in client.Auto)
                        {
                            foreach (RivWorks.Model.Negotiation.Product targetProduct in company.Product)
                            {
                                if (targetProduct.alternateProductID == sourceProduct.AutoID)
                                {
                                    found = true;
                                    break;
                                }
                            }
                            if (!found)
                            {
                                var newProduct = new RivWorks.Model.Negotiation.Product();
                                newProduct.alternateProductID = sourceProduct.AutoID;
                                newProduct.isFromFeed = true;
                                newProduct.isDeleted = false;
                                newProduct.SKU = sourceProduct.StockNumber;
                                company.Product.Add(newProduct);
                            }
                        }
                        _dbRiv.SaveChanges();  // ### THIS BREAKS ### //
                    }
                }

Trochę się spóźniłem, ale też miałem ten błąd. I rozwiązał problem, sprawdzając, co gdzie wartości, które gdzie aktualizacji.

Dowiedziałem się, że moje zapytanie było błędne i że tam, gdzie ponad 250 + edycji oczekujących. Więc poprawiłem moje zapytanie, a teraz działa poprawnie.

Tak więc w mojej sytuacji: Sprawdź zapytanie pod kątem błędów, debugując wynik, który zwraca zapytanie. Następnie popraw zapytanie.

Nadzieję, że to pomoże rozwiązać przyszłość problemy.

Wiem, że to stare pytanie, ale spotkałem się z tym błędem dzisiaj.

I odkryłem, że ten błąd może zostać wyrzucony, gdy wyzwalacz tabeli bazy danych otrzyma błąd.

Dla twojej informacji, możesz sprawdzić wyzwalacze tabel też, gdy pojawi się ten błąd.

Jeśli pojawi się ten błąd spowodowany przez foreach i naprawdę musisz zapisać jeden element w pętli i użyć Wygenerowanej tożsamości dalej w pętli, jak to było w moim przypadku, najprostszym rozwiązaniem jest użycie innego DBContext do wstawienia elementu, który zwróci Id i użyje tego identyfikatora w zewnętrznym kontekście

Na przykład

    using (var context = new DatabaseContext())
    {
        ...
        using (var context1 = new DatabaseContext())
        {
            ...
               context1.SaveChanges();
        }                         
        //get id of inserted object from context1 and use is.   
      context.SaveChanges();
   }

Tworzenie listy zapytań do .ToList () i powinno działać dobrze.