Seguint amb la sèrie de la clsDades aquesta és la funció que s'encarrega d'esborrar un registre a la BBDD.

Fa servir la SP DEL per fer-ho. Així que ha de fer servir la variable ParamsDEL per informar-ne els paràmetres. Normalment aquests paràmetres són la primary key (PK), de tal manera que només s'esborra un registre. Existeix en 2 sabors diferents, un que rep un DataRow i un altra que rep un objecte Dictionary (on les Keys són els noms dels camps i els Values el valor).

Igual que la funció INS, aquesta també invalida la cache.

Com sempre el codi, primer el que rep el Dictionary:

public void DEL(Dictionary<string, string> Params)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;
    bool LocalConn;
    SqlConnection Conn = null;
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }

    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;
    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spDEL;

    foreach (clsCamp Camp in ParamsDEL)
    {
	SqlParam = CreaParametre(Camp, false);
	if (Params.Keys.Contains<string>(Camp.NomCamp))
	{
	    if (string.IsNullOrEmpty(Params[Camp.NomCamp])) SqlParam.Value = DBNull.Value;
	    else SqlParam.Value = Params[Camp.NomCamp];
	}
	else SqlParam.Value = DBNull.Value;
	SqlComm.Parameters.Add(SqlParam);
    }

    SqlComm.ExecuteNonQuery();
    if (TeCache && AutoNetejaCache)
    {
	ClearCache();
    }
    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
}

I després la versió DataRow:

public void DEL(DataRow DR)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;
    bool LocalConn;
    SqlConnection Conn = null;
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }

    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;
    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spDEL;

    foreach (clsCamp Camp in ParamsDEL)
    {
	SqlParam = CreaParametre(Camp, false);
	if (DR.Table.Columns.Contains(Camp.NomCamp))
	{
	    if (DR.IsNull(Camp.NomCamp)) SqlParam.Value = DBNull.Value;
	    else SqlParam.Value = DR[Camp.NomCamp];
	}
	else SqlParam.Value = DBNull.Value;
	SqlComm.Parameters.Add(SqlParam);
    }

    SqlComm.ExecuteNonQuery();
    if (TeCache && AutoNetejaCache)
    {
	ClearCache();
    }
    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
}

Seguint amb la sèrie de la clsDades aquesta és la funció que s'encarrega d'actualitzar un registre a la BBDD.

Fa servir la SP UPD per fer-ho. Així que ha de fer servir la variable ParamsUPD per informar-ne els paràmetres. Existeix en 2 sabors diferents, un que rep un DataRow i un altra que rep un objecte Dictionary (on les Keys són els noms dels camps i els Values el valor).

Igual que la funció INS, aquesta també invalida la cache.

Com sempre el codi, primer el que rep el Dictionary:

public void UPD(Dictionary<string, string> Params)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;

    bool LocalConn;
    SqlConnection Conn = null;
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }
    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;
    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spUPD;

    foreach (clsCamp Camp in ParamsUPD)
    {
	SqlParam = CreaParametre(Camp, false);
	if (Params.Keys.Contains<string>(Camp.NomCamp))
	{
	    if (string.IsNullOrEmpty(Params[Camp.NomCamp]))
	    {
		if (Camp.Nulable) SqlParam.Value = DBNull.Value;
		else
		{
		    Exception Ex = new Exception("El camp " + Camp.NomCamp + " no admet valors nulls");
		    throw Ex;
		}
	    }
	    else SqlParam.Value = Params[Camp.NomCamp];
	}
	else
	{
	    if (Camp.Nulable) SqlParam.Value = DBNull.Value;
	    else
	    {
		if (!Camp.Identitat)
		{
		    Exception Ex = new Exception("El camp " + Camp.NomCamp + " no admet valors nulls");
		    throw Ex;
		}
	    }
	}
	SqlParam.ParameterName = Prefix + Camp.NomCamp;
	SqlParam.Value = Params[Camp.NomCamp];
	SqlComm.Parameters.Add(SqlParam);
    }

    SqlComm.ExecuteNonQuery();

    if (TeCache && AutoNetejaCache)
    {
	ClearCache();
    }

    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
}

I després la versió que rep un DataRow:

public void UPD(DataRow DR)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;

    bool LocalConn;
    SqlConnection Conn = null;
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }
    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;
    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spUPD;

    foreach (clsCamp Camp in ParamsUPD)
    {
	SqlParam = CreaParametre(Camp, false);
	SqlParam.Value = DR[Camp.NomCamp];
	SqlComm.Parameters.Add(SqlParam);
    }


    SqlComm.ExecuteNonQuery();
    if (TeCache && AutoNetejaCache)
    {
	ClearCache();
    }
    

    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
}

Seguint amb la sèrie de la clsDades aquesta és la funció que s'encarrega d'insertar un registre a la BBDD.

Fa servir la SP INS per fer-ho. Així que ha de fer servir la variable ParamsINS per informar-ne els paràmetres. Existeix en 2 sabors diferents, un que rep un DataRow i un altra que rep un objecte Dictionary (on les Keys són els noms dels camps i els Values el valor). Ambdues quan hi ha una identitat en la taula on inserten recuperen el valor que s'ha generat.

Ja posats que hi ha informació sobre si un camp admet nulls o no, es fa aquesta verificació. El que no es mira és el tipus de dades del valor que passa per actualitzar.

Resaltar que aquesta funció invalida la cache de dades, aleshores si la clase fa servir la cache i està activada la auto-neteja aleshores buida la cache. Pot ser que no interessi netejar la cache cada cop, per exemple si hi ha molts inserts seguits, aleshores cal posar el "Autonetejar" a fals.

El codi de la versió DataRow:

public void INS(DataRow DR)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;
    Int64 ID = 0;

    bool LocalConn;
    SqlConnection Conn = null;
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }

    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;
    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spINS;
    
    foreach (clsCamp Camp in ParamsINS)
    {
	SqlParam = CreaParametre(Camp, true);
	if (DR.Table.Columns.Contains(Camp.NomCamp))
	{
	    if (!DR.IsNull(Camp.NomCamp))
	    {
		if (Camp.Nulable) SqlParam.Value = DBNull.Value;
		else
		{
		    if (!Camp.Identitat)
		    {
			Exception Ex = new Exception("El camp " + Camp.NomCamp + " no admet valors nulls");
			throw Ex;
		    }
		}
	    }
	    else SqlParam.Value = DR[Camp.NomCamp];
	}
	else
	{   //Potser la taula té menys columnes que camps hi ha a la BBDD
	    if (Camp.Nulable) SqlParam.Value = DBNull.Value;
	    else
	    {
		if (!Camp.Identitat)
		{
		    Exception Ex = new Exception("El camp " + Camp.NomCamp + " no admet valors nulls");
		    throw Ex;
		}
	    }
	}
	SqlComm.Parameters.Add(SqlParam);
    }

    SqlComm.ExecuteNonQuery();

    if (TeCache && AutoNetejaCache)
    {
	ClearCache();
    }

    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
    if (TeIdentitat)
    {
	//Cal vigilar que la columna identitat no sigui ReadOnly
	//DR.Table.Columns[Identitat].ReadOnly = false;
	ID = Int64.Parse(SqlComm.Parameters[Prefix + Identitat].Value.ToString());
	DR[Identitat] = ID;
    }
    DR.AcceptChanges();
}

La versió que fa servir el Dictionary retorna el ID generat en cas que hagi identitat.

public Int64 INS(Dictionary<string, string> Params)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;
    Int64 ID = 0;

    bool LocalConn;
    SqlConnection Conn = null;
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }
    
    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;
    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spINS;

    foreach (clsCamp Camp in ParamsINS)
    {
	SqlParam = CreaParametre(Camp, true);
	if (Params.Keys.Contains<string>(Camp.NomCamp))
	{
	    if (string.IsNullOrEmpty(Params[Camp.NomCamp]))
	    {
		if (Camp.Nulable) SqlParam.Value = DBNull.Value;
		else
		{
		    Exception Ex = new Exception("El camp " + Camp.NomCamp + " no admet valors nulls");
		    throw Ex;
		}
	    }
	    else SqlParam.Value = Params[Camp.NomCamp];
	}
	else
	{
	    if (Camp.Nulable) SqlParam.Value = DBNull.Value;
	    else
	    {
		if (!Camp.Identitat)
		{
		    Exception Ex = new Exception("El camp " + Camp.NomCamp + " no admet valors nulls");
		    throw Ex;
		}
	    }
	}
	SqlComm.Parameters.Add(SqlParam);
    }

    SqlComm.ExecuteNonQuery();

    if (TeCache && AutoNetejaCache)
    {
	ClearCache();
    }

    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
    if (TeIdentitat) ID = Int64.Parse(SqlComm.Parameters[Prefix + Identitat].Value.ToString());
    else ID = 0;
    return ID;
}

Aquesta funció pertany a la clsDades i funciona igual que la GET però limita el nombre de files retornades a les que se li passen per paràmetre.

Perque és necessària? Suposem que tenim un procés que ha de processar (valgui la redundància) 50.000 registres, això ho retorna el GET sense problemes. Però quan porta 10.000 processats en una aplicació web dóna un timeout. Llavors és necessari processar de 5.000 en 5.000 registres. Durant el procés el registres poden canviar d'estat (per exemple) i així evitar tornar a ser seleccionats a la següent crida del GETTOP. Cada cop que es processa un conjunt de registres es pot enviar a la UI un missatge indicant que encara queden per processar, la UI pot actualitzar alguna barra de progrés o similar i llestos (haurà fet un COUNT per saber el total).

La funció té els mateixos paràmetres que el GET amb un afegit que és el número de registres a retornar.

public DataTable GETTOP(int TOP, Dictionary<string, string> Params)
{
    SqlDataReader Reader = null;
    DataTable Result = new DataTable();
    bool LocalConn;
    SqlConnection Conn = null;

    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;

    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;

    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spGET + "TOP";

    SqlParameter pTOP = new SqlParameter("numRows", SqlDbType.BigInt);
    pTOP.Direction = ParameterDirection.Input;
    pTOP.Value = TOP;
    SqlComm.Parameters.Add(pTOP);

    foreach (clsCamp Camp in ParamsGET)
    {
	SqlParam = CreaParametre(Camp, false);
	if (Params.Keys.Contains<string>(Camp.NomCamp))
	{
	    if (string.IsNullOrEmpty(Params[Camp.NomCamp])) SqlParam.Value = DBNull.Value;
	    else SqlParam.Value = Params[Camp.NomCamp];
	}
	else SqlParam.Value = DBNull.Value;
	SqlComm.Parameters.Add(SqlParam);
    }


    Reader = SqlComm.ExecuteReader();

    Result.Load(Reader);

    Reader.Close();

    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
    return Result;
}

Aquesta funció de la clsDades s'encarrega de transformar els paràmetres informats a paràmetres SqlServer i invocar a la stored procedure GET, obtenint els resultats en un taula (objecte DataTable). Per fer-ho fa servir la funció de creació de paràmetres amb la informació de la variable ParamsGET que és tipus clsCamp (es pot veure un exemple aquí.).

Si no està informat l'objecte connexió a BBDD en crea una nova fent servir l'string CadConn, i la tanca posteriorment (es a dir, per un accés puntual es pot fer servir directament). Si, al contrari, ja hi ha un objecte connexió creat el fa servir sense modificar-ne l'estat. Això és important ja que si es fan servir múltiples objectes de la clsDades i es vol que tots facin servir la mateixa connexió, sense anar obrint i tancant, caldrà informar-los la connexió (i de forma anàloga la transacció) abans de fer servir l'objecte. Com sempre poso el codi per veure que fa.

public DataTable GET(Dictionary<string, string> Params)
{
    SqlDataReader Reader = null;
    DataTable Result = new DataTable();
    bool LocalConn;
    SqlConnection Conn = null;

    //SQLConn és una variable SqlConnection de la clase, si no està instanciada cal crear-la
    if (SQLConn == null)
    {
	LocalConn = true;
	Conn = new SqlConnection(CadConnBBDD);
	Conn.Open();
    }
    else
    {
	LocalConn = false;
	Conn = SQLConn;
    }
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;

    SqlComm.Connection = Conn;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;

    SqlComm.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spGET;

    //Es creen tots els paràmetres i informant els valors dels que existeixen
    foreach (clsCamp Camp in ParamsGET)
    {
	SqlParam = CreaParametre(Camp, false);
	if (Params.Keys.Contains<string>(Camp.NomCamp))
	{
	    if (string.IsNullOrEmpty(Params[Camp.NomCamp])) SqlParam.Value = DBNull.Value;
	    else SqlParam.Value = Params[Camp.NomCamp];
	}
	else SqlParam.Value = DBNull.Value;
	SqlComm.Parameters.Add(SqlParam);
    }

    
    Reader = SqlComm.ExecuteReader();

    Result.Load(Reader);

    Reader.Close();

    if (LocalConn)
    {
	Conn.Close();
	Conn.Dispose();
	Conn = null;
    }
    return Result;
}

Dins de la clsDades hi ha aquesta és una petita funció que s'encarrega de crear un paràmetre de SQLServer a partir de la informació guardada en un objecte clsCamp. L'única variació que té és en el INSERT, que quan es tracta d'una identitat cal recuperar el valor que es genera. Per això en aquest cas es posa el paràmetre de sortida (output). Aquesta funció es fa servir en la resta de funcions que veurem, les que invoquen a les seves corresponents stored procedures. Poso el codi a continuació, es pot seguir fàcilment.

private SqlParameter CreaParametre(clsCamp Camp, bool INSERT)
{
    SqlParameter SqlParam;
    SqlParam = new SqlParameter();

    //Si és un insert interessa recuperar el valor de la identitat, el paràmetre ha de ser output.
    if (INSERT)
    {
	if ((TeIdentitat) && (Camp.NomCamp == Identitat)) SqlParam.Direction = ParameterDirection.Output;
	else SqlParam.Direction = ParameterDirection.Input;
    } //Tots els altres sempre input.
    else SqlParam.Direction = ParameterDirection.Input;

    SqlParam.ParameterName = Prefix + Camp.NomCamp;

    switch (Camp.Tipus)
    {
	case Tipus.bit:
	    SqlParam.SqlDbType = SqlDbType.Bit;
	    break;
	case Tipus.tint:
	    SqlParam.SqlDbType = SqlDbType.Int;
	    break;
	case Tipus.bigint:
	    SqlParam.SqlDbType = SqlDbType.BigInt;
	    break;
	case Tipus.nvarchar:
	    SqlParam.SqlDbType = SqlDbType.NVarChar;
	    SqlParam.Size = Camp.Longitud;
	    break;
	case Tipus.date:
	    SqlParam.SqlDbType = SqlDbType.Date;
	    break;
	case Tipus.time:
	    SqlParam.SqlDbType = SqlDbType.Time;
	    break;
	case Tipus.datetime:
	    SqlParam.SqlDbType = SqlDbType.DateTime;
	    break;
	case Tipus.nchar:
	    SqlParam.SqlDbType = SqlDbType.NChar;
	    SqlParam.Size = Camp.Longitud;
	    break;
	case Tipus.dec:
	    SqlParam.SqlDbType = SqlDbType.Decimal;
	    SqlParam.Precision = Camp.Precisio;
	    SqlParam.Scale = Camp.Escala;
	    break;
	case Tipus.chr:
	    SqlParam.SqlDbType = SqlDbType.Char;
	    SqlParam.Size = Camp.Longitud;
	    break;
	case Tipus.varchar:
	    SqlParam.SqlDbType = SqlDbType.VarChar;
	    SqlParam.Size = Camp.Longitud;
	    break;
    }
    return SqlParam;
}

La clase clsDades, que veurem en detall, conté els mètodes per invocar les SP i les declaracions de variables que fan servir aquests mètodes. En canvi una classe derivada només té les inicialitzacions d'aquestes variables. El programa que genera la capa de dades crea automàticament aquestes inicialitzacions. Es a dir que el següent tros de programa està generat, no picat. Poso un exemple qualsevol, és només indicatiu.

public class clsClassificacio : clsDades
{
	/// <summary>
	/// Constructor de la clase que gestiona l'acces a dades
	/// </summary>
	/// <param name="pCadConnBBDD">Cadena conexio</param>
	public clsClassificacio(string pCadConnBBDD)
	{
		spINS = "DI_EXP_CLASSIFICACIO_INS";
		spUPD = "DI_EXP_CLASSIFICACIO_UPD";
		spGET = "DI_EXP_CLASSIFICACIO_GET";
		spCOUNT = "DI_EXP_CLASSIFICACIO_COUNT";
		spQUERY = "DI_EXP_CLASSIFICACIO_QUERY";
		spDEL = "DI_EXP_CLASSIFICACIO_DEL";
		TeIdentitat = true;
		Identitat = "PK_Classificacio";
		NomTaula = "DI_EXP_CLASSIFICACIO";
		TeCache = false;
		CadConnBBDD = pCadConnBBDD;
		ParamsGET = new clsCamp[7];
		for (int i = 0; i < 7; i++) ParamsGET[i] = new clsCamp();
	#region Llista params GET
		ParamsGET[0].NomCamp = "PK_Classificacio";
		ParamsGET[0].Tipus = Tipus.tint;
		ParamsGET[0].PK = true;
		ParamsGET[0].Identitat = true;
		ParamsGET[0].Nulable = false;
		ParamsGET[1].NomCamp = "Nom";
		ParamsGET[1].Tipus = Tipus.nvarchar;
		ParamsGET[1].Longitud = 200;
		ParamsGET[1].Nulable = false;
		ParamsGET[2].NomCamp = "PK_Arxiu";
		ParamsGET[2].Tipus = Tipus.tint;
		ParamsGET[3].NomCamp = "Codi_TC";
		ParamsGET[3].Tipus = Tipus.nvarchar;
		ParamsGET[3].Longitud = 5;
		ParamsGET[3].Nulable = false;
		ParamsGET[4].NomCamp = "Nivell_Codi";
		ParamsGET[4].Tipus = Tipus.nvarchar;
		ParamsGET[4].Longitud = 100;
		ParamsGET[4].Nulable = false;
		ParamsGET[5].NomCamp = "IdPare";
		ParamsGET[5].Tipus = Tipus.tint;
		ParamsGET[5].Nulable = false;
		ParamsGET[6].NomCamp = "FK_TAAD";
		ParamsGET[6].Tipus = Tipus.tint;
	#endregion
		ParamsINS = new clsCamp[10];
		for (int i = 0; i < 10; i++) ParamsINS[i] = new clsCamp();
	#region Llista params INS
		ParamsINS[0].NomCamp = "PK_Classificacio";
		ParamsINS[0].Tipus = Tipus.tint;
		ParamsINS[0].PK = true;
		ParamsINS[0].Identitat = true;
		ParamsINS[0].Nulable = false;
		ParamsINS[1].NomCamp = "Codi_TC";
		ParamsINS[1].Tipus = Tipus.varchar;
		ParamsINS[1].Longitud = 5;
		ParamsINS[1].Nulable = false;
		ParamsINS[2].NomCamp = "Observacions";
		ParamsINS[2].Tipus = Tipus.varchar;
		ParamsINS[2].Longitud = 3000;
		ParamsINS[3].NomCamp = "DataAlta";
		ParamsINS[3].Tipus = Tipus.datetime;
		ParamsINS[4].NomCamp = "DataBaixa";
		ParamsINS[4].Tipus = Tipus.datetime;
		ParamsINS[5].NomCamp = "Any_inici";
		ParamsINS[5].Tipus = Tipus.tint;
		ParamsINS[5].Nulable = false;
		ParamsINS[6].NomCamp = "Any_final";
		ParamsINS[6].Tipus = Tipus.tint;
		ParamsINS[6].Nulable = false;
		ParamsINS[7].NomCamp = "IdPare";
		ParamsINS[7].Tipus = Tipus.tint;
		ParamsINS[7].Nulable = false;
		ParamsINS[8].NomCamp = "Nom";
		ParamsINS[8].Tipus = Tipus.nvarchar;
		ParamsINS[8].Longitud = 200;
		ParamsINS[8].Nulable = false;
		ParamsINS[9].NomCamp = "Nivell_Codi";
		ParamsINS[9].Tipus = Tipus.varchar;
		ParamsINS[9].Longitud = 100;
		ParamsINS[9].Nulable = false;
	#endregion
		ParamsUPD = new clsCamp[10];
		for (int i = 0; i < 10; i++) ParamsUPD[i] = new clsCamp();
	#region Llista params UPD
		ParamsUPD[0].NomCamp = "PK_Classificacio";
		ParamsUPD[0].Tipus = Tipus.tint;
		ParamsUPD[0].PK = true;
		ParamsUPD[0].Identitat = true;
		ParamsUPD[0].Nulable = false;
		ParamsUPD[1].NomCamp = "Codi_TC";
		ParamsUPD[1].Tipus = Tipus.varchar;
		ParamsUPD[1].Longitud = 5;
		ParamsUPD[1].Nulable = false;
		ParamsUPD[2].NomCamp = "Observacions";
		ParamsUPD[2].Tipus = Tipus.varchar;
		ParamsUPD[2].Longitud = 3000;
		ParamsUPD[3].NomCamp = "DataAlta";
		ParamsUPD[3].Tipus = Tipus.datetime;
		ParamsUPD[4].NomCamp = "DataBaixa";
		ParamsUPD[4].Tipus = Tipus.datetime;
		ParamsUPD[5].NomCamp = "Any_inici";
		ParamsUPD[5].Tipus = Tipus.tint;
		ParamsUPD[5].Nulable = false;
		ParamsUPD[6].NomCamp = "Any_final";
		ParamsUPD[6].Tipus = Tipus.tint;
		ParamsUPD[6].Nulable = false;
		ParamsUPD[7].NomCamp = "IdPare";
		ParamsUPD[7].Tipus = Tipus.tint;
		ParamsUPD[7].Nulable = false;
		ParamsUPD[8].NomCamp = "Nom";
		ParamsUPD[8].Tipus = Tipus.nvarchar;
		ParamsUPD[8].Longitud = 200;
		ParamsUPD[8].Nulable = false;
		ParamsUPD[9].NomCamp = "Nivell_Codi";
		ParamsUPD[9].Tipus = Tipus.varchar;
		ParamsUPD[9].Longitud = 100;
		ParamsUPD[9].Nulable = false;
	#endregion
		ParamsDEL = new clsCamp[7];
		for (int i = 0; i < 7; i++) ParamsDEL[i] = new clsCamp();
	#region Llista params DEL
		ParamsDEL[0].NomCamp = "PK_Classificacio";
		ParamsDEL[0].Tipus = Tipus.tint;
		ParamsDEL[0].PK = true;
		ParamsDEL[0].Identitat = true;
		ParamsDEL[0].Nulable = false;
		ParamsDEL[1].NomCamp = "Nom";
		ParamsDEL[1].Tipus = Tipus.nvarchar;
		ParamsDEL[1].Longitud = 200;
		ParamsDEL[1].Nulable = false;
		ParamsDEL[2].NomCamp = "PK_Arxiu";
		ParamsDEL[2].Tipus = Tipus.tint;
		ParamsDEL[3].NomCamp = "Codi_TC";
		ParamsDEL[3].Tipus = Tipus.nvarchar;
		ParamsDEL[3].Longitud = 5;
		ParamsDEL[3].Nulable = false;
		ParamsDEL[4].NomCamp = "Nivell_Codi";
		ParamsDEL[4].Tipus = Tipus.nvarchar;
		ParamsDEL[4].Longitud = 100;
		ParamsDEL[4].Nulable = false;
		ParamsDEL[5].NomCamp = "IdPare";
		ParamsDEL[5].Tipus = Tipus.tint;
		ParamsDEL[5].Nulable = false;
		ParamsDEL[6].NomCamp = "FK_TAAD";
		ParamsDEL[6].Tipus = Tipus.tint;
	#endregion
		ParamsQUERY = new clsCamp[7];
		for (int i = 0; i < 7; i++) ParamsQUERY[i] = new clsCamp();
	#region Llista params QUERY
		ParamsQUERY[0].NomCamp = "PK_Classificacio";
		ParamsQUERY[0].Tipus = Tipus.tint;
		ParamsQUERY[0].PK = true;
		ParamsQUERY[0].Identitat = true;
		ParamsQUERY[0].Nulable = false;
		ParamsQUERY[1].NomCamp = "Nom";
		ParamsQUERY[1].Tipus = Tipus.nvarchar;
		ParamsQUERY[1].Longitud = 200;
		ParamsQUERY[1].Nulable = false;
		ParamsQUERY[2].NomCamp = "PK_Arxiu";
		ParamsQUERY[2].Tipus = Tipus.tint;
		ParamsQUERY[3].NomCamp = "Codi_TC";
		ParamsQUERY[3].Tipus = Tipus.nvarchar;
		ParamsQUERY[3].Longitud = 5;
		ParamsQUERY[3].Nulable = false;
		ParamsQUERY[4].NomCamp = "Nivell_Codi";
		ParamsQUERY[4].Tipus = Tipus.nvarchar;
		ParamsQUERY[4].Longitud = 100;
		ParamsQUERY[4].Nulable = false;
		ParamsQUERY[5].NomCamp = "IdPare";
		ParamsQUERY[5].Tipus = Tipus.tint;
		ParamsQUERY[5].Nulable = false;
		ParamsQUERY[6].NomCamp = "FK_TAAD";
		ParamsQUERY[6].Tipus = Tipus.tint;
	#endregion
		CampsResultat = new clsCamp[10];
		for (int i = 0; i < 10; i++) CampsResultat[i] = new clsCamp();
	#region Camps resultat
		CampsResultat[0].NomCamp = "PK_Classificacio";
		CampsResultat[0].Tipus = Tipus.tint;
		CampsResultat[0].PK = true;
		CampsResultat[0].Identitat = true;
		CampsResultat[0].Nulable = false;
		CampsResultat[1].NomCamp = "Codi_TC";
		CampsResultat[1].Tipus = Tipus.varchar;
		CampsResultat[1].Longitud = 5;
		CampsResultat[1].Nulable = false;
		CampsResultat[2].NomCamp = "Observacions";
		CampsResultat[2].Tipus = Tipus.varchar;
		CampsResultat[2].Longitud = 3000;
		CampsResultat[3].NomCamp = "DataAlta";
		CampsResultat[3].Tipus = Tipus.datetime;
		CampsResultat[4].NomCamp = "DataBaixa";
		CampsResultat[4].Tipus = Tipus.datetime;
		CampsResultat[5].NomCamp = "Any_inici";
		CampsResultat[5].Tipus = Tipus.tint;
		CampsResultat[5].Nulable = false;
		CampsResultat[6].NomCamp = "Any_final";
		CampsResultat[6].Tipus = Tipus.tint;
		CampsResultat[6].Nulable = false;
		CampsResultat[7].NomCamp = "IdPare";
		CampsResultat[7].Tipus = Tipus.tint;
		CampsResultat[7].Nulable = false;
		CampsResultat[8].NomCamp = "Nom";
		CampsResultat[8].Tipus = Tipus.nvarchar;
		CampsResultat[8].Longitud = 200;
		CampsResultat[8].Nulable = false;
		CampsResultat[9].NomCamp = "Nivell_Codi";
		CampsResultat[9].Tipus = Tipus.varchar;
		CampsResultat[9].Longitud = 100;
		CampsResultat[9].Nulable = false;
	#endregion
		Serialitzar = new clsCamp[10];
		for (int i = 0; i < 10; i++) Serialitzar[i] = new clsCamp();
	#region Camps a serialitzar
		Serialitzar[0].NomCamp = "PK_Classificacio";
		Serialitzar[0].Tipus = Tipus.tint;
		Serialitzar[1].NomCamp = "Codi_TC";
		Serialitzar[1].Tipus = Tipus.varchar;
		Serialitzar[1].Longitud = 5;
		Serialitzar[2].NomCamp = "Observacions";
		Serialitzar[2].Tipus = Tipus.varchar;
		Serialitzar[2].Longitud = 3000;
		Serialitzar[3].NomCamp = "DataAlta";
		Serialitzar[3].Tipus = Tipus.datetime;
		Serialitzar[4].NomCamp = "DataBaixa";
		Serialitzar[4].Tipus = Tipus.datetime;
		Serialitzar[5].NomCamp = "Any_inici";
		Serialitzar[5].Tipus = Tipus.tint;
		Serialitzar[6].NomCamp = "Any_final";
		Serialitzar[6].Tipus = Tipus.tint;
		Serialitzar[7].NomCamp = "IdPare";
		Serialitzar[7].Tipus = Tipus.tint;
		Serialitzar[8].NomCamp = "Nom";
		Serialitzar[8].Tipus = Tipus.nvarchar;
		Serialitzar[8].Longitud = 200;
		Serialitzar[9].NomCamp = "Nivell_Codi";
		Serialitzar[9].Tipus = Tipus.varchar;
		Serialitzar[9].Longitud = 100;
	#endregion
		Deserialitzar = new clsCamp[9];
		for (int i = 0; i < 9; i++) Deserialitzar[i] = new clsCamp();
	#region Camps a Deserialitzar
		Deserialitzar[0].NomCamp = "Codi_TC";
		Deserialitzar[0].Tipus = Tipus.varchar;
		Deserialitzar[0].Longitud = 5;
		Deserialitzar[1].NomCamp = "Observacions";
		Deserialitzar[1].Tipus = Tipus.varchar;
		Deserialitzar[1].Longitud = 3000;
		Deserialitzar[2].NomCamp = "DataAlta";
		Deserialitzar[2].Tipus = Tipus.datetime;
		Deserialitzar[3].NomCamp = "DataBaixa";
		Deserialitzar[3].Tipus = Tipus.datetime;
		Deserialitzar[4].NomCamp = "Any_inici";
		Deserialitzar[4].Tipus = Tipus.tint;
		Deserialitzar[5].NomCamp = "Any_final";
		Deserialitzar[5].Tipus = Tipus.tint;
		Deserialitzar[6].NomCamp = "IdPare";
		Deserialitzar[6].Tipus = Tipus.tint;
		Deserialitzar[7].NomCamp = "Nom";
		Deserialitzar[7].Tipus = Tipus.nvarchar;
		Deserialitzar[7].Longitud = 200;
		Deserialitzar[8].NomCamp = "Nivell_Codi";
		Deserialitzar[8].Tipus = Tipus.varchar;
		Deserialitzar[8].Longitud = 100;
	#endregion
	}
}

Com es pot veure picar això a mà seria mortal, per aquest motiu hi ha un software que ho genera. Els paràmetres de les SP els obté de les pròpies SP, es a dir, han d'estar generades prèviament, abans de generar aquesta classe. La resta de llistes les obté a partir dels camps de la taula que estan al software generador. Si es marca un camp per serialitzar apareixerà a la llista de "Serialitzar", si es marca per deserialitzar... ja es veu la idea. Llavors la capa d'accés a BBDD es compon de la clsDades i un munt de classes derivades.

En aquesta clase, com cobreix molta funcionalitat, hi ha parts que només serveixen per projectes web i en canvi per projectes d'un altra tipus (per exemple WinForms) donen errors de compilació (per que no hi ha el HttpRequest). Per això he fet servir la compilació condicional, típica.

Aquesta compilació condicional afecta a la serialització, deserialització ja que aquests mètodes no es fan servir en projectes no web. Per això es defineix una constant (o símbol) a Projecte -> Propietats -> Build -> Conditional Compilation symbols. Cal vigilar de definir aquest símbol en totes les configuracions (Debug, Release...).

La clsDades conté les declaracions de les diferents variables que fa servir. La gran majoria són arrays de clsCamps. Poso el codi comentat on es veu clarament que fa cada un d'aquestes variables. En les classes que hereten de la clsDades s'inicialitzen les variables amb els valors corresponents a una taula concreta de la BBDD.

    public class clsDades
    {
        /// <summary>
        /// Prefix dels paràmetres de les stored procedures, 
        /// útil per distingir-los de variables declarades dins de la SP.
        /// </summary>
        public string Prefix = "p";

        /// <summary>
        /// Paràmetres del GET, també són params del GETTOP
        /// </summary>
        public clsCamp[] ParamsGET; 

        /// <summary>
        /// Paràmetres del INS
        /// </summary>
        public clsCamp[] ParamsINS;

        /// <summary>
        /// Paràmetres del UPD
        /// </summary>
        public clsCamp[] ParamsUPD;

        /// <summary>
        /// Paràmetres del DEL
        /// </summary>
        public clsCamp[] ParamsDEL;

        /// <summary>
        /// Paràmetres del QUERY
        /// </summary>
        public clsCamp[] ParamsQUERY;

        /// <summary>
        /// Camps que retorna el GET i que seràn columnes del DataTable resultant
        /// </summary>
        public clsCamp[] CampsResultat;

        /// <summary>
        /// Cadena de connexió a BBDD
        /// </summary>
        public string CadConnBBDD;

        /// <summary>
        /// Nom de la SP que fa el GET, p. ex: CLIENTS_GET
        /// </summary>
        public string spGET;

        /// <summary>
        /// Nom de la SP que fa el INS, p. ex: CLIENTS_INS
        /// </summary>
        public string spINS;

        /// <summary>
        /// Nom de la SP que fa el UPD, p. ex: CLIENTS_UPD
        /// </summary>
        public string spUPD;

        /// <summary>
        /// Nom de la SP que fa el DEL, p. ex: CLIENTS_DEL
        /// </summary>
        public string spDEL;

        /// <summary>
        /// Nom de la SP que fa el QUERY, p. ex: CLIENTS_QUERY
        /// </summary>
        public string spQUERY;

        /// <summary>
        /// Nom de la SP que fa el COUNT, p. ex: CLIENTS_COUNT
        /// </summary>
        public string spCOUNT;

        /// <summary>
        /// Objecte conexió a BBDD. Útil per si es vol fer servir
        /// tota l'estona la mateixa conexió, sense obrir i tancar cada cop.
        /// </summary>
        public SqlConnection SQLConn = null;

        /// <summary>
        /// Objecte que conté la transacció. És opcional fer-ne servir.
        /// </summary>
        public SqlTransaction SQLTrans = null;

        /// <summary>
        /// Indica que la taula té un camp identat
        /// </summary>
        public bool TeIdentitat = false;

        /// <summary>
        /// Indica si la taula fa servir una cache de JSON
        /// </summary>
        public bool TeCache = false;

        /// <summary>
        /// Indica si un INS/DEL/UPD netegen la cache automàticament
        /// </summary>
        public bool AutoNetejaCache = true;

        /// <summary>
        /// Nom de la taula
        /// </summary>
        public string NomTaula = "";

        /// <summary>
        /// Nom del camp identitat
        /// </summary>
        public string Identitat = "";

        /// <summary>
        /// Llista dels camps que es serialitzen per enviar al navegador
        /// </summary>
        public clsCamp[] Serialitzar = null;

        /// <summary>
        /// Llista de camps que es deserialitzen quan arriben del navegador
        /// </summary>
        public clsCamp[] Deserialitzar = null;

        //Canviar de projecte en projecte, 
        //ha de tenir el parametre Taula varchar(50) i el parametre URL varchar(500)
        private string SP_Cache = "DI_EXP_CACHE_DEL";
}

En el desenvolupament d'aplicacions web cal una infraestructura per accedir a les dades a la BBDD, es a dir les stored procedures (SP) i també cal una forma fàcil per invocar-les. I a ser possible que NO sigui muntar les crides a mà. Per això he muntat la clsDades.

La clsDades és la classe principal que conté tots els métodes d'accés a BBDD. S'encarrega d'invocar les SP en funció de la definició concreta per cada taula. Es per això que la resta de classes hereden d'aquesta, i l'amplien definint amb detall els diferents paràmetres de cada SP.

Per tan la clsDades, de fet, conté els mètodes, mentre que la definició la tenen les classes particulars corresponents a cada taula. Per això la clsDades conté la declaració de les llistes de paràmetres i la inicialització es troba separada.

El primer que cal definir són les classes de suport que fa servir la clsDades, es a dir la classe Tipus i la classe clsCamp. Concretament la clsDades conté vectors d'objectes clsCamp destinats a construir els paràmetres de les SP. Per això detallaré aquestes classes primer, a demés que són força simples.

La clase Tipus indica el tipus (valgui la redundància) de BBDD, es farà servir per indicar el tipus en la clase Camp i després en el codi queda més clar.

    public static class Tipus
    {
        public const int bit = 1;
        public const int tint = 2;
        public const int bigint = 3;
        public const int nvarchar = 4;
        public const int datetime = 5;
        public const int nchar = 6;
        public const int dec = 7;
        public const int varchar = 8;
        public const int chr = 9;
        public const int date = 10;
        public const int time = 11;
    }

La classe camp també és força senzilla, conté informació d'un camp de BBDD.

    public class clsCamp
    {
        public string NomCamp = "";
        public bool Nulable = true;
        public int Tipus;
        public string Format = "";
        public int Longitud = 0;
        public bool PK = false;
        public bool Identitat = false;
        public byte Precisio = 0;
        public byte Escala = 0;
    }

A partir d'aquí començarem a desgranar poc a poc la clsDades. Però en futurs posts:

• Declaració de variables
• Una clase derivada, per omplir amb valors les variables.
• Creació de paràmetres a SqlServer
• Invocació de la SP GET.
• Invocació de la SP GETTOP.
• Invocació de la SP INS.
• Invocació de la SP UPD.
• Invocació de la SP DEL.
• Invocació de la SP COUNT.
• Invocació de la SP QUERY.
• Serialitzar.
• Deserialitzar.
• Actualitzar una DataTable.
• Gestió de la cache.