Informe QuishpeVladimir ProyectoFinal

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

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.

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

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

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.

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.

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.

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.

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.

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

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.

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.

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.

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();

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>");

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();
());
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();

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)

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

());
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"/>

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" />

<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">

<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>

<asp:TextBox ID="tbNumeroProducto" runat="server"></asp:TextBox>
<br />
<br />
<asp:Label ID="lblNombreProducto" runat="server" Text="Nombre Producto:
"></asp:Label>

20
Vladimir Quishpe

<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" />

<asp:Button ID="btnBorrarProducto" runat="server"
OnClick="btnBorrarProducto_Click" Text="Borrar" />

<asp:Button ID="btnModificarProducto" runat="server"
OnClick="btnModificarProducto_Click" Text="Modificar" />

<asp:Button ID="btnCancelar" runat="server" OnClick="btnCancelar_Click1"
Text="Cancelar" />
               &n
bsp;              &nbs
p;
</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.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()

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.Linq;
using System.Text;
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);

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();
SqlDataAdapter da = new SqlDataAdapter();
try
{
AbrirConexion();
cmd.Connection = Conexion;
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();
SqlDataAdapter da = new SqlDataAdapter();
try
{
AbrirConexion();
cmd.Connection = Conexion;

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.Linq;
using System.Text;
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; }

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.Linq;
using System.Text;
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);
}
}
}

25

Informe QuishpeVladimir ProyectoFinal

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Informe QuishpeVladimir ProyectoFinal

Caricato da

Copyright:

Formati disponibili

Vladimir Quishpe

Universidad de Las Americas

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

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

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

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

Universidad de Las Americas

Construcción de Aplicaciones en Capas

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

El modelo presenta algunas ventajas entre ellas:

 Desarrollos paralelos (en cada capa)

 Aplicaciones más robustas debido al encapsulamiento

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

Universidad de Las Americas

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

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

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

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

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

Universidad de Las Americas

 Acceso a bases de datos (BD)

o Normalmente con BD relacionales

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

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

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

o Idealmente no deben dejar de prestar servicio

Universidad de Las Americas

o No todos los usuarios pueden acceder a la misma funcionalidad

o Es preciso integrar aplicaciones construidas con distintas tecnologías

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

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

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

APLICACIONES DE UNA CAPA

Universidad de Las Americas

APLICACIONES DE DOS CAPAS

Universidad de Las Americas

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

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

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

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

 Los servicios de presentación.

Universidad de Las Americas

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

 Obtener información del usuario.

El nivel de servicios de negocios es responsable de:

 Recibir la entrada del nivel de presentación.

El nivel de servicios de datos es responsable de:

 Almacenar los datos.

Universidad de Las Americas

 Recuperar los datos.

Universidad de Las Americas

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

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

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

Desarrollo de aplicaciones basadas en componentes

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

Universidad de Las Americas

componentes individuales que se comunican entre ellos utilizando estándares

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

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

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

Universidad de Las Americas