Depenent del projecte on estem a vegades no cal muntar classes d'accés a dades, capes i capes de software inútil per executar una mera consulta. També cal valorar la mantenibilitat, allò de que les capes afavoreixen el manteniment, jo sempre he trobat que entorpeixen el manteniment... Però sí que crec necessari que les consultes, encara que siguin un string en el codi, siguin gestionades de forma centralitzada. És en aquest punt quan va sorgir la clsSQLServer. D'això ja fa 5 o més anys... però no se per que no l'he posat al blog fins ara. Bé de fet, l'he ampliat fa pocs dies, portava des del 2013 sense modificacions.

Aquesta classe com el seu nom indica gestiona les consultes al servidor de base de dades. De fet no se com Microsoft no l'han fet ells mateixos. Vull dir que com programador el que vull és executar una sentència SQL i tenir una taula de retorn, sense preocupar-me de si és un Adapter o un Command o X, però bé, ja que MS no s'inspira ho fet jo. Té uns quants mètodes principals i sobrecarregats:

• Exec: Executa un consulta SQL i retorna una taula. Es pot escollir entre no preocupar-se per la connexió, o sí, o afegir-hi una transacció.
• ExecInsertWithIdentity: Executa un INSERT contra una taula que tingui una clau primària (PK) de tipus identitat. I un cop fet l'INSERT retorna el valor de la PK que ha creat com un long.
• ExecNonQuery: Serveix per executar consultes que no retornen res, tipus UPDATEs, DELETEs o INSERTs que no cal recuperar la PK. Retorna els registres afectats per la consulta.
• ExecScalar: Serveix per executar consultes que retornen un valor sencer, com un màxim, un mínim, un COUNT etc... De moment no m'ha fet falta un altra tipus de dada en el retorn.
• FDateSQL: Aquesta és una utilitat per treballar amb dates en SQL Server. Retorna la data en un string en format ISO 8601: yyyy-mm-ddThh:mi:ss. Aquest format el bo que té és que no depèn dels regional settings.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
using System.IO;
using System.Configuration;

namespace Viewer
{
    public class clsSQLServer
    {
        public clsSQLServer()
        {
            Conn = null;
        }

        public SqlConnection Conn { get; set; }

        private string _Ver = "07/03/2018";
        public string Ver
        {
            get
            {
                return _Ver;
            }
        }

        public string CadConn { get; set; }

        public string FDateSQL(DateTime D)
        {
            //ISO 8601: yyyy-mm-ddThh:mi:ss
            return D.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss");
        }

        /// <summary>
        /// Executa una SQL que retorna resultats contra una conexió, no modifica l'estat de la conexió ni de la transaccio
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <param name="SqlTrann">Transacció ja creada sobre la conexió (admet null)</param>
        /// <returns>Retorna un NEW DataTable</returns>
        public DataTable Exec(string SQL, SqlConnection SqlConn, SqlTransaction SqlTrann)
        {
            DataTable TBL = new DataTable();
            SqlCommand SqlComm = new SqlCommand();
            SqlDataReader SqlReader;

            SqlComm.Connection = SqlConn;
            if (SqlTrann != null) SqlComm.Transaction = SqlTrann;
            SqlComm.CommandText = SQL;
            SqlComm.CommandType = CommandType.Text;

            SqlReader = SqlComm.ExecuteReader();

            TBL.Load(SqlReader);
            return TBL;
        }

        /// <summary>
        /// Executa una SQL que retorna resultats contra una conexió, no modifica l'estat de la conexió
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <returns>Retorna un NEW DataTable</returns>
        public DataTable Exec(string SQL, SqlConnection SqlConn)
        {
            return Exec(SQL, SqlConn, null);
        }

        /// <summary>
        /// Executa una sentència SQL que retorna resultats, si està informada la variable Conn la fa
		/// servir de conexio (ha d'estar oberta), si no crea una i la tanca
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <returns>Retorna un NEW DataTable</returns>
        public DataTable Exec(string SQL)
        {
            DataTable TBL;
            SqlConnection SqlConn;
            bool Local = false;
            if (Conn != null)
            {
                SqlConn = Conn;
            }
            else
            {
                Local = true;
                SqlConn = new SqlConnection();
                SqlConn.ConnectionString = CadConn;
                SqlConn.Open();
            }
            TBL = Exec(SQL, SqlConn);
            if (Local) SqlConn.Close();
            return TBL;
        }

        /// <summary>
        /// Executa un INSERT en una taula que té PK identitat. Retorna la identitat creada. 
		/// Obre i tanca conexió a BBDD (la que retorna GetConnStr)
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <returns>Identitat creada</returns>
        public long ExecInsertWithIdentity(string SQL)
        {
            long Identity = 0;
            SqlConnection SqlConn;
            bool Local = false;
            if (Conn != null)
            {
                SqlConn = Conn;
            }
            else
            {
                Local = true;
                SqlConn = new SqlConnection();
                SqlConn.ConnectionString = CadConn;
                SqlConn.Open();
            }
            Identity = ExecInsertWithIdentity(SQL, SqlConn);
            if (Local) SqlConn.Close();
            return Identity;
        }

        /// <summary>
        /// Executa un INSERT en una taula que té PK identitat. 
		/// Retorna la identitat creada. No modifica l'estat de la connexió
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <returns>Identitat creada</returns>
        public long ExecInsertWithIdentity(string SQL, SqlConnection SqlConn)
        {
            long Identity = 0;

            Identity = ExecInsertWithIdentity(SQL, SqlConn, null);

            return Identity;
        }


        /// <summary>
        /// Executa un INSERT en una taula que té PK identitat. Retorna la identitat creada
        /// </summary>
        /// <param name="SQL">Sentència INSERT SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <param name="SqlTrann">Transacció ja creada sobre la conexió (admet null)</param>
        /// <returns>Identitat creada</returns>
        public long ExecInsertWithIdentity(string SQL, SqlConnection SqlConn, SqlTransaction SqlTrann)
        {
            long Identity = 0;

            SqlCommand SqlComm = new SqlCommand();

            SqlComm.Connection = SqlConn;
            if (SqlTrann != null) SqlComm.Transaction = SqlTrann;

            if (!SQL.EndsWith(";")) SQL += ";";
            SQL += " SELECT SCOPE_IDENTITY();";

            SqlComm.CommandText = SQL;
            SqlComm.CommandType = CommandType.Text;

            Identity = (long)(decimal)SqlComm.ExecuteScalar();
            return Identity;
        }



        /// <summary>
        /// Executa una sentència SQL que no retorna resultats, només els registres afectats. 
		/// Obre i tanca conexió a BBDD (la que retorna GetConnStr)
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <returns>Registres afectats</returns>
        public int ExecNonQuery(string SQL)
        {
            int Results = 0;
            SqlConnection SqlConn;
            bool Local = false;
            if (Conn != null)
            {
                SqlConn = Conn;
            }
            else
            {
                Local = true;
                SqlConn = new SqlConnection();
                SqlConn.ConnectionString = CadConn;
                SqlConn.Open();
            }
            Results = ExecNonQuery(SQL, SqlConn);
            if (Local) SqlConn.Close();
            return Results;
        }

        /// <summary>
        /// Executa una sentència SQL que no retorna resultats
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <returns>Registres afectats</returns>
        public int ExecNonQuery(string SQL, SqlConnection SqlConn)
        {
            return ExecNonQuery(SQL, SqlConn, null);
        }

        /// <summary>
        /// Executa una sentència SQL que no retorna resultats
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <param name="SqlTrann">Transacció ja creada sobre la conexió (admet null)</param>
        /// <returns>Registres afectats</returns>
        public int ExecNonQuery(string SQL, SqlConnection SqlConn, SqlTransaction SqlTrann)
        {
            int Results = 0;

            SqlCommand SqlComm = new SqlCommand();

            SqlComm.Connection = SqlConn;
            if (SqlTrann != null) SqlComm.Transaction = SqlTrann;
            SqlComm.CommandText = SQL;
            SqlComm.CommandType = CommandType.Text;

            Results = SqlComm.ExecuteNonQuery();
            return Results;
        }

        /// <summary>
        /// Executa una sentència SQL que no retorna resultats, només la primera columna del primer registre.
		/// Obre i tanca conexió a BBDD (la que retorna GetConnStr)
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <returns>Registres afectats</returns>
        public int ExecScalar(string SQL)
        {
            int Results = 0;
            SqlConnection SqlConn;
            bool Local = false;
            if (Conn != null)
            {
                SqlConn = Conn;
            }
            else
            {
                Local = true;
                SqlConn = new SqlConnection();
                SqlConn.ConnectionString = CadConn;
                SqlConn.Open();
            }
            Results = ExecScalar(SQL, SqlConn);
            if (Local) SqlConn.Close();
            return Results;
        }

        /// <summary>
        /// Executa una sentència SQL que no retorna resultats, només la primera columna del primer registre.
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <returns>Registres afectats</returns>
        public int ExecScalar(string SQL, SqlConnection SqlConn)
        {
            return ExecScalar(SQL, SqlConn, null);
        }

        /// <summary>
        /// Executa una sentència SQL que no retorna resultats, només la primera columna del primer registre.
        /// </summary>
        /// <param name="SQL">Sentència SQL a executar</param>
        /// <param name="SqlConn">Conexió a BBDD, ha d'estar oberta</param>
        /// <param name="SqlTrann">Transacció ja creada sobre la conexió (admet null)</param>
        /// <returns>Registres afectats</returns>
        public int ExecScalar(string SQL, SqlConnection SqlConn, SqlTransaction SqlTrann)
        {
            int Results = 0;
            object objResult;

            SqlCommand SqlComm = new SqlCommand();

            SqlComm.Connection = SqlConn;
            if (SqlTrann != null) SqlComm.Transaction = SqlTrann;
            SqlComm.CommandText = SQL;
            SqlComm.CommandType = CommandType.Text;

            objResult = SqlComm.ExecuteScalar();
            if (objResult != null && objResult != DBNull.Value)
            {
                Results = int.Parse(objResult.ToString());
            }
            return Results;
        }
    }
}