/// <summary> /// Método static y común a todas las 'Entidades' que devuelve en formato byte[] una imagen de la B.D. /// </summary> /// <param name="campo">Nombre del campo con la imagen.</param> /// <param name="tabla">Nombre de la tabla en la B.D.</param> /// <param name="condicion">Condición en formato SQL de la fila de la que se quiere obtener la imagen.</param> /// <returns>La imagen en formato byte[]. / null.- Si la fila no tiene imagen.</returns> protected static byte[] SelectImage(string campo, string tabla, string condicion) { byte[] foto; using (AccesoSql asql = CrearAccesoSQL()) { foto = asql.SelectFoto(campo, tabla, condicion); } return(foto); }
/// <summary> /// Este método devuelve el nº de filas en la B.D. de tabla que representa la clase 'Entidad'. /// <param name="condicion">Condición para las filas que se deben contar. Si no hay condición, /// se cuentan todas las filas de la Tabla/Entidad.</param> /// </summary> /// <returns>Nº de filas en la base de datos.</returns> public static long TotalFilas <T>(string condicion = "") where T : EntidadSQL, new() { long nFilas = 0; T entidad = new T(); using (AccesoSql asql = CrearAccesoSQL()) { nFilas = asql.TotalFilas(entidad.GetTabla(), condicion); } return(nFilas); }
/// <summary> /// Este método inserta un registro/fila con los valores del objeto 'Entidad' actual en la B.D. y tabla /// correspondientes. /// </summary> /// <param name="_accesoSql">Si es distinto de 'null' se utiliza el objeto AccesoSql recibido como parámetro /// para ejecutar la instrucción, así se mantiene la misma conexión entre varias instrucciones Sql y se permite /// el uso de transacciones Sql entre distintos objetos 'EntidadSql'.</param> /// <returns>True.- Si se pudo realizar la insercción. False.- Si no se pudo realizar la insercción.</returns> protected virtual bool Insertar() { bool cerrarConexion = (transactionSql == null) ? true : false; AccesoSql asql = (transactionSql == null) ? CrearAccesoSQL() : transactionSql.accesoSql; CampoID = asql.Insert(GetTabla(), NombresCamposBD(false), ValoresCamposBD(false)); if (cerrarConexion) {//Si existe un objeto 'TransactionSQL' para este objeto, esta instrucción sql forma parte de una transacción y //comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario. asql.Dispose(); } return(CampoID != -1); }
public static AccesoSql CrearAccesoSQL() {//Crea y devuelve el objeto 'AccesoSQL' según si los datos para la conexión al servidor SQL están en //un archivo de configuración de la aplicación o se recibieron en el constructor de la clase 'Entidad'. AccesoSql asql; if (tipoConex == TipoConexion.Manual) { asql = new AccesoSql(dataSource, initialCatalog, userID, password); } else { asql = (nombreConnectionStringWebConfig == "") ? new AccesoSql() : new AccesoSql(nombreConnectionStringWebConfig); } return(asql); }
public static FilasDB EjecutaSQL(SqlCommand cmdSQL, AccesoSql _accesoSql = null) { FilasDB filas; bool cerrarConexion = (_accesoSql == null) ? true : false; AccesoSql asql = (_accesoSql == null) ? CrearAccesoSQL() : _accesoSql; filas = asql.Ejecuta(cmdSQL); if (cerrarConexion) {//Si se recibió un objeto 'AccesoSql' como parámetro entonces esta instrucción sql forma parte de una transacción o //comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario. asql.Dispose(); } return(filas); }
/// <summary> /// Método static y común a todas las clases 'Entidades' que actualiza un campo en la B.D. con una imagen /// en formato byte[]. /// </summary> /// <param name="campo">Nombre del campo para la imagen</param> /// <param name="tabla">Nombre de la tabla en la B.D.</param> /// <param name="condicion">Condición en formato SQL de la fila/filas donde se quiere modificar la imagen.</param> /// <param name="image">La imagen en formato byte[].</param> /// <param name="_accesoSql">Si es distinto de 'null' se utiliza el objeto AccesoSql recibido como parámetro /// para ejecutar la instrucción, así se mantiene la misma conexión entre varias instrucciones Sql y se permite /// el uso de transacciones Sql entre distintos objetos 'EntidadSql'. /// </param> /// <returns>True.- Si se consiguió actualizar el campo de la imagen en la B.D. /// False.- Si no se consiguió actualizar el campo de la imagen en la B.D.</returns> protected static bool UpdateImage(string campo, string tabla, string condicion, byte[] image, AccesoSql _accesoSql = null) { bool todoOK; bool cerrarConexion = (_accesoSql == null) ? true : false; AccesoSql asql = (_accesoSql == null) ? CrearAccesoSQL() : _accesoSql; todoOK = asql.UpdateFoto(campo, tabla, condicion, image); if (cerrarConexion) {//Si se recibió un objeto 'AccesoSql' como parámetro, esta instrucción sql forma parte de una transacción y //comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario. asql.Dispose(); } return(todoOK); }
/// <summary> /// Este método borra el registro/fila de la B.D. correspondiente a esta clase 'Entidad' (mismo Id). /// </summary> /// <param name="_accesoSql">Si es distinto de 'null' se utiliza el objeto AccesoSql recibido como parámetro /// para ejecutar la instrucción, así se mantiene la misma conexión entre varias instrucciones Sql y se permite /// el uso de transacciones Sql entre distintos objetos 'EntidadSql'. /// </param> /// <returns>True.- Se pudo borrar el registro de la B.D. False.- No se pudo borrar el registro en la B.D.</returns> public virtual bool Borrar() { int nRegs; CadenaParametro condicion = new CadenaParametro(NombreCampoID(), "=", CampoID); bool cerrarConexion = (transactionSql == null) ? true : false; AccesoSql asql = (transactionSql == null) ? CrearAccesoSQL() : transactionSql.accesoSql; nRegs = asql.Delete(GetTabla(), condicion); if (cerrarConexion) {//Si existe un objeto 'TransactionSQL' para este objeto, esta instrucción sql forma parte de una transacción y //comparte conexión con otras, por eso solo se cierra la conexión a la B.D. en caso contrario. asql.Dispose(); } return(nRegs > 0); }
/// <summary> /// Método static y genérico que realiza una consulta en la tabla de la B.D. correspondiente al tipo /// de clase 'Entidad' recibida como parámetro genérico. /// </summary> /// <typeparam name="T">Clase derivada de 'EntidadSQL' y que defina un constructor por defecto.</typeparam> /// <param name="condicion">string con la condicion en formato SQL para seleccionar la/s filas /// de la tabla correspondiente en la B.D.</param> /// <param name="orderByCampo">Nombre del campo por el que se deben de ordenar la filas devueltas /// por la consulta.</param> /// <returns>Objeto List del tipo genérico recibido como parámetro en el método."/></returns> protected static List <T> Listar <T>(string orderByCampo = "", params CadenaParametro[] condicion) where T : EntidadSQL, new() { List <T> filasConsulta = new List <T>(); FilasDB filas; T entidad = new T(); using (AccesoSql asql = CrearAccesoSQL()) { filas = asql.Select(entidad.GetTabla(), entidad.NombresCamposBD(true), orderByCampo, condicion); } foreach (Object[] item in filas) { T newEntidad = new T(); newEntidad.AsignarValorCamposBD(item, true); filasConsulta.Add(newEntidad); } return(filasConsulta); }
/// <summary> /// Método static y genérico que realiza una consulta en la tabla de la B.D. corespondiente al tipo /// de la clase 'Entidad' recibida como parámetro genérico pero seleccionando solo aquellas filas cuya /// posición esté dentro de los parámetros 'posIni' y 'posFin'. /// </summary> /// <typeparam name="T">Clase derivada de 'EntidadSQL' y que defina un constructor por defecto.</typeparam> /// <param name="posIni">Indica la posición de la primera fila resultado de la consulta.</param> /// <param name="posFin">Indica la posición de la última fila resultado de la consulta.</param> /// <param name="condicion">Solo se enumerarán aquellas filas que cumplan la condición indicada. Si no hay /// condición, se seleccionan todas las filas dentro del margen de posición indicado.</param> /// <param name="orderCampo">Nombre del campo de la tabla por el que se ordenarán las filas. Si es igual a /// "" no se ordenará por ningún campo y se respetará la posición de las filas en B.D.</param> /// <param name="orderAsc">True: Se ordenan las filas de menor a mayor por el campo indicado. /// False: Se ordenan las filas de mayor a menor por el campo indicado.</param> /// <returns></returns> protected static List <T> ListarPage <T>(int posIni, int posFin, string condicion = "", string orderCampo = "", bool orderAsc = true) where T : EntidadSQL, new() { List <T> filasConsulta = new List <T>(); FilasDB filas; T entidad = new T(); using (AccesoSql asql = CrearAccesoSQL()) { filas = asql.SelectPage(entidad.GetTabla(), entidad.NombresCamposBD(true), posIni, posFin, condicion, orderCampo, orderAsc); } foreach (Object[] item in filas) { T newEntidad = new T(); newEntidad.AsignarValorCamposBD(item, true); filasConsulta.Add(newEntidad); } return(filasConsulta); }
/// <summary> /// Este método crea el objeto 'AccesoSql' con una conexión abierta y una transacción. Se asigna dicho objeto al campo /// 'accesoSql' de todos los objetos derivados de la clase 'EntidadSQL' en la lista 'EntidadesSql'. /// </summary> /// <returns></returns> private void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted) { _accesoSql = EntidadSQL.CrearAccesoSQL(); _accesoSql.BeginTransaction(isolationLevel); }