laatzen/LaaProductionWeb/LaaProductionWeb.Data/SqlClient.cs

namespace LaaProductionWeb.Data
{
    using LaaProductionWeb.Data.Interfaces;

    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Data.SqlClient;

    public class SqlClient : ISqlClient
    {
        private readonly string connectionString;

        public SqlClient(string connectionString)
        {
            this.connectionString = connectionString;

#if DEBUG
            //var connectionBuilder = new SqlConnectionStringBuilder(connectionString);
            //connectionBuilder.PersistSecurityInfo = false;
            //connectionBuilder.Password = string.Empty;
            //connectionBuilder.UserID = string.Empty;
            //connectionBuilder.IntegratedSecurity = true;
            //connectionBuilder.InitialCatalog = "AuftragKopie";

            //this.connectionString = connectionBuilder.ToString();
#endif
        }

        public SQLCommand CreateCommand(string commandText)
            => new SQLCommand(this, commandText);

        public int ExecuteNonQuery(string query, Action<SqlParameters> parameters, SqlInfoMessageEventHandler errorCallback = null)
        {
            var rowsAffected = 0;

            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    parameters(sqlCommand.Parameters);

                    sqlCommand.CommandText = query;
                    rowsAffected = sqlCommand.ExecuteNonQuery();
                }
            }

            return rowsAffected;
        }

        internal IEnumerable<T> ExecuteReader<T>(SQLCommand command, Func<ISqlReader, T> expression)
        {
            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling();

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    sqlCommand.CommandText = command.CommandText;

                    foreach (var kvp in command.Parameters)
                    {
                        var param = sqlCommand.CreateParameter();
                        param.ParameterName = kvp.Key;
                        param.Value = kvp.Value;

                        sqlCommand.Parameters.Add(param);
                    }

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        while (sqlReader.Read())
                        {
                            yield return expression(sqlReader);
                        }
                    }
                }
            }
        }

        public IEnumerable<T> ExecuteReader<T>(string query, Func<ISqlReader, T> reader, SqlInfoMessageEventHandler errorCallback = null)
        {
            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    sqlCommand.CommandText = query;

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader())
                    {
                        while (sqlReader.Read())
                        {
                            yield return reader(sqlReader);
                        }
                    }
                }
            }
        }

        public IEnumerable<T> ExecuteReader<T>(string query, Action<SqlParameters> parameters, Func<ISqlReader, T> reader, SqlInfoMessageEventHandler errorCallback = null)
        {
            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    parameters(sqlCommand.Parameters);

                    sqlCommand.CommandText = query;

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader())
                    {
                        while (sqlReader.Read())
                        {
                            yield return reader(sqlReader);
                        }
                    }
                }
            }
        }

        public IEnumerable<T> ExecuteReader<T>(string query, Func<ISqlReader, T> reader, Action<string[]> columns, SqlInfoMessageEventHandler errorCallback = null)
        {
            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    sqlCommand.CommandText = query;

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader())
                    {
                        columns(sqlReader.GetColumns());

                        while (sqlReader.Read())
                        {
                            yield return reader(sqlReader);
                        }
                    }
                }
            }
        }

        public IEnumerable<T> ExecuteReader<T>(string query, Action<SqlParameters> parameters, Func<ISqlReader, T> reader, Action<string[]> columns, SqlInfoMessageEventHandler errorCallback = null)
        {
            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    parameters(sqlCommand.Parameters);

                    sqlCommand.CommandText = query;

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader())
                    {
                        columns(sqlReader.GetColumns());

                        while (sqlReader.Read())
                        {
                            yield return reader(sqlReader);
                        }
                    }
                }
            }
        }

        public T ExecuteScalar<T>(string query, Action<SqlParameters> parameters, SqlInfoMessageEventHandler errorCallback = null)
        {
            var scalarResult = default(T);

            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    parameters(sqlCommand.Parameters);

                    sqlCommand.CommandText = query;

                    var scalarObject = sqlCommand.ExecuteScalar();

                    if (scalarObject is T scalarValue)
                    {
                        scalarResult = scalarValue;
                    }
                }
            }

            return scalarResult;
        }

        internal T FirstOrDefault<T>(SQLCommand command, Func<ISqlReader, T> expression)
        {
            var firstOrDefaultResult = default(T);

            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling();

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    sqlCommand.CommandText = command.CommandText;

                    foreach (var kvp in command.Parameters)
                    {
                        var param = sqlCommand.CreateParameter();
                        param.ParameterName = kvp.Key;
                        param.Value = kvp.Value;

                        sqlCommand.Parameters.Add(param);
                    }

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        if (sqlReader.Read())
                        {
                            firstOrDefaultResult = expression(sqlReader);
                        }
                    }
                }
            }

            return firstOrDefaultResult;
        }

        public T FirstOrDefault<T>(string query, Func<ISqlReader, T> reader, SqlInfoMessageEventHandler errorCallback = null)
        {
            var firstOrDefaultResult = default(T);

            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    sqlCommand.CommandText = query;

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        if (sqlReader.Read())
                        {
                            firstOrDefaultResult = reader(sqlReader);
                        }
                    }
                }
            }

            return firstOrDefaultResult;
        }

        public T FirstOrDefault<T>(string query, Action<SqlParameters> parameters, Func<ISqlReader, T> reader, SqlInfoMessageEventHandler errorCallback = null)
        {
            var firstOrDefaultResult = default(T);

            using (var sqlConnection = new SqlConnection(this.connectionString))
            {
                sqlConnection.OpenWithErrorHandling(errorCallback);

                using (var sqlCommand = sqlConnection.CreateCommand())
                {
                    parameters(sqlCommand.Parameters);

                    sqlCommand.CommandText = query;

                    using (SqlReader sqlReader = sqlCommand.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        if (sqlReader.Read())
                        {
                            firstOrDefaultResult = reader(sqlReader);
                        }
                    }
                }
            }

            return firstOrDefaultResult;
        }
    }
}