Desarrollo de Aplicaciones Cliente-Servidor

· · ✦ · ·

El modelo cliente-servidor es uno de los paradigmas más influyentes en el desarrollo de software moderno. Detrás de prácticamente toda aplicación empresarial — desde un sistema de inventario hasta una plataforma bancaria — existe una arquitectura donde los clientes solicitan servicios y los servidores los proveen, comunicándose a través de redes y protocolos bien definidos.

Concepto y arquitectura cliente-servidor

Definición

La arquitectura cliente-servidor es un modelo de diseño de software en el que las tareas y la carga de trabajo se distribuyen entre proveedores de recursos o servicios (servidores) y los que los solicitan (clientes). El cliente y el servidor se comunican a través de una red utilizando un protocolo de comunicación común. — Tanenbaum, A. S., Distributed Systems, 2017

En este modelo, los roles están claramente definidos. El cliente es la aplicación que el usuario final utiliza — puede ser una aplicación de escritorio Windows Forms, una aplicación web o una app móvil. El servidor es el sistema que centraliza los datos y la lógica de negocio, típicamente SQL Server en el entorno que trabajamos.

Las ventajas más significativas de este modelo frente a las aplicaciones monolíticas son:

Centralización de datos: un único servidor garantiza que todos los clientes trabajan con la misma información actualizada
Escalabilidad: es posible agregar más clientes sin modificar el servidor
Mantenimiento simplificado: las actualizaciones de lógica de negocio se aplican en el servidor y se propagan a todos los clientes automáticamente
Seguridad: el control de acceso se gestiona de manera centralizada en el servidor

Capas de la aplicación

La arquitectura cliente-servidor moderna se organiza en tres capas bien diferenciadas, cada una con una responsabilidad específica. Esta separación — conocida como arquitectura de tres capas o three-tier architecture — es el estándar en el desarrollo de aplicaciones empresariales con C# y SQL Server.

🖥️

Capa de Presentación

Cliente

Interfaz de usuario

Es la capa con la que interactúa directamente el usuario. Se encarga exclusivamente de mostrar la información y capturar las acciones del usuario, sin contener lógica de negocio ni acceso a datos.

Formularios Windows Forms (Form, DataGridView, TextBox, Button)
Validación básica de entradas del usuario
Llamadas a la capa de negocio para obtener o enviar datos
Presentación de resultados y mensajes al usuario

⚙️

Capa de Negocio

Lógica

Reglas y procesos del negocio

Contiene toda la lógica que define el comportamiento de la aplicación: cálculos, validaciones de negocio, flujos de trabajo y decisiones. Actúa como intermediaria entre la presentación y los datos.

Clases de entidad que representan los objetos del dominio (Producto, Cliente, Factura)
Validaciones de negocio (stock mínimo, precios negativos, duplicados)
Cálculos y transformaciones de datos antes de persistirlos
Coordinación de múltiples operaciones de datos en una sola transacción

🗄️

Capa de Datos

Servidor

Acceso y persistencia de datos

Gestiona toda la comunicación con SQL Server. Contiene el código ADO.NET para ejecutar consultas y procedimientos almacenados, y es la única capa que conoce los detalles de la base de datos.

Clases DAO (Data Access Object) por entidad: ProductoDAO, ClienteDAO
Gestión de conexiones SqlConnection con bloques using
Ejecución de comandos SQL y procedimientos almacenados
Conversión de resultados SqlDataReader a objetos de la capa de negocio

III

Comunicación cliente-servidor

En el contexto de aplicaciones de escritorio C# con SQL Server, la comunicación entre el cliente (Windows Forms) y el servidor (SQL Server) ocurre a través del protocolo TDS (Tabular Data Stream), el protocolo propietario de Microsoft para la comunicación con SQL Server, gestionado de forma transparente por ADO.NET.

Modo 1

Conexión directa

El cliente establece una conexión directa con SQL Server mediante SqlConnection. Es el modelo más simple y adecuado para aplicaciones de escritorio en red local.

Latencia mínima en red local
Ideal para aplicaciones LAN empresariales
Gestión de conexiones con Connection Pooling

Modo 2

Capa intermedia (API)

El cliente se comunica con un servidor de aplicaciones (Web API REST) que a su vez accede a SQL Server. Adecuado para aplicaciones distribuidas o acceso remoto.

Mayor seguridad — SQL Server no expuesto directamente
Escalabilidad para múltiples tipos de clientes
Comunicación mediante JSON sobre HTTP/HTTPS

Connection Pooling — ADO.NET

ADO.NET gestiona automáticamente un pool de conexiones: cuando se cierra una SqlConnection, la conexión física no se destruye sino que regresa al pool para ser reutilizada por la próxima solicitud. Esto mejora significativamente el rendimiento en aplicaciones con muchos usuarios simultáneos.

Implementación con C# y SQL Server

La estructura de carpetas recomendada para una aplicación cliente-servidor de tres capas en C# Windows Forms es la siguiente:

    Estructura del proyecto
MiAplicacion/
├── Models/              ← Capa de Negocio: clases entidad
│   ├── Producto.cs
│   └── Cliente.cs
├── Data/                ← Capa de Datos: acceso a BD
│   ├── Conexion.cs
│   ├── ProductoDAO.cs
│   └── ClienteDAO.cs
├── Forms/               ← Capa de Presentación: formularios
│   ├── FrmProductos.cs
│   └── FrmClientes.cs
└── App.config           ← Cadena de conexión centralizada
  

A continuación se muestra la implementación completa de cada capa para la entidad Producto:

    C# — Models/Producto.cs · Capa de negocio
public class Producto
{
    public int     Id     { get; set; }
    public string  Nombre { get; set; }
    public decimal Precio { get; set; }
    public int     Stock  { get; set; }
 
    // Regla de negocio: un producto no puede tener precio negativo
    public bool EsValido()
    {
        return !string.IsNullOrEmpty(Nombre)
            && Precio >= 0
            && Stock  >= 0;
    }
}
  

    C# — Data/Conexion.cs · Cadena de conexión centralizada
public static class Conexion
{
    public static string CadenaConexion =>
        ConfigurationManager
            .ConnectionStrings["MiBaseDatos"]
            .ConnectionString;
}
  

    C# — Data/ProductoDAO.cs · Capa de datos
public class ProductoDAO
{
    // READ — Obtener todos los productos
    public List<Producto> ObtenerTodos()
    {
        var lista = new List<Producto>();
        using (var con = new SqlConnection(Conexion.CadenaConexion))
        {
            con.Open();
            var cmd = new SqlCommand("SELECT Id, Nombre, Precio, Stock FROM Productos", con);
            using (var reader = cmd.ExecuteReader())
            {
                while (reader.Read())
                {
                    lista.Add(new Producto
                    {
                        Id     = reader.GetInt32(0),
                        Nombre = reader.GetString(1),
                        Precio = reader.GetDecimal(2),
                        Stock  = reader.GetInt32(3)
                    });
                }
            }
        }
        return lista;
    }
 
    // CREATE — Insertar un producto
    public bool Insertar(Producto p)
    {
        using (var con = new SqlConnection(Conexion.CadenaConexion))
        {
            con.Open();
            var sql = "INSERT INTO Productos(Nombre,Precio,Stock) VALUES(@N,@P,@S)";
            using (var cmd = new SqlCommand(sql, con))
            {
                cmd.Parameters.AddWithValue("@N", p.Nombre);
                cmd.Parameters.AddWithValue("@P", p.Precio);
                cmd.Parameters.AddWithValue("@S", p.Stock);
                return cmd.ExecuteNonQuery() > 0;
            }
        }
    }
}
  

    C# — Forms/FrmProductos.cs · Capa de presentación
public partial class FrmProductos : Form
{
    private readonly ProductoDAO _dao = new ProductoDAO();
 
    private void CargarProductos()
    {
        // La presentación solo llama a la capa de datos, no sabe SQL
        dgvProductos.DataSource = _dao.ObtenerTodos();
    }
 
    private void btnGuardar_Click(object sender, EventArgs e)
    {
        var producto = new Producto
        {
            Nombre = txtNombre.Text,
            Precio = decimal.Parse(txtPrecio.Text),
            Stock  = int.Parse(txtStock.Text)
        };
 
        // Validación en la capa de negocio antes de persistir
        if (!producto.EsValido())
        {
            MessageBox.Show("Datos del producto inválidos.");
            return;
        }
 
        if (_dao.Insertar(producto))
            CargarProductos(); // Refrescar la tabla
    }
}
  

Flujo completo de una petición

Para entender cómo interactúan las tres capas, el siguiente diagrama muestra el flujo completo de una operación de guardado desde que el usuario presiona el botón hasta que los datos quedan persistidos en SQL Server:

Capa de Presentación · Cliente

Usuario hace clic en "Guardar"

El evento btnGuardar_Click captura los datos del formulario y crea un objeto Producto con los valores ingresados.

Capa de Negocio · Validación

Se validan las reglas de negocio

El método EsValido() del modelo verifica que los datos cumplen las reglas antes de intentar persistirlos. Si falla, se muestra un mensaje al usuario y se detiene el flujo.

Capa de Datos · DAO

El DAO prepara y ejecuta el comando SQL

ProductoDAO.Insertar() abre una SqlConnection, construye el SqlCommand con parámetros y ejecuta el INSERT.

Servidor · SQL Server

SQL Server procesa y persiste el registro

El motor de base de datos recibe la instrucción, valida las restricciones de la tabla (claves, tipos, nulos) y persiste el registro. Devuelve el número de filas afectadas.

Capa de Presentación · Respuesta

La interfaz se actualiza con los nuevos datos

El formulario llama a CargarProductos() para refrescar el DataGridView y el usuario ve el nuevo registro en la lista.

La separación en capas no es una formalidad académica — es la diferencia entre una aplicación que un solo desarrollador puede mantener y una que puede crecer, adaptarse y sobrevivir al paso del tiempo en un entorno empresarial real.

— Microsoft Application Architecture Guide, 2nd Edition

🏁 Conclusión

El desarrollo de aplicaciones cliente-servidor con C# y SQL Server, organizado en tres capas bien diferenciadas, representa el estándar profesional para la construcción de software empresarial. La capa de presentación gestiona la interfaz, la capa de negocio aplica las reglas del dominio y la capa de datos centraliza el acceso a SQL Server mediante ADO.NET.

Esta arquitectura no solo produce aplicaciones más mantenibles y escalables — también forma el criterio técnico del desarrollador para tomar decisiones de diseño fundamentadas, separando claramente las responsabilidades de cada componente del sistema.

Referencias bibliográficas

Microsoft. (2024). Application Architecture Guide. Microsoft Learn. https://learn.microsoft.com/en-us/azure/architecture/guide/
Microsoft. (2024). N-tier architecture style. Azure Architecture Center. https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/n-tier
Tanenbaum, A. S. & Van Steen, M. (2017). Distributed Systems: Principles and Paradigms, 3rd Edition. Pearson.
Price, M. J. (2023). C# 12 and .NET 8 — Modern Cross-Platform Development. Packt Publishing.
Freeman, A. (2022). Pro ASP.NET Core 6. Apress.

#ClienteServidor #ArquitecturaTresCapas #CSharp #SQLServer #ADONet #HDP-02 #WindowsForms #DAO

· · · · ·

Entradas — HDP-02

Blog No. I

Interfaz Gráfica Moderna en Aplicaciones de Escritorio

Blog No. II

ADO.NET con SQL Server

Próxima entrada
Próximamente

Arquitectura dominante

3 capas

La arquitectura de tres capas — presentación, negocio y datos — es el estándar de facto en el desarrollo de aplicaciones empresariales cliente-servidor

— Microsoft Application Architecture Guide