Proyecto integrador aplicaciones smart client

DOCUMENTACIÓN TÉCNICA –CREACIÓN DE APLICACIÓN SMART CLIENT

CARLOS ANTONIO ROJO SÁNCHEZ - MAESTRÍA EN TECNOLOGÍAS DE INFORMACIÓN – PÁGINA 1

Manual. Creación de Aplicación Smart Client

Introducción, continúa ............................................................................................................................................... 8

Objetivo ............................................................................................................................................................ 8

Justificación ...................................................................................................................................................... 8

A quien se dirige .............................................................................................................................................. 8

1. Requerimientos ................................................................................................................................................ 9

Introducción ..................................................................................................................................................... 9

Lista de Requerimientos ................................................................................................................................. 9

Reglas de Instalación ....................................................................................................................................... 9

2. Caso de Estudio ............................................................................................................................................. 10

Introducción ................................................................................................................................................... 10

Problema ......................................................................................................................................................... 10

Requerimientos .............................................................................................................................................. 10

3. Arquitectura de la Aplicación ....................................................................................................................... 11

Introducción ................................................................................................................................................... 11

Modelo Conceptual ....................................................................................................................................... 11

Identificación de capas .................................................................................................................................. 11

4. SQL Server ..................................................................................................................................................... 12

Introducción ................................................................................................................................................... 12

Paso 1: Acceso SQL Server 2005 ................................................................................................................ 12

Pantalla ............................................................................................................................................................ 12

SQL Server, continúa ......................................................................................................................................... 13

Paso 2: Crear Base de Datos ........................................................................................................................ 13


Paso 3: Crear tabla ......................................................................................................................................... 14



Como crearla .................................................................................................................................................. 14

Descripción de la ........................................................................................................................................... 14

Tabla ................................................................................................................................................................ 14


5. Capa de Datos ................................................................................................................................................ 16

Introducción ................................................................................................................................................... 16

Paso 1: Crear Solución en Visual Studio ................................................................................................... 16

Como crearlo .................................................................................................................................................. 16

Capa de Datos, continúa ................................................................................................................................... 17

Plantilla ............................................................................................................................................................ 17

Paso 2: Agregar Nuevo Proyecto ................................................................................................................ 17

Como Crearlo ................................................................................................................................................. 17


Plantilla ............................................................................................................................................................ 18

Paso 3: Agregar clase de LINQ ................................................................................................................... 18


Como crearlo .................................................................................................................................................. 19

Plantilla ............................................................................................................................................................ 19


Paso 4: Definición de Acceso ...................................................................................................................... 20

Plantilla ............................................................................................................................................................ 20


Tabla en ObjetoLINQ .................................................................................................................................. 21

6. Capa Empresarial ........................................................................................................................................... 22

Introducción ................................................................................................................................................... 22

Paso 1: Crear BusinessChocolate ................................................................................................................ 22

Capa Empresarial, continúa .............................................................................................................................. 23

Paso 2: Codificación ...................................................................................................................................... 23



7. Servicios .......................................................................................................................................................... 24

Introducción ................................................................................................................................................... 24

Paso 1: Crear ServicesChocolate ................................................................................................................. 24

Servicios, continúa ............................................................................................................................................. 25

Creamos proyecto WCF ............................................................................................................................... 25

Paso 2: Crear Clases de Servicio .................................................................................................................. 25


Paso 3: Agregar referencia ............................................................................................................................ 26



Paso 4: Codificación de Estructura del Servicio ....................................................................................... 28

ChocolateProduct .......................................................................................................................................... 28


ChocolateProductCollection ........................................................................................................................ 29


Implementación del Servicio ........................................................................................................................ 30


Codificación de OperationsContracts ........................................................................................................ 31

InsertProductChocolate ................................................................................................................................ 31


DeleteProductChocolate............................................................................................................................... 32

GetProducts.................................................................................................................................................... 32


Paso 5: Visualizar el Servicio ........................................................................................................................ 33


8. Cliente .............................................................................................................................................................. 35

Introducción ................................................................................................................................................... 35

Paso 1: Crear Solución en Visual Studio WPF ......................................................................................... 35



Cliente, continúa ................................................................................................................................................. 36

Layout Cliente ................................................................................................................................................ 36

Agregar Service Reference ............................................................................................................................ 36


Codificación Cliente ...................................................................................................................................... 37



9. Prueba de ClientChocolateFactory.............................................................................................................. 40

Introducción ................................................................................................................................................... 40

Agregando productos .................................................................................................................................... 40


Eliminar productos ........................................................................................................................................ 41

10. Conclusiones ............................................................................................................................................... 42



Tabla de Ilustraciones

Ilustración 3:1 Modelo Conceptual Arquitectura .......................................................................................................... 11

Ilustración 4:1 Acceso Servidor SQL........................................................................................................................... 12

Ilustración 4:2 Creación de Base de Datos ................................................................................................................... 13

Ilustración 4:3 Nombre de la Base de Datos ................................................................................................................ 13

Ilustración 4:4 Creación de Nueva tabla ...................................................................................................................... 14

Ilustración 4:5 Nombre de la Nueva tabla ................................................................................................................... 15

Ilustración 5:1 Creación de Proyecto Visual Studio 2008 ............................................................................................ 16

Ilustración 5:2 Plantilla Solución SmartChocolateFactory ............................................................................................ 17

Ilustración 5:3 Nuevo Proyecto .................................................................................................................................... 17

Ilustración 5:4 Plantilla Biblioteca Clases .................................................................................................................... 18

Ilustración 5:5 Nuevo Elemento .................................................................................................................................. 19

Ilustración 5:6 Administrador de Servidores ................................................................................................................ 20

Ilustración 5:7 Agregar Servidor de SQL ................................................................................................................... 20

Ilustración 5:8 Estableciendo Conexión ....................................................................................................................... 21

Ilustración 5:9 DAOChocolate ................................................................................................................................... 21

Ilustración 6:1 Clase Empresarial ............................................................................................................................... 22

Ilustración 6:2 Clase BusinessChocolate ....................................................................................................................... 23

Ilustración 7:1 Agregamos un nuevo Sitio Web ............................................................................................................ 24

Ilustración 7:2 Plantilla Servicio WCF ....................................................................................................................... 25

Ilustración 7:3 Clases de Implementación de Servicio .................................................................................................... 26

Ilustración 7:4 Agregar Referencia ............................................................................................................................... 27

Ilustración 7:5 Referencia Proyectos. ............................................................................................................................. 27

Ilustración 7:6 DataContract ChocolateProduct ........................................................................................................... 28

Ilustración 7:7 DataContractCollection ChocolateProductCollection ............................................................................. 29

Ilustración 7:8 Implementar Interfaz IService .............................................................................................................. 30

Ilustración 7:9 Código generado por la herramienta ...................................................................................................... 30



Ilustración 7:10 InsertProductChocolate ....................................................................................................................... 31

Ilustración 7:11 DeleteProductChocolate ...................................................................................................................... 32

Ilustración 7:12 GetProducts ....................................................................................................................................... 32

Ilustración 7:13 Probar Servicio .................................................................................................................................. 33

Ilustración 7:14 Navegador I....................................................................................................................................... 33

Ilustración 7:15 Service.svc .......................................................................................................................................... 34

Ilustración 7:16 WSDL ............................................................................................................................................. 34

Ilustración 8:1 Aplicación WPF ................................................................................................................................. 35

Ilustración 8:2 Layout Cliente ..................................................................................................................................... 36

Ilustración 8:3 Agregar referencia de servicio................................................................................................................. 36

Ilustración 8:4 Asociar Servicio ............................................................................................................................ 37

Ilustración 8:5 Operaciones I ....................................................................................................................................... 38

Ilustración 8:6 Operaciones II ...................................................................................................................................... 38

Ilustración 8:7 XAML .............................................................................................................................................. 39

Ilustración 9:1 Agregar producto .................................................................................................................................. 40

Ilustración 9:2 Seleccionamos Producto ......................................................................................................................... 41

Ilustración 9:3 Eliminado Producto ............................................................................................................................. 41



Introducción

Actualmente los nuevos sistemas de información requieren una mayor interactividad con el usuario y los sitios web tienen mu-chas limitantes.

Según la definición de un smart client es Una aplicación que com-bina el alcance de internet (web client) con el poder del computo local (rich client). Las aplicaciones smart client permiten al usuario local interactuar con las aplicaciones web a través del uso de web ser-vices. Por ejemplo un smart client está corriendo una aplicación word que puede comunicarse a una base de datos remota, per-mitiendo el consumo de información y actualización de la misma.

Los smart clients son distinguidos por estas características:

Las aplicaciones windows nos permite utilizar herramientas de desarrollo que nos permiten una construcción rápida.

Las interfaces de usuario ofrecen funcionalidad más útil y enriquecida para el usuario.

Smart client son aplicaciones que tienen la habilidad de ser desarrolladas y actualizadas en tiempo real sobre la red en un servidor central.

Suportan múltiples plataformas y lenguajes porque son cons-truidas sobre web services.

Pueden correr sobre cualquier dispositivo que tenga conecti-vidad en internet, incluyendo desktops, workstations, note-books, tablet PCs, PDA y dispositivos móviles.

Continúa en la siguiente página



Introducción, continúa

Objetivo Crear un manual que muestre como desarrollar una aplicación

smart client, cumpliendo con una arquitectura de n capas (capa de datos, capa empresarial, servicios y capa de presentación) con aplica-ciones windows.

Se realizará un caso de estudio para dar una solución con aplica-ciones smart clients.

Utilizar las mejores prácticas de desarrollo existentes para la creación de smart clients utilizando lo último en tecnología

(Windows Presentation Foundation, Windows Communication Foundation y LINQ).

Justificación Hoy en día los ingenieros de software no cuentan con una guía clara de cómo crear una aplicación smart client con aplicaciones

windows que ofrezca la unificación de tecnologías como Win-dows Presentation Foundation, Windows Communication Founda-tion y LINQ.

A quien se dirige Este manual va dirigido a los desarrolladores de software enfo-cados tecnologías Microsoft.



1. Requerimientos

Introducción Para cumplir con el objetivo principal de este manual se requiere

una serie de herramientas instaladas en nuestros PC’s para des-

arrollar nuestra aplicación smart client.

Lista de Requerimien-

tos

Se muestra a continuación:

SQL 2005

Visual Studio 2008

Reglas de Instalación Sigue este orden de instalación para cumplir con la lista de reque-rimientos:

1 SQL 2005

2 Visual Studio 2008



2. Caso de Estudio

Introducción Se dará una breve explicación de un problema ficticio dentro de una empresa pastelera.

Problema Actualmente la empresa exportadora “Chocolate Factory” cuenta

con la necesidad que el departamento de mercadotecnia promocione

los nuevos productos que serán exportados a nivel mundial y esta información sea compartida a todas las sucursales que se encuentran distribuidas en el mundo.

Requerimientos Estos son los siguientes:

Creación de una base de datos que permita el almacenamien-to de los nuevos productos.

Se expondrá la información mediante servicios web. Para el consumo de las demás sucursales distribuidas en el mundo.

Permitir el alta de los nuevos productos mediante una apli-cación de escritorio.



3. Arquitectura de la Aplicación

Introducción La arquitectura de la aplicación es la espina dorsal de un sistema de software. Esta nos permitirá dividir en módulos los componentes que se comunicarán entre sí para realizar de forma correcta nuestra aplicación.

Modelo Conceptual

Ilustración 3:1 Modelo Conceptual Arquitectura

Identificación de ca-

pas

La arquitectura tiene las siguientes características

Capa Concepto

Data Es el control del acceso a base de datos que almacenará la información de los nuevos productos.

Empresarial Tendrá todas las reglas del negocio necesa-rias y permitirá la comunicación entre los servicios y la capa de datos.

Servicios Expondrá toda la lógica de negocio requeri-da para que sea consumida por el cliente a través de la red.

Cliente Permitirá la comunicación con el usuario y con el servicio de alta de productos.



4. SQL Server

Introducción En este capítulo crearemos la base de datos relacional con la API de SQL Server 2005. Esto nos permitirá crear de manera rápida y eficaz nuestra base de datos.

Paso 1: Acceso SQL

Server 2005

Para conectarse a SQL estos son los pasos:

1 Selecciona el nombre del servidor local o remoto.

2 Elige el tipo de autenticación del SQL.

3 Haz clic en el botón Conectar. A continuación se describe cada paso.

Pantalla Nombre del Servidor

Ilustración 4:1 Acceso Servidor SQL

Conectar al Servidor de SQL




SQL Server, continúa

Paso 2: Crear Base de

Datos

La creación de la base de datos consiste en dos pasos:

1 Primero debes elegir la opción Nueva base de datos. 2 Establecer el nombre de la Nueva base de datos “ChololateFacto-

ry” y hacer clic en botón aceptar. A continuación se describe

cada paso.

Nueva Base de Datos

Ilustración 4:2 Creación de Base de Datos

Nombre Base de Datos

Ilustración 4:3 Nombre de la Base de Datos





Paso 3: Crear tabla La creación de la tabla datos consiste en dos pasos:

1 Debes elegir la opción Nueva tabla. 2 Agregar los campos. 3 Guardar tabla con el nombre “ProductCholocateFactory”. A con-

tinuación se describe cada paso.

Como crearla Nueva Tabla

Ilustración 4:4 Creación de Nueva tabla

Descripción de la

Tabla

La estructura la tabla es la siguiente

Nombre Tipo Tamaño

idProducto Int

nombreProducto nvarchar(50) 50

descripcion nvarchar(max) max

categoria nvarchar(50) 50





Guardar Tabla

Ilustración 4:5 Nombre de la Nueva tabla



5. Capa de Datos

Introducción En este capítulo crearemos la arquitectura de la capa de datos que se

comunicara con la base de datos “ChocolateFactory”. Utilizando co-

mo medio de acceso LINQ.

Paso 1: Crear Solu-

ción en Visual Studio

Para crear una nueva solución en Visual Studio estos son los pasos.

1 Crear un nuevo Proyecto.

2 Tomar una plantilla de solución. 3 Establecer el nombre de la solución Smart Chocolate Factory.

Como crearlo Nuevo Proyecto

Ilustración 5:1 Creación de Proyecto Visual Studio 2008




Capa de Datos, continúa

Plantilla Nueva Solución

Ilustración 5:2 Plantilla Solución SmartChocolateFactory

Paso 2: Agregar Nue-

vo Proyecto

Para agregar un nuevo proyecto en Visual Studio estos son los pasos.

1 Agregar un nuevo proyecto.

2 Tomar una Biblioteca de Clases. 3 Establecer el nombre de la solución DataCholocateFactory.

Como Crearlo Agregar Nuevo Proyecto

Ilustración 5:3 Nuevo Proyecto

Continúa la siguiente página




Plantilla Biblioteca de Clases

Ilustración 5:4 Plantilla Biblioteca Clases

Paso 3: Agregar clase

de LINQ

Para agregar un nuevo elemento en DataCholocateFactory estos son

los pasos.

1 Agregar nuevo elemento

2 Tomar un Clase de LINQ.

3 Establecer el nombre de la solución DAOChocolate.





Como crearlo Agregar Nuevo Elemento

Ilustración 5:5 Nuevo Elemento

Plantilla Clase LINQ





Paso 4: Definición de

Acceso

Este paso estableceremos conexión a nuestro servidor de base de datos local. y establecer la tabla de

1 Para ello necesitamos iniciar conexión en el administrador de servidores.

Ilustración 5:6 Administrador de Servidores

Plantilla 2 Hacemos clic derecho y seleccionamos la opción Agregar co-nexion.

Ilustración 5:7 Agregar Servidor de SQL





3 Seleccionamos nuestro servidor de SQL.

4 Establecemos nuestra cuenta de usuario y password.

5 Elegimos la base de datos ChocolateFactory.

Ilustración 5:8 Estableciendo Conexión

Configuración Servidor

Tabla en ObjetoLINQ 6 Después de establecer conexión arrastramos la tabla ProductCho-colateFactory al objeto LINQ DAOChocolate.

Ilustración 5:9 DAOChocolate

Continúa la siguiente página.



6. Capa Empresarial

Introducción En este capítulo crearemos la capa de negocio que permitirá la co-municación entre la los servicios y el acceso a Base de datos. Además que cuenta con las reglas de negocio de la aplicación.

El lenguaje de programación que usaremos para este ejemplo será C#. Pero es indiferente para nosotros puede ser el lenguaje que más estemos familiarizado y nos ofrezca Visual Studio 2008.

Paso 1: Crear Busi-

nessChocolate

1 Agregamos un nuevo elemento al proyecto DataChocolateFactory de tipo clase con el nombre “BusinessChocolate”. (véase, Agregar nuevo elemento).

2 Seleccionar plantilla tipo clase.

Clase

Ilustración 6:1 Clase Empresarial




Capa Empresarial, continúa

Paso 2: Codificación El siguiente paso es crear los métodos necesarios para ingresar nuevos productos y eliminar productos.

Utilizaremos como medio de acceso DAOChocolate con LINQ.

1 Instanciamos un objeto de tipo DAOChocolateDataContext.

2 Crearemos el primer método que se llamará InsertProductChocola-te(). Este método nos permitirá insertar nuevos productos.

3 Crearemos el segundo método que se llamará DeleteProductCho-colate(). Este método nos permitirá eliminar productos.

4 Por último crearemos una función que se llamará GetProducts(). Esta función nos permitirá obtener la lista de productos existentes.

Ilustración 6:2 Clase BusinessChocolate

Métodos Sugeridos

Es posible que tu clase de negocio crezca entonces puedes tener más operaciones de negocio en la misma.



7. Servicios

Introducción En este capítulo crearemos la estructura de servicios. Aquí se hace la diferencia entre una aplicación de escritorio a una aplicación Smart Client.

Visual Studio cuenta con WCF para la creación de servicios estructu-rados. WCF nos permite exponer funcionalidad para cualquier tipo de protocolo de comunicación que sea configurado.

Para este ejemplo utilizaremos el protocolo HTTP, nos permitirá transportar la información en un formato XML.

XML es un formato estándar en que cualquier plataforma de desa-rrollo lo pueda interpretar.

A continuación los pasos a seguir para crear la capa de servicios de ChocolateFactory.

Paso 1: Crear Servi-

cesChocolate

Son los siguientes pasos:

1 Agregamos un nuevo sitio web.

Métodos Sugeridos

Ilustración 7:1 Agregamos un nuevo Sitio Web

Este sitio web nos permitirá hostear nuestro servicio para ser com-partida nuestra funcionalidad en la red.




Servicios, continúa

Creamos proyecto

WCF

2 Elegimos la plantilla de WCF y establecemos el nombre “Services Chocolate”.

Servicio WCF

Ilustración 7:2 Plantilla Servicio WCF

Paso 2: Crear Clases

de Servicio

En este paso nos preocuparemos por crear los ServicesContracts, Data-Contracts y ServiceImplementation. A continuación se explicarán breve-mente estos términos que son la estructura del servicio.

Término Concepto

ServiceContract Describe lo que hace el servicio. Se definen las operaciones del servicio ejemplo “Ob-tenerSaldo”.

DataContract Es la estructura del objeto que se va estar intercambiando en nuestro servicio

ServiceImplementation Esta clase implementa las operaciones del ServiceContract.





Nota:

Al momento de crear el nuevo sitio web nos generará tres clases IServi-ce.cs, Service.cs y Service.svc.

Servicio WCF

Ilustración 7:3 Clases de Implementación de Servicio

Paso 3: Agregar refe-

rencia

Necesitamos comunicar nuestra capa empresarial “DataChocoloateFac-tory” con nuestra capa de servicios “ServicesChocolate”. Esto es para

utilizar la funcionalidad de la capa de acceso a datos con el servicio WCF.

1 Hacer clic derecho sobre el proyecto de servicios “AgregarReferen-cia”.

2 Hacer clic izquierdo en la pestaña llamada “Proyectos”.

3 Hacer clic en el botón “Aceptar”.





Referencia

Ilustración 7:4 Agregar Referencia

Elegimos la pestaña “Proyectos” donde se encuentra nuestro proyecto

“DataChocolateFactory”.

Proyectos

Ilustración 7:5 Referencia Proyectos.





Paso 4: Codificación

de Estructura del Ser-

vicio

Iniciaremos a construir la estructura del servicio que expondremos en la red. A continuación se muestra en estos pasos:

1 En nuestra clase “IService” codificaremos la clase “Chocolate-Product”. Esta es la siguiente estructura:

DataMember Descripción

IdProducto Clave del producto.

NombreProducto Nombre del producto.

Descripción La descripción del producto

Categoria Contiene la categoría del Producto

ChocolateProduct Código DataContract

Ilustración 7:6 DataContract ChocolateProduct





ChocolateProductCollection Para obtener la lista de productos necesitaremos crear una clase de tipo

colección de objetos que nos retorne una lista “ChocolatteProduct”.

2 En nuestra clase “IService” codificaremos la clase “Chocolate-ProductCollection”. Esta es la siguiente estructura:

Constructores Descripción

ChocolateProductCollection Nos permite inicializar un objeto sin paráme-tros.

ChocolateProductCollection(IEnumerable)

Nos permite inicializar una colección de obje-tos mandando como parámetros una lista de

tipo “ChocolateProduct”.

Código DataContractCollection

Ilustración 7:7 DataContractCollection ChocolateProductCollection





Implementación del

Servicio

El siguiente paso es implementar la funcionalidad “IService” en nuestra

clase “Service”. La clase “Service” contendrá todas las operaciones

establecidas en nuestra clase ServiceContract “IService” lista para codificar la comunicación entre la capa de servicios y la capa

empresarial. “DataChocolateFactory”.

3 Implementar clase “IService” en nuestra clase “Service”. Haz clic

derecho elige la opción “Implementar Interfaz”.

Opción Implementar Interfaz

Ilustración 7:8 Implementar Interfaz IService

Código generado por la herramienta de Visual Studio 2008.

Ilustración 7:9 Código generado por la herramienta





Codificación de Ope-

rationsContracts

En esta sección nosotros codificaremos la funcionalidad necesaria para comunicar nuestros servicios con la capa empresarial y de datos.

Es importante saber que la creación de un servicio no debe tomarse tan a la ligera pues el punto de existencia de estos es compartir funcionalidad a terceros. Y saber analizar que operaciones son requeridas y funcionales para exponerlas en nuestro servicio.

InsertProductChocolate Después de haber generado el código con la API de Visual Studio 2008. El siguiente paso es alimentar los métodos para comunicar nuestra aplicación entre capas. Iniciaremos con el método

“InsertProductChocolate”.

Codificación

Ilustración 7:10 InsertProductChocolate

Cuando agregamos la referencia fue con esta intención utilizar la funcio-

nalidad del proyecto DataChocolateFactory.

En este método nosotros instanciamos un objeto de tipo Product-Chocolatefactory llamado objProduct para asignarles todos los valores

obtenidos por nuestro parámetro product.

Nosotros instanciamos un objeto de BusinessChocolate al cual

ejecutaremos el método InsertProductChocolate mandándole como

parámetro objProduct.

Con esto finalizaremos la funcionalidad de nuestro método.





DeleteProductChocolate El siguiente método es crear la funcionalidad para eliminar un producto

de ChocolateFactory.

Codificación

Ilustración 7:11 DeleteProductChocolate

En este método nosotros instanciaremos nuevamente un objeto de

tipo ProductChocolateFactory.

Le asignaremos los valores obtenidos de nuestro parámetro product.

Instanciaremos un objeto llamado objChocolate de tipo BusinessCho-colate.

Por último ejecutamos el método DeleteProductChocolate.

GetProducts El siguiente método es para obtener la lista de productos de Chocolate-Factory.

Codificación

Ilustración 7:12 GetProducts

En este método nosotros instanciaremos un objeto BusinessChocolate llamado objChocolate.

Crearemos un objeto tipo lista ChocolateProductCollection llamado

list.

Creamos un foreach para recorrer la lista de objetos obtenidos de

objChocolate.GetProducts() y Por último retornaremos la lista obteni-

da de ChocolateProductCollection.





Paso 5: Visualizar el

Servicio

Por último probaremos nuestro servicio para saber si está sirviendo correctamente.

Ver en el explorador

Ilustración 7:13 Probar Servicio

Esto veremos en nuestro browser

Explorador

Ilustración 7:14 Navegador I

Continúa en la página siguiente




Hacemos clic el link Service.svc y la próxima pantalla será la siguiente.

Ilustración 7:15 Service.svc

Hacemos clic en el link que nos genera el servicio en este caso es el siguiente

svcutil.exe http://localhost:51788/ServicesChocolate/Service.svc?wsdl

Veremos el WSDL del servicio:

Ilustración 7:16 WSDL

http://localhost:51788/ServicesChocolate/Service.svc?wsdl



8. Cliente

Introducción En este capítulo crearemos un nuevo proyecto de tipo WPF que nos permita consumir nuestro servicio.

La parte fundamental de este capítulo es simular de que nuestro cliente se encuentra en una sucursal de otra región y requiere obtener la lista de los nuevos productos de ChocolateFactory

Paso 1: Crear Solu-

ción en Visual Studio

WPF

Para crear una nueva solución véase como Crear un nuevo Proyec-to.

Establecer el nombre como ClientChocolateFactory.

Agregaremos un nuevo proyecto véase como Agregar un nuevo proyecto.

Seleccionaremos una plantilla de tipo Aplicación WPF.

Plantilla WPF

Ilustración 8:1 Aplicación WPF




Cliente, continúa

Layout Cliente Lo siguiente es crear el interfaz de usuario que la podemos diseñar muy fácil con Visual Studio 2008

Es la siguiente:

Ilustración 8:2 Layout Cliente

Agregar Service Refe-

rence

Ahora sigue lo bueno, consumir nuestro servicio creado. Comenzare-mos agregando la referencia.

Service reference

Ilustración 8:3 Agregar referencia de servicio




Cliente, continúa

En la siguiente imagen se muestra como busca el servicio. Nosotros le establecemos un sobrenombre al servicio para identificarlo más fácil en

este caso es ServiceChocolateFactory.

Service reference

Ilustración 8:4 Asociar Servicio

Sobrenombre del Servicio

Codificación Cliente El siguiente paso es codificar toda la parte del cliente para con-sumir nuestro servicio.

Tendremos cinco funciones principales Window_Loaded, brnAcep-tar_Click, btnEliminar_Click y CargaGrid.

Las cuales usaremos para operar las funciones necesarias para guardar,

consultar y eliminar en nuestra forma Window1.xaml que se genera automáticamente de la creación del proyecto.




Cliente, continúa

A continuación se muestra como se creará la funcionalidad de nuestras

funciones clientes en code behind de la forma Window1.xaml.

Codificación

Ilustración 8:5 Operaciones I

Ilustración 8:6 Operaciones II




Cliente, continúa

A continuación se muestra como queda de lado del XAML de nuestra

forma Window1.xaml.

Script XAML

Ilustración 8:7 XAML



9. Prueba de ClientChocolateFactory

Introducción En este capítulo por último realizaremos la prueba de nuestra aplicación

ClientChocolatefactory. Llegando a nuestro final de la aplicación smart

client.

Agregando produc-

tos

En la siguiente imagen se muestra como se agrega un nuevo producto al catalogo.

Agregar Producto

Ilustración 9:1 Agregar producto




Cliente, continúa

Eliminar productos En la siguiente imagen se muestra como se agrega un nuevo producto al catalogo.

Eliminar Producto

Ilustración 9:2 Seleccionamos Producto

Ilustración 9:3 Eliminado Producto



10. Conclusiones

En este manual se mostró una manera sencilla de crear una aplicación smart client usando usando buenas prácticas de desarrollo y lo último en tecnología.

Lo importante de utilizar estas tecnologías es la aceleración de desarrollo y disminución de tiempos.

Para los desarrolladores una parte esencial al crear aplicaciones robustas que tengan implementadas buenas prácticas.

Proyecto integrador aplicaciones smart client

Education

Transcript of Proyecto integrador aplicaciones smart client