Esempio n. 1
0
 internal static void ExecuteReader <T>(
     IDbCommand cmd, CommandBehavior cmdBehaviour,
     int recordOffset, int recordCount,
     IDataReaderResult <T> result)
 {
     EnsureConnectionOpen(cmd.Connection, () => {
         try {
             using (var rdr = cmd.ExecuteReader(cmdBehaviour)) {
                 int index     = 0;
                 int processed = 0;
                 result.Init(rdr);
                 while (rdr.Read() && processed < recordCount)
                 {
                     if (index >= recordOffset)
                     {
                         processed++;
                         result.Read(rdr);
                     }
                     index++;
                 }
             }
         } catch (Exception ex) {
             throw new ExecuteDbCommandException(cmd, ex);
         }
     });
 }
Esempio n. 2
0
        internal static async Task <T> ExecuteReaderAsync <T>(
            IDbCommand cmd, CommandBehavior cmdBehaviour,
            int recordOffset, int recordCount,
            IDataReaderResult <T> result, CancellationToken cancel)
        {
            var isOpenConn = cmd.Connection.State != ConnectionState.Closed;

            if (!isOpenConn)
            {
                await cmd.Connection.OpenAsync(cancel).ConfigureAwait(false);
            }
            IDataReader rdr = null;

            try {
                if (cmd is DbCommand)
                {
                    rdr = await((DbCommand)cmd).ExecuteReaderAsync(cmdBehaviour, cancel).ConfigureAwait(false);
                }
                else
                {
                    rdr = cmd.ExecuteReader(cmdBehaviour);
                }

                int index     = 0;
                int processed = 0;

                result.Init(rdr);
                while ((await rdr.ReadAsync(cancel)) && processed < recordCount)
                {
                    if (index >= recordOffset)
                    {
                        processed++;
                        result.Read(rdr);
                    }
                    index++;
                }
            } catch (Exception ex) {
                throw new ExecuteDbCommandException(cmd, ex);
            } finally {
                if (rdr != null)
                {
                    rdr.Dispose();
                }
                if (!isOpenConn)
                {
                    cmd.Connection.Close();
                }
            }
            return(result.Result);
        }
Esempio n. 3
0
        void ExecuteReader <T>(IDataReaderResult <T> result, int recordCount)
        {
            int index     = 0;
            int processed = 0;

            result.Init(DataReader);
            while (DataReader.Read() && processed < recordCount)
            {
                if (index >= RecordOffset)
                {
                    processed++;
                    result.Read(DataReader);
                }
                index++;
            }
        }
Esempio n. 4
0
        async Task <T> ExecuteReaderAsync <T>(IDataReaderResult <T> result, int recordCount, CancellationToken cancel)
        {
            int index     = 0;
            int processed = 0;

            result.Init(DataReader);
            while ((await DataReader.ReadAsync(cancel)) && processed < recordCount)
            {
                if (index >= RecordOffset)
                {
                    processed++;
                    result.Read(DataReader);
                }
                index++;
            }
            return(result.Result);
        }