Ds - Dt vs2005/8 - Introduccion

DataSet/DataTable tipados y Table Adapter con Visual Studio 2005 y 2008
Introducción- Data Label- Capa de Datos- Capa de Negocios- UI Interfaz

Bueno amigos.

Lo prometido es deuda, si es que vienen siguiendo los artículos que he publicado se darán cuenta que había prometido mostrarles como crear una aplicación en tres capas con el objeto dataset tipado de visual studio 2005, presente también en la nueva versión 2008 de este producto. Así que, esta forma de trabajar les permitirá utilizar esta filosofía en las dos versiones del producto de visual studio.

Antes de partir con los ejemplos, quisiera introducirlos a las modificaciones y mejoras que se han llevado a cabo en la versión de dataset tipados desde vs2003 a vs2005, que en mi opinion es enorme.

Si nos gusta trabajar orientado a los objetos, podemos modelar las entidades que pertenecen a un objeto en un dataset tipado correspondiente, el cual crea automáticamente las relaciones de referencia que existen entre estas entidades, mapenado las estructuras desde la misma base de datos (esto dependerá del proveedor de conexión que estemos utilizando) y las exije al igual que en un modelo entidad relación, lo cual no existía en vs2003, ya que las relaciones las debíamos crear nosotros. Para Sql Server, los mapeos y generaciones de estructuras a raíz de las entidades seleccionadas es completo.

En segundo caso han agregado un nuevo metodo llamado getData(), a parte del método Fill() asociado al adapter seleccionado dependiendo del proveedor.

Si recordamos, el método Fill, nos permitía cargar un DataTable dentro de un dataset, utilizando el objeto Adapter correspondiente al proveedor que estabamos utilizando.

• En vs2005 se mantiene el método Fill en la zona de diseño de un table adapter, asociado a un datatable, ya que el adaptador de consultas se crea directamente cuando tipamos la entidad, con lo cual accedemos al objeto Fill desde el objeto dataset, es decir dataset.modelodetabla.Fill, etc.
• A la plantilla de dataset tipados se le ha agregado una nueva opción denominada GETDATA, la cual permite crear desde la sección de table adapter consultas a bases de datos, pudiendo ser de sql y/o procedimientos almecenados. Los mapeos a procedimientos almacenados pueden ser definidos desde procedimientos existentes o crear estos desde el diseñador provisto por esta plantilla.
  

Estos ejemplos quedarán bien destacados en nuestra aplicación ya que trabajaremos con procedimientos almacenados.

Al crear una Biblioteca de clases utilizando estos objetos, veremos que cuando generamos la Capa de Datos, en el cuadro de herramientas disponibles se agregarán una serie de componentes resultado de él o los dataset tipados que definamos, es decir, si en un dataset tipado definimos la estructura de un objeto, todas las entidades que atienden a este objeto, sean una o muchas se generan dentro del DataSet, por lo cual observarán el nombre del dataset que han creado como componente, adicionalmente observarán todos los tableAdapter que se asocian a cada una de las entidades, es decir, verán un componente con el nombre de la entidad seguido de TableAdapter. Estos componentes generados tendrán todos los métodos GetData que deben realizar las transacciones con las entidades físicas.

Se torna muy importante destacar que cada vez que se realiza una modificación en el modelo de datos Entidad Relación, se deben realizar las modificaciones pertinentes en la capa de datos, así como en los métodos correspondientes de las diferentes capaz que lo acompañan.

Bueno ahora a lo suyo, ver segunda parte

• En este artículo definiremos el modelo entidad relación en una Base de Datos Sql server 2000 o 2005, con procedimientos almacenados para mostrarles las opciones respectivas.


• Crearemos una capa de datos desde una biblioteca de clases tratando de mostrar la forma de desarrollar orientado a objetos (Ya que en un ejemplo con dos entidades no queda muy claro este tema).


• Crearemos una Capa de negocios que relizará las llamadas a los métodos creados en la Capa de Datos y que utilizará las estructuras definidas en ésta para retornar la información.


• Por último, crearemos una UI (Interfaz de usuario que realizará las solicitudes y que utilizará las estructuras definidas para capturar la información). Claro está que para que las capaz de datos y negocios sean totalmente portables, solo deben recibir variables y parámetros, nunca componentes, ya que si definimos una aplicación web y pasamos a una capa de negocios un control para que se carge, este metodo ya no nos servirá para una aplicación web (Los controles son distintos).

Ds - Dt vs2005 - Data Label

DataSet/DataTable tipados y Table Adapter con Visual Studio 2005 y 2008
Introducción- Data Label- Capa de Datos- Capa de Negocios- UI Interfaz

Crear Capa de Datos

En esta fase del artículo definiremos la estructura de nuestra Base de Datos que llamaremos LinQ (La Base de datos que utilizamos en el ejercicio de linq to sql con las mismas entidades, para los que la tienen), así como los procedimientos almacenados que utilizaremos.

1 - Tablas
2 - Procedimientos

Debo mencionarles, que como hago estos ejemplos en la marcha, es decir, a medida que escribo el artículo, es posible que realicemos modificaciones o correcciones de los mismos en el transcurso del ejercicio. Espero que no, ya que la filosofía de trabajar a tres capas esta asociada a la posibilidad de definir cada paso del proyecto una vez terminada una fase anterior, es decir, modelamos e implantamos la Base de Datos, las entidades y los procedimientos almacenados, por que ya tenemos una versión sólida de esta que puede ser implementada, por lo cual la definición de una arquitectura debe ser ascendente. Con esto quiero decir, que, por lo menos en mi caso prefiero definir primero el modelo de datos, luego los procedimientos y funciones y a medida que se van agregando funcionalidades se debe seguir con el mismo paso, el modelo de datos, los procedimientos, y luego la Capa de Datos y la Capa de Negocios.

Mi objetivo no es enceñarles a trabajar Orientado a los objetos, pero en mi artículo de LinQ to Sql de Marzo del 2008 hago una receña a que es OO.

El modelo de datos que debemos implementar es muy simple, solo trabajaremos con 2 tablas y en la capa de datos, a pesar de definir un objeto con las dos entidades, solo crearemos los métodos de transacción de datos en una tabla. Bueno el modelo se observa a continuación:

Y como me gusta facilitarles las cosas les pongo los script de creación de los mismos. Para los que han realizado el ejemplo de Linq to Sql podrán apreciar que el modelo es el mismo.

TABLAS

CREATE TABLE [lnqEmpleado](
[empCodigo] [int] IDENTITY(1,1) NOT NULL,
[empNombre] [varchar](70) NOT NULL,
[empApellidoPrimero] [varchar](70) NOT NULL,
[empApellidoSegundo] [varchar](70) NOT NULL,
[empFechaActivacion] [datetime] NOT NULL,
[empEstado] [char](1) NOT NULL,
CONSTRAINT [PK_lnqEmpleado] PRIMARY KEY CLUSTERED
(
[empCodigo] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

CREATE TABLE [lnqUsuario](
[usuCodigo] [int] IDENTITY(1,1) NOT NULL,
[empCodigo] [int] NOT NULL,
[usuLogin] [char](10) NOT NULL,
[usuClave] [char](10) NOT NULL,
[usuEstado] [char](1) NOT NULL,
CONSTRAINT [PK_lnqUsuario] PRIMARY KEY CLUSTERED
(
[usuCodigo] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

ALTER TABLE [lnqUsuario] WITH CHECK ADD CONSTRAINT [FK_lnqUsuario_lnqEmpleado] FOREIGN KEY([empCodigo])
REFERENCES [lnqEmpleado] ([empCodigo])
ALTER TABLE [lnqUsuario] CHECK CONSTRAINT [FK_lnqUsuario_lnqEmpleado]

Los procedimientos almacenados que utilizaremos solo realizarán transacciones con la tabla lnqUsuario, estos procedimientos almacenados se los pongo a continuación (Miren que me gusta facilitar las cosas):

PROCEDIMIENTOS

CREATE PROCEDURE [dbo].[prcUsuarioConsultar]
@empCodigo int
AS
begin
select
lnqEmpleado.*
from
lnqEmpleado
where
lnqEmpleado.empCodigo = @empCodigo
end

CREATE PROCEDURE [prcUsuarioLista]
AS
begin
select
*
from
lnqUsuario
end

CREATE PROCEDURE [prcUsuarioInsertar]
@empCodigo int,
@usuLogin char(10),
@usuClave char(10),
@usuEstado char(1)
AS
begin
declare @iExiste int
set @iExiste = 0
select @iExiste = count(usuLogin) from lnqUsuario
where usuLogin = @usuLogin
if @iExiste>0
begin
return 1
end
else
begin
insert into lnqUsuario
(empCodigo, usuLogin, usuClave, usuEstado)
values
(@empCodigo, @usuLogin, @usuClave, @usuEstado)
end
return 0
end


CREATE PROCEDURE [prcUsuarioModificar]
@usuLogin char(10),
@usuClave char(10),
@usuEstado char(1)
AS
begin
declare @iExiste int
set @iExiste = 0
select @iExiste = count(usuLogin) from lnqUsuario
where usuLogin = @usuLogin
if @iExiste>0
begin
update lnqUsuario
set
usuClave = @usuClave,
usuEstado = @usuEstado
where
usuLogin = @usuLogin and
usuClave = @usuClave
end
return 0
end

CREATE PROCEDURE [prcUsuarioEliminar]
@usuLogin char(10),
@usuClave char(10)
AS
begin
declare @iExiste int
set @iExiste = 0
select @iExiste = count(usuLogin) from lnqUsuario
where usuLogin = @usuLogin
if @iExiste>0
begin
update lnqUsuario
set
usuEstado = 'I'
where
usuLogin = @usuLogin and
usuClave = @usuClave
end
return 0
end

Ds - Dt vs2005 - Capa Dato

DataSet/DataTable tipados y Table Adapter con Visual Studio 2005 y 2008
Introducción- Data Label- Capa de Datos- Capa de Negocios- UI Interfaz

Bueno amigos, la creación de la capa de datos en esta aplicación es muy simple, ya que como tenemos todo montado en la Base de Datos, que para mi opinion, crear las consultas y transacciones en la base de datos es mucho mejor que crear las consultas en la solución, es decir, en esta capa, es mucho mejor.

Por que digo esto, por la sencilla razón de que cuando definimos las consultas y transacciones en procedimientos almacenados y funciones, tenemos una precomplicación de las mismas y lo único que le queda al motor de base de datos, es ejecutar estas sin tener que hacer un analisis, lexico, sintaxico y semantico (lo explican en la uni cuando pasan sql (es lo básico)). Esto no quita que en algunas ocaciones, por motivos de portabilidad de las aplicaciones entre distintos motores de bases de datos, se opte por hacerlo en la capa de datos correspondiente, pero esto está amarrado a la posibilidad de distintos motores. En el caso de que trabajemos con un solo motor de base de datos, saquemosle el máximo de provecho a las herramientas y pasemos las cargas donde corresponden. Los pasos a seguir para crear nuestra Capa de Datos va a ser la siguiente:

Primero Crearemos un nuevo proyecto de vs2005 o vs2008, para los dos casos los pasos son los mismos. ir a Archivo/Nuevo/Proyecto y seleccionar una aplicación de windows que en este caso será una Biblioteca de Clases, como se muestra en las 2 siguientes imágenes.

Definiremos como nombre del proyecto CapaDato y como nombre de la solución WinApp. A continuación, borraremos la clase que se crea por defecto en el proyecto de bibliotecas de clases y seleccionaremos con el botón derecho del ratón, sobre el nombre del proyecto la opción Agregar/ Nuevo item, en donde se desplegará la ventana que presentará la opción de selección. En esta ventana seleccionaremos la plantilla DataSet, a la cual llamaremos dsUsuario.

Llevado a cabo este paso, ahora el siguiente paso será tipar el dataset, para ello, desde el explorador de servidores, crearemos una conexión al motor de bases de datos y a la Base de Datos en específico que deseamos utilizar para mapear. Abriremos el nodo de conexión y seleccionaremos, en este caso las tablas que deseamos utilizar, arrastrándolas al diseñador definido. Al terminar la acción el DataSet quedará de la siguiente forma:

Si observamos, podremos ver que las estructuras de entidades mapeadas han creado los campos y han creado por defecto un método Fill y otro de tipo GetData. El método Fill por defecto cargará la información de una consulta a un DataTable perteneciente a un dataset que contenga la estructura definida y, el método GetData realizará lo mismo, pero solo retornará un DataTable con el resultado. Estos métodos si se ejecutan retornan toda la información que contiene la tabla en la Base de Datos.

Si se observa, estos métodos están definidos en una sección denominada TableAdapter, por lo cual, no tenemos que crear un Adapter para cargar la información a un DataSet o a un DataTable como lo haciamos en 2003, todo a quedado mapeado y el diseñador nos ha hecho estos métodos por defecto. Ver siguiente figura.

El siguiente paso será asociar nuestros procedimientos a nuestro TableAdapter, para ello deberemos crear unas nuevas consultas de transacciones, para ello nos posicionaremos sobre el table adapter y seleccionaremos con el botón derecho del mouse la opción agregar consulta, como se muestra en la siguiente imagen.

Esto nos habrirá la herramienta de diseño que nos permitirá definir que deseamos hacer.

• La primera nos permite crear consultas sql que estarán en nuestra capa de datos, estas consultas pueden ser de Insert, Update, Delete y de consultas.
• La segunda opción nos permite crear procedimientos almacenados en nuestra Base de Datos, directamente.
• La tercera opción, nos permite consumir los procedimientos almacenados que hemos construído con anterioridad. Un buen diseñador de arquitectura trabaja de esta forma

Ver figura

Al seleccionar la opción de usar procedimientos almacenados , nos desplegará una lista con todos los procedimientos almacendados disponibles en la base de datos, como se muestra en la siguiente figura.

Para realizar el ejemplo, seleccionaremos el procedimiento prcUsuarioListar, el cual al ser seleccionado, desplegará en pantalla los datos que solicita para ser ejecutado correctamente. Al seleccionar la opción siguiente prodremos observar que se despliegan tres opciones.

• Desplegar la información en filas y columnas.
• Entregar solo un resultado
• No retornar valor

Cuando ejecutamos una consulta que retorna una select en un procedimiento almacenado deberemos seleccionar la primera opción, en el caso de que solo deseemos ejecutar un procedimiento que haga algo y debamos controlar un retorno de datos, es decir, 0 o 1 como en nuestros procedimientos de actualización, modificación y eliminación, seleccionaremos la segunda opción. Para el procedimiento seleccionado ejecutaremos la primera opción.

El siguiente paso es definir los métodos Fill y GetData que utilizaremos para la carga de datos de un DataTable dentro de un DataSet o un DataTable, si vamos a retornar solo las filas, solo debemos utilizar un DataTable, para ello solo definiremos que solo utilizaremos DataTable.

Para nuestro ejemplo, solo utilizaremos DataTables y verán que con esta filosofía casi siempre se usa solo la segunda opción, ya que las modificaciones se realizan directamente a la Base de Datos y no se utiliza un DataSet de por medio para modificar y ejecutar el metodo Update del mismo.

Al generar el nuevo método veremos que la sección de Table Adapter cuenta con dos nuevos métodos que retornarán la misma información de dos formas de llamada y carga distintos DataSet y DataTable o DataTable solamente.

Los procedimientos de inserción, modificación y eliminación, retornarán un solo valor 0 o 1, por lo cual no se crean métodos Fill y/o GetData, esto se puede observar en la siguiente figura.

El ultimo paso y el más importantes es el de generación, con el cual se generarán los controles que podremos utilizar desde el cuadro de herramientas cuando creemos los objetos desde la Capa de Negocios.

Bueno como ven, cuando una plicación se encuentra bien diseñada podremos trabajar muy rapidamente en esta capa.

No dejen de lado el trabajar Orientado a Objetos, les facilita la programación, pero la programación OO depende del Análisis y Diseño. Si el análisis y Diseño no esta orientado a Objetos, aunque sean unos muy buenos programadores, nunca podrán desarrollar un diseño que no esta orientado a objetos, esto dará como resultado algo a "medio morir saltando" (chilenismo).

Ds - Dt vs2005 - Capa Negocio

DataSet/DataTable tipados y Table Adapter con Visual Studio 2005 y 2008
Introducción- Data Label- Capa de Datos- Capa de Negocios- UI Interfaz

Crear Capa de Negocios

Despues de haber creado la Capa de Datos y de generar ésta, lo siguientes es crear nuestra Capa de Negocios. En esta utilizaremos las estructuras definidas en nuestra capa de datos con el objeto de capturar la información y realizaremos las llamadas a los métodos de transacciones definidos que nos permitirán realizar desde la Capa de Datos el acceso a la Base de Datos. Lo ideal es que las llamadas a la Base de Datos siempre se hagan desde la Capa de Negios hacia la Capa de Datos y que la ultima realice la transacción y entregue el resultado a la Capa de Negocio. A su vez, la Capa de Negocio es instanciada desde la UI (Interfaz de Usuario) y esta a su vez, retorna los resultados a ésta.

Para poder construir una capa de negocio, se necesita crear un nuevo proyecto de bilbioteca de clases, el cual nos permitirá manejar todo en ambito del negocio dentro de esta clase. Adicionalmente, en esta Capa deben existir los objetos que se han definido en la Capa de datos, ya que los objetos son parte importante de un diseño OO y de una arquitectura de aplicación (A ver si algún día publico como hacer un buen análisis y diseño Orientado a los Objetos), ya que todos dicen siempre saber, pero nunca lo hacen. Para crear el nuevo proyecto, desde el explorador de soluciones seleccionaremos con el boton derecho del mouse (sobre la solución), la opcion agregar/nuevo proyecto, como se muestra a continuación:

Se deplegará la interfaz de definición de proyectos en donde definiremos el nombre de este, como se muestra a continuación:

Bueno, ya creado el proyecto de Biblioteca de Clases que hemos llamada CapaNegocio, borraremos la clase que se crea por defecto y, con el botón derecho de mouse, seleccionaremos (sobre el proyecto creado), la opción Agregar/nuevo item y seleccionaremos la plantilla de Clase de Componentes, que la llamaremos clsEmpleado, respetando el nombre del objeto, como se muestra a continuación:

Al agregar este elemento veremos que se despliegua un diseñador (Bueno, hasta acá todo bien). El siguiente paso será ir a la ventana de herramientas y veremos que al generar el proyecto de Capa de Datos, en el paso anterior se han agregado los controles asociados al dataset y a los TableAdapters que se encuentran definidos para cada una de las entidades mapeadas que componen el objeto, si no se encuentran los componentes del objeto CapaDato en el cuadro de herramientas, deben volver a generar este. Para poder verlos también, deben de tener habierto el diseñador del objeto de clase de componentes que se ha definido. Ver figura.

El siguiente paso será arrastrar a la ventana del diseñador el componente lnqUsuarioTableAdapter, en el diseñador, seleccionaremos el componente agregado y en la ventana de propiedades lo renombraremos como dallnqUsuario (dal de Data Access Label).

Lo que hemos hecho es definir la instancia de llamada al control de la capa de datos que contiene el o los métodos de transacción con la Base de Datos, la interfaz quedará de la siguiente forma:

Al inluir el componente al diseñador, automáticamente se agregar al proyecto de Capa de Negocio una referencia al proyecto de Capa de Datos y en este caso, tenemos acceso a los métodos del TableAdapter lnqUsuarioTableAdapter.

Hasta ahora todo bien, pero tenemos que picar código, para ello nos posicionaremos en el diseñador y seleccionaremos con el botón derecho del mouse la opción Ver código, el cual nos mostrará la ventana de código de la aplicación. Ver figura.

Esto abrirá el archivo de código de la clase de componentes, como yo trabajo en C#, espero que no les moleste que presente los códigos de de los métodos con este lenguaje.

Dentro del espacio de trabajo de la clase y debajo del contructor agregaremos la función que será llamada desde la UI y que retornará la lista de los Usuarios, la cual se muestra a continuación:

// funci¢n encargada de retornar la informacion
public CapaDato.dsEmpleado.lnqUsuarioDataTable fnUsuarioLista() {
CapaDato.dsEmpleado.lnqUsuarioDataTable dt = new
CapaDato.dsEmpleado.lnqUsuarioDataTable();
try{
dt = this.dallnqUsuario.GetDataByUsuarioListar();
}catch (Exception ex) {
throw ex;
}
return dt;
}

Analisemos el código

Como se observa, creamos una función fnUsuarioLista, que retornará la estructura de la tabla lnqUsuario con los datos que este tenga asociados, en el caso de que exista algún tipo de problema elevamos una exception a la UI, que es donde se deben definir los controles de errores para cada aplicación que consuma las llamadas.

Si se observa dallnqUsuario referencia al TableAdapter de la Capa de Datos y es esta la que realmente realiza la transacción con la Base de Datos.

A continuación pongo todos los otros códigos de transacción entre la Capa de Datos y la Capa de Negocios.

// funcion encargada de realizar la inserci¢n de datos de un nuevo usuario
public int prcUsuarioInsertar(Int32 empCodigo, string usuLogin, string usuClave) {
int iReturn = 0;
try {
this.dallnqUsuario.prcUsuarioInsertar(empCodigo, usuLogin, usuClave, ('A').ToString());
}catch (Exception ex) {
throw ex;
}
return iReturn;
}

// funcion encargada de modificar los datos de un usuario
public void prcUsuarioModificar(string usuLogin, string usuClave, string usuEstado){
try {
this.dallnqUsuario.prcUsuarioModificar(usuLogin, usuClave, usuEstado);
}
catch (Exception ex)
{
throw ex;
}
}

// funci¢n encargada de eliminar los datos de usuario
public void prcUsuarioEliminar(string usuLogin, string usuClave) {
try{
this.dallnqUsuario.prcUsuarioEliminar(usuLogin, usuClave);
}catch (Exception ex){
throw ex;
}
}

Lo que nos queda es definir lo mismo que hicimos para lnqUsuariosTableAdapters en lnqEmpleadosTableAdapters, es decir, arrastrar este componente desde el cuadro de herramientas al diseñador, renombrarlos como dallnqEmpleado y luego crear la función de consulta del procedimiento utilizando el id seleccionado, todo quedaría de la siguiente forma:

Y la función que retorna el registro debe quedar de la siguiente forma:

// funci¢n que retorna la informaci¢n de los datos del empleado
public CapaDato.dsEmpleado.lnqEmpleadoDataTable fnUsuarioConsultar(int empCodigo) {
CapaDato.dsEmpleado.lnqEmpleadoDataTable dt = new
CapaDato.dsEmpleado.lnqEmpleadoDataTable();
try {
dt = this.dallnqEmpleado.GetDataByEmpleadoConsultar(empCodigo)
}catch (Exception ex){
throw ex;
}
return dt;
}

Bueno amigos, con esto hemos dado una pincelada a los conceptos de programación orientada a los objetos en vs2005 y vs2008, ya nos queda poco, solo falta la UI.

Ds - Dt vs2005 - Interfaz

DataSet/DataTable tipados y Table Adapter con Visual Studio 2005 y 2008
Introducción- Data Label- Capa de Datos- Capa de Negocios- UI Interfaz

Creando la interfaz que consumirá las Capas creadas

Como ultimo paso, vamos a consumir la información y realizar las transacciones correspondientes a consultas de datos. Las transacciones de actualización de información se las dejo a ustedes.

Como requisito previo para este ejemplo necesitamos tener creado por lo menos un registro de empleado y un registro de usuario para realizar las consultas de despliegue de este.

Podríamos definir la interfaz en una aplicación web o en wpf, pero requeriría mucho trabajo y como estamos entregando lineamientos metodológicos de arquitectura de programación, me centraré en esta idea y agregaremos a la solución una aplicación de tipo windows en C#

Para esto, nos posicionaremos en el explorador de lasolución, sobre el nombre de esta y con el botón derecho del mouse seleccionaremos la opcion Nuevo/Agregar nuevo proyecto y seleccionaremos una aplicación de windows form, la cual llamaremos WinApp, como se muestra en la siguiente figura:

En el formulario por defecto agregaremos los siguientes controles:

ListBox lbxUsuario;
TextBox txtNombre;
TextBox txtAppPrimero;
TextBox txtAppSegundo;
TextBox txtFechaActivacion;
Label lblNombre;
Label lblAppPrimero;
Label lblAppSegundo;
Label lblFechaActivacion;

Quedando el formulario de la siguiente forma:

El siguiente paso es picar código, ahunque podríamos realizar las referencias desde los objetos, pero esto presenta algunos problemitas, si existe problemas en la ejecución la aplicación fallará y deberemos crear manejadores de errores el un archivo general, lo cual lo veremos más adelante y, adicionalmente, prefiero picar el código para hacer estas cosas, por que es más controlado y podemos tener un código más transaprente.

Para esto habilitaremos dos métodos que adienten eventos:

• Un método que atienda el evento de carga del formulario (Load)
• Un método que atienda el evento select del listbox (SelectedIndexChanged)

Los métodos que deben crearse y que se generan al seleccionar los objetos despues del construtor son:

private void Form1_Load(object sender, EventArgs e)
{
}

private void lblUsuario_SelectedIndexChanged(object sender, EventArgs e)
{
}


Hasta aquí todo bien, lo siguiente es tener accesibilidad a las capas que hemos creado, para ello agregaremos dos referencias en el proyecto, una ac CapaDato y otra a CapaNegocio.

Desde la aplicación Windows utilizaremos las estructuras creadas para rescatar la información retornada desde la Capa de Negocio y Capa de Negocio a su vez necesita realizar las solicitudes a Capa de Datos para que esta realice las transacciones a la Base de Datos. Para los que no se recuerdan como agregar referencias, les pongo dos imágenes de como se debe hacer.

Primero seleccionamos con el botón derecho del mouse, sobre el proyecto al que se desea agregar las referencias la opción agregar referencia, como se muestra a continuación

Al seleccionar esta opción, se nos abrirá la ventana que nos permitirá realizar esta acción, para este casoseleccionaremos la pestaña Proyectos y seleccionaremos el o los proyectos que deseamos referenciar, en esta caso serán CapaDato y CapaNegocio y seleccionaremos aceptar, como se muestra a continuación.

Si revisamos en el explorador de soluciones, en el proyecto en cuestión al que se le están agregando las referencias, veremos que se han agregado estas, como se muestra a continuación:

Nos queda poco, solo nos falta picar el código y probar, el código lo pongo a continuación:

En el método que atiende el evento load de la pagina, agregaremos las siguientes líneas de código:

private void Form1_Load(object sender, EventArgs e)
{
try
{
CapaDato.dsEmpleado.lnqUsuarioDataTable dt = new
CapaDato.dsEmpleado.lnqUsuarioDataTable();
CapaNegocio.clsEmpleado cls = new CapaNegocio.clsEmpleado();
dt = cls.fnUsuarioLista();
if (dt.Rows.Count>0){
this.lbxUsuario.DataSource = dt;
this.lbxUsuario.DisplayMember = dt.usuLoginColumn.ToString();
this.lbxUsuario.ValueMember = dt.empCodigoColumn.ToString();
}
}
catch (Exception ex) {
MessageBox.Show(ex.Message);
}
}

ANALISEMOS EL CODIGO

• Primero definimos una variable del tipo de datatable lnqUsuario, esto es para cargar la información que se retorna desde la Capa de Negocio.
• En segundo lugar creamos una instancias a la clase de la Capa de Negocio que contiene el método que debemos llamar para realizar la carga de datos.
• Luego se realiza la llamada al método específico y el resultado se carga en la variable que tiene la misma estructura de lo retornado.

Bueno el resto del código se explica por si solo.

Si ejecutamos la aplicación y tenemos registro asociados, la información se verá de la siguiente forma:

Lo ultimo es habilitar el código de consulta del empleado en custión seleccionado, para ello deben agregar el siguiente ´codigo en el método que atiende el evento SelectedIndexChanged del control ListBox:

private void lblUsuario_SelectedIndexChanged(object sender, EventArgs e) {
int idx = -1;
try { idx = (int)this.lbxUsuario.SelectedValue; }
catch{ idx = -1; }
try {
if (idx>-1){
CapaDato.dsEmpleado.lnqEmpleadoDataTable dt = new
CapaDato.dsEmpleado.lnqEmpleadoDataTable();
CapaNegocio.clsEmpleado cls = new CapaNegocio.clsEmpleado();
dt = cls.fnUsuarioConsultar(idx);
if (dt.Rows.Count > 0){
this.txtNombre.Text = dt[0].empNombre.ToString();
this.txtAppPrimero.Text = dt[0].empApellidoPrimero.ToString();
this.txtAppSegundo.Text = dt[0].empApellidoSegundo.ToString();
this.txtFechaActivacion.Text = dt[0].empFechaActivacion.ToString("dd/MM/yyyy");
}
}
}catch (Exception ex){
MessageBox.Show(ex.Message);
}
}

ANALISEMOS EL CODIGO

Bueno amigos, aquí he tenido que hacer un arreglin, que por falta de tiempo no lo he solucionado así que esta tarea se las dejo a ustedes.

El try catch que se ha agregado al inicio se define para controlar la primera entrada de carga, ya que al asignar el origen de datos, se instancia el método que atiende el evento selectedindexshange y como en este momento no tiene la información cargada, al rescatar el selectedvalue entrega System.Data.DataRowView, lo cual no nos sirve, así que he creado un condicionador con el control de errores (ocurrente no???).

• Bueno lo demás va por la misma línea, creamos una variable con la estructura de la información que deseamos rescatar.
• En segundo lugar creamos una instancias a la clase de la Capa de Negocio que contiene el método que debemos llamar para realizar la carga de datos.
• Luego se realiza la llamada al método específico y el resultado se carga en la variable que tiene la misma estructura de lo retornado.

Bueno amigos a ejecutar y suerte, a mi me funciona.