Varlık Çerçevesi: Bu Komutla ilişkilendirilmiş zaten açık bir DataReader var

Entity Framework kullanıyorum ve bazen bu hatayı alırım.

EntityCommandExecutionException
{"There is already an open DataReader associated with this Command which must be closed first."}
   at System.Data.EntityClient.EntityCommandDefinition.ExecuteStoreCommands...

Düz-se bile herhangi bir manuel bağlantı yönetimi yapmıyorum.

bu hata zaman zaman meydana gelir.

hatayı tetikleyen kod (okuma kolaylığı nedeniyle kısaltılmıştır):

        if (critera.FromDate > x) {
            t= _tEntitites.T.Where(predicate).ToList();
        }
        else {
            t= new List<T>(_tEntitites.TA.Where(historicPredicate).ToList());
        }

Her seferinde yeni bağlantı açmak için Desen ata seçeneğini kullanın.

using (_tEntitites = new TEntities(GetEntityConnection())) {

    if (critera.FromDate > x) {
        t= _tEntitites.T.Where(predicate).ToList();
    }
    else {
        t= new List<T>(_tEntitites.TA.Where(historicPredicate).ToList());
    }

}

hala problemli

EF zaten açıksa neden bir bağlantıyı tekrar kullanmayasınız?

Bu bağlantıyı kapatmakla ilgili değil. EF bağlantıyı doğru yönetir. Bu sorunu anlıyorum, bir sonraki DataReader birincisi okumayı tamamlamadan önce yürütülürken, tek bağlantıda (veya birden çok seçimli tek bir komut) yürütülen birden çok veri alma komutunun olmasıdır. Kural dışı durumu önlemenin tek yolu, birden çok iç içe DataReaders = MultipleActiveResultSets özelliğini etkinleştirmektir. Bu her zaman gerçekleşen başka bir senaryo, sorgu (IQueryable) sonucunu yinelediğinizde ve yineleme içindeki yüklü varlık için tembel yüklemeyi tetikleyeceğinizdir.

MARS (MultipleActiveResultSets) kullanmaya alternatif olarak, birden çok sonuç kümesi açmamanız için kodunuzu yazabilirsiniz.

Yapabileceğiniz şey verileri belleğe almak, böylece okuyucuyu açmayacaksınız. Genellikle başka bir sonuç kümesi açmaya çalışırken bir sonuç kümesi üzerinden yineleme yapılır.

Basit kod:

public class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

public class Blog
{
    public int BlogID { get; set; }
    public virtual ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostID { get; set; }
    public virtual Blog Blog { get; set; }
    public string Text { get; set; }
}

Diyelim ki veritabanınızda aşağıdakileri içeren bir arama yapıyorsunuz:

var context = new MyContext();

//here we have one resultset
var largeBlogs = context.Blogs.Where(b => b.Posts.Count > 5); 

foreach (var blog in largeBlogs) //we use the result set here
{
     //here we try to get another result set while we are still reading the above set.
    var postsWithImportantText = blog.Posts.Where(p=>p.Text.Contains("Important Text"));
}

Bunun için .ToList () ekleyerek basit bir çözüm yapabiliriz :

var largeBlogs = context.Blogs.Where(b => b.Posts.Count > 5).ToList();

Bu, varlık çerçevesini listeyi belleğe yüklemeye zorlar, böylece foreach döngüsünde yinelediğimizde artık listeyi açmak için veri okuyucusunu kullanmaz, bunun yerine bellekte olur.

Örneğin bazı özellikleri tembelleştirmek istiyorsanız bunun istenmeyebileceğini anlıyorum. Bu çoğunlukla umarım bu sorunu nasıl / neden alabileceğinizi açıklayan bir örnektir, böylece buna göre karar verebilirsiniz

Bu sorunun üstesinden gelmenin başka bir yolu var. Bunun daha iyi bir yol olup olmadığı durumunuza bağlıdır.

Sorun tembel yüklemeden kaynaklanmaktadır, bu nedenle bundan kaçınmanın bir yolu, Dahil Et'i kullanarak tembel yüklemeye sahip olmamaktır:

var results = myContext.Customers
    .Include(x => x.Orders)
    .Include(x => x.Addresses)
    .Include(x => x.PaymentMethods);

Uygun Includeolanları kullanırsanız, MARS'yi etkinleştirmekten kaçınabilirsiniz. Ancak birini kaçırırsanız hatayı alırsınız, bu nedenle MARS'yi etkinleştirmek muhtemelen düzeltmenin en kolay yoludur.

Bu hatayı alıyorsunuz, yinelemeye çalıştığınız koleksiyon bir çeşit tembel yükleme (IQueriable).

foreach (var user in _dbContext.Users)
{    
}

IQueriable koleksiyonunu diğer numaralandırılabilir koleksiyona dönüştürmek bu sorunu çözecektir. misal

_dbContext.Users.ToList()

Not: .ToList () her seferinde yeni bir küme oluşturur ve büyük verilerle uğraşıyorsanız performans sorununa neden olabilir.

Yapıcıya seçeneği ekleyerek sorunu kolayca (pragmatik) çözdüm. Böylece, sadece gerektiğinde kullanıyorum.

public class Something : DbContext
{
    public Something(bool MultipleActiveResultSets = false)
    {
        this.Database
            .Connection
            .ConnectionString = Shared.ConnectionString /* your connection string */
                              + (MultipleActiveResultSets ? ";MultipleActiveResultSets=true;" : "");
    }
...

Ayarlamak için bağlantı dizenizde deneyin MultipleActiveResultSets=true. Bu, veritabanında çoklu göreve izin verir.

Server=yourserver ;AttachDbFilename=database;User Id=sa;Password=blah ;MultipleActiveResultSets=true;App=EntityFramework

Bu benim için işe yarar ... app.config'deki bağlantınız veya programlı olarak ayarlasanız da ...

Başlangıçta MyDataContext nesnesinin (Burada MyDataContext bir EF5 Context nesnesidir) bir örneğine başvurmak için API sınıfımda statik bir alan kullanmaya karar vermiştim, ancak bu sorunu yaratmak gibi görünüyordu. API yöntemlerimin her birine aşağıdaki gibi bir kod ekledim ve bu sorunu çözdü.

using(MyDBContext db = new MyDBContext())
{
    //Do some linq queries
}

Diğer insanların belirttiği gibi, EF Data Context nesneleri iş parçacığı için güvenli DEĞİLDİR. Bu nedenle, bunları statik nesneye yerleştirmek en sonunda doğru koşullarda "veri okuyucu" hatasına neden olacaktır.

Orijinal varsayımım, nesnenin yalnızca bir örneğini oluşturmanın daha verimli olacağı ve daha iyi bellek yönetimi sağlayabileceğiydi. Bu konuyu araştırmak için topladığım şeyden, durum böyle değil. Aslında, API'nıza yapılan her bir çağrıyı izole edilmiş, iş parçacığı açısından güvenli bir olay olarak ele almak daha verimli görünmektedir. Nesne kapsam dışına çıktığında, tüm kaynakların düzgün bir şekilde serbest bırakılmasını sağlamak.

Bu, özellikle API'nizi bir WebService veya REST API'si olarak gösterecek bir sonraki doğal ilerlemeye götürürseniz mantıklıdır.

ifşa

• İşletim Sistemi: Windows Server 2012
• .NET: Yüklü 4.5, 4.0 kullanarak proje
• Veri Kaynağı: MySQL
• Uygulama Çerçevesi: MVC3
• Kimlik Doğrulama: Formlar

Görünüme bir IQueriable gönderdiğimde ve iç foreach'in de bağlantıyı kullanması gereken bir çift foreach içinde kullandığımda bu hatanın meydana geldiğini fark ettim. Basit örnek (ViewBag.parents IQueriable veya DbSet olabilir):

foreach (var parent in ViewBag.parents)
{
    foreach (var child in parent.childs)
    {

    }
}

Basit çözüm, .ToList()koleksiyonu kullanmadan önce koleksiyonda kullanmaktır. Ayrıca MARS'ın MySQL ile çalışmadığını unutmayın.

Ben de aynı hatayı buldum ve senin Func<TEntity, bool>yerine bir yerine kullanırken meydana geldi .Expression<Func<TEntity, bool>>predicate

Ben hepsini değiştirdi kez Func'skarşı Expression'sistisna atılan durdurdu.

Ben inanıyorum EntityFramworkbazı zekice şeyler yapar Expression'sbasitçe ile ilgisi olmadığıFunc's

Bu sorunu azaltmak için 2 çözüm:

1. .ToList()Sorgunuzdan sonra tembel yüklemeyi koruyarak bellek önbelleğe almayı zorlayın , böylece yeni bir DataReader açarak tekrarlayabilirsiniz.
2. .Include(/ sorguya yüklemek istediğiniz ek varlıklar /) buna istekli yükleme adı verilir, bu da DataReader ile bir sorguyu yürütürken ilişkili nesneleri (varlıkları) eklemenize izin verir.

MARS'yi etkinleştirmek ve tüm sonuç kümesini belleğe almak arasında iyi bir orta yol, yalnızca bir ilk sorgudaki kimlikleri almak ve daha sonra gittiğiniz her öğeyi gerçekleştiren kimlikler arasında geçiş yapmaktır.

Örneğin ( bu yanıttaki gibi "Blog ve Yayınlar" örnek varlıklarını kullanarak ):

using (var context = new BlogContext())
{
    // Get the IDs of all the items to loop through. This is
    // materialized so that the data reader is closed by the
    // time we're looping through the list.
    var blogIds = context.Blogs.Select(blog => blog.Id).ToList();

    // This query represents all our items in their full glory,
    // but, items are only materialized one at a time as we
    // loop through them.
    var blogs =
        blogIds.Select(id => context.Blogs.First(blog => blog.Id == id));

    foreach (var blog in blogs)
    {
        this.DoSomethingWith(blog.Posts);

        context.SaveChanges();
    }
}

Bunu yapmak, binlerce nesne nesnesinin aksine, sadece birkaç bin tamsayıyı belleğe çekebileceğiniz anlamına gelir; bu, MARS'yi etkinleştirmeden tek tek çalışmanızı sağlarken bellek kullanımını en aza indirmelidir.

Bunun bir diğer güzel yararı, örnekte görüldüğü gibi, döngünün sonuna kadar (veya başka bir geçici çözüm) beklemek zorunda kalmadan, her öğeye döngü yaptığınızda değişiklikleri kaydedebilmenizdir. MARS etkin ( buraya ve buraya bakınız ).

Benim durumumda, myContext.SaveChangesAsync () çağrıları öncesinde eksik "bekliyor" ifadeleri olduğunu buldum. Bu zaman uyumsuz çağrılardan önce beklemek, veri okuyucu sorunlarını benim için düzeltti.

Koşullarımızın bir kısmını bir Func <> veya uzantı yönteminde gruplandırmaya çalışırsak, bu hatayı alırız, şöyle bir kodumuz olduğunu varsayalım:

public static Func<PriceList, bool> IsCurrent()
{
  return p => (p.ValidFrom == null || p.ValidFrom <= DateTime.Now) &&
              (p.ValidTo == null || p.ValidTo >= DateTime.Now);
}

Or

public static IEnumerable<PriceList> IsCurrent(this IEnumerable<PriceList> prices) { .... }

Bunu bir Where () içinde kullanmaya çalışırsak istisna atar, bunun yerine yapmamız gereken şey böyle bir Predicate oluşturmaktır:

public static Expression<Func<PriceList, bool>> IsCurrent()
{
    return p => (p.ValidFrom == null || p.ValidFrom <= DateTime.Now) &&
                (p.ValidTo == null || p.ValidTo >= DateTime.Now);
}

Daha fazla bilgi için: http://www.albahari.com/nutshell/predicatebuilder.aspx

Bu sorun, verileri bir listeye dönüştürerek çözülebilir

 var details = _webcontext.products.ToList();


            if (details != null)
            {
                Parallel.ForEach(details, x =>
                {
                    Products obj = new Products();
                    obj.slno = x.slno;
                    obj.ProductName = x.ProductName;
                    obj.Price = Convert.ToInt32(x.Price);
                    li.Add(obj);

                });
                return li;
            }

Benim durumumda, bağımlılık enjeksiyon kaydı nedeniyle sorun oluştu. Tek bir kayıtlı hizmete bir dbcontext kullanıyordu istek başına hizmet enjekte edildi. Bu nedenle, dbcontext çoklu istek ve dolayısıyla hata içinde kullanılmıştır.

Benim durumumda sorunun MARS bağlantı dizesi ile ilgisi yoktu ama json serileştirmesi. Projemi NetCore2'den 3'e yükselttikten sonra bu hatayı aldım.

Daha fazla bilgiyi burada bulabilirsiniz

Ben ikinci sorgu önce kodun aşağıdaki bölümünü kullanarak bu sorunu çözdü:

 ...first query
 while (_dbContext.Connection.State != System.Data.ConnectionState.Closed)
 {
     System.Threading.Thread.Sleep(500);
 }
 ...second query

uyku süresini milisaniye cinsinden değiştirebilirsiniz

PD Dişleri kullanırken kullanışlıdır