Está en la página 1de 25

Vladimir Quishpe

2018
Vladimir Quishpe

Contenido
INTRODUCCION ...................................................................................................................................................3
OBJETIVOS ...........................................................................................................................................................3
MARCO TEORICO .................................................................................................................................................4
Construcción de Aplicaciones en Capas ..........................................................................................................4
Generalidades ..............................................................................................................................................4
CARACTERÍSTICAS ........................................................................................................................................5
APLICACIONES DE UNA CAPA ......................................................................................................................7
APLICACIONES DE DOS CAPAS .....................................................................................................................8
APLICACIONES DE 3 CAPAS ..........................................................................................................................9
APLICACIONES DE N CAPAS ...................................................................................................................... 12
Desarrollo de aplicaciones basadas en componentes .............................................................................. 12
PROCEDIMIENTO .............................................................................................................................................. 13
Capa de Negocio ............................................................................................... Error! Bookmark not defined.
Definición del servicio ...................................................................................... Error! Bookmark not defined.
Implementación del servicio ............................................................................ Error! Bookmark not defined.
Desarrollo del servidor ..................................................................................... Error! Bookmark not defined.
Desarrollo del cliente........................................................................................ Error! Bookmark not defined.
Compilación ...................................................................................................... Error! Bookmark not defined.
Ejecución........................................................................................................... Error! Bookmark not defined.
CONCLUSIONES ................................................................................................................................................ 15
Bibliografía ........................................................................................................................................................ 16

Universidad de Las Americas


2
Vladimir Quishpe

INTRODUCCION

Cuando se construye software como producto empresarial o comercial, se llevan a cabo


varias técnicas de manera que el desarrollo se haga en forma ordenada y así poder asegurar
un avance continuo del proyecto, un producto final de calidad, y además realizar posteriores
mejoras sea una tarea más fácil.

Existen muchas prácticas de programación, dependiendo del tipo de software que se va a


desarrollar y de la disciplina o disciplinas de programación que se utilicen en el desarrollo
del producto. Una de las más utilizadas se llama la programación por capas, que consiste
en dividir el código fuente según su funcionalidad principal.

La programación para lograr sacarle el mayor provecho a la programación por capas se


necesita seguir una serie de pasos complejos los cuales primeramente deben ser definidos
para cada proyecto en específico, luego deben ser revisados para asegurarse de que el
modelo adoptado cumpla con las normas necesarias para que la aplicación sea del agrado
del usuario, y por último debe ser implementado por el grupo de desarrollo encargado para
tal fin, los cuales siguiendo el modelo propuesto obtienen una herramienta útil para facilitar
la labor de programación dividiendo la aplicación en módulos y capas fáciles de pulir.

OBJETIVOS
 Reconocer modelos de programación avanzados, específicamente la programación
en 4 capas.

 Describir y utilizar cada una de las capas de programación para la generación de


aplicaciones orientadas a objetos

Universidad de Las Americas


3
Vladimir Quishpe

MARCO TEORICO

Construcción de Aplicaciones en Capas

Generalidades

La construcción de aplicaciones n-tier (n-capas) distribuidas ha emergido como la


arquitectura predominante para la construcción de aplicaciones multiplataforma en la mayor
parte de las empresas.

Este cambio radical en los modelos de computación, desde los sistemas monolíticos
basados en mainframe y los tradicionales sistemas cliente-servidor, hacia sistemas
distribuidos multiplataforma altamente modularles, representa el desarrollo rápido y avance
de la investigación en el mundo del desarrollo de aplicaciones, tal y como se pone de
manifiesto en las últimas tendencias de las grandes empresas de tecnología, como Sun con
su estrategia Sun One, o Microsoft con DotNET (.Net).

El modelo presenta algunas ventajas entre ellas:

 Desarrollos paralelos (en cada capa)

 Aplicaciones más robustas debido al encapsulamiento

 Mantenimiento y soporte más sencillo (es más sencillo cambiar un componente que
modificar una aplicación monolítica)

 Mayor flexibilidad (se pueden añadir nuevos módulos para dotar al sistema de nueva
funcionalidad)

 Alta escalabilidad. La principal ventaja de una aplicación distribuida bien diseñada es


su buen escalado, es decir, que puede manejar muchas peticiones con el mismo
rendimiento simplemente añadiendo más hardware. El crecimiento es casi lineal y no
es necesario añadir más código para conseguir esta escalabilidad.

Universidad de Las Americas


4
Vladimir Quishpe

Como tecnología, las arquitecturas de n-capas proporcionan una gran cantidad de


beneficios para las empresas que necesitan soluciones flexibles y fiables para resolver
complejos problemas inmersos en cambios constantes.

Todas las aplicaciones basadas en n-capas permitirán trabajar con clientes ligeros, tal
como navegadores de Internet, WebTV, Teléfonos Inteligentes, PDAs (Personal Digital
Assistants o Asistentes Personales Digitales) y muchos otros dispositivos preparados
para conectarse a Internet.

De este modo, las arquitecturas de n-capas se están posicionando rápidamente como la


piedra angular de los desarrollos de aplicaciones empresariales y las compañías están
adoptando esta estrategia a una velocidad de vértigo como mecanismo de
posicionamiento en la economía emergente que tiene su base en la red (lo que se ha
venido a denominar "Nueva Economía").

Actualmente, la Red (Internet, intranets y extranets) es el ordenador o, como diría Sun


Microsystems, el ordenador es la Red. Este paradigma está creando un cambio
fundamental en los modelos de computación que, a su vez, proporciona desafíos y
oportunidades como nunca antes había se habían producido.

Realmente, los componentes distribuidos de una arquitectura de n-capas es una


tecnología esencial para crear la siguiente generación de aplicaciones e-business,
aplicaciones que son altamente escalables, fiables y que proporcionan un alto
rendimiento y una integración sin fisuras con los sistemas de back-end heredados.

A diferencia de lo que se pudiera pensar, el desarrollo en n-capas no es un producto o


un estándar, es un concepto estratégico que ayuda a la construcción y despliegue lógico
de un sistema distribuido. Los sistemas de n-capas subdivididos ayudan a facilitar el
desarrollo rápido de aplicaciones y su posterior despliegue, con beneficios incrementales
fruto de los esfuerzos del desarrollo en paralelo coordinado y del outsourcing inteligente,
resultando un enorme decremento del tiempo de desarrollo y de sus costes. Muchas de
las aplicaciones de e-business que se utilizan actualmente simplemente utilizan un
navegador de Internet como cliente ligero que implementa una interfaz universal. Una
arquitectura basada en clientes ligeros desplaza la capa de presentación de la aplicación
en el lado del cliente, mientras que la lógica de negocio y los datos residen en el
middleware y los servidores de back-end. El diseño para clientes ligeros minimiza los
problemas de despliegue de las aplicaciones, mientras que maximiza la accesibilidad a
la misma desde una amplia variedad de plataformas heterogéneas. Los frameworks
basados en n-capas se crean para obtener las ventajas de los estándares abiertos de la
industria que permiten a las aplicaciones resultantes operar en entornos distribuidos
multiplataforma.

CARACTERÍSTICAS

Universidad de Las Americas


5
Vladimir Quishpe

Las aplicaciones que se construyen con una arquitectura multicapa tienen entre otras las
siguientes características:

 Acceso a bases de datos (BD)

o Normalmente con BD relacionales

 Transaccionales

o Propiedades ACID (Atomicity-Consistency-Isolation-Durability)

 Operaciones atómicas (Atomicity) son operaciones que se completan en


su totalidad o no se completan en absoluto. Así, en el ejemplo anterior de
la transferencia tanto el crédito como el débito deben haber sido exitosos
para que el estado de transformación sea exitoso (para que haga efectos),
de otro modo el estado de la transformación falla, y el sistema es regresado
a su último estado conocido.
 Transformaciones consistentes (Consistency) preservan la integridad
interna de los recursos involucrados. Por ejemplo, el borrar registros de una
tabla primaria viola la integridad referencial de la base de datos si hay
registros relacionados que concuerden.
 Transformaciones aisladas (Isolation) parecen ocurrir serialmente, una
detrás de otra, creando la ilusión de que ninguna transformación está
siendo ejecutada al mismo tiempo.
 La durabilidad (Durability) se refiere a la habilidad para almacenar los
resultados de una transformación de estado, usualmente en un disco, de
tal modo que los resultados de una transformación puedan ser recuperados
en caso de una falla del sistema.

 Escalables

o Deberían poder soportar más carga de trabajo sin necesidad de modificar el


software (sólo añadir más máquinas)

 Disponibilidad

o Idealmente no deben dejar de prestar servicio

 Seguras

Universidad de Las Americas


6
Vladimir Quishpe

o No todos los usuarios pueden acceder a la misma funcionalidad

 Integración

o Es preciso integrar aplicaciones construidas con distintas tecnologías

 Tipo de interfaz

o De entorno de ventanas (clientes desktop): normalmente sólo tiene sentido en


intranets.
o Web: En Internet y en intranets.

 Separación clara entre la interfaz gráfica y la Capa de componentes

o Capa de componentes: encapsulan la lógica de negocio.


o Ejemplo => aplicación bancaria
 Capa de componentes: conjunto de clases que nos permiten: crear
cuentas, destruirlas, encontrarlas por distintos criterios, hacer
transferencias bancarias, etc.
o La capa de componentes debería ser reusable con distintas interfaces gráficas
o En el ejemplo de la aplicación bancaria podría haber dos clientes: uno Web y
otro desktop.

APLICACIONES DE UNA CAPA

Las capas dentro de una arquitectura son nada más que un conjunto de servicios
especializados que pueden ser accesibles por múltiples clientes y fácilmente
reutilizables.

Este tipo de arquitectura se caracteriza por tener en una sola asociación lógica y en ella a
la presentación, la lógica de negocios y los datos; que si los ponemos como servicios se
convierten en capas, lo veremos más adelante.

Universidad de Las Americas


7
Vladimir Quishpe

Ejemplos de esta arquitectura son desarrollos realizados en Excel, Access, Fox, entre otros.

APLICACIONES DE DOS CAPAS

Se caracterizan por tener 2 asociaciones lógicas, que prestan servicios y que a la final son
capas.

Universidad de Las Americas


8
Vladimir Quishpe

En la primera capa se incluye a la presentación (Interface grafica) y a la lógica de negocios,


toda la lógica la escribimos en las formas (en el onClick del botón por ejemplo), y accedemos
a un servicio de datos para la gestión de los mismos, por lo general a un servidor de Base
de Datos.

Esta arquitectura es comúnmente llamada cliente servidor, puesto que también el programa
fuente puede residir en un servidor y muchos cliente pueden acceder a él para ejecutar una
copia del programa.

Pero quisiera plantear la siguiente problemática:

¿Qué podría suceder si tuviésemos que hacer cambios en la implementación de la lógica


de negocios?

El resultado es la recompilación de toda la aplicación y reinstalación en todos y cada uno de


los clientes; y….si mis clientes suman como 200 máquinas?

La solución está en separar la lógica de negocios en un servicio aparte, allí es donde


aparece la tercera capa.

APLICACIONES DE 3 CAPAS

Una aplicación de tres capas es una aplicación cuya funcionalidad puede ser segmentada
en tres niveles lógicos (capas):

 Los servicios de presentación.


 Los servicios de negocios (Lógica de Negocios)
 Los servicios de datos.

Universidad de Las Americas


9
Vladimir Quishpe

La capa de servicios de presentación es responsable de:

 Obtener información del usuario.


 Enviar la información del usuario a los servicios de negocios para su procesamiento.
 Recibir los resultados del procesamiento de los servicios de negocios.
 Presentar estos resultados al usuario.

El nivel de servicios de negocios es responsable de:

 Recibir la entrada del nivel de presentación.


 Interactuar con los servicios de datos para ejecutar las operaciones de negocios para
los que la aplicación fue diseñada a automatizar (por ejemplo, la preparación de
impuestos por ingresos, el procesamiento de ordenes y así sucesivamente).
 Enviar el resultado procesado al nivel de presentación.

El nivel de servicios de datos es responsable de:

 Almacenar los datos.

Universidad de Las Americas


10
Vladimir Quishpe

 Recuperar los datos.


 Mantener los datos.
 La integridad de los datos.

Al ser la primera capa un servicio, se puede inferir que las aplicaciones no solo podrían ser
de escritorio, si quisiéramos que nuestra aplicación tenga una interface web, pues
solamente bastaría con cambiar la capa de presentación y de allí en adelante nada tiene
porque cambiar.

Entonces nuestras páginas web estarían alojadas en un Servidor Web las mismas que se
conectan a la lógica de negocios y de allí a los servicios de datos.

Universidad de Las Americas


11
Vladimir Quishpe

APLICACIONES DE N CAPAS

Podríamos ir separando nuestra aplicación en mas niveles lógicos, por ejemplo, vamos a
querer que nuestra aplicación tenga múltiples interfaces, es decir interface gráfica
(standalone o desktop) y también interface Web.

Lo aconsejado en esta circunstancia es separar al Servidor Web encargado de alojar las


páginas Web en una capa más. En este caso se tendrían 4 capas.

Mientras más servicios coloquemos a nuestra aplicación y mientras más escalable lo


imaginemos, mas capas lógicas van a irse añadiendo a nuestra arquitectura; allí está el
inicio del estudio de las siguientes secciones del curso, LOS PATRONES DE DISEÑO.

 La arquitectura en 3 capas es la más usada


 La arquitectura en 4 capas puede ser más escalable

Desarrollo de aplicaciones basadas en componentes

El surgimiento de la tecnología de componentes distribuidos es la clave de las


arquitecturas de n-capas. Estos sistemas de computación utilizan un número variable de

Universidad de Las Americas


12
Vladimir Quishpe

componentes individuales que se comunican entre ellos utilizando estándares


predefinidos y frameworks de comunicación como:

 CORBA: (Common Object Request Broker Architecture) del Object Management


Group (OMG).
 DNA : (Distributed Network Applications) de Microsoft (incluye COM/DCOM y COM+
además de MTS, MSMQ, etc.).
 EJB : (Enterprise Java Beans) de Sun Microsystems.
 XML : (eXtensible Markup Language) del World Wide Web Consortium (W3C).
 .NET: de Microsoft que incluye nuevos lenguajes como Visual Basic.net, C#.

Estas y otras tecnologías en rápida evolución proporcionan la infraestructura necesaria


que permite a las compañías operar en un entorno complejo, multiplataforma y con
capacidades de computación distribuida, tanto interna como externamente según se
requiera en cada caso.

PROCEDIMIENTO

Capa de presentación

Es la capa que ve el usuario (también se la denomina "capa de usuario"), presenta el


sistema al usuario, le comunica la información y captura la información del usuario en
un mínimo de proceso (realiza un filtrado previo para comprobar que no hay errores de
formato). También es conocida como interfaz gráfica y debe tener la característica de
ser "amigable" (entendible y fácil de usar) para el usuario. Esta capa se comunica
únicamente con la capa de negocio.

Universidad de Las Americas


13
Vladimir Quishpe

Capa de negocio

Es donde residen los programas que se ejecutan, se reciben las peticiones del usuario
y se envían las respuestas tras el proceso. Se denomina capa de negocio (e incluso de
lógica del negocio) porque es aquí donde se establecen todas las reglas que deben
cumplirse. Esta capa se comunica con la capa de presentación, para recibir las
solicitudes y presentar los resultados, y con la capa de datos, para solicitar al gestor
de base de datos almacenar o recuperar datos de él. También se consideran aquí los
programas de aplicación.

Capa de datos

Es donde residen los datos y es la encargada de acceder a los mismos. Está formada
por uno o más gestores de bases de datos que realizan todo el almacenamiento de
datos, reciben solicitudes de almacenamiento o recuperación de información desde la
capa de negocio.

Todas estas capas pueden residir en un único ordenador, si bien lo más usual es que
haya una multitud de ordenadores en donde reside la capa de presentación (son los
clientes de la arquitectura cliente/servidor). Las capas de negocio y de datos pueden
residir en el mismo ordenador, y si el crecimiento de las necesidades lo aconseja se
pueden separar en dos o más ordenadores. Así, si el tamaño o complejidad de la base
de datos aumenta, se puede separar en varios ordenadores los cuales recibirán las
peticiones del ordenador en que resida la capa de negocio.

Universidad de Las Americas


14
Vladimir Quishpe

Si, por el contrario, fuese la complejidad en la capa de negocio lo que obligase a la


separación, esta capa de negocio podría residir en uno o más ordenadores que
realizarían solicitudes a una única base de datos. En sistemas muy complejos se llega
a tener una serie de ordenadores sobre los cuales corre la capa de negocio, y otra serie
de ordenadores sobre los cuales corre la base de datos.

CONCLUSIONES
La programación en capas ha sido una de las últimas tendencias en cuanto a software
comercial se refiere, es una tendencia que bien aplicada puede resultar en un desarrollo de
software eficiente.

Sin embargo, no todos los equipos ni empresas desarrolladoras usan un sistema


rígido, ni existe una forma estricta en la que tenga que implementarse el modelo de capas,
cada quién debe hacerlo según sus necesidades, alcances y lo más importante; las
tendencias y nuevas tecnologías que vayan surgiendo.

Universidad de Las Americas


15
Vladimir Quishpe

Es importante tener en cuenta que no importa el lenguaje de programación usado,


o el tipo de implementación que se le dé al modelo; se debe buscar una alta cohesión y
un bajo acoplamiento dentro de los objetos y capas para lograr que la aplicación sea
fácilmente desarmable y sea más sencillo realizar mejoras y actualizaciones al sistema.

Bibliografía

 Anonimo. (05 de 12 de 2017). Sistemas Distribuidos. Obtenido de Sistemas


Distribuidos: https://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf

 NEREDIA. (05 de 12 de 2017). Neredia.ull. Obtenido de


http://nereida.deioc.ull.es/~cleon/doctorado/doc06/doc06/html/node9.html

 Valdivia, J., & Perez, D. (2015). Comunicacion entre procesos Sockets. Huanuco-
Peru: Universidad Nacional Hermilio Valdizan.

ANEXOS

Anexo 1 : CODIGO FUENTE Default.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data;
using Entidades;
using Negocios;

public partial class _Default : System.Web.UI.Page


{

public E_Producto objEntProducto = new E_Producto();


public N_Productos objNegProducto = new N_Productos();

Universidad de Las Americas


16
Vladimir Quishpe

protected void Page_Load(object sender, EventArgs e)


{
EscondeControl();
}

private void EscondeControl()


{
pnlAltas.Visible = false;
pnlListadoProductos.Visible = false;
btnGrabarProducto.Visible = false;
btnModificarProducto.Visible = false;
btnBorrarProducto.Visible = false;
}

private void VaciaTextBox()


{
tbNombreProducto.Text = string.Empty;
tbNumeroProducto.Text = string.Empty;
}

private void PonMsg(string pTipo, string pMsg)


{
lblMensaje.Text = pTipo + ": " + pMsg;
if (pTipo == "AVISO")
lblMensaje.ForeColor = System.Drawing.Color.DarkBlue;
else
lblMensaje.ForeColor = System.Drawing.Color.Red;
lblMensaje.Visible = true;

private void TextBoxAObjeto()


{
objEntProducto.NumeroProducto = tbNumeroProducto.Text;
objEntProducto.NombreProducto = tbNombreProducto.Text;
}

protected void btnNuevoProducto_Click(object sender, EventArgs e)


{
btnGrabarProducto.Visible = true;
VaciaTextBox();
pnlAltas.Visible = true;
lblMensaje.Text = string.Empty;
lblOpcion.Text = "MODULO: ALTAS";
}

protected void btnBorrarProducto_Click(object sender, EventArgs e)


{
int nResultado = -1;
TextBoxAObjeto();
objEntProducto.IdProducto =
Convert.ToInt16(grvListadoProducto.DataKeys[grvListadoProducto.SelectedIndex].Value.ToString
());

nResultado = objNegProducto.abcProducto("BORRAR", objEntProducto);

if (nResultado != 1)
{
Response.Write("<script>windows.alert('El producto fue Borrado')</script>");

Universidad de Las Americas


17
Vladimir Quishpe

}
else
{
Response.Write("<script>window.alert('El producto fue borrado')</script>");

}
}

protected void btnModificarProducto_Click(object sender, EventArgs e)


{
int nResultado = -1;
TextBoxAObjeto();
objEntProducto.IdProducto =
Convert.ToInt16(grvListadoProducto.DataKeys[grvListadoProducto.SelectedIndex].Value.ToString
());

nResultado = objNegProducto.abcProducto("MODIFICAR", objEntProducto);

if (nResultado != 1)
{
Response.Write("<script>windows.alert('El producto fue modificado')</script>");
}
else
{
Response.Write("<script>window.alert('El producto NO fue
modificado')</script>");

}
}

private void ObjetoATextBox(DataSet ds)


{
tbNumeroProducto.Text = ds.Tables[0].Rows[0]["NumeroProducto"].ToString();
tbNombreProducto.Text = ds.Tables[0].Rows[0]["NombreProducto"].ToString();

protected void btnGrabarProducto_Click(object sender, EventArgs e)


{

int nGrabados = -1;


TextBoxAObjeto();
nGrabados = objNegProducto.abcProducto("AGREGAR", objEntProducto);
if (nGrabados != 1)
PonMsg("AVISO", "<script>El producto fue grabado correctamente<script/>");
else
PonMsg("ERROR", "<script>El producto no fue grabado<script/>");

protected void btnListadoProducto_Click(object sender, EventArgs e)


{
pnlListadoProductos.Visible = true;

DataSet ds = new DataSet();

Universidad de Las Americas


18
Vladimir Quishpe

EscondeControl();

ds = objNegProducto.ListadoProductos();

if (ds.Tables[0].Rows.Count > 0)
{
grvListadoProducto.DataSource = ds.Tables[0];
grvListadoProducto.DataBind();
pnlListadoProductos.Visible = true;
}
else
Response.Write("<script>windows.alert('No existen productos en el
sistema')</script>");
}

protected void grvListadoProducto_SelectedIndexChanged1(object sender, EventArgs e)


{
DataSet ds = new DataSet();

lblOpcion.Text = "MODULO: MODIFICACIONES Y BAJAS";


objEntProducto.IdProducto =
Convert.ToInt16(grvListadoProducto.DataKeys[grvListadoProducto.SelectedIndex].Value.ToString
());

btnBorrarProducto.Visible = true;
btnModificarProducto.Visible = true;

ds = objNegProducto.SeleccionarProducto(objEntProducto.IdProducto);

if (ds.Tables[0].Rows.Count > 0)
{
ObjetoATextBox(ds);

pnlAltas.Visible = true;
btnGrabarProducto.Visible = false;
}
}

protected void btnCancelar_Click1(object sender, EventArgs e)


{
VaciaTextBox();

}
}

Anexo 2: CODIGO FUENTE Default.aspx (HTML)

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs"


Inherits="_Default" %>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>

Universidad de Las Americas


19
Vladimir Quishpe

<title></title>
<style type="text/css">
.auto-style1 {
margin-bottom: 0px;
}
</style>
</head>
<body>
<form id="form1" runat="server">
<div>
ALMACEN
<br />
<br />
<asp:Button ID="btnNuevoProducto" runat="server" OnClick="btnNuevoProducto_Click"
Text="Nuevo" />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<asp:Button ID="btnListadoProducto" runat="server"
OnClick="btnListadoProducto_Click" style="height: 29px" Text="Listado" />
<br />
<br />
<br />
<asp:Panel ID="pnlListadoProductos" runat="server" BackColor="#999966"
Height="271px">
<asp:GridView ID="grvListadoProducto" runat="server" AutoGenerateColumns="False"
BackColor="White" BorderColor="#336666" BorderStyle="Double" BorderWidth="3px"
CellPadding="4" DataKeyNames="IdProducto" GridLines="Horizontal" HorizontalAlign="Center"
OnSelectedIndexChanged="grvListadoProducto_SelectedIndexChanged1" Width="90%">
<Columns>
<asp:BoundField DataField="NumeroProducto" HeaderText="Numero" />
<asp:BoundField DataField="NombreProducto" HeaderText="Nombre" />
<asp:CommandField ShowSelectButton="True" />
</Columns>
<FooterStyle BackColor="White" ForeColor="#333333" />
<HeaderStyle BackColor="#336666" Font-Bold="True" ForeColor="White" />
<PagerStyle BackColor="#336666" ForeColor="White" HorizontalAlign="Center"
/>
<RowStyle BackColor="White" ForeColor="#333333" />
<SelectedRowStyle BackColor="#339966" Font-Bold="True" ForeColor="White" />
<SortedAscendingCellStyle BackColor="#F7F7F7" />
<SortedAscendingHeaderStyle BackColor="#487575" />
<SortedDescendingCellStyle BackColor="#E5E5E5" />
<SortedDescendingHeaderStyle BackColor="#275353" />
</asp:GridView>
</asp:Panel>
<br />
<br />
<asp:Panel ID="pnlAltas" runat="server" BackColor="Gray" Height="293px">
&nbsp;&nbsp;&nbsp;&nbsp;
<br />
<asp:Label ID="lblOpcion" runat="server" Text="ALTAS"></asp:Label>
<br />
<br />
<br />
<asp:Label ID="lblNumeroProducto" runat="server" Text="No. Producto:
"></asp:Label>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<asp:TextBox ID="tbNumeroProducto" runat="server"></asp:TextBox>
<br />
<br />
<asp:Label ID="lblNombreProducto" runat="server" Text="Nombre Producto:
"></asp:Label>

Universidad de Las Americas


20
Vladimir Quishpe

&nbsp;&nbsp;&nbsp;&nbsp;
<asp:TextBox ID="tbNombreProducto" runat="server" CssClass="auto-
style1"></asp:TextBox>
<br />
<br />
<asp:Label ID="lblMensaje" runat="server"></asp:Label>
<br />
<br />
<asp:Button ID="btnGrabarProducto" runat="server"
OnClick="btnGrabarProducto_Click" Text="Grabar" />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<asp:Button ID="btnBorrarProducto" runat="server"
OnClick="btnBorrarProducto_Click" Text="Borrar" />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<asp:Button ID="btnModificarProducto" runat="server"
OnClick="btnModificarProducto_Click" Text="Modificar" />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<asp:Button ID="btnCancelar" runat="server" OnClick="btnCancelar_Click1"
Text="Cancelar" />

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&n
bsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</asp:Panel>
<br />
<asp:SqlDataSource ID="CadenaConexion" runat="server"
ConnectionString="<%$ ConnectionStrings:ConnectionString %>" SelectCommand="SELECT
[NumeroProducto], [IdProducto], [NombreProducto] FROM [tbProductos]"></asp:SqlDataSource>
</div>
</form>
</body>
</html>

Anexo 3: CODIGO FUENTE D_ConexionBD.cs (Capa Datos)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace Datos
{
public class D_ConexionBD
{
public SqlConnection Conexion;

public D_ConexionBD()
{
Conexion = new
SqlConnection(ConfigurationManager.ConnectionStrings["connectionString"].ConnectionString);
}

public void AbrirConexion()

Universidad de Las Americas


21
Vladimir Quishpe

{
try
{
if (Conexion.State == ConnectionState.Broken || Conexion.State ==
ConnectionState.Closed)
{
Conexion.Open();
}
}
catch (Exception e)
{
throw new Exception("Error al abrir la conexión", e);
}
}

public void CerrarConexion()


{
try
{
if (Conexion.State == ConnectionState.Open)
Conexion.Close();
}
catch (Exception e)
{
throw new Exception("Error al cerrar la conexión", e);

}
}
}
}

Anexo 4: CODIGO FUENTE D_Productos.cs (Capa Datos)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
using Entidades;

namespace Datos
{
public class D_Productos : D_ConexionBD
{
public D_Productos() { }

public int abcProducto(string pAccion, E_Producto objE_Producto)


{
int Resultado = 0;
SqlCommand cmd = new SqlCommand("abcProducto", Conexion);
cmd.CommandType = CommandType.StoredProcedure;

cmd.Parameters.AddWithValue("@Accion", pAccion);
cmd.Parameters.AddWithValue("@IdProducto", objE_Producto.IdProducto);
cmd.Parameters.AddWithValue("@NumeroProducto", objE_Producto.NumeroProducto);
cmd.Parameters.AddWithValue("@NombreProducto", objE_Producto.NombreProducto);

Universidad de Las Americas


22
Vladimir Quishpe

try
{
AbrirConexion();
Resultado = cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw new Exception("Error al Almacenar, Borrar o Modificar datos", e); ;

}
finally
{
CerrarConexion();
cmd.Dispose();
}
return Resultado;

public DataSet ListadoProductos()


{
SqlCommand cmd = new SqlCommand();
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter();
try
{
AbrirConexion();
cmd.Connection = Conexion;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "[dbo].[ListadoProductos]";

da.SelectCommand = cmd;
da.Fill(ds);

}
catch (Exception ex)
{
throw new Exception("Datos Productos", ex);
}
finally
{
Conexion.Close();
cmd.Dispose();
}
return ds;
}

public DataSet SeleccionarProducto(int pIdProducto)


{
SqlCommand cmd = new SqlCommand();
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter();
try
{
AbrirConexion();
cmd.Connection = Conexion;
cmd.CommandType = CommandType.StoredProcedure;

Universidad de Las Americas


23
Vladimir Quishpe

cmd.Parameters.AddWithValue("@IdProducto", pIdProducto);

cmd.CommandText = "[dbo].[SeleccionarProducto]";

da.SelectCommand = cmd;
da.Fill(ds);

}
catch (Exception ex)
{
throw new Exception("Datos Producto", ex);
}
finally
{
Conexion.Close();
cmd.Dispose();
}
return ds;
}
}
}

Anexo 5: CODIGO FUENTE E_Producto.cs (Capa Entidades)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Entidades
{
public class E_Producto
{
private int _IdProducto;

private string _NumeroProducto;

private string _NombreProducto;

public E_Producto()
{
_IdProducto = 0;
_NumeroProducto = string.Empty;
_NombreProducto = string.Empty;

public int IdProducto


{
get { return _IdProducto; }

Universidad de Las Americas


24
Vladimir Quishpe

set { _IdProducto = value; }


}

public string NumeroProducto


{
get { return _NumeroProducto; }
set { _NumeroProducto = value; }
}

public string NombreProducto


{
get { return _NombreProducto; }
set { _NombreProducto = value; }
}
}
}

Anexo 6: CODIGO FUENTE N_Productos.cs (Capa Negocios)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Datos;
using Entidades;
using System.Data;

namespace Negocios
{
public class N_Productos
{
D_Productos objNegocioProducto = new D_Productos();

public int abcProducto(string pAccion, E_Producto objE_Producto)


{
return objNegocioProducto.abcProducto(pAccion, objE_Producto);
}

public DataSet ListadoProductos()


{
return objNegocioProducto.ListadoProductos();
}

public DataSet SeleccionarProducto(int pIdProducto)


{
return objNegocioProducto.SeleccionarProducto(pIdProducto);
}

}
}

Universidad de Las Americas


25