Aquesta acostuma a ser una operació senzilla dins d'una aplicació, sigui web o no. Només cal invocar al ASHX amb l'acció corresponent, la clau primària i llestos. De fet és una crida Ajax força curta, i la poso en un botó al formulari web. També es pot invocar des d'un grid fent un botó adhoc. Un cop rebuda la petició no cal fer res més que crida al DEL de la classe derivada de la clsDades. Alguna vegada m'he trobat que cal fer verificacions de que el registre no tingui altres vinculats en altres taules per donar el missatge pertinent, però res més complicat que això. En l'exemple que hi ha a continuació s'esborra el fitxer que hi ha associat i després el registre de la BBDD.

private void Delete()
{
	try
	{
		Resp.ContentType = "plain/text";
		string IdImatge = Req["IdImatge"];
		clsImatges Imatges = new clsImatges(ConnStr);
		Dictionary<string, string> Params = new Dictionary<string, string>();
		DataTable tblImatges;

		Params.Add("IdImatge", IdImatge);
		tblImatges = Imatges.GET(Params);
		if (File.Exists(tblImatges.Rows[0]["Imatge"].ToString()))
		{
			File.Delete(tblImatges.Rows[0]["Imatge"].ToString());
			Imatges.DEL(Params);
			Resp.Write("OK");
		}
		else
		{
			Resp.Write("ERROR: Fitxer no trobat");
		}
		
	}
	catch (Exception Err)
	{
		Resp.Write("ERROR: " + Err.Message);
	}
}

Seguint la sèrie de posts dedicats al desenvolupament d'aplicacions web, ara toca processar una petició de nou registre que arriba des del formulari web. Aquesta part del ASHX òbviament crida a la deserialització per obtenir els valors dels camps que arriben al "request" que es col·loquen en un Dictionary (és un objecte que té una estructura clau-valor, que faig servir per posar nom_camp_BBDD-valor_camp) i posteriorment es crida a l'INS de la classe derivada corresponent (derivada de la clsDades). Aquest mecanisme de deserialització fa que no importi el nombre de camps que hi ha al formulari, 5 o 50 ens costarà el mateix de programar. La llista de camps a deserialitzar la genera un programa a partir dels camps a la BBDD i amb un "checkbox" (casella de verificació? Que malament sona), deia que amb un "checkbox" es decideix si es deserialitza o no. De forma similar al Update també es pot posar aquí verificacions de negoci, o es pot afegir al Dictionary algo com la data de creació del registre... La diferència principal respecte l'update és que es recull el valor del clau primària (PK, primary key) que es genera i s'envia al formulari web. Un cop el formulari web rep aquest PK, el formulari passa de mode insert a mode update, ja que posteriors gravacions no crearan registres nous si no que actualitzaran el mateix registre tota l'estona. La plantilla que genera ASHXs crea aquest mètode "Insertar", com sempre el codi comentat:

private void Insertar()
{
	Resp.ContentType = "plain/text";
	Req.ContentEncoding = Encoding.GetEncoding("UTF-8");
	try
	{
		//Clase derivada de clsDades que té informació sobre el camps a
		//Deserialitzar
		clsClassificacio ClassificacioTA = new clsClassificacio(ConnStr);

		//Objecte Dictionary on guardarem nom_camp-valor_camp
		Dictionary<string, string> Params = new Dictionary<string, string>(); ;

		//Verificació de la lògica de negoci
		string Errors = ComprovacionsDadesUpdateInsert();
		if (Errors == "")
		{
		    decimal PK_Classificacio;

                    //Deserialitzar propiament dit
		    Params = ClassificacioTA.Deserialize(Req);
		    
		    //Obtenim la nova PK
		    PK_Classificacio = ClassificacioTA.INS(Params);

		    //S'envia la PK al formulari
		    Resp.Write(PK_Classificacio.ToString());
		}
		else
		{
		    Resp.Write(Errors);
		}
	}
	catch (Exception Err)
	{
		Resp.Write("ERROR: " + Err.Message);
	}
}

Els ASHX han de permetre actualitzar dades i aquesta funció s'encarrega d'actualitzar el registre que està mostrant actualment un formulari. Es poden donar molts casos, per exemple que el formulari mostri dades de més d'una sola taula. No passa res, quan es cridi a les funcions de deserialització corresponents cadascuna agafarà els camps que li pertoca. La única condició es que els camps del formulari tinguin noms diferents. Igual que al serialitzar no importa que el formulari tingui 5 camps o 50, el cost de programació (en aquest punt) és el mateix. La informació sobre els camps a recuperar estarà en una classe derivada de la clsDades.
També acostuma a passar que els camps que es mostren en un formulari no són tots els que es mostren al formulari, llavors el que es fa és carregar el registre amb un GET prèviament i després deserialitzar només els camps que s'actualitzen fent un UPD. L'exemple que es mostra a continuació és aquest cas. També en aquesta funció es sol afegir lògica de verificació que sigui de negoci (la típica de camps buits, números i dates es posa al navegador).

private void UpdateData()
{
	Resp.ContentType = "plain/text";
	Req.ContentEncoding = Encoding.GetEncoding("UTF-8");
	try
	{
		//Classe derivada de clsDades
		clsClassificacio ClassificacioTA = new clsClassificacio(ConnStr);
		DataTable TBL;
		DataRow DR;

		//Dictionary per recuperar dades
		Dictionary<string, string> Params = new Dictionary<string, string>();
		string pPK_Classificacio = Req["PK_Classificacio"];

		//Es verifica la lógica de negoci
		string Errors = ComprovacionsDadesUpdateInsert();
		if (Errors != "")
		{
		    Resp.Write(Errors);
		}
		else
		{
		    //Es recuperen les dades		
		    Params.Add("PK_Classificacio", pPK_Classificacio);
		    TBL = ClassificacioTA.GET(Params);
		    DR = TBL.Rows[0];

		    //Es deserialitza
		    ClassificacioTA.Deserialize(DR, Req);

		    //Es fa el Update
		    ClassificacioTA.UPD(DR);

		    Resp.Write("Update Classificacio OK");
		}
	}
	catch (Exception Err)
	{
		Resp.Write("ERROR: " + Err.Message);
	}
}

Una de les accions del ASHX és obtenir un registre de la BBDD (fent servir les "stored procedures" i la clsDades), serialitzar els camps que formen el registre, convertir-ho a JSON i enviar-ho al navegador. El millor d'aquest proces és que el seu cost no depèn del número de camps que té el formulari al que van destinades les dades. És a dir em resulta igual que el formulari tingui 5 camps o 50. La funció que s'encarrega de fer això és diu LoadData, normalment recupera la clau primària sobre la que ha de retornar un registre. El generador que fa ASHX a partir d'una plantilla genera aquesta funció automàticament. Com sempre el codi:

private void LoadData()
{
	//Es posa el content type que toca
	Resp.ContentType = "application/json";

	//Paràmetres per fer la crida
	Dictionary<string, string> Params = new Dictionary<string, string>();

	//Clase derivada de la clsDades que té la informació
	//dels camps a serialitzar
	clsDestruccio TA = new clsDestruccio(ConnStr);

	//Recollim la PK
	string pPK_Destruccio = Req["PK_Destruccio"];
	Params.Add("PK_Destruccio", pPK_Destruccio);

	//Fem un GET
	DataTable TBL = TA.GET(Params);

	//Es serialitza i s'envia el JSON
	//al fer la serialització no importa que siguin 5 camps o 50
	Resp.Write(TA.Serialize(TBL.Rows[0]));
}

Dins del desenvolupament d'aplicacions web cal una peça que enllaci la capa de BBDD (clsDades i "stored procedures" que estan sota) amb les pàgines web que llencen peticions. Per això faig servir els "manejadors generics" (que malament sonen traduïts), "generic handler" (millor). Són com pàgines web però a les que s'ha tret tota la part HTML de .NET. Tenen l'extensió ASHX i estan en .NET des del primer Visual Studio (bé jo només puc afirmar que estan des del VS 2005, el 2003 no estic segur).

Al no tenir HTML no tenen ViewState, no gestionen events, al no tenir aquests dos components el seu rendiment és millor que el d'una pàgina ASPX (concretament el pipeline (cadena de muntatge) és més curt), són força ràpids. El seu punt d'entrada és una funció:

public void ProcessRequest(HttpContext context)

Dins de l'objecte HttpContext disposem dels objectes HttpResponse per enviar dades a la pàgina web que invoca al ASHX i l'objecte HttpRequest per recuperar informació que ens envien.

Normalment cada taula de la BBDD, o entitat que es vulgui té un ASHX associat. En aquest ASHX es fan les operacions bàsiques (típiques d'un CRUD). A més a més es pot afegir la lògica de negoci (les operacions específiques d'un objecte) que estigui relacionada amb l'objecte. Per exemple si tractem comandes, en el ASHX corresponent a les comandes hi haurà, alta, baixa, actualitzar, obtenir un conjunt de comandes (per muntar un grid), i a més a més també poden existir canvi d'estat de la comanda, tancar comanda, verificar comanda, enviar comanda a algú, autocompletes, etc... (això seria la lògica de negoci). El generador de codi munta un ASHX normal, amb les operacions CRUD ja definides, però no crea la lògica de negoci (no ho pot endevinar). Poso el codi d'un ASHX típic.

public class classificacions : IHttpHandler, IReadOnlySessionState
{
	private HttpResponse Resp;
	private HttpRequest Req;
	private HttpSessionState Ses;
	string IdPersona = "";
	private Connexions Conn = new Connexions();
	private string ConnStr;

	public void ProcessRequest(HttpContext context)
	{
		ConnStr = Conn.GetConnStr();
		Resp = context.Response;
		Req = context.Request;
		Ses = context.Session;
		Resp.Cache.SetCacheability(HttpCacheability.NoCache);
		Resp.ContentEncoding = Encoding.Default;
		Resp.Charset = "ISO-8859-1";

		//Verificació de seguretat, es pot fer d'altres formes
                //Normalment el login informa aquestes variables a sessió, BBDD...
		if (Ses["idPersona"] == null)
		{
			Resp.Write("ERROR: Sessió expirada, torni a validar-se al sistema.");
			return;
		}
		else
		{
			IdPersona = Ses["idPersona"].ToString();
		}


		string Action = Req["action"];
		switch (Action)
		{
			case "data":
				LoadData();
				break;
			case "update":
				UpdateData();
				break;
			case "insert":
				Insertar();
				break;
			case "delete":
				Delete();
				break;
			case "loadgrid":
				LoadGrid();
				break;
		}
	}
	
	public bool IsReusable
	{
		get
		{
			return false;
		}
	}
}

En posts posteriors anirem desgranant les funcions que estan al switch:

• LoadData();
• UpdateData();
• Insertar();
• Delete();
• LoadGrid();

Algunes d'aquestes funcions envien JSON a la part client, concretament LoadData i LoadGrid. Cal doncs una llibreria que converteixi a JSON el resultat. Jo faig servir aquesta.

Dins de la clsDades hi ha el mètode UPD que actualitza un registre, però i si volem actualitzar una DataTable? Cap problema. Fent servir tots els mètodes de la clsDades és possible cridar al que correspon segons l'estat de cada registre de la DataTable. Al final es fa un AcceptChanges per resetejar l'estat dels registres i llestos. Com sempre el codi:

/// <summary>
/// Actualitza una taula contra la BBDD, fa els inserts, updates i deletes segons l'estat de la fila.
/// Quan acaba deixa totes les files en DataRowState.Unchanged fent una crida a AcceptChanges
/// </summary>
/// <param name="TBL">La taula que s'ha d'actualitzar</param>
public void UPD(DataTable TBL)
{
    foreach (DataRow DR in TBL.Rows)
    {
	switch (DR.RowState)
	{
	    case DataRowState.Added:
		INS(DR);
		break;
	    case DataRowState.Deleted:
		DEL(DR);
		break;
	    case DataRowState.Modified:
		UPD(DR);
		break;
	}
    }
    TBL.AcceptChanges();
}

Igual que el procés que deserialitza, també és important la part que envia les dades. I la part comuna està a la clsDades.

Es a dir recuperar els valors de la BBDD, normalment amb un GET, després empaquetar-los en alguna estructura que després sigui fàcil enviar per JSON al navegador (faig servir un Dictionary). Els Dictionary són objectes que guarden valors (en el cas de la clsDades cadenes de text (strings)) en forma de parells, clau-valor, això és ideal per convertir-los a JSON, ja que el JSON també són claus-valors. Un cop al navegador hi ha una llibreria que fa el procés contrari (passar del JSON als camps), aquesta llibreria es crida en la funció LoadData de Javascript.

El que fa el serialitzar es crear aquest Dictionary, amb les dades adequades. La funció fa servir la llista de camps que està a la variable "Serialitzar" que s'inicialitza amb els camps de la taula que toqui (una d'exemple). Hi ha tipus de dades que admeten un determinat format, per exemple les dates o els decimals, el string que defineix com és aquest format surt de la propietat "format" (valgui la redundància) de la clsCamp (en el post de clsDades està descrita la clsCamp) i s'informa en el programa generador de classes. Per exemple podria ser un "dd-mm-yyyy" per dates o un "D2" per números.

La funció Serialize existeix en dos sabors, una que retorna el Dictionary (a vegades es recuperen dades i es vol afegir algo) o directament el JSON. Com la signatura de les funcions és la mateixa vaig posar un paràmetre dummy per diferenciar-les. El codi a continuació.

public Dictionary<string, string> Serialize(DataRow DR, bool Partial)
{
    Dictionary<string, string> Result = new Dictionary<string, string>();
    DateTime ValorData;
    Decimal ValorDecimal;
    foreach (clsCamp Camp in Serialitzar)
    {
	if (!DR.IsNull(Camp.NomCamp))
	{
	    switch (Camp.Tipus)
	    {
		case Tipus.date:
		    ValorData = (DateTime)DR[Camp.NomCamp];
		    if(string.IsNullOrEmpty(Camp.Format)) Result.Add(Camp.NomCamp, ValorData.ToShortDateString());
		    else Result.Add(Camp.NomCamp, ValorData.ToString(Camp.Format));
		    break;
		case Tipus.datetime:
		    ValorData = (DateTime)DR[Camp.NomCamp];
		    if (string.IsNullOrEmpty(Camp.Format)) Result.Add(Camp.NomCamp, ValorData.ToString("dd/MM/yyyy HH:mm"));
		    else Result.Add(Camp.NomCamp, ValorData.ToString(Camp.Format));
		    break;
		case Tipus.time:
		    ValorData = (DateTime)DR[Camp.NomCamp];
		    if (string.IsNullOrEmpty(Camp.Format)) Result.Add(Camp.NomCamp, ValorData.ToString("HH:mm"));
		    else Result.Add(Camp.NomCamp, ValorData.ToString(Camp.Format));
		    break;
		case Tipus.dec:
		    ValorDecimal = (Decimal)DR[Camp.NomCamp];
		    if (string.IsNullOrEmpty(Camp.Format)) Result.Add(Camp.NomCamp, ValorDecimal.ToString());
		    else Result.Add(Camp.NomCamp, ValorDecimal.ToString(Camp.Format));
		    break;
		default:
		    Result.Add(Camp.NomCamp, DR[Camp.NomCamp].ToString().Trim());
		    break;
	    }
	}
    }
    return Result;
}

public string Serialize(DataRow DR)
{
    return clsJSON.Serialize(Serialize(DR, false));
}

D'una forma visual aquesta funció es podria veure com la imatge:

En un projecte web, una part molt important i que acostuma a consumir molt temps de programació és recuperar els valors d'un formulari al servidor quan es rep un submit (ja sigui per Ajax o normal) per posar-los en una estructura que permeti guardar-los, normalment a una BBDD.

Per evitar-ho el que es fa és una llista dels camps a recuperar (variable "Deserialitzar" que és un array de clsCamp). Es a dir de tots els camps que pertanyen a una taula es marquen els que es volen deserialitzar (recuperar) i el software que genera la classe els inclou en aquesta llista (variable). Així el que s'acostuma a fer és invocar a la funció deserialitzar i després fer un UPD o un INS. Durant la deseriatlització es verifica el tipus dels valors que es reben des del formulari web.

La funció genèrica que realitza aquest procés està a la clsDades, però la llista de camps a deserialitzar està a cada classe especifica (derivada), la que correspon a cada taula. La funció Deserialitzar rep el Request (per obtenir les dades) i un DataRow o un Dictionary (acostuma a fer-se servir el DataRow per updates i l'altra per inserts).

Com sempre el codi associat, primer la versió Dictionary:

public Dictionary<string, string> Deserialize(HttpRequest Req)
{
    Dictionary<string, string> Values = new Dictionary<string, string>();
    string ValorCamp;
    decimal ValorDecimal;
    Int64 ValorInt64;
    int ValorInt;
    DateTime ValorData;

    foreach (clsCamp Camp in Deserialitzar)
    {
	ValorCamp = Req[Camp.NomCamp];
	switch (Camp.Tipus)
	{
	    case Tipus.bit:
		if (string.IsNullOrEmpty(Req[Camp.NomCamp])) Values.Add(Camp.NomCamp, "False");
		else Values.Add(Camp.NomCamp, "True");
		break;
	    case Tipus.bigint:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (Int64.TryParse(ValorCamp, out ValorInt64)) Values.Add(Camp.NomCamp, ValorCamp);
		    else throw new Exception("El camp "
			+ Camp.NomCamp + " no té un valor sencer de 64 bits vàlid");
		}
		break;
	    case Tipus.tint:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (int.TryParse(ValorCamp, out ValorInt)) Values.Add(Camp.NomCamp, ValorCamp);
		    else throw new Exception("El camp "
			+ Camp.NomCamp + " no té un valor sencer vàlid");
		}
		break;
	    case Tipus.dec:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (decimal.TryParse(ValorCamp, out ValorDecimal)) Values.Add(Camp.NomCamp, ValorCamp);
		    else throw new Exception("El camp "
			+ Camp.NomCamp + " no té un valor numèric vàlid");
		}
		break;
	    case Tipus.datetime:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (DateTime.TryParse(ValorCamp, out ValorData)) Values.Add(Camp.NomCamp, ValorCamp);
		    else throw new Exception("El camp "
			+ Camp.NomCamp + " no té una data vàlida");
		}
		break;
	    case Tipus.varchar:
	    case Tipus.chr:
	    case Tipus.nchar:
	    case Tipus.nvarchar:
		if (!string.IsNullOrEmpty(ValorCamp))
		{   //Els varchar(max) i nvarchar(max) tenen longitud -1 i no s'ha de verificar la seva longitud.
		    if (ValorCamp.Length > Camp.Longitud && Camp.Longitud != -1)
			throw new Exception("Camp " + Camp.NomCamp + " supera longitud permesa");
		    else Values.Add(Camp.NomCamp, ValorCamp);
		}
		break;
	}
    }
    return Values;
}

Ara la versió DataRow:

public void Deserialize(DataRow DR, HttpRequest Req)
{
    string ValorCamp;
    decimal ValorDecimal;
    int ValorInt;
    Int64 ValorInt64;
    DateTime ValorData;

    foreach (clsCamp Camp in Deserialitzar)
    {
	ValorCamp = Req[Camp.NomCamp];
	switch (Camp.Tipus)
	{
	    case Tipus.bit:
		if (string.IsNullOrEmpty(Req[Camp.NomCamp])) DR[Camp.NomCamp] = false;
		else DR[Camp.NomCamp] = true;
		break;
	    case Tipus.bigint:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (Int64.TryParse(ValorCamp, out ValorInt64)) DR[Camp.NomCamp] = ValorCamp;
		    else throw new Exception("Camp "
			 + Camp.NomCamp + " no té un valor sencer de 64 bits vàlid");
		}
		else
		{
		    if (Camp.Nulable) DR[Camp.NomCamp] = DBNull.Value;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no permet valors nulls");
		}
		break;
	    case Tipus.tint:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (int.TryParse(ValorCamp, out ValorInt)) DR[Camp.NomCamp] = ValorCamp;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no té un valor sencer vàlid");
		}
		else
		{
		    if (Camp.Nulable) DR[Camp.NomCamp] = DBNull.Value;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no permet valors nulls");
		}
		break;
	    case Tipus.dec:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (decimal.TryParse(ValorCamp, out ValorDecimal)) DR[Camp.NomCamp] = ValorCamp;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no té un valor numèric vàlid");
		}
		else
		{
		    if (Camp.Nulable) DR[Camp.NomCamp] = DBNull.Value;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no permet valors nulls");
		}
		break;
	    case Tipus.time:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (string.IsNullOrEmpty(Camp.Format))
		    {
			if (DateTime.TryParseExact(ValorCamp, "HH:mm",
			    System.Globalization.CultureInfo.CurrentCulture,
			    System.Globalization.DateTimeStyles.None,
			    out ValorData)) DR[Camp.NomCamp] = ValorCamp;
			else throw new Exception("Camp "
			    + Camp.NomCamp + " no té una hora vàlida");
		    }
		    else
		    {
			if (DateTime.TryParseExact(ValorCamp,
			    Camp.Format,
			    System.Globalization.CultureInfo.CurrentCulture,
			    System.Globalization.DateTimeStyles.None,
			    out ValorData)) DR[Camp.NomCamp] = ValorCamp;
			else throw new Exception("Camp "
			    + Camp.NomCamp + " no té una hora vàlida");
		    }
		}
		else
		{
		    if (Camp.Nulable) DR[Camp.NomCamp] = DBNull.Value;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no permet valors nulls");
		}
		break;
	    case Tipus.datetime:
	    case Tipus.date:
		if (!string.IsNullOrEmpty(ValorCamp))
		{
		    if (DateTime.TryParse(ValorCamp, out ValorData)) DR[Camp.NomCamp] = ValorCamp;
		    else throw new Exception("Camp "
			+ Camp.NomCamp + " no té una data vàlida");
		}
		else
		{
		    if (Camp.Nulable) DR[Camp.NomCamp] = DBNull.Value;
		    else throw new Exception("Camp " + Camp.NomCamp + " no permet valors nulls");
		}
		break;
	    case Tipus.varchar:
	    case Tipus.chr:
	    case Tipus.nchar:
	    case Tipus.nvarchar:
		if (!string.IsNullOrEmpty(ValorCamp))
		{   //Els varchar(max) i nvarchar(max) tenen longitud -1 i no s'ha de verificar la seva longitud.
		    if (ValorCamp.Length > Camp.Longitud && Camp.Longitud != -1)
			throw new Exception("Camp " + Camp.NomCamp + " supera longitud permesa");
		    else DR[Camp.NomCamp] = ValorCamp;
		}
		else
		{
		    if (Camp.Nulable) DR[Camp.NomCamp] = DBNull.Value;
		    else throw new Exception("Camp " + Camp.NomCamp + " no permet valors nulls");
		}
		break;
	}
    }
}

Seguint amb la sèrie de la clsDades aquesta és la funció que s'encarrega d'obtenir de la BBDD una pàgina de registres, ordenats d'una forma determinada i filtrats si cal.

Fa servir la SP QUERY per fer-ho, en realitat la SP és la que fa tota la feina, la clsDades només té la invocació a aquesta SP. Així que ha de fer servir la variable ParamsQUERY per informar-ne els paràmetres, a més a més hi ha uns paràmetres fixes que són:

• SortColumn: Columna per la que s'ordena (haurà de coincidir amb alguna de les que té la SP). En el literal de la columna també està informat el sentit, ascendent o descendent.
• PageSize: Mida de la pàgina, en número de registres, 5, 10, 20...
• PageNum: Número de la pàgina que es vol, la 1, 2, 3...

A més a més d'aquests paràmetres d'entrada la SP té un valor important de sortida que cal recollir, el número total de registres un cop filtrat (sense paginar). Es podria fer amb un COUNT però seria fer el filtre dues vegades, dins de la SP ja es calcula i llavors només es fa un cop. Aquest valor és important per calcular el número total de pàgines donat un filtre a una taula. En la funció és el paràmetre NumTotRegs, que està declarat de sortida. Com sempre el codi:

public DataTable QUERY(Dictionary<string, string> Params, out int NumTotRegs)
{
    SqlDataReader Reader = null;
    DataTable Result = new DataTable();
    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;
    SqlComm.CommandTimeout = 120;
    if (SQLTrans != null) SqlComm.Transaction = SQLTrans;

    foreach (clsCamp Camp in ParamsQUERY)
    {
	SqlParam = CreaParametre(Camp, false);
	if (Params.Keys.Contains(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.CommandType = CommandType.StoredProcedure;

    SqlParameter pSortColumn = new SqlParameter("pSortColumn", SqlDbType.NVarChar, 50);
    pSortColumn.Direction = ParameterDirection.Input;
    pSortColumn.Value = Params["SortColumn"];
    SqlComm.Parameters.Add(pSortColumn);

    SqlParameter pPageSize = new SqlParameter("pPageSize", SqlDbType.Int);
    pPageSize.Direction = ParameterDirection.Input;
    pPageSize.Value = Params["PageSize"];
    SqlComm.Parameters.Add(pPageSize);

    SqlParameter pPageNum = new SqlParameter("pPageNum", SqlDbType.Int);
    pPageNum.Direction = ParameterDirection.Input;
    pPageNum.Value = Params["PageNum"];
    SqlComm.Parameters.Add(pPageNum);

    SqlComm.CommandText = spQUERY;

    Reader = SqlComm.ExecuteReader();

    Result.Load(Reader);

    Reader.Close();

    if (Result.Rows.Count > 0)
    {
	NumTotRegs = int.Parse(Result.Rows[0]["NumRegs"].ToString());
    }
    else
    {
	NumTotRegs = 0;
    }

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

Seguint amb la sèrie de la clsDades aquesta és la funció que s'encarrega de contar quants registres hi ha a la BBDD que compleixin un cert criteri.

Fa servir la SP COUNT per fer-ho. Fa servir els mateixos paràmetres que el GET (que són els mateixos que el QUERY), es a dir es poden aplicar els mateixos criteris de cerca que quan es fa un GET però enlloc d'obtenir registres retorna només el número de registres. Això és útil quan hi ha una barra de progres i es vol saber el número total de registres, o quan s'ha de calcular el número de pàgines...

Fa servir ParamsQUERY per informar els seus paràmetres. La funció només admet un Dictionary per informar els seus paràmetres, no cal que siguin tots, només el que volem filtrar. Com sempre el codi:

public int COUNT(Dictionary<string, string> Params)
{
    SqlCommand SqlComm = new SqlCommand();
    SqlParameter SqlParam;
    bool LocalConn;
    SqlConnection Conn = null;
    int Result = 0;
    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;

    foreach (clsCamp Camp in ParamsQUERY)
    {
	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.CommandType = CommandType.StoredProcedure;
    SqlComm.CommandText = spCOUNT;

    Result = int.Parse(SqlComm.ExecuteScalar().ToString());

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