common/Logic/Common.Logic.Extensions.SQL/SQLReader.cs

namespace Common.Logic.Extensions.SQL
{
    using Common.Logic.Extensions.SQL.Interfaces;
    
    using System;
    using System.Data.SqlClient;
    using System.Diagnostics;
    using System.IO;
    using System.Xml;

    public class SQLReader : ISQLReader, IDisposable
    {
        private readonly SqlDataReader sqlDataReader;

        private SQLReader(SqlDataReader sqlDataReader) 
            => this.sqlDataReader = sqlDataReader.EnsureNotNull(nameof(sqlDataReader));

        public void Dispose()
        {
            this.sqlDataReader.Close();
            this.sqlDataReader.Dispose();
        }

        public XmlReader GetXml(Int32 index)
        {
            var value = default(XmlReader);

            if (0 <= index && index < this.sqlDataReader.FieldCount)
            {
                if (!this.sqlDataReader.IsDBNull(index))
                {
                    value = this.sqlDataReader.GetSqlXml(index)?.CreateReader();
                }
            }

            return value;
        }

        public T GetValue<T>(Int32 index)
        {
            var value = default(T);

            if (0 <= index && index < this.sqlDataReader.FieldCount)
            {
                if (!this.sqlDataReader.IsDBNull(index))
                {
                    var readedValue = this.sqlDataReader.GetValue(index);
                    var type = Nullable.GetUnderlyingType(typeof(T));

                    if (type is null)
                    {
                        type = typeof(T);
                    }

                    var tryParse = true;

                    if (tryParse)
                    {
                        try
                        {
                            readedValue = Convert.ChangeType(readedValue, type);
                            tryParse = false;
                        }
                        catch (Exception e)
                        {
                            Debug.Print(e.ToString());
                        }
                    }

                    if (tryParse)
                    {
                        try
                        {
                            readedValue = Enum.Parse(type, $"{readedValue}", true);
                            tryParse = false;
                        }
                        catch (Exception e)
                        {
                            Debug.Print(e.ToString());
                        }
                    }

                    if (!tryParse && readedValue is T expectedValue)
                    {
                        value = expectedValue;
                    }
                }
            }

            return value;
        }

        internal Boolean Read() => this.sqlDataReader.Read();

        public static implicit operator SQLReader(SqlDataReader sqlDataReader) => new SQLReader(sqlDataReader);
    }
}