You are on page 1of 41

Tutorial de acceso a datos con Visual Studio 2008 y

SubSonic 2.1

Autor: Eduardo Rivera (eriveraa@gmail.com)

Septiembre del 2008
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Tabla de Contenidos
1. Introducción................................................................................................................................................................................ 3

2. Herramientas .............................................................................................................................................................................. 4
2.1. Microsoft Visual Studio 2008 ............................................................................................................................................ 4
2.2. Microsoft Visual Studio 2008 Service Pack 1 (ISO) ......................................................................................................... 4
2.3. Microsoft SQL Server 2005 Express SP2.......................................................................................................................... 4
2.4. SubSonic ORM .................................................................................................................................................................. 5

3. Creación de la base de datos...................................................................................................................................................... 6
3.1. Iniciar el SQL Server Express ........................................................................................................................................... 6
3.2. Crear la base de datos Personas ........................................................................................................................................ 6
3.3. Adjuntar la base de datos Personas................................................................................................................................... 9
3.4. Datos de prueba................................................................................................................................................................ 10

4. Inicialización de la solución y creación de los proyectos. ...................................................................................................... 11
4.1. Crear la solución en Visual Studio.................................................................................................................................. 11
4.2. Crear el proyecto Windows .............................................................................................................................................. 11
4.3. Crear el proyecto Class Library....................................................................................................................................... 12
4.4. Estructura del proyecto.................................................................................................................................................... 13
4.5. Agregar referencias al proyecto ...................................................................................................................................... 13
4.6. Eliminar archivos innecesarios. ...................................................................................................................................... 15

5. Creación de los formularios..................................................................................................................................................... 17
5.1. Crear el formulario principal .......................................................................................................................................... 17
5.2. Crear el formulario de edición ........................................................................................................................................ 17

6. Diseño de los formularios......................................................................................................................................................... 19
6.1. Introducción..................................................................................................................................................................... 19
6.2. Diseño del formulario principal ...................................................................................................................................... 20
6.3. Diseño del formulario de edición .................................................................................................................................... 22

7. Generación de la DAL (Data Access Layer) con SubSonic................................................................................................... 23
7.1. Configurar Visual Studio para utilizar SubSonic........................................................................................................... 23
7.2. Generar información de configuración con SubStage ................................................................................................... 26
7.3. Preparar el proyecto Personas.Library para la generación ........................................................................................... 29
7.4. Generar las clases de SubSonic....................................................................................................................................... 31

8. Programación de los formularios............................................................................................................................................ 33
8.1. Pasos previos .................................................................................................................................................................... 33
8.2. Programación del formulario de edición ........................................................................................................................ 34
8.3. Programación del formulario principal .......................................................................................................................... 38

9. Ejecución de la aplicación........................................................................................................................................................ 41

2
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

1. Introducción
En este tutorial se desarrollará una aplicación Windows que accederá a una base de datos SQL Server,
siguiendo una arquitectura de capas. El tutorial explica paso a paso y en forma detallada la construcción de la
aplicación, haciendo fácil el entendimiento inclusive para aquellos con pocos conocimientos de programación
sobre la plataforma Microsoft.

En ese sentido se utilizará / creará una base de datos de Personas (en SQL Server Express 2005), y una
aplicación Windows (desarrollada con Visual Studio 2008) con el lenguaje C# (CSharp), que permitirá dar
mantenimiento a la información con las opciones clásicas de creación, actualización y eliminación.

Para la creación de la capa de acceso a datos, se utilizará el patrón ActiveRecord mediante el ORM SubSonic,
ya que nos brinda gran productividad en la generación del mapeo de las clases con las tablas de la base de
datos.

Resumiendo, nuestro proyecto estará organizado de la siguiente manera:

Cliente: Aplicación Windows Forms
(Desarrollada con Visual Studio 2008 y C#)

Capa de acceso a datos: Librería de Clases
(Desarrollada con Visual Studio 2008, C# y SubSonic)

Base de Datos: Personas
(Creada en SQL Server 2005 Express SP2)

Se espera que durante el desarrollo de este tutorial no se presenten errores, sin embargo para consultas, dudas
o reporte de algún error pueden contactarme a eriveraa@gmail.com.

3
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

2. Herramientas
Para el desarrollo del taller es necesaria la instalación de ciertas herramientas básicas de programación, como
el Visual Studio 2008 y el SQL Server Express 2005. Al terminar esta sección se tendrán instaladas las
herramientas con la cual podremos desarrollar todo el taller.

2.1. Microsoft Visual Studio 2008
Las diferentes ediciones de Visual Studio 2008 pueden ser descargadas (versión Trial de 90 días) desde la
siguiente dirección: http://msdn.microsoft.com/en-us/vstudio/products/aa700831.aspx

Sin embargo, se recomienda descargar la versión Visual Studio Team System 2008 / Team Suite, desde la
siguiente dirección: http://msdn.microsoft.com/en-us/vsts2008/products/cc268310.aspx

TIP: Al instalar, elegir la instalación personalizada o completa, confirmando que se instalen los
componentes “Visual C#” y “Visual Web Developer”. Puede obviarse la instalación de SQL Express
2005 porque la instalaremos manualmente.

2.2. Microsoft Visual Studio 2008 Service Pack 1 (ISO)
Se recomienda descargar el ISO del Service Pack 1 de Visual Studio 2008, el cual puede ser descargado
desde la siguiente dirección: http://www.microsoft.com/downloads/details.aspx?familyid=27673C47-
B3B5-4C67-BD99-84E525B5CE61&displaylang=en

2.3. Microsoft SQL Server 2005 Express SP2
El SQL Server 2005 Express puede ser descargado desde la siguiente dirección:
http://www.microsoft.com/express/2005/sql/download/

Desde esa página descargar SQL Server 2005 Express Edition with Advanced Services SP2
(http://go.microsoft.com/fwlink/?linkid=65109)

TIP: Al instalar, elegir la instalación personalizada o completa, confirmando que se instale el componente
“SQL Server Management Studio Express” (la consola administrativa de SQL Server 2005).

4
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

2.4. SubSonic ORM
La version mas reciente de SubSonic (2.1) puede ser descargada desde la siguiente dirección:
http://www.codeplex.com/subsonic/Release/ProjectReleases.aspx

Información adicional de dicho ORM como manuales, tutoriales y videos los pueden encontrar en:
http://subsonicproject.com/

5
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

3. Creación de la base de datos

3.1. Iniciar el SQL Server Express
Iniciar el SQL Server 2005 Express:

Conectarse al servidor (local):

3.2. Crear la base de datos Personas
Si YA SE DISPONE de la base de datos, no es necesario crearla. Se puede pasar al siguiente punto.

La creación de la BD se realizará agregando una base de datos al item Databases del Object Explorer:

Poner el nombre a la base de datos: Personas

6
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Se agregará la base de datos recién creada, y se verá de la siguiente manera en el Object Explorer:

Ahora se procede a crear la Tabla Personas:

Agregar los campos de acuerdo a la siguiente estructura:

7
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Adicionalmente, se modifica la propiedad “Is Identity” del campo a ID y establecerla en Yes. Como se
puede observar en la imagen:

También se convertirá el campo ID en la llave primaria, de la siguiente manera:

8
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Finalmente, ir al menú File / Save y ponerle nombre a la tabla, de la siguiente manera:

3.3. Adjuntar la base de datos Personas
Si YA SE DISPONE de la base de datos, se adjuntará la BD al servidor SQL Server.

Se adjuntará la base de datos de la siguiente manera:

En la siguiente pantalla presionar el botón Add:

9
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Explorar y buscar el archivo Personas.mdf:

Presionar el botón OK en la siguiente pantalla:

3.4. Datos de prueba
Abrir la tabla e ingresar datos de prueba que servirán para testear nuestra aplicación que desarrollaremos
en este documento.

10
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

4. Inicialización de la solución y creación de los proyectos.
En esta sección se creará una solución en blanco conteniendo dos (2) proyectos. El primer proyecto será la
aplicación Windows (destinada al usuario final) y el segundo proyecto será una librería de clases que serán
accedidas desde la aplicación Windows. Al terminar esta sección se tendrá la estructura de la solución con sus
dos proyectos necesarios para trabajar.

4.1. Crear la solución en Visual Studio
Iniciar el IDE de Visual Studio 2008 y crear una solución en blanco:

Seleccionar el tipo de proyecto “Visual Studio Solutions” y luego la plantilla “Blank Solution”. Darle el
nombre Personas:

4.2. Crear el proyecto Windows
Agregar a la solución recién creada, un proyecto del tipo “Windows Forms Application” con el nombre:
Personas.WinApp
11
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

No olvidar seleccionar en la opción Solution, el item: “Add to Solution”.

4.3. Crear el proyecto Class Library
Agregar un proyecto Class Library igual que en el paso anterior, con el nombre: Personas.Library

12
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

4.4. Estructura del proyecto
Se debería tener la siguiente estructura:

4.5. Agregar referencias al proyecto
Agregar la referencia al proyecto Personas.Library desde el proyecto Personas.WinApp:

13
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

La referencia quedará de la siguiente manera:

14
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

4.6. Eliminar archivos innecesarios.
4.6.1. Eliminar Class1.cs del proyecto Personas.Library

4.6.2. Eliminar Form1.cs del proyecto Personas.WinApp:

15
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

4.6.3. El proyecto quedará con la siguiente estructura:

16
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

5. Creación de los formularios
En esta sección se crearán los formularios que utilizaremos en el proyecto Windows. Al terminar esta sección
se tendrán los formularios listos para empezar a agregar controles y modificar su diseño.

5.1. Crear el formulario principal
Creamos el formulario principal del Mantenimiento de Personas, agregando un nuevo elemento al
proyecto Personas.WinApp:

Le damos el nombre de frmPrincipal y presionamos el botón Add:

5.2. Crear el formulario de edición

17
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Igual que en el paso anterior creamos el formulario frmEdicionPersona que nos permitirá editar la
información de las personas:

18
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

6. Diseño de los formularios
En esta sección se modificarán los formularios creados en la sección anterior agregando controles y
definiendo su aspecto visual. Al terminar esta sección se tendrán los formularios diseñados para el usuario
final.

6.1. Introducción
El diseño de los formularios básicamente consiste en operaciones de “Drag and Drop” (arrastrar y soltar),
es decir se arrastrarán los controles necesarios desde el Toolbox (caja de herramientas) y se soltarán sobre
la superficie del formulario (esta superficie por lo general es de color plomo) construyendo de esta manera
todo el aspecto visual del formulario.

El Toolbox por lo general se encuentra en la parte izquierda del IDE del Visual Studio:

Al pasar el Mouse por el Toolbox se expandirá mostrando todos los controles disponibles para “arrastrar y
soltar” sobre el formulario, de la siguiente manera:

19
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

6.2. Diseño del formulario principal
El diseño final del formulario será el siguiente:

Abrir el formulario, haciendo click en el formulario frmPrincipal.cs del proyecto Personas.WinApp y
cambiar las siguientes propiedades:

Control / Formulario Propiedad Valor
frmPrincipal Text Administración de Personas
StartPosition CenterScreen
Size / Width 600
Size / Height 400

Luego agregar los siguientes controles y establecer sus propiedades respectivas:

Control Propiedad Valor
MenuStrip Name mnuPrincipal
StatusStrip Name ssBarraEstatus
DataGridView Name dgvGrilla
AllowUserToAddRows False
AllowUserToDeleteRows False
ReadOnly Trae
SelectionMode FullRowSelect
Dock Fill

En el diseñador del menú, agregar las siguientes opciones al control mnuPrincipal:

20
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Control Propiedad Valor
ToolStripMenuItem Name mnuAgregar
ToolStripMenuItem Name mnuModificar
ToolStripMenuItem Name mnuEliminar
ToolStripMenuItem Name mnuActualizar
ToolStripMenuItem Name mnuSalir

Luego, agregar un objeto StatusLabel al control ssBarraStatus (StatusStrip) con las siguientes
propiedades:

21
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Control Propiedad Valor
ToolStripStatusLabel Name ssBarraEstatusLabel
(StatusLabel)

Text (cadena vacía)

Creamos el formulario de edición de la Persona.

6.3. Diseño del formulario de edición
El diseño final del formulario será el siguiente:

Abrir el formulario, haciendo click en el formulario frmEditarPersona.cs del proyecto
Personas.WinApp y cambiar las siguientes propiedades:

Control / Formulario Propiedad Valor
frmEditarPersona (Form) Text Editar Persona
StartPosition CenterScreen
Size / Width 600
Size / Height 400
ControlBox False
FormBorderStyle FixedDialog

Luego agregar los siguientes controles y establecer sus propiedades respectivas:

22
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Control Propiedad Valor
TextBox Name txtID
ReadOnly true
TextBox Name txtNombres
TextBox Name txtApellidoPaterno
TextBox Name txtApellidoMaterno
DateTimePicker Name dtpFechaNacimiento
Format Custom
CustomFormat dd/MM/yyyy
TextBox Name txtSexo
TextBox Name txtNroHijos
Text 0
TextBox Name txtSueldo
Text 0.0
TextBox Name txtNroDocumento
ComboBox Name cboTipoDocumento
Items DNI
Libreta Militar
Pasaporte
ComboBox Name cboEstadoCivil
Items Soltero(a)
Casado(a)
Viudo(a)
Divorciado(a)
TextBox Name txtTelefono01
TextBox Name txtTelefono02
TextBox Name txtDireccion
Multiline True
TextBox Name txtNacionalidad
Button Name btnGuardar
DialogResult OK
Text Guardar
Button Name btnCancelar
DialogResult Cancel
Text Cancelar

7. Generación de la DAL (Data Access Layer) con SubSonic
En esta sección se utilizará el ORM SubSonic para generar los componentes necesarios para construir la capa
de acceso a datos de nuestra aplicación. Al terminar esta sección se tendrán las clases generadas en el
proyecto Personas.Library para ser utilizadas desde la aplicación Windows.

7.1. Configurar Visual Studio para utilizar SubSonic
Para utilizar SubSonic es necesario configurar Visual Studio previamente:

7.1.1. Ir al menú Tools > External Tools.

7.1.2. Hacer clic en “Add” e ingresar lo siguiente:

23
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

a) Title: “SubSonic DAL”
b) Command: “C:\Program Files\SubSonic\SubSonic 2.1 Final\SubCommander\sonic.exe”
(apuntar a dicho archivo).
c) Arguments: “generate /out Generated”
d) Initial directory: “$(ProjectDir)”
e) Use Output window: (Checked)
f) Prompt for arguments: (Checked)

7.1.3. Observar el menu Tools:

Se encontrarán los External Commands:
24
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

1 – Create GUID
2 – Dotfuscator Community Edition
3 – SubSonic DAL (lo cual significa que es el item: External Command 3). Esto se utilizará mas
adelante.

7.1.4. Ir a Tools > Customize y agregar una nueva barra de herramientas (Toolbar) con el nombre
SubSonic:

7.1.5. Ir a la pestaña Commands. Seleccionar la categoría “Tools” y luego el “External Command 3”.

7.1.6. Arrastrar el “External Command 3” hacia el Toolbar “SubSonic” que hemos creado
anteriormente, quedando de la siguiente manera:

25
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

7.1.7. Presionar el botón Close para terminar.

7.2. Generar información de configuración con SubStage
SubStage es una herramienta de SubSonic que nos permitirá generar la información de configuración que
debemos incrustar en nuestra aplicación Windows para lograr la integración con SubSonic.

Ejecutar el programa SubStage desde el menu Start / All Programs / SubSonic / SubSonic 2.1 Final de
Microsoft Windows. Se verá una pantalla como esta:

Presionar el botón derecho sobre el item “Connection Strings” y seleccionar la opción “Add Connection
String”

26
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Modificar las propiedades de la cadena de conexión (Connection String) recién creada:

Connection String Properties
Propiedad Valor
ConnectionString Data Source=(local)\sqlexpress;Initial Catalog=Personas;Integrated
Security=True
Name Personas

Hacer click en el ícono “New Project” y modificar sus propiedades:

Project Properties
Propiedad Valor
Name Personas

En el proyecto Personas, presionar el botón derecho y seleccionar la opción “Add Provider”:

Modificar las propiedades del proveedor (Provider) recién creado:

Propiedad Valor
ConnectionStringId Personas
GeneratedNamespace Personas.Library
Name SQLProvider
ProviderTypeId SQL Server

Dar click en el botón “Test Connection” para probar la conexión. Se debe obtener el mensaje:
“Connection Successful” en la parte inferior, como se observa en la pantalla:

27
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Hacer clic en la pestaña “Configuration Output”:

El código generado debe ser similar al siguiente:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="SubSonicService" type="SubSonic.SubSonicSection, SubSonic"
allowDefinition="MachineToApplication" restartOnExternalChanges="true" requirePermission="false"/>
</configSections>
<connectionStrings>
<add name="Personas" connectionString="Data Source=(local)\sqlexpress;Initial
Catalog=Personas;Integrated Security=True"/>

28
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

</connectionStrings>
<SubSonicService defaultProvider="SQLProvider" enableTrace="false" templateDirectory="">
<providers>
<clear/>
<add name="SQLProvider" type="SubSonic.SqlDataProvider, SubSonic"
connectionStringName="Personas" generatedNamespace="Personas.Library"/>
</providers>
</SubSonicService>
</configuration>

Este código será utilizado posteriormente en nuestra aplicación.

7.3. Preparar el proyecto Personas.Library para la generación
En el proyecto Personas.Library, agregar una carpeta ( Add > New Folder) con el nombre “Generated”:

29
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Luego, agregamos la referencia hacia la librería SubSonic.dll, la cual debe estar en la carpeta
“C:\Program Files\SubSonic\SubSonic 2.1 Final\SubSonic”:

Adicionalmente, desde la pestaña .NET agregar referencias a los componentes:

- System.Web
- System.Configuration

Ahora agregamos un archivo de configuración, mediante la opción: “Add > New Item > Application
Configuration File” y le damos el nombre de App.config.

30
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

En este archivo (App.config) copiaremos el código generado por SubStage (en el paso anterior),
quedando de la siguiente manera:

Finalmente, grabar todos los archivos mediante el menú: File > Save All.

7.4. Generar las clases de SubSonic
Habiendo seleccionado el proyecto Personas.Library, ejecutar el External Command de SubSonic
haciendo clic en el botón “SubSonic DAL” de la barra de herramientas SubSonic:

Se mostrará la pantalla de ejecución del External Command, de la siguiente manera:

Al hacer click en OK, se invocará al generador SubSonic y generará las clases necesarias dentro de la
carpeta “\Generated” del proyecto Personas.Library.

El resultado del proceso se puede observar en la ventana Output:

31
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Para visualizar lo generado, es necesario activar la visualización de archivos ocultos, haciendo clic en el
icono (Show All Files).

Ahora, seleccionar los archivos que se han generado dentro de la carpeta “Generated” e incluirlos en el
proyecto mediante la opción “Include In Project”:

A partir de este momento, las clases están incluidas en nuestro proyecto Personas.Library y las podemos
acceder desde nuestra aplicación Windows o cualquier aplicación que haga referencia a
Personas.Library.

32
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

8. Programación de los formularios

8.1. Pasos previos
Desde el proyecto Personas.WinApp, agregar la referencia al componente SubSonic (Igual que en el
paso 7.3):

Agregar el archivo App.config al proyecto Personas.WinApp, con el siguiente contenido:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="SubSonicService" type="SubSonic.SubSonicSection, SubSonic"
allowDefinition="MachineToApplication" restartOnExternalChanges="true"
requirePermission="false"/>
</configSections>
<connectionStrings>
<add name="Personas" connectionString="Data Source=(local)\sqlexpress;Initial
Catalog=Personas;Integrated Security=True"/>
</connectionStrings>
<SubSonicService defaultProvider="SQLProvider" enableTrace="false"
templateDirectory="">
<providers>
<clear/>
<add name="SQLProvider" type="SubSonic.SqlDataProvider, SubSonic"
connectionStringName="Personas" generatedNamespace="Personas.Library"/>
</providers>
</SubSonicService>
</configuration>

En el archivo Program.cs del proyecto Personas.WinApp modificar el formulario de inicio de la
siguiente manera:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace Personas.WinApp
{
static class Program
33
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmPrincipal());
}
}
}

Agregar la clase Utils.cs al proyecto Personas.WinApp con el siguiente contenido:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Personas.WinApp
{
class Utils
{
}

public enum ModoFormularioEdicion
{
Nuevo,
Modificar,
Consultar
}
}

8.2. Programación del formulario de edición
En el formulario frmEditarPersona.cs, hacer referencia desde el código a la librería Personas.Library:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Personas.Library;

Agregar las variables locales y modificar el constructor del formulario de la siguiente manera:
namespace Personas.WinApp
{
public partial class frmEditarPersona : Form
{
private ModoFormularioEdicion _modo;
private string _ID;
private Persona _obj;

public frmEditarPersona(ModoFormularioEdicion modo, string ID)
{
InitializeComponent();

this._modo = modo;
this._ID = ID;
}
34
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

Crear los métodos auxiliares de la siguiente manera:
private void InicializarValoresFormulario()
{
// En este método se cargan los valores iniciales del formulario
this.cboEstadoCivil.SelectedIndex = 0;
this.cboTipoDocumento.SelectedIndex = 0;
this.txtSueldo.Text = "1000.0";
}

private void ObtenerDatosDesdeObjeto()
{
// Este método llena los controles del formulario, en base al objeto editado
txtID.Text = _obj.Id.ToString();
txtNombres.Text = _obj.Nombres.ToString();
txtApellidoPaterno.Text = _obj.ApellidoPaterno.ToString();
txtApellidoMaterno.Text = _obj.ApellidoMaterno.ToString();
dtpFechaNacimiento.Value = (DateTime) _obj.FechaNacimiento;
txtSexo.Text = _obj.Sexo;
txtNroHijos.Text = _obj.NroHijos.ToString();
txtSueldo.Text = _obj.Sueldo.ToString();
txtNroDocumento.Text = _obj.NroDocumento.ToString();
cboTipoDocumento.SelectedIndex = (int) _obj.TipoDocumento;
cboEstadoCivil.SelectedIndex = (int) _obj.EstadoCivil;
txtTelefono01.Text = _obj.Telefono01.ToString();
txtTelefono02.Text = _obj.Telefono02.ToString();
txtDireccion.Text = _obj.Direccion.ToString();
txtNacionalidad.Text = _obj.Nacionalidad.ToString();
}

private void IngresarDatosAObjeto()
{
// Este método pasa los valores de los controles del formulario, hacia el objeto

// El ID no se asigna porque es IDENTITY
_obj.Nombres = txtNombres.Text.Trim();
_obj.ApellidoPaterno = txtApellidoPaterno.Text.Trim();
_obj.ApellidoMaterno = txtApellidoMaterno.Text.Trim();
_obj.FechaNacimiento = dtpFechaNacimiento.Value;
_obj.Sexo = txtSexo.Text.Trim();
_obj.NroHijos = int.Parse(txtNroHijos.Text.Trim());
_obj.Sueldo = float.Parse(txtSueldo.Text.Trim());
_obj.NroDocumento = txtNroDocumento.Text.Trim();
_obj.TipoDocumento = cboTipoDocumento.SelectedIndex;
_obj.EstadoCivil = cboEstadoCivil.SelectedIndex;
_obj.Telefono01 = txtTelefono01.Text.Trim();
_obj.Telefono02 = txtTelefono02.Text.Trim();
_obj.Direccion = txtDireccion.Text.Trim();
_obj.Nacionalidad = txtNacionalidad.Text.Trim();
}

Los nombres de los eventos se pueden generar automáticamente al hacer doble clic sobre el control. Por
ejemplo al hacer doble clic sobre el botón Guardar, se generará el evento btnGuardar_Click en el
código fuente. Ahora, agregar el código para el manejo de los eventos:

private void frmEditarPersona_Load(object sender, EventArgs e)
{
// Inicializar los controles del formulario
this.InicializarValoresFormulario();

switch (_modo)
{
case ModoFormularioEdicion.Nuevo:
_obj = new Persona();
break;

case ModoFormularioEdicion.Modificar:
35
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

_obj =

Personas.Library.DB.Select().From<Persona>().Where(Persona.IdColumn).IsEqualTo(int.Parse(_ID))
.ExecuteSingle<Persona>();
this.ObtenerDatosDesdeObjeto();
break;

default:
break;
}
}

private void btnGuardar_Click(object sender, EventArgs e)
{
// Realizar algún código de validación aquí

// Pasar los datos ingresados en el formulario hacia el objeto
this.IngresarDatosAObjeto();

// Guardar los datos
_obj.Save();

// Cerrar el formulario
this.Close();
}

private void btnCancelar_Click(object sender, EventArgs e)
{
this.Close();
}

El código total del formulario debe quedar de la siguiente manera:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Personas.Library;

namespace Personas.WinApp
{
public partial class frmEditarPersona : Form
{
private ModoFormularioEdicion _modo;
private string _ID;
private Persona _obj;

public frmEditarPersona(ModoFormularioEdicion modo, string ID)
{
InitializeComponent();

this._modo = modo;
this._ID = ID;
}

private void frmEditarPersona_Load(object sender, EventArgs e)
{
// Inicializar los controles del formulario
this.InicializarValoresFormulario();

switch (_modo)
{
case ModoFormularioEdicion.Nuevo:
_obj = new Persona();

36
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

break;

case ModoFormularioEdicion.Modificar:
_obj =

Personas.Library.DB.Select().From<Persona>().Where(Persona.IdColumn).IsEqualTo(int.Parse(_ID))
.ExecuteSingle<Persona>();
this.ObtenerDatosDesdeObjeto();
break;

default:
break;
}
}

private void InicializarValoresFormulario()
{
// En este método se cargan los valores iniciales del formulario
this.cboEstadoCivil.SelectedIndex = 0;
this.cboTipoDocumento.SelectedIndex = 0;
this.txtSueldo.Text = "1000.0";
}

private void ObtenerDatosDesdeObjeto()
{
// Este método llena los controles del formulario, en base al objeto editado
txtID.Text = _obj.Id.ToString();
txtNombres.Text = _obj.Nombres.ToString();
txtApellidoPaterno.Text = _obj.ApellidoPaterno.ToString();
txtApellidoMaterno.Text = _obj.ApellidoMaterno.ToString();
dtpFechaNacimiento.Value = (DateTime) _obj.FechaNacimiento;
txtSexo.Text = _obj.Sexo;
txtNroHijos.Text = _obj.NroHijos.ToString();
txtSueldo.Text = _obj.Sueldo.ToString();
txtNroDocumento.Text = _obj.NroDocumento.ToString();
cboTipoDocumento.SelectedIndex = (int) _obj.TipoDocumento;
cboEstadoCivil.SelectedIndex = (int) _obj.EstadoCivil;
txtTelefono01.Text = _obj.Telefono01.ToString();
txtTelefono02.Text = _obj.Telefono02.ToString();
txtDireccion.Text = _obj.Direccion.ToString();
txtNacionalidad.Text = _obj.Nacionalidad.ToString();
}

private void IngresarDatosAObjeto()
{
// Este método pasa los valores de los controles del formulario, hacia el objeto

// El ID no se asigna porque es IDENTITY
_obj.Nombres = txtNombres.Text.Trim();
_obj.ApellidoPaterno = txtApellidoPaterno.Text.Trim();
_obj.ApellidoMaterno = txtApellidoMaterno.Text.Trim();
_obj.FechaNacimiento = dtpFechaNacimiento.Value;
_obj.Sexo = txtSexo.Text.Trim();
_obj.NroHijos = int.Parse(txtNroHijos.Text.Trim());
_obj.Sueldo = float.Parse(txtSueldo.Text.Trim());
_obj.NroDocumento = txtNroDocumento.Text.Trim();
_obj.TipoDocumento = cboTipoDocumento.SelectedIndex;
_obj.EstadoCivil = cboEstadoCivil.SelectedIndex;
_obj.Telefono01 = txtTelefono01.Text.Trim();
_obj.Telefono02 = txtTelefono02.Text.Trim();
_obj.Direccion = txtDireccion.Text.Trim();
_obj.Nacionalidad = txtNacionalidad.Text.Trim();
}

private void btnGuardar_Click(object sender, EventArgs e)
{
// Realizar algún código de validación aquí

// Pasar los datos ingresados en el formulario hacia el objeto

37
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

this.IngresarDatosAObjeto();

// Guardar los datos
_obj.Save();

// Cerrar el formulario
this.Close();
}

private void btnCancelar_Click(object sender, EventArgs e)
{
this.Close();
}
}
}

8.3. Programación del formulario principal
De la misma manera en que se ha programado el formulario anterior, aquí se mostrará todo el código
fuente del formulario: (No olvidar la sentencia using)

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Personas.Library;

namespace Personas.WinApp
{
public partial class frmPrincipal : Form
{
public frmPrincipal()
{
InitializeComponent();
}

private void frmPrincipal_Load(object sender, EventArgs e)
{
this.ActualizarFormulario();
}

private void ActualizarFormulario()
{
// Crear el objeto colección
PersonaCollection lista = new PersonaCollection();

// Obtener la data desde la BD
//lista =
SubSonic.Select.AllColumnsFrom<Persona>().ExecuteAsCollection<PersonaCollection>();
//lista =
Personas.Library.DB.Select().From(Persona.Schema).ExecuteAsCollection<PersonaCollection>();
lista =
Personas.Library.DB.Select().From<Persona>().ExecuteAsCollection<PersonaCollection>();

// Enlazar la grilla
dgvGrilla.DataSource = lista;

// Mostrar el número de elementos devueltos
ssBarraEstatusLabel.Text = string.Format("{0} elementos encontrados.",
lista.Count);
}

private void mnuAgregar_Click(object sender, EventArgs e)

38
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

{
// Crear el objeto formulario
frmEditarPersona frm = new frmEditarPersona(ModoFormularioEdicion.Nuevo, "");

// Mostrar el formulario e interceptar la acción ejecutada en el
if (frm.ShowDialog() == DialogResult.OK)
{
// Actualizar el formulario
this.ActualizarFormulario();
}
}

private void mnuModificar_Click(object sender, EventArgs e)
{
// Si la grilla tiene elementos y hay alguno seleccionado, abrir el formulario de
edición
if ((dgvGrilla.Rows.Count > 0) && (dgvGrilla.CurrentRow.Cells[0].Value != null))
{
// Obtener el ID seleccionado
string ID = dgvGrilla.CurrentRow.Cells[0].Value.ToString();

// Crear el objeto formulario
frmEditarPersona frm = new frmEditarPersona(ModoFormularioEdicion.Modificar,
ID);

// Mostrar el formulario e interceptar la acción ejecutada en el
if (frm.ShowDialog() == DialogResult.OK)
{
// Actualizar el formulario
this.ActualizarFormulario();
}
}
else
{
MessageBox.Show("No se seleccionó ningún elemento, o no existen elementos a
seleccionar!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}

private void mnuEliminar_Click(object sender, EventArgs e)
{
// Si la grilla tiene elementos y hay alguno seleccionado, proceder
if ((dgvGrilla.Rows.Count > 0) && (dgvGrilla.CurrentRow.Cells[0].Value != null))
{
// Obtener el ID seleccionado
string ID = dgvGrilla.CurrentRow.Cells[0].Value.ToString();

// Preguntar
DialogResult result = MessageBox.Show("Está seguro de eliminar el elemento
seleccionado?", "Eliminar", MessageBoxButtons.YesNo, MessageBoxIcon.Question);

// Eliminar
if (result == DialogResult.Yes)
{
// Eliminar de la BD
int RegistrosAfectados =
DB.Delete().From<Persona>().Where(Persona.IdColumn).IsEqualTo(int.Parse(ID)).Execute();

// Mensaje
MessageBox.Show(string.Format("Se eliminó {0} elemento(s).",
RegistrosAfectados), "Eliminar", MessageBoxButtons.OK, MessageBoxIcon.Information);

// Actualizar el formulario
this.ActualizarFormulario();
}
}
else
{
MessageBox.Show("No se seleccionó ningún elemento, o no existen elementos a

39
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

seleccionar!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}

private void mnuActualizar_Click(object sender, EventArgs e)
{
this.ActualizarFormulario();
}

private void mnuSalir_Click(object sender, EventArgs e)
{
this.Close();
}
}
}

Recompilar la Solución con F6 y luego ejecutar la aplicación con F5.

40
Tutorial de acceso a datos con Visual Studio 2008 y SubSonic
Autor: Eduardo Rivera Alva (eriveraa@gmail.com)

9. Ejecución de la aplicación
Al ejecutar la aplicación debe verse similar a las siguientes pantallas:

41