c# - visual - multipleactiveresultsets=true;

Ya hay un DataReader abierto asociado con este comando que debe cerrarse primero

Question

Tengo esta consulta y me sale el error en esta función:

var accounts = from account in context.Accounts
               from guranteer in account.Gurantors
               select new AccountsReport
               {
                   CreditRegistryId = account.CreditRegistryId,
                   AccountNumber = account.AccountNo,
                   DateOpened = account.DateOpened,
               };

 return accounts.AsEnumerable()
                .Select((account, index) => new AccountsReport()
                    {
                        RecordNumber = FormattedRowNumber(account, index + 1),
                        CreditRegistryId = account.CreditRegistryId,
                        DateLastUpdated = DateLastUpdated(account.CreditRegistryId, account.AccountNumber),
                        AccountNumber = FormattedAccountNumber(account.AccountType, account.AccountNumber)
                    })
                .OrderBy(c=>c.FormattedRecordNumber)
                .ThenByDescending(c => c.StateChangeDate);


public DateTime DateLastUpdated(long creditorRegistryId, string accountNo)
{
    return (from h in context.AccountHistory
            where h.CreditorRegistryId == creditorRegistryId && h.AccountNo == accountNo
            select h.LastUpdated).Max();
}

Error es

Ya hay un DataReader abierto asociado con este comando que debe cerrarse primero.

Actualizar:

seguimiento de la pila añadido:

InvalidOperationException: There is already an open DataReader associated with this Command which must be closed first.]
   System.Data.SqlClient.SqlInternalConnectionTds.ValidateConnectionForExecute(SqlCommand command) +5008639
   System.Data.SqlClient.SqlConnection.ValidateConnectionForExecute(String method, SqlCommand command) +23
   System.Data.SqlClient.SqlCommand.ValidateCommand(String method, Boolean async) +144
   System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, DbAsyncResult result) +87
   System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method) +32
   System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior, String method) +141
   System.Data.SqlClient.SqlCommand.ExecuteDbDataReader(CommandBehavior behavior) +12
   System.Data.Common.DbCommand.ExecuteReader(CommandBehavior behavior) +10
   System.Data.EntityClient.EntityCommandDefinition.ExecuteStoreCommands(EntityCommand entityCommand, CommandBehavior behavior) +443

[EntityCommandExecutionException: An error occurred while executing the command definition. See the inner exception for details.]
   System.Data.EntityClient.EntityCommandDefinition.ExecuteStoreCommands(EntityCommand entityCommand, CommandBehavior behavior) +479
   System.Data.Objects.Internal.ObjectQueryExecutionPlan.Execute(ObjectContext context, ObjectParameterCollection parameterValues) +683
   System.Data.Objects.ObjectQuery`1.GetResults(Nullable`1 forMergeOption) +119
   System.Data.Objects.ObjectQuery`1.System.Collections.Generic.IEnumerable<T>.GetEnumerator() +38
   System.Linq.Enumerable.Single(IEnumerable`1 source) +114
   System.Data.Objects.ELinq.ObjectQueryProvider.<GetElementFunction>b__3(IEnumerable`1 sequence) +4
   System.Data.Objects.ELinq.ObjectQueryProvider.ExecuteSingle(IEnumerable`1 query, Expression queryRoot) +29
   System.Data.Objects.ELinq.ObjectQueryProvider.System.Linq.IQueryProvider.Execute(Expression expression) +91
   System.Data.Entity.Internal.Linq.DbQueryProvider.Execute(Expression expression) +69
   System.Linq.Queryable.Max(IQueryable`1 source) +216
   CreditRegistry.Repositories.CreditRegistryRepository.DateLastUpdated(Int64 creditorRegistryId, String accountNo) in D:/Freelance Work/SuperExpert/CreditRegistry/CreditRegistry/Repositories/CreditRegistryRepository.cs:1497
   CreditRegistry.Repositories.CreditRegistryRepository.<AccountDetails>b__88(AccountsReport account, Int32 index) in D:/Freelance Work/SuperExpert/CreditRegistry/CreditRegistry/Repositories/CreditRegistryRepository.cs:1250
   System.Linq.<SelectIterator>d__7`2.MoveNext() +198
   System.Linq.Buffer`1..ctor(IEnumerable`1 source) +217
   System.Linq.<GetEnumerator>d__0.MoveNext() +96

Answer 1

Además de la respuesta de Ladislav Mrnka :

Si está publicando y anulando el contenedor en la pestaña Configuración , puede establecer MultipleActiveResultSet en True. Puede encontrar esta opción haciendo clic en Avanzado ... y estará en el grupo Avanzado .

Answer 2

Aquí hay una cadena de conexión de trabajo para alguien que necesita referencia.

  <connectionStrings>
    <add name="IdentityConnection" connectionString="Data Source=(LocalDb)/v11.0;AttachDbFilename=|DataDirectory|/IdentityDb.mdf;Integrated Security=True;MultipleActiveResultSets=true;" providerName="System.Data.SqlClient" />
  </connectionStrings>

Answer 3

Bueno para mi fue mi propio error. Estaba intentando ejecutar un INSERT utilizando SqlCommand.executeReader() cuando debería haber estado usando SqlCommand.ExecuteNonQuery() . Fue abierto y nunca cerrado, causando el error. Cuidado con este descuido.

Answer 4

Como nota al margen ... esto también puede suceder cuando hay un problema con la asignación de datos (internos) de los objetos de SQL.

Por ejemplo...

SQL Scalar Function que accidentalmente devolvió un VARCHAR ... y luego ... lo usé para generar una columna en una vista. La vista se asignó correctamente en el DbContext ... así que Linq lo estaba llamando bien. Sin embargo, ¿la Entidad esperaba DateTime? y la VIEW estaba volviendo a String .

Que ODDLY lanza ...

"Ya existe un DataReader abierto asociado con este comando que debe cerrarse primero"

Fue difícil entenderlo ... pero después de corregir los parámetros de retorno ... todo estaba bien

Answer 5

En mi caso, el uso de Include() solucionó este error y, dependiendo de la situación, puede ser mucho más eficiente que emitir múltiples consultas cuando se puede consultar todo al mismo tiempo con una unión.

IEnumerable<User> users = db.Users.Include("Projects.Tasks.Messages");

foreach (User user in users)
{
    Console.WriteLine(user.Name);
    foreach (Project project in user.Projects)
    {
        Console.WriteLine("/t"+project.Name);
        foreach (Task task in project.Tasks)
        {
            Console.WriteLine("/t/t" + task.Subject);
            foreach (Message message in task.Messages)
            {
                Console.WriteLine("/t/t/t" + message.Text);
            }
        }
    }
}

Answer 6

En mi caso, había abierto una consulta desde el contexto de datos, como

    Dim stores = DataContext.Stores _
        .Where(Function(d) filter.Contains(d.code)) _

... y luego consultó lo mismo ...

    Dim stores = DataContext.Stores _
        .Where(Function(d) filter.Contains(d.code)).ToList

Agregar el .ToList a la primera resolvió mi problema. Creo que tiene sentido envolver esto en una propiedad como:

Public ReadOnly Property Stores As List(Of Store)
    Get
        If _stores Is Nothing Then
            _stores = DataContext.Stores _
                .Where(Function(d) Filters.Contains(d.code)).ToList
        End If
        Return _stores
    End Get
End Property

Donde _stores es una variable privada, y Filtros también es una propiedad de solo lectura que se lee desde AppSettings.

Answer 7

Esto puede suceder si ejecuta una consulta mientras itera los resultados de otra consulta. No queda claro en su ejemplo dónde sucede esto porque el ejemplo no está completo.

Una cosa que puede causar esto es la carga perezosa activada al iterar sobre los resultados de alguna consulta.

Esto se puede resolver fácilmente permitiendo MARS en su cadena de conexión. Agregue MultipleActiveResultSets=true a la parte del proveedor de su cadena de conexión (donde se especifican el origen de datos, el catálogo inicial, etc.).

Answer 8

Esto se extrae de un escenario del mundo real:

• El código funciona bien en un entorno Stage con MultipleActiveResultSets establecido en la cadena de conexión
• Código publicado en el entorno de producción sin MultipleActiveResultSets = true
• Tantas páginas / llamadas funcionan mientras que una sola falla
• Mirando más de cerca la llamada, se realiza una llamada innecesaria a la base de datos y debe eliminarse
• Establezca MultipleActiveResultSets = true en Producción y publique el código limpiado, todo funciona bien y, de manera eficiente

En conclusión, sin olvidarnos de MultipleActiveResultSets, el código podría haberse ejecutado durante mucho tiempo antes de descubrir una llamada db redundante que podría ser muy costosa, y sugiero que no dependamos completamente de la configuración del atributo MultipleActiveResultSets sino que también descubramos por qué el código lo necesita. donde falló

Answer 9

Estoy usando el servicio web en mi herramienta, donde esos servicios obtienen el procedimiento almacenado. Mientras más número de herramientas cliente obtiene el servicio web, surge este problema. Lo he solucionado especificando el atributo Sincronizado para esas funciones que busca el procedimiento almacenado. ahora está funcionando bien, el error nunca apareció en mi herramienta.

 [MethodImpl(MethodImplOptions.Synchronized)]
 public static List<t> MyDBFunction(string parameter1)
  {
  }

Este atributo permite procesar una solicitud a la vez. por lo que esto resuelve el problema.

Answer 10

Lo más probable es que este problema ocurra debido a la función de "carga lenta" de Entity Framework. Por lo general, a menos que se requiera explícitamente durante la búsqueda inicial, todos los datos unidos (cualquier cosa que se almacene en otras tablas de la base de datos) se recuperan solo cuando se requieren. En muchos casos esto es bueno, ya que evita la obtención de datos innecesarios y, por lo tanto, mejora el rendimiento de las consultas (sin uniones) y ahorra ancho de banda.

En la situación descrita en la pregunta, se realiza la búsqueda inicial, y durante la fase de "selección" se solicitan los datos de carga diferida, se emiten consultas adicionales y, luego, EF se queja de "abrir DataReader".

La solución propuesta en la respuesta aceptada permitirá la ejecución de estas consultas, y de hecho, toda la solicitud tendrá éxito.

Sin embargo, si examina las solicitudes enviadas a la base de datos, notará varias solicitudes: solicitud adicional por cada información faltante (cargada perezoso). Esto podría ser un asesino de rendimiento.

Un mejor enfoque es decirle a EF que precargue todos los datos cargados perezosos necesarios durante la consulta inicial. Esto se puede hacer usando la declaración "Include":

using System.Data.Entity;

query = query.Include(a => a.LazyLoadedProperty);

De esta manera, se realizarán todas las combinaciones necesarias y todos los datos necesarios se devolverán como una sola consulta. El problema descrito en la pregunta será resuelto.

Answer 11

No sé si esta es una respuesta duplicada o no. Si es que lo siento. Solo quiero que los necesitados sepan cómo resolví mi problema usando ToList ().

En mi caso obtuve la misma excepción para la siguiente consulta.

int id = adjustmentContext.InformationRequestOrderLinks.Where(item => item.OrderNumber == irOrderLinkVO.OrderNumber && item.InformationRequestId == irOrderLinkVO.InformationRequestId).Max(item => item.Id);

Resolví como abajo

List<Entities.InformationRequestOrderLink> links = adjustmentContext.InformationRequestOrderLinks
.Where(item => item.OrderNumber == irOrderLinkVO.OrderNumber && item.InformationRequestId == irOrderLinkVO.InformationRequestId).ToList();

int id = 0;

if (links.Any())
{
  id = links.Max(x => x.Id);
 }
if (id == 0)
{
//do something here
}

Answer 12

Para aquellos que encuentran esto a través de Google;
Recibía este error porque, como lo sugería el error, no pude cerrar un SqlDataReader antes de crear otro en el mismo SqlCommand, asumiendo erróneamente que sería basura recolectada al dejar el método en el que se creó.

sqlDataReader.Close(); el problema llamando a sqlDataReader.Close(); Antes de crear el segundo lector.

Answer 13

Parece que está llamando a DateLastUpdated desde una consulta activa que utiliza el mismo contexto de EF y DateLastUpdate emite un comando para el almacén de datos. Entity Framework solo admite un comando activo por contexto a la vez.

Puede refactorizar sus dos consultas anteriores en una como esta:

return accounts.AsEnumerable()
        .Select((account, index) => new AccountsReport()
        {
          RecordNumber = FormattedRowNumber(account, index + 1),
          CreditRegistryId = account.CreditRegistryId,
          DateLastUpdated = (
                                                from h in context.AccountHistory 
                                                where h.CreditorRegistryId == creditorRegistryId 
                              && h.AccountNo == accountNo 
                                                select h.LastUpdated).Max(),
          AccountNumber = FormattedAccountNumber(account.AccountType, account.AccountNumber)
        })
        .OrderBy(c=>c.FormattedRecordNumber)
        .ThenByDescending(c => c.StateChangeDate);

También noté que estás llamando a funciones como FormattedAccountNumber y FormattedRecordNumber en las consultas. A menos que se trate de procesos o funciones almacenados que haya importado de su base de datos al modelo de datos de la entidad y que se hayan asignado correctamente, estos también arrojarán excepciones, ya que EF no sabrá cómo traducir esas funciones en declaraciones que puede enviar al almacén de datos.

También tenga en cuenta que llamar a AsEnumerable no obliga a la consulta a ejecutarse. Hasta que la ejecución de la consulta se aplace hasta que se enumere. Puede forzar la enumeración con ToList o ToArray si así lo desea.

Answer 14

Puede usar el método ToList() antes de la declaración de return .

var accounts =
from account in context.Accounts
from guranteer in account.Gurantors

 select new AccountsReport
{
    CreditRegistryId = account.CreditRegistryId,
    AccountNumber = account.AccountNo,
    DateOpened = account.DateOpened,
};

 return accounts.AsEnumerable()
               .Select((account, index) => new AccountsReport()
                       {
                           RecordNumber = FormattedRowNumber(account, index + 1),
                           CreditRegistryId = account.CreditRegistryId,
                              DateLastUpdated = DateLastUpdated(account.CreditRegistryId, account.AccountNumber),
                           AccountNumber = FormattedAccountNumber(account.AccountType, account.AccountNumber)}).OrderBy(c=>c.FormattedRecordNumber).ThenByDescending(c => c.StateChangeDate).ToList();


 public DateTime DateLastUpdated(long creditorRegistryId, string accountNo)
    {
        var dateReported = (from h in context.AccountHistory
                            where h.CreditorRegistryId == creditorRegistryId && h.AccountNo == accountNo
                            select h.LastUpdated).Max();
        return dateReported;
    }

Answer 15

Resolví este problema cambiando await _accountSessionDataModel.SaveChangesAsync (); a _accountSessionDataModel.SaveChanges (); en mi clase de repositorio.

 public async Task<Session> CreateSession()
    {
        var session = new Session();

        _accountSessionDataModel.Sessions.Add(session);
        await _accountSessionDataModel.SaveChangesAsync();
     }

Se cambió a

 public Session CreateSession()
    {
        var session = new Session();

        _accountSessionDataModel.Sessions.Add(session);
        _accountSessionDataModel.SaveChanges();
     }

El problema fue que actualicé las Sesiones en el frontend después de crear una sesión (en código), pero debido a que SaveChangesAsync sucede de forma asíncrona, la búsqueda de las sesiones causó este error porque aparentemente la operación SaveChangesAsync aún no estaba lista.

Answer 16

Tuve el mismo error, cuando intenté actualizar algunos registros dentro del ciclo de lectura. He probado la respuesta más votada MultipleActiveResultSets=true y he encontrado que es solo una solución para obtener el siguiente error

La nueva transacción no está permitida porque hay otros subprocesos que se ejecutan en la sesión

El mejor enfoque, que funcionará para los grandes ResultSets es usar fragmentos y abrir un contexto separado para cada parte, tal como se describe en SqlException de Entity Framework: no se permite una nueva transacción porque hay otros subprocesos que se ejecutan en la sesión

Answer 17

use la sintaxis .ToList() para convertir el objeto leído de db a lista para evitar que se vuelva a leer. Espero que esto funcione para él. Gracias.