SafeDataReader.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="SafeDataReader.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>This is a DataReader that 'fixes' any null values before</summary>
//-----------------------------------------------------------------------
using System;
using System.Data;
#if !NETSTANDARD2_0 && !NET5_0
using System.Data.SqlClient;
using System.Threading.Tasks;
#endif
 
namespace Csla.Data
{
  public class SafeDataReader : IDataReader
  {
#if !NETSTANDARD2_0 && !NET5_0
    private SqlDataReader _sqlDataReader;
#endif
 
    protected IDataReader DataReader { get; private set; }
 
    public SafeDataReader(IDataReader dataReader)
    {
      DataReader = dataReader;
#if !NETSTANDARD2_0 && !NET5_0
      _sqlDataReader = DataReader as SqlDataReader;
#endif
    }
 
#if !NETSTANDARD2_0 && !NET5_0
    public Task<T> GetFieldValueAsync<T>(int ordinal)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("GetFieldValueAsync");
      return _sqlDataReader.GetFieldValueAsync<T>(ordinal);
    }
 
    public Task<T> GetFieldValueAsync<T>(int ordinal, System.Threading.CancellationToken cancellationToken)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("GetFieldValueAsync");
      return _sqlDataReader.GetFieldValueAsync<T>(ordinal, cancellationToken);
    }
 
    public Task<bool> IsDbNullAsync(int ordinal)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("IsDbNullAsync");
      return _sqlDataReader.IsDBNullAsync(ordinal);
    }
 
    public Task<bool> IsDbNullAsync(int ordinal, System.Threading.CancellationToken cancellationToken)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("IsDbNullAsync");
      return _sqlDataReader.IsDBNullAsync(ordinal, cancellationToken);
    }
 
    public Task<bool> NextResultAsync()
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("NextResultAsync");
      return _sqlDataReader.NextResultAsync();
    }
 
    public Task<bool> NextResultAsync(System.Threading.CancellationToken cancellationToken)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("NextResultAsync");
      return _sqlDataReader.NextResultAsync(cancellationToken);
    }
 
    public Task<bool> ReadAsync()
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("NextResultAsync");
      return _sqlDataReader.ReadAsync();
    }
 
    public Task<bool> ReadAsync(System.Threading.CancellationToken cancellationToken)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("NextResultAsync");
      return _sqlDataReader.ReadAsync(cancellationToken);
    }
#endif
 
    public string GetString(string name)
    {
      return GetString(DataReader.GetOrdinal(name));
    }
 
    public virtual string GetString(int i)
    {
      if (DataReader.IsDBNull(i))
        return string.Empty;
      else
        return DataReader.GetString(i);
    }
 
 
    public object GetValue(string name)
    {
      return GetValue(DataReader.GetOrdinal(name));
    }
 
    public virtual object GetValue(int i)
    {
      if (DataReader.IsDBNull(i))
        return null;
      else
        return DataReader.GetValue(i);
    }
 
    public int GetInt32(string name)
    {
      return GetInt32(DataReader.GetOrdinal(name));
    }
 
    public virtual int GetInt32(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetInt32(i);
    }
 
    public double GetDouble(string name)
    {
      return GetDouble(DataReader.GetOrdinal(name));
    }
 
    public virtual double GetDouble(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetDouble(i);
    }
 
    public Csla.SmartDate GetSmartDate(string name)
    {
      return GetSmartDate(DataReader.GetOrdinal(name), true);
    }
 
    public virtual Csla.SmartDate GetSmartDate(int i)
    {
      return GetSmartDate(i, true);
    }
 
    public Csla.SmartDate GetSmartDate(string name, bool minIsEmpty)
    {
      return GetSmartDate(DataReader.GetOrdinal(name), minIsEmpty);
    }
 
    public virtual Csla.SmartDate GetSmartDate(
      int i, bool minIsEmpty)
    {
      if (DataReader.IsDBNull(i))
        return new Csla.SmartDate(minIsEmpty);
      else
        return new Csla.SmartDate(
          DataReader.GetDateTime(i), minIsEmpty);
    }
 
    public System.Guid GetGuid(string name)
    {
      return GetGuid(DataReader.GetOrdinal(name));
    }
 
    public virtual System.Guid GetGuid(int i)
    {
      if (DataReader.IsDBNull(i))
        return Guid.Empty;
      else
        return DataReader.GetGuid(i);
    }
 
    public bool Read()
    {
      return DataReader.Read();
    }
 
    public bool NextResult()
    {
      return DataReader.NextResult();
    }
 
    public void Close()
    {
      DataReader.Close();
    }
 
    public int Depth
    {
      get
      {
        return DataReader.Depth;
      }
    }
 
    public int FieldCount
    {
      get
      {
        return DataReader.FieldCount;
      }
    }
 
    public bool GetBoolean(string name)
    {
      return GetBoolean(DataReader.GetOrdinal(name));
    }
 
    public virtual bool GetBoolean(int i)
    {
      if (DataReader.IsDBNull(i))
        return false;
      else
        return DataReader.GetBoolean(i);
    }
 
    public byte GetByte(string name)
    {
      return GetByte(DataReader.GetOrdinal(name));
    }
 
    public virtual byte GetByte(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetByte(i);
    }
 
    public Int64 GetBytes(string name, Int64 fieldOffset,
      byte[] buffer, int bufferOffset, int length)
    {
      return GetBytes(DataReader.GetOrdinal(name), fieldOffset, buffer, bufferOffset, length);
    }
 
    public virtual Int64 GetBytes(int i, Int64 fieldOffset,
      byte[] buffer, int bufferOffset, int length)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetBytes(i, fieldOffset, buffer, bufferOffset, length);
    }
 
    public char GetChar(string name)
    {
      return GetChar(DataReader.GetOrdinal(name));
    }
 
    public virtual char GetChar(int i)
    {
      if (DataReader.IsDBNull(i))
        return char.MinValue;
      else
      {
        char[] myChar = new char[1];
        DataReader.GetChars(i, 0, myChar, 0, 1);
        return myChar[0];
      }
    }
 
    public Int64 GetChars(string name, Int64 fieldOffset,
      char[] buffer, int bufferOffset, int length)
    {
      return GetChars(DataReader.GetOrdinal(name), fieldOffset, buffer, bufferOffset, length);
    }
 
    public virtual Int64 GetChars(int i, Int64 fieldOffset,
      char[] buffer, int bufferOffset, int length)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetChars(i, fieldOffset, buffer, bufferOffset, length);
    }
 
    public IDataReader GetData(string name)
    {
      return GetData(DataReader.GetOrdinal(name));
    }
 
    public virtual IDataReader GetData(int i)
    {
      return DataReader.GetData(i);
    }
 
    public string GetDataTypeName(string name)
    {
      return GetDataTypeName(DataReader.GetOrdinal(name));
    }
 
    public virtual string GetDataTypeName(int i)
    {
      return DataReader.GetDataTypeName(i);
    }
 
    public virtual DateTime GetDateTime(string name)
    {
      return GetDateTime(DataReader.GetOrdinal(name));
    }
 
    public virtual DateTime GetDateTime(int i)
    {
      if (DataReader.IsDBNull(i))
        return DateTime.MinValue;
      else
        return DataReader.GetDateTime(i);
    }
 
    public virtual DateTimeOffset GetDateTimeOffset(string name)
    {
      return GetDateTimeOffset(DataReader.GetOrdinal(name));
    }
 
    public virtual DateTimeOffset GetDateTimeOffset(int i)
    {
      if (DataReader.IsDBNull(i))
        return DateTimeOffset.MinValue;
      else
        return (DateTimeOffset)DataReader.GetValue(i);
    }
 
    public decimal GetDecimal(string name)
    {
      return GetDecimal(DataReader.GetOrdinal(name));
    }
 
    public virtual decimal GetDecimal(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetDecimal(i);
    }
 
    public Type GetFieldType(string name)
    {
      return GetFieldType(DataReader.GetOrdinal(name));
    }
 
    public virtual Type GetFieldType(int i)
    {
      return DataReader.GetFieldType(i);
    }
 
    public float GetFloat(string name)
    {
      return GetFloat(DataReader.GetOrdinal(name));
    }
 
    public virtual float GetFloat(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetFloat(i);
    }
 
    public short GetInt16(string name)
    {
      return GetInt16(DataReader.GetOrdinal(name));
    }
 
    public virtual short GetInt16(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetInt16(i);
    }
 
    public Int64 GetInt64(string name)
    {
      return GetInt64(DataReader.GetOrdinal(name));
    }
 
    public virtual Int64 GetInt64(int i)
    {
      if (DataReader.IsDBNull(i))
        return 0;
      else
        return DataReader.GetInt64(i);
    }
 
    public virtual string GetName(int i)
    {
      return DataReader.GetName(i);
    }
 
    public int GetOrdinal(string name)
    {
      return DataReader.GetOrdinal(name);
    }
 
    public DataTable GetSchemaTable()
    {
      return DataReader.GetSchemaTable();
    }
 
 
    public int GetValues(object[] values)
    {
      return DataReader.GetValues(values);
    }
 
    public bool IsClosed
    {
      get
      {
        return DataReader.IsClosed;
      }
    }
 
    public virtual bool IsDBNull(int i)
    {
      return DataReader.IsDBNull(i);
    }
 
    public virtual bool IsDBNull(string name)
    {
      int index = this.GetOrdinal(name);
      return this.IsDBNull(index);
    }
 
    public object this[string name]
    {
      get
      {
        object val = DataReader[name];
        if (DBNull.Value.Equals(val))
          return null;
        else
          return val;
      }
    }
 
    public virtual object this[int i]
    {
      get
      {
        if (DataReader.IsDBNull(i))
          return null;
        else
          return DataReader[i];
      }
    }
    public int RecordsAffected
    {
      get
      {
        return DataReader.RecordsAffected;
      }
    }
 
#region IDisposable Support
 
    private bool _disposedValue; // To detect redundant calls
 
    protected virtual void Dispose(bool disposing)
    {
      if (!_disposedValue)
      {
        if (disposing)
        {
          // free unmanaged resources when explicitly called
          DataReader.Dispose();
        }
 
        // free shared unmanaged resources
      }
      _disposedValue = true;
    }
 
    public void Dispose()
    {
      // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
      Dispose(true);
      GC.SuppressFinalize(this);
    }
 
    ~SafeDataReader()
    {
      Dispose(false);
    }
 
#endregion
 
  }
}