Tutorial Zonas WWF .NET Framework 4

Tutorial Entity Framework con Windows Workflow Foundation en .NET Framework 4

El objetivo del siguiente tutorial es modelar un sistema de información utilizando las herramientas que ofrece .NET Framework 4.0, utilizando Microsoft Visual Studio 2010 como entorno de programación. El tutorial utiliza un sistema de Gestión de Zonas geográficas, y la gestión de la información se hace con LINQ to Entities.

Tabla de Contenidos

1. Prerrequisitos 2

2. Descripción del sistema de información 3

3. Descripción de actores y de use cases 4

4. Modelando los casos de uso 12

5. Creación del modelo de datos-Entidades 14

6. Generación de la base de datos 17

7. Generación del diagrama de clases 21

8. Transición de los casos de uso a las actividades propias y a los Workflows 23

8.1 Gestión de países… ……………………………………………………………………………………………..268.2 Gestión de departamentos…………………………………………………………………………………….388.3 Gestión de municipios……………………………………………………………………………………………42

9. Integración con la GUI1 46

10. Clases parciales……………………………………………………………………………………….…………………..59

11. Bibliografía adicional 66

1 GUI: Graphic User Interface.

2Tutorial Entity Framework con Windows Workflow Foundation en .NET Framework 4

1. PRERREQUISITOS

Para seguir el tutorial debe instalar Microsoft Visual Studio 2010. Si tiene cuenta con MSDN Academic Alliance, descargue Visual Studio 2010 en: Icesi Academic Alliance with Microsoft (http://www.icesi.edu.co/student_tech_club/recursos.aspx). Si tiene dificultades para hacerlo, puede contactar a José Mauricio Gadban en el centro de servicios informáticos.

2. DESCRIPCIÓN DEL SISTEMA DE INFORMACIÓN

El sistema de información de zonas geográficas permite a un usuario ingresar y consultar información de varios países con sus departamentos y municipios. Cada municipio tiene alcalde, habitantes y área; cada departamento tiene municipios, uno de los cuales es su capital. Un departamento tiene gobernador, área igual a la suma de las áreas de sus municipios y habitantes igual a la suma de los habitantes de sus municipios. Cada país tiene departamentos, presidente, un municipio como capital, área igual a la suma de las áreas de sus departamentos y habitantes igual a la suma de los habitantes de sus departamentos. El modelo debe permitir consultas sobre municipios, departamentos y países. De un municipio debe mostrar su nombre, nombre del alcalde, área y habitantes. De un departamento debe mostrar su nombre, nombres de todos sus municipios, nombre del gobernador, área, habitantes y el nombre de su municipio capital. De un país debe mostrar su nombre, nombres de todos sus departamentos, nombre de su municipio capital, nombre del presidente, área y habitantes. Todas las zonas tienen un código que las identifica.

El objetivo del sistema es guardar información sobre zonas geográficas, y consultar información sobre una zona. Primero se ingresa la información de los países, luego la información de los departamentos y por último la de los municipios. Para ingresar un departamento o un municipio es necesario que ya exista la zona a la cual pertenece.

https://msdn34.e-academy.com/elms/Security/Login.aspx?campus=icesi_informatica

https://msdn34.e-academy.com/elms/Security/Login.aspx?campus=icesi_informatica


3. DESCRIPCIÓN DE ACTORES Y DE USE CASES

ACTORES EXTERNOS

Nombre UsuarioCasos de Uso

Gestionar País, Gestionar Dpto, Gestionar Mpio

Tipo Primario

Descripción Realiza todas las inserciones, modificaciones, consultas y eliminaciones de las zonas.

Nombre Base de datosCasos de Uso

Gestionar País, Gestionar Dpto, Gestionar Mpio

Tipo Secundario

Descripción Mantiene la información de las zonas y le da persistencia.

USE CASES

Use case: UC1

VALIDAR ZONA

Actores Base de DatosTipo Inclusión – Actividad propia simplePropósito Validar la existencia de una zonaResumen Este use case se invoca cada vez que alguna de las gestiones

necesita validar la existencia de una zona en la base de datos Entradas Referencia al modelo de datos, Código de la zonaSalidas Referencia a la zona encontrada o mensaje de no existencia

Flujo PrincipalSe valida la existencia de una zona con ese código en la base de datos, se retorna referencia a la zona encontrada y se continua con el use case de gestión que lo invoco

Use case: UC2

GESTIONAR ZONA

Actores Usuario


Tipo Básico – InterfazPropósito Ejecutar las actividades comunes a los tres subtipos de gestión

y ofrecer los servicios del sistemas al usuarioResumen El usuario inicia este use case, el cual le permite seleccionar

cualquiera de las opciones que ofrece el sistemaFlujo Principal

Se presenta al usuario la pantalla de menú principal- El usuario puede seleccionar: “Gestión País”, “Gestión Dpto”,

“Gestión Mpio” o “Salir”- Si selecciona “Gestión País”, se continua con el use case UC3:

Gestionar País - Si selecciona “Gestión Dpto”, se continua con el use case UC4:

Gestionar Depto- Si selecciona “Gestión Mpio”, se continua con el use case UC5:

Gestionar Mpio- Si selecciona “Salir”, se saldrá del sistema

Interface usuario

Use case: UC3 GESTIONAR PAÍSActores UsuarioTipo Extensión – WorkflowPropósito Permitir al usuario realizar la gestión de un país.Resumen El usuario inicia este use case, el cual le permite adicionar,

consultar, modificar, eliminar un país, o retornar al menú principal

Precondiciones

Requiere ejecutar inicialmente el use case UC2: Gestionar Zona


Flujo Principal

Se invoca el evento externo EE1: Administrar Países

Interface usuario

Eventos externosEE1: Administrar Países- El sistema muestra la pantalla Gestión País- Si el usuario digita el código del país, nombre, presidente y selecciona “Adicionar”, se invoca el evento externo EE2: Adicionar País- Si el usuario digita el código del país y selecciona “Consultar” se invoca el evento externo EE3: Consultar País- Para modificar la información de un país se debe haber invocado el evento externo EE3: Consultar País, el usuario actualiza la información del país consultado y selecciona “Modificar”, se invoca el evento externo EE4: Modificar País- Si el usuario digita el código del país y selecciona “Eliminar” se invoca el evento externo EE5: Eliminar País- Si el usuario selecciona “Menú” se invoca el use case UC2: Gestionar ZonaEE2: Adicionar País- Se invoca el use case UC1: Validar Zona para el país- Si el país ya existe (EX1) o la información del país es incompleta (EX2) se invoca el evento externo EE1: Administrar Países - Si el código del país no existe y la información es completa se registra en la base de datos, se notifica al usuario del registro y se invoca el evento externo EE1: Administrar PaísesEE3: Consultar País- Se invoca el use case UC1: Validar Zona para el país- Si el código del país no existe (EX3) se invoca el evento externo EE1: Administrar Países- Si el país existe el sistemas obtiene toda la información del país de la base de datos, se invoca el evento externo EE1: Administrar Países con la información correspondienteEE4: Modificar País- Se actualiza el registro del país con la información modificada en la base de datos, se notifica al usuario y se invoca el evento externo EE1: Administrar


PaísesEE5: Eliminar País- Se invoca el use case UC1: Validar Zona para el país- Si el código del país no existe (EX3) se invoca el evento externo EE1: Administrar Países- Si el país existe el sistema solicita reconfirmar la eliminación y lo elimina de la base de datos, se invoca el evento externo EE1: Administrar Países

Excepciones

EX1: Ya existe una zona con ese código, se muestra el mensaje correspondiente y continúa el use case.EX2: La información del país está incompleta, el sistema muestra el mensaje correspondiente y continúa el use caseEX3: Zona inexistente, se muestre el mensaje correspondiente y se continua con el use case

Use case: UC4 GESTIONAR DPTOActores UsuarioTipo Extensión – WorkflowPropósito Permitir al usuario realizar la gestión de un departamento.Resumen El usuario inicia este use case el cual le permite adicionar,

consultar, modificar, eliminar un departamento o regresar a la pantalla principal

Precondiciones


Flujo Principal

Se invoca el evento externo EE1: Administrar Dptos

Interfaces usuario

Eventos externosEE1: Administrar Dptos- El sistema muestra la pantalla Gestión Departamento


- Si el usuario digita el código del departamento, nombre, gobernador, código del país al que pertenece y selecciona “Adicionar”, se invoca el evento externo EE1: Adicionar Dpto- Si el usuario digita el código del departamento y selecciona “Consultar” se invoca el evento externo EE3: Consultar Dpto- Para modificar la información de un departamento se debe haber invocado el evento externo EE3: Consultar Dpto, el usuario actualiza la información del departamento consultado y selecciona “Modificar”, se invoca el evento externo EE4: Modificar Dpto- Si el usuario digita el código del departamento y selecciona “Eliminar” se invoca el evento externo EE5: Eliminar Dpto- Si el usuario selecciona “Menú” se invoca el use case UC2: Gestionar ZonaEE2: Adicionar Dpto- Se invoca el use case UC1: Validar Zona para el departamento - Si el departamento existe (E1) o la información del departamento es incompleta (E2), se invoca el evento externo EE1: Administrar Dptos- Si el departamento no existe y la información es completa se invoca el use case UC1: Validar Zona para el país- Si el país no existe (E4) se invoca el evento externo EE1: Administrar Dptos- Si el departamento no existe, el país si existe y la información es completa, el sistemas adiciona el departamento a la base de datos y se invoca el evento externo EE1: Administrar DptosEE3: Consultar Dpto- Se invoca el use case UC1: Validar Zona para el departamento- Si el código del departamento no existe (E3) se invoca el evento externo EE1: Administrar Dptos- Si el departamento existe el sistema obtiene toda la información del departamento de la base de datos, se invoca el evento externo EE1: Administrar Dptos con la información correspondienteEE4: Modificar Dpto- Se actualiza el registro del departamento con la información modificada en la base de datos, se notifica al usuario y se invoca el evento externo EE1: Administrar DptosEE5: Eliminar Dpto- Se invoca el use case UC1: Validar Zona para el departamento- Si el código del departamento no existe (E3) se invoca el evento externo EE1: Administrar Dptos- Si el departamento existe el sistema solicita reconfirmar la eliminación y lo elimina de la base de datos, se invoca el evento externo EE1: Administrar Dptos

Excepciones

EX1: El departamento ha sido ingresado con anterioridad. El sistema muestra el mensaje correspondiente y continúa el use case.EX2: La información del departamento está incompleta. El sistema muestra el mensaje correspondiente y continúa el use case.EX3: El código del departamento no se encontró. El sistema muestra el mensaje y continua con el use case


EX4: El código del departamento no se encontró. El sistema muestra el mensaje y continua con el use case

Use case: UC5 GESTIÓN MPIOActores UsuarioTipo Extensión – WorkflowPropósito Permitir al usuario realizar la gestión de un municipio.Resumen El usuario inicia este use case, el cual le permite adicionar,

modificar, eliminar o consultar un país.Precondiciones


Flujo Principal

Se invoca el evento externo EE1: Administrar Mpios

Interface usuario

Eventos externosEE1: Administrar Mpios- El sistema muestra la pantalla Gestión Municipio- Si el usuario digita el código del municipio, nombre, alcalde, código del departamento al que pertenece, si es capital de país y/o departamento, el área en m2, la población y selecciona “Adicionar”, se invoca el evento externo EE2: Adicionar Mpio- Si el usuario digita el código del municipio y selecciona “Consultar” se invoca el evento externo EE3: Consultar Mpio- Para modificar la información de un municipio se debe haber invocado el evento externo EE3: Consultar Mpio, el usuario actualiza la información del municipio consultado y selecciona “Modificar”, se invoca el evento externo EE4: Modificar Mpio


- Si el usuario digita el código del municipio y selecciona “Eliminar” se invoca el evento externo EE5: Eliminar Mpio- Si el usuario selecciona “Menú” se invoca el use case UC2: Gestionar ZonaEE2: Adicionar Mpio- Se invoca el use case UC1: Validar Zona para el municipio - Si el municipio existe (EX1) o la información del municipio es incompleta (EX2), se invoca el evento externo EE1: Administrar Mpios- Si el municipio no existe y la información es completa se invoca el use case UC1: Validar Zona para el departamento- Si el departamento no existe (EX4) se invoca el evento externo EE1: Administrar Mpios- Si el municipio no existe, el departamento si existe y la información es completa, el sistemas adiciona el municipio a la base de datos y se invoca el evento externo EE1: Administrar MpiosEE3: Consultar Mpio- Se invoca el use case UC1: Validar Zona para el municipio- Si el código del municipio no existe (EX3) se invoca el evento externo EE1: Administrar Mpios- Si el municipio existe el sistema obtiene toda la información del municipio de la base de datos, se invoca el evento externo EE1: Administrar Mpios con la información correspondienteEE4: Modificar Mpio- Se actualiza el registro del municipio con la información modificada en la base de datos, se notifica al usuario y se invoca el evento externo EE1: Administrar MpiosEE5: Eliminar Municipio- Se invoca el use case UC1: Validar Zona para el municipio- Si el código del municipio no existe (EX3) se invoca el evento externo EE1: Administrar Mpios- Si el municipio existe el sistema solicita reconfirmar la eliminación y lo elimina de la base de datos, se invoca el evento externo EE1: Administrar Mpios

Excepciones

EX1: El municipio ha sido ingresado con anterioridad. El sistema muestra el mensaje correspondiente y continúa el use case.EX2: La información del municipio está incompleta. El sistema muestra el mensaje correspondiente y continúa el use case.EX3: El código del municipio no se encontró. El sistema muestra el mensaje y continua con el use caseEX4: El código del departamento no se encontró. El sistema muestra el mensaje y continua con el use case


4. MODELANDO LOS CASOS DE USO

Nota: Cabe resaltar el hecho de que el .NET 4.0 es bastante pobre en cuanto a casos de uso, y simplemente sirven como una referencia gráfica y de documentación, aunque se le pueden adjuntar documentos de texto donde se explique la descripción de cada caso de uso mediante objetos tipo Artifact.

1. Cree una solución en blanco llamada Zonas geográficas.2. Dé click derecho en la solución que esté desarrollando y luego click en

AddNew ítemModeling project.

3. Dé click derecho sobre el proyecto de modelado que acaba de crear y luego AddNew ítemUML Use Case diagram.


4. Diagrame los casos de uso arrastrando los elementos necesarios en el Toolbox que ofrece la herramienta y colóquelos en el área de diagramación que ofrece .NET 4.0.

5. Si desea agregarle un documento con la descripción de los casos de uso, arrastre al área de dibujo un objeto tipo Artifact.

6. En las propiedades del artefacto, enlace el documento en donde tiene la descripción –puede ser una ubicación en internet o un documento en disco- en la propiedad Hyperlink.


5. CREACIÓN DEL MODELO DE ENTIDADES

A continuación se utilizarán las herramientas que ofrece el Entity Framework de .NET 4.0 mediante el lenguaje LINQ to Entities.

1. Cree un proyecto de tipo Class Library.2. Adicione al proyecto un ADO.NET Entity Data Model.

3. Seleccione Empty Model en el Wizard de creación del modelo.


4. Cree las entidades correspondientes al ejercicio. El modelo de entidades debe ser similar a este:

Es importante en este paso tener en cuenta las siguientes consideraciones:

En la ventana de propiedades de Zona, coloque Abstract = true, Entity set name = Zonas. En los demás conceptos colocar la propiedad Abstract = False

Adicione relaciones de herencia entre zona y las otras entidades La propiedades escalar Área debe ser double, Habitantes debe ser int32, y

tanto EsCptalDpto como EsCptalPais deben ser booleans. Adicione una asociación dependiente uno a muchos entre Pais ➜ Dpto y

otra entre Dpto ➜ Mpio. Seleccione Cascade en End1 on Delete. Adicione una asociación independiente o..1 en ambos extremos entre Pais

➜ Mpio y otra entre Dpto ➜ Mpio, sin propiedades de navegación Mpio ➜ Pais, ni Mpio ➜ Dpto.

NOTA: Para adicionar una asociación entre dos entidades, se recomienda seguir el siguiente procedimiento:

i. Presione click derecho sobre cualquiera de las dos entidades que van a asociarse, luego, seleccione AddAssociation:


ii. Adicione los parámetros para la asociación (se muestra para país--Dpto)


6. GENERACIÓN DE LA BASE DE DATOS

1. Sobre el diseñador del modelo, en un lugar en blanco, dé click derecho y luego Generate Database from model.

2. En el Wizard de creación del modelo, dé click en New Connection.


3. Establezca el servidor que tiene conexión con el SQL Server .

4. Confirme que desea crear la base de datos hasta ahora inexistente.


5. Confirme que el Connection String hace referencia a la base de datos que acaba de crear. Luego de esto dé click en Next.

6. Revise el Script de creación de la base de datos, ya que será muy útil a la hora de hacer las consultas –Mire que todas las entidades se mapearon de manera correcta-. Luego de esto dé click en Finish.


7. Abra el archivo Conceptos.edmx.sql, dé click derecho sobre alguna parte del código y luego ejecute el SQL, esto con el fin de que se creen las tablas en la base de datos generada.

8. Cuando ejecute el Script SQL, debe pedirle confirmación para conectarse al SQL Server. Simplemente conéctese por la ventana que le sale.


7. CREACIÓN DEL DIAGRAMA DE CLASES

Abra el archivo Conceptos.Designer.cs

En este archivo se encuentran todas las entidades que se generaron en el modelo de datos-entidades. Es aquí donde más adelante se realizarán las consultas LINQ to Entities, ya sean de inserción, modificación o borrado.

Si quiere ver el diagrama de clases generado, puede darle click derecho sobre el proyecto donde está el modelo de datos (en este caso Modelo_Datos_Entidad), y luego click en View class diagram


El diagrama de clases que se genere debe ser similar a este:


8. TRANSICIÓN DE LOS CASOS DE USO A LAS ACTIVIDADES PROPIAS Y A LOS WORKFLOWS

Para realizarla es necesario tener en mente el marco de trabajo de Windows Workflow Foundation. A continuación se presenta una esquematización del proceso:

WINDOWS WORKFLOW FOUNDATION

Al hacer la transición de los Use cases a los Workflows, se deben tener en cuenta las siguientes consideraciones:


- De cada use case de inclusión derivamos una actividad reusable.

- De cada use case básico con eventos externos derivamos un workflow.

- De cada evento externo de un use case complejo derivamos una actividad.

- El controlador principal corresponde a la aplicación que aloja los workflow.

- Cada controlador representa el control de flujo de un workflow.

- Los datos de entrada salida de un evento externo corresponden a los datos de entrada salida de una actividad.

- Los métodos de un controlador corresponden a los métodos de su workflow.

Tabla de correspondencia de Casos de uso y eventos externos a Actividades y Workflow

Modelo Casos de Uso Implementación .NET WWF

UC1 Validar Zona Actividad PropiaUC2 Gestionar Zona Windows FormUC3 Gestionar Pais Workflow Secuencial

EE1 Administrar Pais Windows FormEE2 Adicionar Pais Actividad PropiaEE3 Consultar Pais Actividad PropiaEE4 Modificar Pais Actividad Propia

EE5 Eliminar Pais Actividad PropiaEX1 Actividad de CódigoEX2 Código del FormEX3 Actividad de Código

UC3 Gestionar Dpto Workflow SecuencialEE1 Administar Dpto Windows Form

EE2 Adicionar Dpto Actividad propiaEE3 Consultar Dpto Actividad propiaEE4 Modificar Dpto Actividad propia

EE5 Eliminar Dpto Actividad propiaEX1 Actividad de CódigoEX2 Código del FormEX3 Actividad de CódigoEX4 Actividad de Código

UC3 Gestionar Mpio Workflow Secuencial


EE1 Administrar Mpio Windows FormEE2 Adicionar Mpio Actividad propiaEE3 Consultar Mpio Actividad propiaEE4 Modificar Mpio Actividad propia

EE5 Eliminar Mpio Actividad propiaEX1 Código del FormEX2 Actividad de CódigoEX3 Actividad de CódigoEX4 Actividad de Código

Tabla 8.1: Transición de los Use cases a actividades propias y Workflows

A continuación se presenta el proceso de transición de use case a Workflow para la gestión de países, departamentos y municipios. Es claro resaltar que la gestión de países se explicara paso a paso, pero las otras dos, solamente se presentará el código necesario para su correcto funcionamiento.


8.1 Gestión de países

1. Adicione un proyecto a su solución de tipo Activity Library. Es muy importante que seleccione .NET Framework 4.0 como plataforma de desarrollo.

2. Adicione una referencia al proyecto que contiene el modelo de entidades.


3. Adicione las referencias System.Activities, System.Data.Entity y System.Windows.Forms


4. Adicione dos carpetas al proyecto que acaba de crear, esto con el fin de darle más orden a la solución, en una irán las actividades, y en la otra, los workflows.


5. Adicione las siguientes actividades: InsertarPaís, ModificarPaís, ConsultarPaís y EliminarPaís.

En el proyecto

6. Revise que el proyecto Actividades_Workflows tenga las mismas referencias que aparecen en la siguiente imagen –en caso que no, por favor adiciónelas manualmente-


7. Para adicionar una actividad, dé click derecho sobre la carpeta Actividades que acaba de crear, luego AddNew Item y se selecciona la actividad de tipo CodeActivity.


8. Inserte el siguiente argumento de entrada para la actividad InsertarPaís:

Nombre Tipo Descripción

PaisEntrada Pais País que usuario desea consultar, el cual se crea solo con el atributo del identificador.

Tabla 8.2: Argumentos para InsertarPaís

Las actividades tienen argumentos tanto de entrada como de salida.

public InArgument<Pais> PaisEntrada { get; set; }

9. Adicione el siguiente código para la ejecución de la actividad en el método Execute:

Pais pais = PaisEntrada.Get(context); int codigo = pais.Id; ModeloContainer contexto = new ModeloContainer(); contexto.AddToZonas(pais); contexto.SaveChanges(); MessageBox.Show("El país se grabó exitosamente", "GRABACIÓN

DEPARTAMENTO");


10.Cree otra actividad que se llame modificarPaís.cs. Añada el siguiente código para el correcto funcionamiento de la actividad:

// Define an activity input argument of type string public InArgument<Pais> PaisNuevo { get; set; } public InArgument<Pais> PaisViejo { get; set; } // If your activity returns a value, derive from CodeActivity<TResult>

protected override void Execute(CodeActivityContext context) { // and return the value from the Execute method. ModeloContainer contexto = new ModeloContainer(); Pais nuevo = PaisNuevo.Get(context); Pais viejo = (Pais)contexto.Zonas.Where(p =>

p.Id.Equals(nuevo.Id)).DefaultIfEmpty().First();

viejo.Nombre = nuevo.Nombre; viejo.Gobernante = nuevo.Gobernante; contexto.SaveChanges(); MessageBox.Show("El país se actualizó exitosamente", "MOFIFICAR PAÍS"); }

11.Añada el siguiente código para el correcto funcionamiento de la actividad consultarPaís:

// Define an activity input argument of type string public InArgument<Pais> PaisEntrada { get; set; } public OutArgument<Pais> PaisSalida { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd= new ConceptosContainer (); Pais paisEntrada= PaisEntrada.Get(context); String gobernante=paisEntrada.Gobernante; Pais paisSalida= (Pais)bd.ZonaSet.Where(p => p.Id.Equals(paisEntrada.Id)).DefaultIfEmpty().First(); PaisSalida.Set(context, paisSalida); } }

12. Adicione el siguiente código para el correcto funcionamiento de la actividad eliminarPais:

public sealed class EliminarPais : CodeActivity { // Define an activity input argument of type string public InArgument<Pais> PaisEntrada { get; set; }


// If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { using (ConceptosContainer bd = new ConceptosContainer ()) { Pais paisEntrada = PaisEntrada.Get(context); Pais eliminar = (Pais)bd.ZonaSet.Where(c => c.Id == paisEntrada.Id).ToList()[0]; bd.DeleteObject(eliminar); bd.SaveChanges(); MessageBox.Show("El país se eliminó exitosamente", "BORRADO PAÍS"); } } }

13.Cree un Workflow secuencial llamado GestiónPaís.cs.


14.Añada los siguientes Argumentos al workflow:

Nombre Tipo DescripciónAccion String (in) Permite escoger dentro

de las distintas opciones del Workflow.

PaisEntrada Pais (In) Instancia de País que se va a ingresar, o modificar, o eliminar, o consultar.

PaisSalida Pais (Out) Instancia del país que se retorna cuando se consulta o se valida su existencia.

Tabla 8.6: Argumentos para el Workflow GestiónPaís

15.Diseñe el workflow GestiónPaís de tal manera que quede similar al siguiente:


16.Cuando esté diseñando el Workflow y vaya a hacer el Switch<t> para incluir las opciones que puede tomar el Workflow durante su ejecución, tenga en cuenta lo siguiente:

a. Debe indicar en el Switch que variable tendrá los casos para acceder a los diferentes procesos, en nuestro caso es el argumento Acción.


17.A cada una de las actividades propias del Workflow GestiónPaís, debe “amarrarle” los argumentos del Workflow como de la actividad, esto con el fin de que se pueda realizar una comunicación entre el Workflow y la actividad, y ésta última pueda realizar su tarea propia. Para ello, seleccione una actividad propia (por ejemplo, consultarPaís), y vaya a sus propiedades. Llene las categorías de la siguiente manera:

a. Hay que ligar los argumentos de entrada y salida de la actividad con los argumentos de entrada y salida del workflow.

b. Seleccionamos la actividad a la cual queremos ligar los argumentos, vamos a sus propiedades y vemos como aparecen los argumentos de dicha actividad. Para relacionarlos con los del workflow, solo basta con escribir el nombre del argumento correspondiente del workflow, tal y como se muestra a continuación.

8.2 Gestión de departamentos

1. Adicione al proyecto Actividades_Workflows las actividades: InsertarDpto, ModificarDpto, ConsultarDpto y EliminarDpto.


2. A la actividad InsertarDpto, adicione el siguiente código para la ejecución de la actividad InsertarDpto:

public sealed class InsertarDpto : CodeActivity { // Define an activity input argument of type string public InArgument<Dpto> DptoInsertar { get; set; } public InArgument<Pais> PaisEntrada { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd = new ConceptosContainer(); Pais pais = PaisEntrada.Get(context); Dpto dptoInsertar = DptoInsertar.Get(context); bd.AddToZonaSet(dptoInsertar); bd.SaveChanges(); MessageBox.Show("El departamento se grabó exitosamente", "GRABACIÓN DEPARTAMENTO"); }

3. A la actividad ModificarDpto, añada el siguiente código para el funcionamiento de la actividad ModificarDpto:

public sealed class ModificarDpto : CodeActivity { // Define an activity input argument of type string public InArgument<Dpto> DptoNuevo { get; set; } public InArgument<Dpto> DptoViejo { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd = new ConceptosContainer(); Dpto nuevo = DptoNuevo.Get(context); Dpto viejo = (Dpto)bd.ZonaSet.Where(d => d.Id.Equals(nuevo.Id)).DefaultIfEmpty().First(); viejo.Nombre = nuevo.Nombre; viejo.Gobernante = nuevo.Gobernante; bd.SaveChanges(); MessageBox.Show("El departamento se actualizó exitosamente", "MODIFICACIÓN DEPARTAMENTO"); } }


4. A la actividad ConsultarDpto, adicione el siguiente código para el correcto funcionamiento de la actividad ConsultarDpto:

public sealed class ConsultarDpto : CodeActivity { // Define an activity input argument of type string public InArgument<Dpto> DptoEntrada { get; set; } public OutArgument<Dpto> DptoSalida { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd = new ConceptosContainer(); Dpto dptoEntrada = DptoEntrada.Get(context); if (dptoEntrada != null) { Dpto salida = (Dpto)bd.ZonaSet.Where(d => d.Id.Equals(dptoEntrada.Id)).DefaultIfEmpty().First(); DptoSalida.Set(context, salida); } } }

5. Adicione el siguiente código para el correcto funcionamiento de la actividad EliminarDpto:

public sealed class EliminarDpto : CodeActivity { // Define an activity input argument of type string public InArgument<Dpto> DptoEntrada { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { using (ConceptosContainer bd = new ConceptosContainer()) { Dpto entrada = DptoEntrada.Get(context); Dpto eliminar= (Dpto)bd.ZonaSet.Where(c => c.Id == entrada.Id).ToList()[0]; bd.DeleteObject(eliminar); bd.SaveChanges(); MessageBox.Show("El Departamento se eliminó exitosamente", "BORRADO DEPARTAMENTO"); }


} }6. Cree un Workflow secuencial llamado GestiónDpto, añádale las

siguientes propiedades de dependencia:

Nombre Tipo DescripciónAccion String (IN) Permite escoger dentro


PaisEntrada Pais (IN) Instancia de País que ingresa del formulario.

PaisSalida Pais (OUT) Retorno del País encontrado en la BD.

DptoEntrada Dpto (IN) Instancia del departamento que se va a ingresar, modificar, eliminar o consultar.

DptoSalida Dpto (OUT) Instancia del departamento que se retorna cuando se consulta o se valida su existencia.

Tabla 8.12: Argumentos para el Workflow GestiónDpto

7. Diseñe el Workflow de tal manera que quede similar al siguiente:


Recuerde ligar los argumentos de las actividades con los del workflow como se hizo pasos anteriores.


8.3 Gestión de municipios

1. Adicione al proyecto Actividades_Workflows las actividades: InsertarMpio, ModificarMpio, ConsultarMpio y EliminarMpio.

2. A la actividad InsertarMpio, adicione el siguiente código para el correcto funcionamiento de la actividad InsertarMpio:

public sealed class InsertarMpio : CodeActivity { // Define an activity input argument of type string public InArgument<Mpio> MpioEntrada { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd = new ConceptosContainer(); Mpio mpioEntrada = MpioEntrada.Get(context); bd.AddToZonaSet(mpioEntrada); bd.SaveChanges(); MessageBox.Show("El municipio se grabó exitosamente", "GRABACIÓN MUNICIPIO"); }

3. Adicione el siguiente código para el correcto funcionamiento de la actividad ModificarMpio:

public sealed class ModificarMpio : CodeActivity { // Define an activity input argument of type string public InArgument<Mpio> MpioNuevo { get; set; } public InArgument<Mpio> MpioViejo { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd = new ConceptosContainer(); Mpio nuevo = MpioNuevo.Get(context); Mpio viejo = (Mpio)bd.ZonaSet.Where(p => p.Id.Equals(nuevo.Id)).DefaultIfEmpty().First(); viejo.Nombre = nuevo.Nombre; viejo.Gobernante = nuevo.Gobernante; bd.SaveChanges(); MessageBox.Show("El municipio se actualizó exitosamente", "MODIFICACIÓN MUNICIPIO");


} }

4. Adicione el siguiente código para el correcto funcionamiento de la actividad ConsultarMpio:

public sealed class ConsultarMpio : CodeActivity { // Define an activity input argument of type string public InArgument<Mpio> MpioEntrada { get; set; } public OutArgument<Mpio> MpioSalida { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { ConceptosContainer bd = new ConceptosContainer(); Mpio entrada = MpioEntrada.Get(context); Mpio salida = (Mpio)bd.ZonaSet.Where(m => m.Id.Equals(entrada.Id)).DefaultIfEmpty().First(); MpioSalida.Set(context, salida); } }

5. Adicione el siguiente código para el funcionamiento de la actividad EliminarMpio:

public sealed class EliminarMpio : CodeActivity { // Define an activity input argument of type string public InArgument<Mpio> MpioEntrada { get; set; } // If your activity returns a value, derive from CodeActivity<TResult> // and return the value from the Execute method. protected override void Execute(CodeActivityContext context) { using(ConceptosContainer bd = new ConceptosContainer() ) { Mpio entrada = MpioEntrada.Get(context); Mpio eliminar = (Mpio)bd.ZonaSet.Where(c => c.Id ==entrada.Id).ToList()[0]; bd.DeleteObject(eliminar); bd.SaveChanges();


MessageBox.Show("El municipio se eliminó exitosamente", "BORRADO MUNICIPIO"); } } }}6. Cree un Workflow secuencial llamado GestiónMpio. Adiciónele las

siguientes propiedades de dependencia:

Nombre Tipo DescripciónAccion String (IN) Permite escoger dentro


DptoEntrada Dpto (IN) Instancia de Dpto que ingresa del formulario.

DptoSalida Dpto (OUT) Retorno del Dpto encontrado en la BD.

MpioEntrada Mpio (IN) Instancia del municipio que se va a ingresar, modificar, eliminar o consultar.

MpioSalida Mpio (OUT) Instancia del municipio que se retorna cuando se consulta o se valida su existencia.

Tabla 8.18: Argumentos para el Workflow GestiónMpio


7. Diseñe el Workflow de tal manera que quede similar al siguiente:


9 Integración con la GUI1. Cambie el Target del proyecto en el cual se encuentran alojados los

Workflows y las actividades a uno de tipo Windows Application, esto con el fin de evitar un ciclo a la hora de hacer las referencias entre la vista y los Workflows.

2. Añada las siguientes formas al proyecto: FormaPpal, FormaGestiónPaís. FormaGestiónDptos y FormaGestionMpios. Deben lucir similares a las siguientes:

FormaPpal


FormaGestiónPaís

FormaGestiónDpto

FormaGestónMpio


Nota: Antes de entrar a explicar la manera de instanciar los Workflows desde las formas de Windows, se procederá a mostrar un diagrama de interacción entre las ventanas y los Workflows:

Como se puede observar, cada vez que un usuario dé click en alguno de los botones de las diferentes gestiones –a excepción del botón MenuPpal-, se iniciará una instancia del Workflow respectivo. Con los datos que se ingresen en el formulario y la opción escogida –insertar, consultar, modificar o eliminar-, se crea la instancia.

Recuerde que debe referenciar las el proyecto Actividades_workflows, modelo_datos_entidad, importarlos e importar:

System.Data.Entity; System.Activities;


3. En FormaPpal, simplemente adicione el código necesario para instanciar las ventanas que se van a abrir cuando se de click en un determinado botón.

private void buttonGestiónPaís_Click(object sender, EventArgs e) { FormaGestiónPaís gestiónPaís = new FormaGestiónPaís(); gestiónPaís.Show();

}private void buttonGestiónDpto_Click_1(object sender, EventArgs e)

{ FormaGestiónDpto gestiónDpto = new FormaGestiónDpto(); gestiónDpto.Show(); }

private void buttonGestiónMpio_Click(object sender, EventArgs e) { FormaGestiónMpio gestiónMpio = new FormaGestiónMpio(); gestiónMpio.Show(); }

private void buttonSalir_Click_1(object sender, EventArgs e) { base.Dispose(); base.Close(); }

4. Adicione el siguiente código en el formulario FormaGestiónPaís:

public partial class FormaGestiónPaís : Form { public static Pais p = new Pais(); public FormaGestiónPaís() { InitializeComponent(); } private void buttonAdiciona_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxPresidente.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); p.Id = Int32.Parse(textBoxCódigo.Text); p.Nombre = textBoxNombre.Text.Trim();


p.Gobernante = textBoxPresidente.Text.Trim(); wfArguments.Add("PaisEntrada", p); wfArguments.Add("Accion", "insertar"); GestionPais wf = new GestionPais(); IDictionary<String, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonConsulta_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); p.Id = Int32.Parse(textBoxCódigo.Text.Trim()); wfArguments.Add("Accion", "consultar"); wfArguments.Add("PaisEntrada", p); GestionPais wf = new GestionPais(); IDictionary<String, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); Pais country = (Pais)Result["PaisSalida"]; if (country == null) { MessageBox.Show("País no existe en la base de datos"); } else { country.resetearValores(); textBoxNombre.Text = country.Nombre; textBoxPresidente.Text = country.Gobernante; //Mostrar el área y la población haciendo uso de las clases parciales. country.calcularValores(country.Id); label2.Visible = true; labelCapital.Visible = true;


if (country.CapitalPaís != null) { labelCapital.Text = country.CapitalPaís.Nombre; } label5.Visible = true; label6.Visible = true; label1.Visible = true; lblAreaPais.Text = "" + country.AreaPais; lblPoblPais.Text = "" + country.HabitantesPais; // MessageBox.Show("Área: " + country.AreaPais + " Km2; población: " + country.HabitantesPais + " habitantes."); } } else { MessageBox.Show("CÓDIGO NO EXISTE EN LA BASE DE DATOS", "ERROR"); } } private void buttonModifica_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxPresidente.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); p.Id = Int32.Parse(textBoxCódigo.Text); p.Nombre = textBoxNombre.Text.Trim(); p.Gobernante = textBoxPresidente.Text.Trim(); wfArguments.Add("Accion", "modificar"); wfArguments.Add("PaisEntrada", p); GestionPais wf = new GestionPais(); IDictionary<String, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonElimina_Click(object sender, EventArgs e)


{ if (textBoxCódigo.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); p.Id = Int32.Parse(textBoxCódigo.Text); p.Nombre = textBoxNombre.Text.Trim(); p.Gobernante = textBoxPresidente.Text.Trim(); wfArguments.Add("Accion", "eliminar"); wfArguments.Add("PaisEntrada", p); GestionPais wf = new GestionPais (); WorkflowInvoker.Invoke(wf, wfArguments); } else { MessageBox.Show("Digitar el código", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonMenuPpal_Click(object sender, EventArgs e) { base.Dispose(); base.Close(); } }

5. Adicione el siguiente código en FormaGestiónDpto:

public partial class FormaGestiónDpto : Form { public static Pais p = new Pais(); public static Dpto d = new Dpto(); public FormaGestiónDpto() { InitializeComponent(); } private void buttonAdiciona_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoPaís.Text != string.Empty


&& textBoxNombre.Text != string.Empty && textBoxGobernador.Text != string.Empty) { p.Id = Int32.Parse(textBoxCódigoPaís.Text); d.Id = Int32.Parse(textBoxCódigo.Text); d.Nombre = textBoxNombre.Text.Trim(); d.Gobernante = textBoxGobernador.Text.Trim(); d.PaisId = p.Id; GestionDpto wf = new GestionDpto(); //Se adiciona un Workflow para traer el país al cual pertenece el dpto a insertar, ya que solo se conoce su Id. Dictionary<String, Object> wfPais = new Dictionary<string, object>(); wfPais.Add("Accion", "consultar"); wfPais.Add("PaisEntrada", p); IDictionary<string, Object> Result = WorkflowInvoker.Invoke(wf, wfPais); Pais country = (Pais)Result["PaisSalida"]; if (country == null) { MessageBox.Show("País no existe en la base de datos"); } else { p.Nombre = country.Nombre; p.Gobernante = country.Gobernante; } Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); GestionDpto wf1 = new GestionDpto(); wfArguments.Add("Accion", "insertar"); wfArguments.Add("PaisEntrada", p); wfArguments.Add("DptoEntrada", d); MessageBox.Show("País entrada del form gestión depto:" + p.Nombre); Result = WorkflowInvoker.Invoke(wf1, wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); }


} private void buttonConsulta_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoPaís.Text != string.Empty) { p.Id = Int32.Parse(textBoxCódigoPaís.Text.Trim()); d.Id = Int32.Parse(textBoxCódigo.Text.Trim()); d.Nombre = textBoxNombre.Text.Trim(); d.Gobernante = textBoxGobernador.Text.Trim(); d.PaisId = p.Id; d.Pais = p; Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); wfArguments.Add("Accion", "consultar"); wfArguments.Add("PaisEntrada", p); wfArguments.Add("DptoEntrada", d); GestionDpto wf = new GestionDpto(); IDictionary<string, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); Pais country = (Pais)Result["PaisSalida"]; Dpto dep = (Dpto)Result["DptoSalida"]; if (country == null) { MessageBox.Show("País no existe en la base de datos"); } else { if (dep == null) { MessageBox.Show("El departamento no existe en la base de datos"); } else { textBoxNombre.Text = dep.Nombre; textBoxGobernador.Text = dep.Gobernante; //Mostrar el área y la población haciendo uso de las clases parciales. dep.calcularValores(dep.Id); label8.Visible = true;


labelCapital.Visible = true; try { labelCapital.Text = dep.CapitalDpto.Nombre; } catch (NullReferenceException ex) { labelCapital.Text = "Aun sin asignar."; } label5.Visible = true; label6.Visible = true; label7.Visible = true; lblAreaDpto.Text = "" + dep.AreaDpto; lblPoblDpto.Text = "" + dep.HabitantesDpto; //MessageBox.Show("Área: " + dep.AreaDpto + " Km2; población: " + dep.HabitantesDpto + " habitantes."); } } } else { MessageBox.Show("CÓDIGO NO EXISTE EN LA BASE DE DATOS", "ERROR"); } } private void buttonModifica_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoPaís.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxGobernador.Text != string.Empty) { p.Id = Int32.Parse(textBoxCódigoPaís.Text.Trim()); d.Id = Int32.Parse(textBoxCódigo.Text.Trim()); d.Nombre = textBoxNombre.Text.Trim(); d.Gobernante = textBoxGobernador.Text.Trim(); d.PaisId = p.Id; d.Pais = p; Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); wfArguments.Add("Accion", "modificar"); wfArguments.Add("PaisEntrada", p); wfArguments.Add("DptoEntrada", d); GestionDpto wf = new GestionDpto (); IDictionary<string, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); }


else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonElimina_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoPaís.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxGobernador.Text != string.Empty) { p.Id = Int32.Parse(textBoxCódigoPaís.Text.Trim()); d.Id = Int32.Parse(textBoxCódigo.Text.Trim()); d.Nombre = textBoxNombre.Text.Trim(); d.Gobernante = textBoxGobernador.Text.Trim(); d.PaisId = p.Id; d.Pais = p; Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); wfArguments.Add("Accion", "eliminar"); wfArguments.Add("PaisEntrada", p); wfArguments.Add("DptoEntrada", d); GestionDpto wf = new GestionDpto(); IDictionary<string, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonMenú_Click(object sender, EventArgs e) { base.Dispose(); base.Close(); } public Pais TraerPais(Dpto dptoEntrada) { ConceptosContainer bd = new ConceptosContainer(); Dpto dptoBD = (Dpto)bd.ZonaSet.Where(d => d.Id.Equals(dptoEntrada.Id)).DefaultIfEmpty().First(); Pais paisBD = (Pais)bd.ZonaSet.Where(p => p.Id.Equals(dptoBD.PaisId)).DefaultIfEmpty().First(); // MessageBox.Show("Id del pais en TraerPais: "+paisBD.Id); return paisBD; }


}

6. Adicione el siguiente código en FormaGestiónMpio:

public partial class FormaGestiónMpio : Form { public static Dpto d = new Dpto(); public static Mpio m = new Mpio(); public FormaGestiónMpio() { InitializeComponent(); } private void buttonAdiciona_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoDpto.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxAlcalde.Text != string.Empty && textBoxArea.Text != string.Empty && textBoxPoblacion.Text != string.Empty) { d.Id = Int32.Parse(textBoxCódigoDpto.Text); m.Id = Int32.Parse(textBoxCódigo.Text); m.Nombre = textBoxNombre.Text; m.Gobernante = textBoxAlcalde.Text; m.Area = textBoxArea.Text; m.Habitantes = textBoxPoblacion.Text; m.DptoId = d.Id; m.IsCapitalDpto = checkBoxCapitalDpto.Checked; m.IsCapitalPais = checkBoxCapitalPais.Checked; FormaGestiónDpto forma = new FormaGestiónDpto(); Pais paisDelDpto = forma.TraerPais(d); d.Pais = paisDelDpto; Dictionary<String, Object> wfDpto = new Dictionary<string, object>(); wfDpto.Add("Accion", "consultar"); wfDpto.Add("PaisEntrada", paisDelDpto); wfDpto.Add("DptoEntrada", d); GestionDpto wf1 = new GestionDpto(); IDictionary<String, Object> Result = WorkflowInvoker.Invoke(wf1, wfDpto); Dpto dep = (Dpto)Result["DptoSalida"]; if (dep == null) {


MessageBox.Show("El departamento no existe en la base de datos"); } else { d.Nombre = dep.Nombre; d.Gobernante = dep.Gobernante; } Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); wfArguments.Add("Accion", "insertar"); wfArguments.Add("DptoEntrada", d); wfArguments.Add("MpioEntrada", m); GestionMpio wf = new GestionMpio(); WorkflowInvoker.Invoke(wf, wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonConsulta_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoDpto.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); d.Id = Int32.Parse(textBoxCódigoDpto.Text.Trim()); m.Id = Int32.Parse(textBoxCódigo.Text.Trim()); m.Nombre = textBoxNombre.Text.Trim(); m.Gobernante = textBoxAlcalde.Text.Trim(); m.DptoId = d.Id; m.Dpto = d; wfArguments.Add("Accion", "consultar"); wfArguments.Add("DptoEntrada", d); wfArguments.Add("MpioEntrada", m); GestionMpio wf = new GestionMpio();


IDictionary<String, Object> Result = WorkflowInvoker.Invoke(wf, wfArguments); Dpto dep = (Dpto)Result["DptoSalida"]; Mpio mun = (Mpio)Result["MpioSalida"]; if (dep == null) { MessageBox.Show("Departamento no existe en la base de datos"); } else { if (mun == null) { MessageBox.Show("Municipio no existe en la base de datos"); } else { textBoxNombre.Text = mun.Nombre; textBoxAlcalde.Text = mun.Gobernante; textBoxArea.Text = mun.Area; textBoxPoblacion.Text = mun.Habitantes; //InsertarMpio.mpio mpio = new InsertarMpio.mpio(); } } } else { MessageBox.Show("CÓDIGO NO EXISTE EN LA BASE DE DATOS", "ERROR"); } } private void buttonModifica_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoDpto.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxAlcalde.Text != string.Empty && textBoxArea.Text != string.Empty && textBoxPoblacion.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); d.Id = Int32.Parse(textBoxCódigoDpto.Text); m.Id = Int32.Parse(textBoxCódigo.Text); m.Nombre = textBoxNombre.Text; m.Gobernante = textBoxAlcalde.Text; m.Area = textBoxArea.Text;


m.Habitantes = textBoxPoblacion.Text; m.DptoId = d.Id; m.Dpto = d; wfArguments.Add("Accion", "modificar"); wfArguments.Add("DptoEntrada", d); wfArguments.Add("MpioEntrada", m); GestionMpio wf = new GestionMpio(); WorkflowInvoker.Invoke(wf, wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } } private void buttonElimina_Click(object sender, EventArgs e) { if (textBoxCódigo.Text != string.Empty && textBoxCódigoDpto.Text != string.Empty && textBoxNombre.Text != string.Empty && textBoxAlcalde.Text != string.Empty) { Dictionary<String, Object> wfArguments = new Dictionary<string, object>(); d.Id = Int32.Parse(textBoxCódigoDpto.Text); m.Id = Int32.Parse(textBoxCódigo.Text); m.Nombre = textBoxNombre.Text; m.Gobernante = textBoxAlcalde.Text; m.DptoId = d.Id; m.Dpto = d; wfArguments.Add("Accion", "eliminar"); wfArguments.Add("DptoEntrada", d); wfArguments.Add("MpioEntrada", m); GestionMpio wf = new GestionMpio (); WorkflowInvoker.Invoke(wf,wfArguments); } else { MessageBox.Show("Datos incompletos", "ZONAS GEOGRÁFICAS: ERROR"); } }


private void buttonMenú_Click(object sender, EventArgs e) { base.Dispose(); base.Close(); } }

10. CLASES PARCIALESPara agregarle más funcionalidades a la solución ya construida, se implementaron clases parciales2 a la hora de calcular el área y población de los departamentos y países. Dadas las características propias de estas clases, se pudo utilizar el polimorfismo y la sobre-escritura de métodos, aprovechando al máximo las herramientas que ofrece Visual Studio 2010. Para adicionar esta funcionalidad, tenga en cuenta los siguientes pasos:

1. Abra la clase Conceptos.Designer.cs

2. Adicione el siguiente código:

#region Clases parciales #region Clase Parcial Dpto /// <summary> /// Clase Parcial Dpto, que calculará el área y población sumando la información de sus municipios. /// </summary> public partial class Dpto { private double areaDpto; private int habitantesDpto; private Boolean mpioIsChecked = true; private Mpio capital; private Mpio capitalPais;

2 Para mayor información sobre las clases parciales, remítase a http://msdn.microsoft.com/es-es/library/wa80x488(VS.80).aspx

http://msdn.microsoft.com/es-es/library/wa80x488(VS.80).aspx


/// <summary> /// Recorrerá la colección de municipios propia de cada departamento -que se genera con la relación /// uno a muchos en el EDM-, e irá sumando las áreas y poblaciones de cada municipio. El contador /// lleva el registro del número de municipios que se van recorriendo, para evitar que se repitan. /// </summary> /// <param name="dptoId"></param> public void calcularValores(int dptoId) { int contador = 0; foreach (Mpio m in Mpio) { if (m.DptoId == dptoId) { if (mpioIsChecked) { areaDpto += double.Parse(m.Area); habitantesDpto += int.Parse(m.Habitantes); if ((bool)m.IsCapitalDpto) capital = m; if ((bool)m.IsCapitalPais) capitalPais = m; } contador++; } if (Mpio.Count == contador) mpioIsChecked = false; } } public double AreaDpto { get { return areaDpto; } set { areaDpto = value; } } public int HabitantesDpto { get { return habitantesDpto; } set { habitantesDpto = value; } } public Mpio CapitalDpto {


get { return capital; } set { capital = value; } } public Mpio CapitalPaís { get { return capitalPais; } set { capitalPais = value; } } } #endregion /// <summary> /// Clase Parcial Pais, que calculará el área y población sumando la información de sus departamentos. /// </summary> #region Clase Parcial Pais public partial class Pais { private double areaPais; private int habitantesPais; private int paisId; private Mpio capital; /// <summary> /// Recorrerá la colección de departamentos propia de cada país -que se genera con la relación /// uno a muchos en el EDM-, e irá sumando las áreas y poblaciones de cada departamento. /// </summary> /// <param name="paisId"></param> public void calcularValores(int paisId) { foreach (Dpto d in Dptos) { if (d.PaisId == paisId) { d.calcularValores(d.Id); areaPais += d.AreaDpto; habitantesPais += d.HabitantesDpto;


if (d.CapitalPaís != null) CapitalPaís = d.CapitalPaís; } } } /// <summary> /// Resetea los valores de areaPais y habitantesPais, para evitar que se dupliquen los resultados /// cuando se vuelve a consultar el país. /// </summary> public void resetearValores() { areaPais = 0; habitantesPais = 0; } public double AreaPais { get { return areaPais; } set { areaPais = value; } } public int HabitantesPais { get { return habitantesPais; } set { habitantesPais = value; } } public int PaisId { get { return paisId; } set { paisId = value; } }


public Mpio CapitalPaís { get { return capital; } set { capital = value; } } } #endregion #endregion

11 BIBLIOGRAFÍA ADICIONAL


Si gusta obtener mayor información acerca del Entity Framework en el .NET Framework 4, se le recomienda al lector consultar los siguientes textos:

MACKEY, Alex. Introducing .NET 4.0 With Visual Studio 2010. Copyright © 2010. ISBN-13 (electronic): 978-1-4302-2456-3

KLEIN, Scott. Pro Entity Framework 4.0. . Copyright © 2010.ISBN-13 (electronic): 978-1-4302-0648-4

Para entender mayor el manejo de los Workflows, por favor remítase a:

BUCKOVICS, Bruce. Pro WF: Windows Workflow in .NET 3.5. Copyright © 2010. ISBN-13 (electronic): 978-1-4302-0976-8

Tutorial Zonas WWF .NET Framework 4

Documents

Transcript of Tutorial Zonas WWF .NET Framework 4