Implemented abstraction for IDataReader

Author: codeapologist

src/DataAbstractions.Dapper/DataAccessor.Dapper.Contrib.cs renamed to src/DataAbstractions.Dapper/DataAccessor/DataAccessor.Dapper.Contrib.cs

@@ -1,8 +1,8 @@
-using System;
+using Dapper;
+using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Threading.Tasks;
-using Dapper;
 
 namespace DataAbstractions.Dapper
 {
@@ -145,7 +145,7 @@ public Task<IEnumerable<TReturn>> QueryAsync<TReturn>(string sql, Type[] types,
             _connection.QueryAsync(sql, types, map, param, transaction, buffered, splitOn, commandTimeout, commandType);
 
         public async Task<IGridAccessor> QueryMultipleAsync(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null) =>
-           new GridAccessor( await _connection.QueryMultipleAsync(sql, param, transaction, commandTimeout, commandType));
+           new GridAccessor(await _connection.QueryMultipleAsync(sql, param, transaction, commandTimeout, commandType));
 
         public async Task<IGridAccessor> QueryMultipleAsync(CommandDefinition command) =>
             new GridAccessor(await _connection.QueryMultipleAsync(command));

src/DataAbstractions.Dapper/DataAccessor.Dapper.cs renamed to src/DataAbstractions.Dapper/DataAccessor/DataAccessor.Dapper.cs

@@ -9,12 +9,19 @@ public partial class DataAccessor : IDataAccessor
         private readonly IDbConnection _connection;
 
         public DataAccessor(DbConnection connection)
-        {           
+        {
             _connection = connection ?? throw new ArgumentNullException(nameof(connection));
         }
 
         public IDbConnection GetUnderlyingConnection() => _connection;
 
+        public IDataReaderAccessor GetDataReaderAbstraction(IDataReader reader)
+        {
+            return new DataReaderAccessor(reader);
+        }
+
         public void Dispose() => _connection.Dispose();
+
+
     }
 }

src/DataAbstractions.Dapper/DataAccessor.IDbConnection.cs renamed to src/DataAbstractions.Dapper/DataAccessor/DataAccessor.IDbConnection.cs

@@ -0,0 +1,40 @@
+using Dapper;
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace DataAbstractions.Dapper
+{
+
+    public partial class DataReaderAccessor : IDataReaderAccessor
+    {
+
+        //Dapper Extensions
+        public IEnumerable<T> Parse<T>()
+        {
+            return _dataReader.Parse<T>();
+        }
+
+        public IEnumerable<object> Parse(Type type)
+        {
+            return _dataReader.Parse(type);
+        }
+
+        public IEnumerable<dynamic> Parse()
+        {
+            return _dataReader.Parse();
+        }
+
+        public Func<IDataReader, object> GetRowParser(Type type, int startIndex = 0, int length = -1, bool returnNullIfFirstMissing = false)
+        {
+            return _dataReader.GetRowParser(type, startIndex, length, returnNullIfFirstMissing);
+        }
+
+        public Func<IDataReader, T> GetRowParser<T>(Type concreteType = null, int startIndex = 0, int length = -1, bool returnNullIfFirstMissing = false)
+        {
+            return _dataReader.GetRowParser<T>(concreteType, startIndex, length, returnNullIfFirstMissing);
+        }
+
+
+    }
+}

src/DataAbstractions.Dapper/DataAccessor.cs renamed to src/DataAbstractions.Dapper/DataAccessor/DataAccessor.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Data;
+
+namespace DataAbstractions.Dapper
+{
+
+    public partial class DataReaderAccessor : IDataReaderAccessor
+    {
+        private readonly IDataReader _dataReader;
+
+        public DataReaderAccessor(IDataReader dataReader)
+        {
+            _dataReader = dataReader;
+        }
+
+        public object this[int i] => _dataReader[i];
+
+        public object this[string name] => _dataReader[name];
+
+        public int Depth => _dataReader.Depth;
+
+        public bool IsClosed => _dataReader.IsClosed;
+
+        public int RecordsAffected => _dataReader.RecordsAffected;
+
+        public int FieldCount => _dataReader.FieldCount;
+
+        public void Close()
+        {
+            _dataReader.Close();
+        }
+
+        public void Dispose()
+        {
+            _dataReader.Dispose();
+        }
+
+        public bool GetBoolean(int i)
+        {
+            return _dataReader.GetBoolean(i);
+        }
+
+        public byte GetByte(int i)
+        {
+            return _dataReader.GetByte(i);
+        }
+
+        public long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
+        {
+            return _dataReader.GetBytes(i, fieldOffset, buffer, bufferoffset, length);
+        }
+
+        public char GetChar(int i)
+        {
+            return _dataReader.GetChar(i);
+        }
+
+        public long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
+        {
+            return _dataReader.GetChars(i, fieldoffset, buffer, bufferoffset, length);
+        }
+
+        public IDataReader GetData(int i)
+        {
+            return _dataReader.GetData(i);
+        }
+
+        public string GetDataTypeName(int i)
+        {
+            return _dataReader.GetDataTypeName(i);
+        }
+
+        public DateTime GetDateTime(int i)
+        {
+            return _dataReader.GetDateTime(i);
+        }
+
+        public decimal GetDecimal(int i)
+        {
+            return _dataReader.GetDecimal(i);
+        }
+
+        public double GetDouble(int i)
+        {
+            return _dataReader.GetDouble(i);
+        }
+
+        public Type GetFieldType(int i)
+        {
+            return _dataReader.GetFieldType(i);
+        }
+
+        public float GetFloat(int i)
+        {
+            return _dataReader.GetFloat(i);
+        }
+
+        public Guid GetGuid(int i)
+        {
+            return _dataReader.GetGuid(i);
+        }
+
+        public short GetInt16(int i)
+        {
+            return _dataReader.GetInt16(i);
+        }
+
+        public int GetInt32(int i)
+        {
+            return _dataReader.GetInt32(i);
+
+        }
+
+        public long GetInt64(int i)
+        {
+            return _dataReader.GetInt64(i);
+        }
+
+        public string GetName(int i)
+        {
+            return _dataReader.GetName(i);
+
+        }
+
+        public int GetOrdinal(string name)
+        {
+            return _dataReader.GetOrdinal(name);
+        }
+
+
+
+        public DataTable GetSchemaTable()
+        {
+            return _dataReader.GetSchemaTable();
+        }
+
+        public string GetString(int i)
+        {
+            return _dataReader.GetString(i);
+
+        }
+
+        public object GetValue(int i)
+        {
+            return _dataReader.GetValue(i);
+
+        }
+
+        public int GetValues(object[] values)
+        {
+            return _dataReader.GetValues(values);
+
+        }
+
+        public bool IsDBNull(int i)
+        {
+            return _dataReader.IsDBNull(i);
+
+        }
+
+        public bool NextResult()
+        {
+            return _dataReader.NextResult();
+
+        }
+
+        public bool Read()
+        {
+            return _dataReader.Read();
+
+        }
+
+    }
+}

src/DataAbstractions.Dapper/DataReaderAccessor/DataReaderAccessor.Dapper.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Threading.Tasks;
+
+namespace DataAbstractions.Dapper
+{
+    public partial interface IDataAccessor : IDbConnection
+    {
+
+        //Dapper.Contrib methods
+        Task<T> GetAsync<T>(dynamic id, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        Task<IEnumerable<T>> GetAllAsync<T>(IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        Task<int> InsertAsync<T>(T entityToInsert, IDbTransaction transaction = null, int? commandTimeout = null, ISqlAdapter sqlAdapter = null) where T : class;
+        Task<bool> UpdateAsync<T>(T entityToUpdate, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        Task<bool> DeleteAsync<T>(T entityToDelete, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        Task<bool> DeleteAllAsync<T>(IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        T Get<T>(dynamic id, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        IEnumerable<T> GetAll<T>(IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        long Insert<T>(T entityToInsert, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        bool Update<T>(T entityToUpdate, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        bool Delete<T>(T entityToDelete, IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+        bool DeleteAll<T>(IDbTransaction transaction = null, int? commandTimeout = null) where T : class;
+
+    }
+
+
+}
+