Biblioteca de Utilidades XF.net para Desarrollo Industrial

La biblioteca XF.net es una colección de utilidades que he desarrollado a lo largo de mi carrera profesional, encapsulando funcionalidades comunes para facilitar el desarrollo de aplicaciones idnustriales. Esta biblioteca incluye:

  • Funciones generales como copia profunda de objetos, cifrado/descifrado, serialización/deserialización, compresión/descompresión, etc.
  • Funcionalidades específicas para la industria de control como lectura de archivos DBC, aálisis de mensajes de comunicación, programación de sisteams BMS, acceso a bases de datos, etc.

Si en tu trabajo diario de desarrollo de código te encuentras con estas necesidades, esta biblioteca puede simplificar tu trabajo, abstrayendo los detalles complejos. A continuación, presento ejemplos de uso en estas dos áreas principales.

Instalación de la Biblioteca

Para comenzar, instala la biblioteca XF.net a través del gestor de paquetes NuGet en Visual Studio:

1. Protocolos de Comunicación y Mensajes

1.1. Lectura de Archivos DBC

Los archivos DBC (Database CAN) se utilizan para definir la estructura de mensajes en redes CAN. A continuación se muestra un ejemplo de archivo DBC:


BO_ 123 VehicleStatus: 8 ECU1
SG_ Speed : 0|16@0+ (0.1,0) [0|255] "km/h" ECU1
SG_ EngineRPM : 16|16@0+ (1,0) [0|65535] "RPM" ECU1
SG_ FuelLevel : 32|8@0+ (0.5,0) [0|100] "%" ECU1
CM_ BO_ 123 "Mensaje de estado del vehículo"
CM_ SG_ Speed "Señal de velocidad"
CM_ SG_ EngineRPM "Señal de RPM del motor"
CM_ SG_ FuelLevel "Señal de nivel de combustible"

BO_ 456 DiagnosticData: 8 ECU2
SG_ ErrorCode : 0|32@0+ (1,0) [0|4294967295] "Sin signo" ECU2
CM_ BO_ 456 "Mensaje de datos de diagnóstico"
CM_ SG_ ErrorCode "Código de error"

Para leer este archivo DBC utilizando la biblioteca XF.net:


private static void LeerArchivoDbc()
{
    System.Text.Encoding encoding = System.Text.Encoding.UTF8;
    
    // Instanciar el lector de archivos DBC
    var lectorDbc = new LectorDbc();
    
    // Leer el archivo DBC con una sola línea de código
    var listaMensajes = lectorDbc.AbrirYLeerMensajes(@"C:\Ruta\Al\Archivo.dbc", "", ref encoding, true, out var contenidoDbc);
    
    // Convertir a JSON para visualización
    Console.WriteLine(UtilesJson.ConvertirAJson(listaMensajes, false, true));
}

1.2. Análisis de Parámetros de Mensajes DBC

Una vez leído el archivo DBC, puedes analizar los mensajes recibidos:


/// <summary>
/// Analiza los parámetros de un mensaje DBC
/// </summary>
private static void AnalizarParametrosDbc()
{
    // Crear un mensaje de prueba
    var mensajePrueba = new ModeloMensaje() { 
        ID = 123, 
        Datos = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 } 
    };
    
    // Diccionario para almacenar los parámetros analizados
    var diccionarioParametros = new ConcurrentDictionary<string double="">();
    
    // Analizar el mensaje
    if (AnalizadorDbc.AnalizarSenialDbc(
        new LectorDbc().AbrirYLeerMensajes(@"C:\Ruta\Al\Archivo.dbc", "", ref _encoding, true, out _).First().ListaSeniales,
        mensajePrueba,
        diccionarioParametros))
    {
        // Mostrar resultados
        foreach (var parametro in diccionarioParametros)
        {
            Console.WriteLine($"Parámetro: {parametro.Key}, Valor: {parametro.Value}");
        }
    }
}
</string>

1.3. Análisis Personalizado de Parámetros de Mensajes

La biblioteca también permite analizar parámetros que abarcan múltiples bits:


/// <summary>
/// Analiza parámetros de mensajes personalizados
/// </summary>
public static void AnalizarParametrosMensaje()
{
    var datos = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
    
    Console.WriteLine($"Valor sin signo (bit 9-20, coef:1, offset:0, little-endian): " +
        $"{AnalizadorProtocolo.AnalizarBit(datos, 9, 12, 1, 0, false)}");
    
    Console.WriteLine($"Valor con signo (bit 9-20, coef:1, offset:0, big-endian): " +
        $"{AnalizadorProtocolo.AnalizarBitConSigno(datos, 9, 12, 1, 0, true)}");
    
    Console.WriteLine($"Valor Float (bit 9-32, coef:1, offset:0, little-endian): " +
        $"{AnalizadorProtocolo.AnalizarFloat(datos, 9, 32, 1, 0, false)}");
    
    Console.WriteLine($"Valor Double (bit 0-63, coef:1, offset:0, little-endian): " +
        $"{AnalizadorProtocolo.AnalarDouble(datos, 0, 64, 1, 0, false)}");
}

1.4. Actualización de Datos de Mensajes

Puedes modificar los datos de un mensaje específico:


/// <summary>
/// Actualiza los datos de un mensaje
/// </summary>
private static void ActualizarDatosMensaje()
{
    var datos = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
    Console.WriteLine($"Mensaje ANTES: {BitConverter.ToString(datos)}");
    
    // Actualizar bits específicos
    AnalizadorProtocolo.ConvertirIntEnBit(datos, 6, 10, 66, true);
    Console.WriteLine($"Mensaje DESPUÉS (bits 6-15 actualizados): {BitConverter.ToString(datos)}");
}

1.5. Programación de BMS/ECU mediante UDS

La biblioteca incluye herramientas para programar dispositivos mediante el protocolo UDS (Unified Diagnostic Services):


namespace XF.net.ProgramacionBms
{
    /// <summary>
    /// Lee datos HEX de archivos ASC para programación BMS
    /// </summary>
    public class LectorHexAsc
    {
        /// <summary>
        /// Método principal para leer datos de programación
        /// </summary>
        /// <param name="rutaArchivo"></param>Ruta al archivo
        /// <param name="desbloqueoSeguridad"></param>Acción de desbloqueo de seguridad
        /// <param name="ejecucionDescarga"></param>Acción durante la transferencia de archivos
        /// <param name="idFuncion"></param>ID de función CAN
        /// <param name="idFisico"></param>ID CAN físico
        /// <param name="respuestaBms"></param>ID de respuesta BMS
        /// <returns>Lista de modelos de mensajes de programación</returns>
        public virtual List<modelomensajeprogramacion> Leer(
            string rutaArchivo,
            Action<modelomensajeprogramacion> desbloqueoSeguridad,
            Action<modelomensajeprogramacion> ejecucionDescarga,
            uint idFuncion = 0x7DF,
            uint idFisico = 0x7C0,
            uint respuestaBms = 0x7C8)
            
        /// <summary>
        /// Inicia sesión extendida
        /// </summary>
        public virtual void IniciarSesionExtendida(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Detiene la comprobación DTC
        /// </summary>
        public virtual void DetenerDTC(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Deshabilita comunicación no diagnóstica
        /// </summary>
        public virtual void DeshabilitarComunicacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Inicia sesión de programación
        /// </summary>
        public virtual void IniciarSesionProgramacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Escribe huella digital
        /// </summary>
        public virtual void EscribirHuellaDigital(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Escribe fecha de programación
        /// </summary>
        public virtual void EscribirFechaProgramacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Borra memoria de software de aplicación
        /// </summary>
        public virtual void BorrarMemoriaSoftwareAplicacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Descarga software de aplicación
        /// </summary>
        public virtual void DescargarSoftwareAplicacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, Action<modelomensajeprogramacion> ejecucionDescarga, float progreso)
        
        /// <summary>
        /// Verifica integridad de datos de aplicación
        /// </summary>
        public virtual void VerificarIntegridadDatosAplicacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Verifica dependencias de datos de aplicación
        /// </summary>
        public virtual void VerificarDependenciasDatosAplicacion(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Reinicia ECU
        /// </summary>
        public virtual void ReiniciarEcu(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Inicia configuración de DTC
        /// </summary>
        public virtual void IniciarConfiguracionDTC(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Entra en sesión por defecto
        /// </summary>
        public virtual void EntrarSesionPorDefecto(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
        
        /// <summary>
        /// Limpia DTC
        /// </summary>
        public virtual void LimpiarDTC(string[] datos, List<modelomensajeprogramacion> lista, uint idFuncion, uint idFisico, uint respuestaBms, float progreso)
    }
}
</modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion></modelomensajeprogramacion>

2. Utilidades Comunes

2.1. Serialización JSON

La biblioteca proporciona utilidades para trabajar con JSON:


namespace XF.net.Utilidades.Json
{
    /// <summary>
    /// Extensiones para JSON con System.Text.Json
    /// </summary>
    public static class ExtensionesJsonSystemText
    {
        /// <summary>
        /// Serializa un objeto a JSON
        /// </summary>
        /// <param name="objeto"></param>Objeto a serializar
        /// <param name="indentado"></param>Si el JSON debe estar indentado
        /// <returns>Cadena JSON</returns>
        public static string SerializarJson(this objeto objeto, bool indentado = false)
        
        /// <summary>
        /// Deserializa una cadena JSON a un objeto
        /// </summary>
        /// <typeparam name="T">Tipo del objeto resultante</typeparam>
        /// <param name="json"></param>Cadena JSON
        /// <returns>Objeto deserializado</returns>
        public static T DeserializarJson<t>(this string json)
        
        /// <summary>
        /// Serializa un objeto a matriz de bytes JSON
        /// </summary>
        /// <param name="objeto"></param>Objeto a serializar
        /// <param name="indentado"></param>Si el JSON debe estar indentado
        /// <returns>Matriz de bytes JSON</returns>
        public static byte[] SerializarJsonBytes(this objeto objeto, bool indentado = false)
        
        /// <summary>
        /// Deserializa una matriz de bytes JSON a un objeto
        /// </summary>
        /// <typeparam name="T">Tipo del objeto resultante</typeparam>
        /// <param name="jsonBytes"></param>Matriz de bytes JSON
        /// <returns>Objeto deserializado</returns>
        public static T DeserializarJson<t>(this byte[] jsonBytes)
    }
}
</t></t>

2.2. Serialización XML

Para trabajar con XML, la biblioteca ofrece estas extensiones:


namespace XF.net.Utilidades.Xml
{
    /// <summary>
    /// Extensiones para serialización XML
    /// </summary>
    public static class ExtensionesXml
    {
        /// <summary>
        /// Serializa un objeto a XML
        /// </summary>
        /// <param name="objeto"></param>Objeto a serializar
        /// <returns>Cadena XML</returns>
        public static string SerializarXml(this objeto objeto)
        
        /// <summary>
        /// Deserializa una cadena XML a un objeto
        /// </summary>
        /// <typeparam name="T">Tipo del objeto resultante</typeparam>
        /// <param name="xml"></param>Cadena XML
        /// <returns>Objeto deserializado</returns>
        public static T DeserializarXml<t>(this string xml)
        
        /// <summary>
        /// Deserializa una cadena XML a un objeto
        /// </summary>
        /// <param name="xml"></param>Cadena XML
        /// <param name="tipo"></param>Tipo del objeto resultante
        /// <returns>Objeto deserializado</returns>
        public static objeto DeserializarXml(this string xml, Tipo tipo)
    }
}
</t>

2.3. Compresión ZIP

La biblioteca incluye herramientas para trabajar con archivos ZIP:


namespace XF.net.Utilidades.Comunes
{
    /// <summary>
    /// Utilidades para manejar archivos ZIP
    /// </summary>
    public static class AyudanteZip
    {
        /// <summary>
        /// Extrae archivos de un ZIP a un directorio
        /// </summary>
        /// <param name="rutaZip"></param>Ruta al archivo ZIP
        /// <param name="rutaDestino"></param>Directorio de destino
        public static void ExtraerArchivos(string rutaZip, string rutaDestino)
        
        /// <summary>
        /// Lee un ZIP en un diccionario en memoria
        /// </summary>
        /// <param name="rutaZip"></param>Ruta al archivo ZIP
        /// <returns>Lista de tuplas con nombre de archivo y contenido</returns>
        public static List<tuple byte="">> Leer(string rutaZip)
        
        /// <summary>
        /// Comprime un directorio en un archivo ZIP
        /// </summary>
        /// <param name="rutaDirectorio"></param>Directorio a comprimir
        /// <param name="rutaZip"></param>Ruta del archivo ZIP resultante
        public static void Comprimir(string rutaDirectorio, string rutaZip)
        
        /// <summary>
        /// Crea un ZIP a partir de archivos en memoria
        /// </summary>
        /// <param name="archivos"></param>Lista de tuplas con nombre y contenido
        /// <param name="rutaZip"></param>Ruta del archivo ZIP resultante
        public static void Comprimir(List<tuple byte="">> archivos, string rutaZip)
        
        /// <summary>
        /// Crea un ZIP a partir de una lista de archivos
        /// </summary>
        /// <param name="archivos"></param>Lista de archivos a comprimir
        /// <param name="rutaZip"></param>Ruta del archivo ZIP resultante
        public static void Comprimir(List<tuple objeto="">> archivos, string rutaZip)
    }
}
</tuple></tuple></tuple>

2.4. Conversiones de Estructuras

Para trabajar con estructuras y bytes:


namespace XF.net.Utilidades.Comunes
{
    /// <summary>
    /// Herramientas para conversiones de estructuras
    /// </summary>
    public static class AyudanteEstructuras
    {
        /// <summary>
        /// Convierte una estructura a matriz de bytes
        /// </summary>
        /// <typeparam name="T">Tipo de la estructura</typeparam>
        /// <param name="estructura"></param>Estructura a convertir
        /// <returns>Matriz de bytes resultante</returns>
        public static byte[] EstructuraABytes<t>(T estructura)
        
        /// <summary>
        /// Convierte una matriz de bytes a una estructura
        /// </summary>
        /// <typeparam name="T">Tipo de la estructura</typeparam>
        /// <param name="bytes"></param>Matriz de bytes
        /// <returns>Estructura resultante</returns>
        public static T BytesAEstructura<t>(byte[] bytes)
        
        /// <summary>
        /// Convierte una matriz de bytes a una estructura con tamaño específico
        /// </summary>
        /// <typeparam name="T">Tipo de la estructura</typeparam>
        /// <param name="bytes"></param>Matriz de bytes
        /// <param name="tamano"></param>Tamaño de la estructura
        /// <returns>Estructura resultante</returns>
        public static T BytesAEstructura<t>(byte[] bytes, int tamano)
    }
}
</t></t></t>

2.5. Conversiones de Datos

Para conversiones entre diferentes tipos de datos:


namespace XF.net.Utilidades.Comunes
{
    public class CalculadorDatos
    {
        /// <summary>
        /// Convierte un long a matriz de bytes
        /// Para valores flotantes, multiplica por el coeficiente primero
        /// </summary>
        /// <param name="valor"></param>Valor a convertir
        /// <param name="longitud"></param>Longitud de la matriz resultante
        /// <returns>Matriz de bytes</returns>
        public static byte[] LongABytes(long valor, int longitud)
        
        /// <summary>
        /// Convierte un int a matriz de bytes
        /// </summary>
        /// <param name="valor"></param>Valor a convertir
        /// <param name="longitud"></param>Longitud de la matriz resultante
        /// <returns>Matriz de bytes</returns>
        public static byte[] IntABytes(int valor, int longitud)
        
        /// <summary>
        /// Convierte una matriz de bytes a int
        /// </summary>
        /// <param name="datos"></param>Matriz de bytes
        /// <returns>Valor int resultante</returns>
        public static int BytesAInt(byte[] datos)
        
        /// <summary>
        /// Convierte una parte de una matriz de bytes a int
        /// </summary>
        /// <param name="datos"></param>Matriz de bytes
        /// <param name="indice"></param>Índice inicial
        /// <param name="longitud"></param>Longitud a convertir
        /// <returns>Valor int resultante</returns>
        public static int BytesAInt(byte[] datos, int indice, int longitud)
        
        /// <summary>
        /// Convierte una parte de una lista de bytes a int
        /// </summary>
        /// <param name="datos"></param>Lista de bytes
        /// <param name="indice"></param>Índice inicial
        /// <param name="longitud"></param>Longitud a convertir
        /// <returns>Valor int resultante</returns>
        public static int BytesAInt(List<byte> datos, int indice, int longitud)
        
        /// <summary>
        /// Convierte una parte de una matriz de bytes a long
        /// </summary>
        /// <param name="datos"></param>Matriz de bytes
        /// <param name="indice"></param>Índice inicial
        /// <param name="longitud"></param>Longitud a convertir
        /// <returns>Valor long resultante</returns>
        public static long BytesALong(byte[] datos, int indice, int longitud)
        
        /// <summary>
        /// Convierte una matriz de bytes completa a long
        /// </summary>
        /// <param name="datos"></param>Matriz de bytes
        /// <returns>Valor long resultante</returns>
        public static long BytesALong(byte[] datos)
    }
}
</byte>

2.6. Suma de Verificación CRC16

Para calcular sumas de verificación CRC:


namespace XF.net.Utilidades.Comunes
{
    public static class CalculadorChecksum
    {
        /// <summary>
        /// Calcula checksum CRC16
        /// </summary>
        /// <param name="buffer"></param>Buffer a verificar
        /// <param name="indice"></param>Índice inicial
        /// <param name="longitud"></param>Longitud a procesar
        /// <param name="crcAlto"></param>Byte alto del resultado
        /// <param name="crcBajo"></param>Byte bajo del resultado
        public static void CalcularCrc16(IEnumerable<byte> buffer, int indice, int longitud, out byte crcAlto, out byte crcBajo)
    }
}
</byte>

2.7. Gestión de Piscinas de Arrays

Para optimizar el uso de memoria con arrays reutilizables:


namespace XF.net.Utilidades.Comunes
{
    public static class AdministradorArrayPool
    {
        /// <summary>
        /// Alquila un array de 8 bytes
        /// </summary>
        /// <returns>Array de 8 bytes</returns>
        public static byte[] AlquilarArray8()
        
        /// <summary>
        /// Alquila un array de 64 bytes
        /// </summary>
        /// <returns>Array de 64 bytes</returns>
        public static byte[] AlquilarArray64()
        
        /// <summary>
        /// Alquila un array de 72 bytes
        /// </summary>
        /// <returns>Array de 72 bytes</returns>
        public static byte[] AlquilarArray72()
        
        /// <summary>
        /// Alquila un array de tamaño específico
        /// </summary>
        /// <param name="longitud"></param>Longitud del array
        /// <returns>Array del tamaño solicitado</returns>
        public static byte[] AlquilarArray(int longitud)
        
        /// <summary>
        /// Devuelve un array a la piscina
        /// </summary>
        /// <param name="array"></param>Array a devolver
        public static void Devolver(this byte[] array)
    }
}

2.8. Cliente TCP

Para comunicación mediante TCP:


namespace XF.net.Puertos
{
    /// <summary>
    /// Cliente TCP
    /// </summary>
    public class ClienteTcp : System.IDisposable
    {
        /// <summary>
        /// Indica si está conectado
        /// </summary>
        public bool EstaConectado
        
        /// <summary>
        /// Conecta al servidor TCP
        /// </summary>
        /// <param name="ip"></param>Dirección IP
        /// <param name="puerto"></param>Puerto
        /// <param name="recibido"></param>Acción al recibir datos
        /// <param name="error"></param>Acción al ocurrir un error
        /// <returns>Si la conexión fue exitosa</returns>
        public bool Conectar(string ip, int puerto, Action<string byte=""> recibido, Action<exception string=""> error)
        
        /// <summary>
        /// Envía datos
        /// </summary>
        /// <param name="datos"></param>Datos a enviar
        public void Enviar(byte[] datos)
        
        /// <summary>
        /// Libera recursos
        /// </summary>
        public void Dispose()
    }
}
</exception></string>

2.9. Ayudante para SQL Server

Para interactuar con bases de datos SQL Server:


namespace XF.net.ContextoBaseDatos
{
    /// <summary>
    /// Ayudante para SQL Server
    /// </summary>
    public class AyudanteSqlServer : IAyudanteBaseDatos
    {
        /// <summary>
        /// Inicia una transacción
        /// </summary>
        /// <param name="nivelAislamiento"></param>Nivel de aislamiento
        /// <returns>Transacción iniciada</returns>
        public override DbTransaction IniciarTransaccion(IsolationLevel nivelAislamiento)
        
        /// <summary>
        /// Establece conexión con la base de datos
        /// </summary>
        public override void Conectar()
        
        /// <summary>
        /// Establece conexión con la base de datos
        /// </summary>
        /// <param name="cadenaConexion"></param>Cadena de conexión
        public override void Conectar(string cadenaConexion)
        
        /// <summary>
        /// Crea un comando de consulta
        /// </summary>
        /// <returns>Comando creado</returns>
        public override DbCommand CrearComando()
        
        /// <summary>
        /// Libera recursos
        /// </summary>
        public override void Dispose()
        
        /// <summary>
        /// Ejecuta una consulta no select
        /// </summary>
        /// <param name="sql"></param>Consulta SQL
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <param name="tiempoEspera"></param>Tiempo de espera en segundos
        /// <returns>Si la ejecución fue exitosa</returns>
        public override bool EjecutarNonQuery(string sql, bool liberar = true, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Ejecuta una consulta y devuelve el primer valor
        /// </summary>
        /// <param name="sql"></param>Consulta SQL
        /// <param name="tiempoEspera"></param>Tiempo de espera en segundos
        /// <returns>Primer valor resultante</returns>
        public override object EjecutarScalar(string sql, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Ejecuta una consulta y devuelve un DataTable
        /// </summary>
        /// <param name="sql"></param>Consulta SQL
        /// <param name="nombreTabla"></param>Nombre de la tabla resultante
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <param name="tiempoEspera"></param>Tiempo de espera en segundos
        /// <returns>DataTable con los resultados</returns>
        public override DataTable ADataTable(string sql, string nombreTabla = "xf-tab", bool liberar = true, int tiempoEspera = TiempoEsperaComando)
    }
}

2.10. Ayudante para SQLite

Para interactuar con bases de datos SQLite:


namespace XF.net.ContextoBaseDatos
{
    /// <summary>
    /// Ayudante para SQLite
    /// </summary>
    public class AyudanteSqlite : IAyudanteBaseDatos
    {
        /// <summary>
        /// Constructor
        /// </summary>
        public AyudanteSqlite()
        
        /// <summary>
        /// Crea un archivo de base de datos
        /// </summary>
        /// <param name="nombreArchivoBaseDatos"></param>Nombre del archivo
        public static void CrearArchivo(string nombreArchivoBaseDatos)
        
        /// <summary>
        /// Establece conexión con la base de datos
        /// </summary>
        public override void Conectar()
        
        /// <summary>
        /// Establece conexión con la base de datos
        /// </summary>
        /// <param name="nombreArchivoBaseDatos"></param>Nombre del archivo
        public override void Conectar(string nombreArchivoBaseDatos)
        
        /// <summary>
        /// Ejecuta una consulta no select
        /// </summary>
        /// <param name="sql"></param>Consulta SQL
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <param name="tiempoEspera"></param>Tiempo de espera en segundos
        /// <returns>Si la ejecución fue exitosa</returns>
        public override bool EjecutarNonQuery(string sql, bool liberar = true, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Ejecuta una consulta dentro de una transacción
        /// </summary>
        /// <param name="nombreArchivoBaseDatos"></param>Nombre del archivo
        /// <param name="sql"></param>Consulta SQL
        /// <param name="transaccion"></param>Transacción existente
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <returns>Si la ejecución fue exitosa</returns>
        public bool EjecutarNonQuery(string nombreArchivoBaseDatos, string sql, SqliteTransaction transaccion, bool liberar = true, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Ejecuta una consulta y devuelve un DataTable
        /// </summary>
        /// <param name="sql"></param>Consulta SQL
        /// <param name="nombreTabla"></param>Nombre de la tabla resultante
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <returns>DataTable con los resultados</returns>
        public override DataTable ADataTable(string sql, string nombreTabla = "xf-tab", bool liberar = true, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Crea un comando SQL
        /// </summary>
        /// <returns>Comando creado</returns>
        public override DbCommand CrearComando()
        
        /// <summary>
        /// Inicia una transacción
        /// </summary>
        /// <param name="nivelAislamiento"></param>Nivel de aislamiento
        /// <returns>Transacción iniciada</returns>
        public override DbTransaction IniciarTransaccion(IsolationLevel nivelAislamiento)
        
        /// <summary>
        /// Ejecuta una consulta y devuelve un DataTable soportando valores nulos
        /// </summary>
        /// <param name="nombreArchivoBaseDatos"></param>Nombre del archivo
        /// <param name="sql"></param>Consulta SQL
        /// <param name="nombreTabla"></param>Nombre de la tabla resultante
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <returns>DataTable con los resultados</returns>
        public DataTable ADataTableConNulos(string nombreArchivoBaseDatos, string sql, string nombreTabla = "xf-tab", bool liberar = true, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Ejecuta una consulta y devuelve un DataTable soportando valores nulos
        /// </summary>
        /// <param name="conexion"></param>Conexión existente
        /// <param name="sql"></param>Consulta SQL
        /// <param name="nombreTabla"></param>Nombre de la tabla resultante
        /// <param name="liberar"></param>Si debe liberar recursos al finalizar
        /// <returns>DataTable con los resultados</returns>
        public DataTable ADataTableConNulos(SqliteConnection conexion, string sql, string nombreTabla = "xf-tab", bool liberar = true, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Ejecuta una consulta y devuelve el primer valor
        /// </summary>
        /// <param name="sql"></param>Consulta SQL
        /// <param name="tiempoEspera"></param>Tiempo de espera en segundos
        /// <returns>Primer valor resultante</returns>
        public override object EjecutarScalar(string sql, int tiempoEspera = TiempoEsperaComando)
        
        /// <summary>
        /// Libera recursos
        /// </summary>
        public override void Dispose()
        
        /// <summary>
        /// Libera piscinas de conexiones
        /// </summary>
        public static void LimpiarTodasLasPiscinas()
    }
}

Etiquetas: XF.net .NET C# comunicación industrial DBC

Publicado el 7-11 04:51

Etiquetas populares

©2026 Friki Work