APLICACIÓN: BIBLIOTECA CON CAPAS

1. En el Visual Studio crear un nuevo proyecto del tipo Aplicación para Windows (AppBiblioteca)
2. Agregue a la solución dos proyectos del tipo Biblioteca de clases (LibClases y LibFormularios). Elimine de estos
proyectos la clase por defecto Class1. El resultado final debe ser el siguiente:

LA LIBRERÍA DE CLASES
Esta librería será la encargada de realizar las transacciones con la Base de Datos. Cuenta con tres clases iniciales:
- CConexion: Permite conectar a la aplicación con la base de datos.
- CEntidad: Clase ancestro de todas las demás. Implementa métodos para realizar el mantenimiento de las
tablas de la Base de Datos, aunque no se conecta con ninguna en especifico. Esta clase es abstracta por lo
cual no se puede instanciar.
- CLibro: Clase heredera de CEntidad. Implementa aspectos necesarios para el mantenimiento de la tabla
TLibro.
El aspecto final de la capa LibClases deberá ser:

1. En el proyecto LibClases agregue una nueva clase denominada CConexion, cuyo código se tiene a continuación:

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace LibClases
{

Ing. Robert Alzamora Paredes Página 1

 public class CConexion
{ //============== ATRIBUTOS =============================
private SqlConnection aConexion;
private SqlDataAdapter aAdaptador;
private DataSet aDatos;
//============== METODOS ===============================
//------------ Constructor -----------------------------
public CConexion()
{ //-- iniciar la conexion
aDatos = new DataSet();
aAdaptador = new SqlDataAdapter();
// realizar la conexion
string CadenaConexion = "Data Source=NOMBRE-PC\\SQLEXPRESS;
Initial Catalog=bdBiblioteca;Integrated Security=SSPI;";
aConexion = new SqlConnection(CadenaConexion);
}
//----------- Propiedades ----------------------------
public SqlConnection Conexion
{
get { return aConexion; }
}
//----------------------------------------------------
public SqlDataAdapter Adaptador
{
get { return aAdaptador; }
}
//----------------------------------------------------
public DataSet Datos
{
get { return aDatos; }
}
//------------- Servicios ------------------------------
// --- Metodos para ejecutar comandos sql server
// --- Devuelve el resultado en la tabla cero del dataset
public virtual DataSet EjecutarSelect(string pConsulta)
{ // metodo para ejecutar consultas del tipo SELECT
aAdaptador.SelectCommand = new SqlCommand(pConsulta, aConexion);
aDatos = new DataSet();
aAdaptador.Fill(aDatos);
return aDatos;
}
// -------------------------------------------------------------------
// --- Metodo para ejecutar instrucciones DML. No retorna resultado.
// -------------------------------------------------------------------
public virtual void EjecutarComando(string pComando)
{ // metodo para ejecutar consultas del tipo INSERT, UPDATE, DELETE
SqlCommand oComando = new SqlCommand(pComando, aConexion);
aConexion.Open();
oComando.ExecuteNonQuery();
aConexion.Close();
}
}
}

2. Agregue una nueva clase denominada CEntidad, cuyo código se tiene a continuación:

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace LibClases
{

Ing. Robert Alzamora Paredes Página 2

 public abstract class CEntidad
{ // ============================ Atributos ==============================
private CConexion aConexion;
private string aNombreTabla;
string[] aNombres = null; //-- nombres de los campos de la tabla
string[] aValores = null; //-- valores de los campos de la tabla
private bool aNuevo;

// =========================== Metodos ==================================

// ---------------------- Constructores ---------------------------------
public CEntidad(string pNombreTabla)
{ // inicializar los atributos
aNuevo = true;
aNombreTabla = pNombreTabla;
aConexion = new CConexion();
aNombres = NombresAtributos();
aValores = null;
}
// ---------------------- Propiedades -------------------------------------
public bool Nuevo
{
get {return aNuevo;}
set {aNuevo=value;}
}

//-------------- Metodos de soporte de BD ---------------------------------

// -------------------------------------------------------------------------
// -- Metodo abstracto encargado de establecer los nombres de los campos
// -- (atributos) de la tabla. Se deben implementar necesariamente
// -- en los herederos como arreglos de cadenas.
// -- Estos atributos deben concidir con los existentes en la Base de Datos
// --------------------------------------------------------------------------
public abstract string[] NombresAtributos();

// -------------------------------------------------------------------
// --- Metodos para el mantenimiento de la tabla
// ---------------------------------------------------------------------

// --------------- Insercion de nuevos registros -----------------------

public virtual void Insertar(params string[] Atributos)
{ //-- Permite insertar informacion de un registro en la tabla

//-- Recuperar los valores de los atributos

aValores = Atributos;
//-- Formar la cadena de insercion
string CadenaInsertar = "insert into " + aNombreTabla + " values ('";
for (int k = 0; k < aValores.Length; k++)
{ //-- incluir los atributos en la consulta
CadenaInsertar += aValores[k];
if (k == aValores.Length - 1)
//-- se concatenó el ultimo atributo. Terminar la consulta.
CadenaInsertar += "')";
else //-- dejar la consulta lista para el siguiente atributo
CadenaInsertar += "', '";
}

// Ejecutar la consulta para insertar el registro

aConexion.EjecutarComando(CadenaInsertar);
aNuevo = false;
}

// --------------- Actualizacion de registros --------------------------

public void Actualizar(params string[] Atributos)
{ //-- Permite actualizar la informacion de un registro de la tabla

Ing. Robert Alzamora Paredes Página 3

 //-- Recuperar los nombres y valores de los atributos de la tabla.
aNombres = NombresAtributos();
aValores = Atributos;

//-- Formar la cadena de actualizacion.

//-- Se asume que la clave principal es el primer atributo (Posicion CERO)
string CadenaActualizar = "update " + aNombreTabla + " set ";
for (int k = 1; k < aValores.Length; k++ )
{ //-- incluir los atributos en la consulta
CadenaActualizar += aNombres[k] + "= '" + aValores[k];
if (k == aValores.Length - 1)
//-- se concatenó el ultimo atributo. Terminar asignacion de valores
CadenaActualizar += "'";
else //-- dejar la consulta lista para el siguiente atributo
CadenaActualizar += "', ";
}
//-- Agregar a la consulta la clausula WHERE
CadenaActualizar += " where " + aNombres[0] + "= '" + aValores[0] + "'";

//-- Ejecutar la consulta para actualizar el registro

aConexion.EjecutarComando(CadenaActualizar);
}
// --------------------- Eliminación de un registro ------------------------
public void Eliminar(params string[] Atributos)
{ //-- Permite eliminar un registro

//-- Recuperar los nombres y valores de los atributos de la tabla.

aNombres = NombresAtributos();
aValores = Atributos;

//-- Formar la cadena de eliminacion

string CadenaEliminar = "delete from " + aNombreTabla +
" where " + aNombres[0] + "= '" + aValores[0] + "'";

//-- Ejecutar la consulta para eliminar el registro

aConexion.EjecutarComando(CadenaEliminar);
}
// -------------------------------------------------------------------
public bool ExisteClavePrimaria(params string[] Atributos)
{ // verifica si un registro especifico existe

//-- Recuperar los nombres y valores de los atributos de la tabla.

aNombres = NombresAtributos();
aValores = Atributos;

//-- Formar la consulta

string CadenaConsulta = "select * from " + aNombreTabla +
" where " + aNombres[0] + "= '" + aValores[0] + "'";

//-- Ejecutar la consulta

aConexion.EjecutarSelect(CadenaConsulta);

//-- Si existen registros en la tabla 0 del dataset, la clave primaria existe

return (aConexion.Datos.Tables[0].Rows.Count > 0);
}
// -------------------------------------------------------------------
public DataTable Registro(params string[] Atributos)
{ //-- Recupera la informacion de un registro

//-- Recuperar los nombres y valores de los atributos de la tabla.

aNombres = NombresAtributos();
aValores = Atributos;

//-- Formar la consulta

string CadenaConsulta = "select * from " + aNombreTabla +
" where " + aNombres[0] + "= '" + aValores[0] + "'";
Ing. Robert Alzamora Paredes Página 4
 //-- Ejecutar la consulta y devolver el resultado
aConexion.EjecutarSelect(CadenaConsulta);
return aConexion.Datos.Tables[0];
}
// ---------------------------------------------------------------------
public string ValorAtributo(string pNombreCampo)
{ //-- Recupera el valor de un atributo del dataset
return aConexion.Datos.Tables[0].Rows[0][pNombreCampo].ToString();
}
//----------------------------------------------------------------------
public DataTable ListaGeneral()
{ //-- retorna una tabla con la lista completa de libros
string Consulta = "select * from " + aNombreTabla;
aConexion.EjecutarSelect(Consulta);
return aConexion.Datos.Tables[0];
}
}
}

3. Agregue una nueva clase denominada CLibro, cuyo código se tiene a continuación:

using System;
using System.Collections.Generic;
using System.Text;

namespace LibClases
{
public class CLibro: CEntidad
{ //=============== ATRIBUTOS =======================
//-- Todos heredados de CEntidad ----

//================ METODOS ========================

//-------------- Constructores --------------------
public CLibro(): base ("TLibro")
{
}
//------ Implementación de metodos abstractos -----
public override string[] NombresAtributos()
{
return new string[] {"CodLibro", "Titulo", "Autor", "Editorial", "Agno"};
}
}
}

LA LIBRERÍA DE FORMULARIOS
Esta librería será la encargada de implementar la interfaz que utilizará el usuario final. Es una biblioteca de
formularios visuales. Utiliza la librería dinámica generada por el proyecto LibClases.
Cuenta con dos formularios iniciales:
- FrmPadre: Formulario que implementa aspectos generales del trabajo con la capa de clases. Posee un
atributo de tipo CEntidad para realizar las transacciones con la Base de Datos.
- FrmLibro: Clase heredera del formulario FrmPadre. Implementa aspectos
necesarios para el mantenimiento de la tabla TLibro, para lo cual utiliza
la clase CLibro de la librería LibClases.
El aspecto final de la capa LibFormularios deberá ser como se muestra en la
figura:

Ing. Robert Alzamora Paredes Página 5

1. En el proyecto LibFormularios agregue las referencias hacia el proyecto LibClases (para ello, el proyecto LibClases
debió ser generado satisfactoriamente)
Para agregar la referencia, siga los siguientes pasos:
a. En el menú contextual de la opción Referencias seleccione Agregar Referencia.

b. En la pestaña Proyectos del formulario Agregar Referencia, seleccione la librería LibClases.dll

c. La biblioteca de clases debe quedar agregada al proyecto

Ing. Robert Alzamora Paredes Página 6

2. En el proyecto LibFormularios agregue un nuevo formulario denominado FrmPadre y diséñelo de acuerdo al
siguiente modelo:

Nota: Tenga cuidado en diseñar el formulario de tal forma que en los herederos se puedan realizar las
modificaciones necesarias. Para ello, todo aquel componente que pueda (o deba) cambiarse en los
descendientes deben tener su propiedad Modifiers en Protected

3. El código de este formulario es el que se muestra a continuación:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using LibClases;

namespace LibFormularios
{
public partial class FrmPadre : Form
{ //==================== ATRIBUTOS ==============================
protected CEntidad aEntidad;

//==================== METODOS ===============================

//------------------- Constructor ----------------------------
public FrmPadre()
{
InitializeComponent();
}
//------------------ Metodos base -------------------------------
/// <summary>
/// Metodo VIRTUAL que permite indicar qué valores del formulario
/// deben ir a la tabla relacionada. Los valores deben ser definidos
/// en el mismo orden en que están considerados en la base de datos.
/// Es obligatorio redefinir este metodo en todos los heredros de FrmPadre.
/// </summary>
/// <returns>Arreglo de strings con los valores que deben ir a la tabla</returns>
public virtual string[] AsignarValoresAtributos()
{
return null;
}
Ing. Robert Alzamora Paredes Página 7
 //---------------------------------------------------------------
public void IniciarEntidad(CEntidad pEntidad)
{ //-- Indicar con que entidad trabajará el formulario
aEntidad = pEntidad;
}
//---------------------------------------------------------------
public virtual void InicializarAtributoClave()
{ //-- Dar valores a los controles relacionados al atributo clave
}
//---------------------------------------------------------------
public virtual void InicializarAtributosNoClave()
{ //-- Dar valores a los controles relacionados a los atributos no clave
}
//---------------------------------------------------------------
public virtual void InicializarAtributos()
{ //-- Dar valor inicial a todos los atributos del formulario
InicializarAtributoClave();
InicializarAtributosNoClave();
}
//---------------------------------------------------------------
public virtual void MostrarDatos()
{ //-- Visualiza la informacion de un registro en el formulario

}
//---------------------------------------------------------------
public virtual void ListarRegistros()
{ //-- lista todos los registros de la tabla relacionada

}
//--------------------------------------------------------------
public virtual bool EsRegistroValido()
{ //-- verifica que los datos esten completos en el formulario
return true;
}

//---------------------------------------------------------------
public virtual void ProcesarClave()
{
//-- Recuperar atributos, el primer atributo es la clave
string[] Atributos = AsignarValoresAtributos();
// ----- Verificar si existe clave primaria
if (aEntidad.ExisteClavePrimaria(Atributos))
{ //-- Registro existente, Recuperar Atributos y mostrarlos
MostrarDatos();
aEntidad.Nuevo = false;
}
else
{ //-- Registro nuevo, inicializar atributos no clave
InicializarAtributosNoClave();
}
}
//---------------------------------------------------------------
public virtual void Grabar()
{
try
{
if (EsRegistroValido())
{ //-- Recuperar atributos, el primer atributo es la clave
string[] Atributos = AsignarValoresAtributos();
//-- Verificar si existe clave primaria
if (aEntidad.ExisteClavePrimaria(Atributos))
aEntidad.Actualizar(Atributos);
else
aEntidad.Insertar(Atributos);
//-- Inicializar el formulario
MessageBox.Show("OPERACION REALIZADA EXITOSAMENTE", "CONFIRMACION");
Ing. Robert Alzamora Paredes Página 8
 InicializarAtributos();
ListarRegistros();
}
else
MessageBox.Show("DEBE COMPLETAR EL LLENADO DEL FORMULARIO",
"ALERTA");
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "ERROR AL REALIZAR LA OPERACION");
}
}

//------------------------ EVENTOS ------------------------

private void BtnGuardar_Click(object sender, System.EventArgs e)
{
Grabar();
}

//---------------------------------------------------------------
private void BtnSalir_Click(object sender, System.EventArgs e)
{
Close();
}

//---------------------------------------------------------------
private void buNuevo_Click(object sender, System.EventArgs e)
{
InicializarAtributos();
}
}
}

4. Agregue al proyecto un segundo formulario FrmLibro heredero de FrmPadre. Para ello, en el código de FrmLibro
agregue las siguientes cláusulas en la definición de la clase parcial:
public partial class FrmLibro : FrmPadre
Luego, diseñar el formulario de tal manera que tenga un aspecto similar al siguiente modelo:

Ing. Robert Alzamora Paredes Página 9

5. El código de este formulario es el que se muestra a continuación:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using LibClases;

namespace LibFormularios
{
public partial class FrmLibro : FrmPadre
{
public FrmLibro()
{
InitializeComponent();
IniciarEntidad(new CLibro());
}
//============= REDEFINICION DE LOS METODOS VIRTUALES ====================

//-- Establecer los valores que iran a la tabla

public override string[] AsignarValoresAtributos()
{
return new string[] {TxtCodLibro.Text, TxtTitulo.Text, TxtAutor.Text,
TxtEditorial.Text, TxtAgno.Text};
}
//-----------------------------------------------------------
//-- Mostrar los datos de un registro
public override void MostrarDatos()
{ //-- muestra la informacion contenida en el dataset de CLibro
TxtTitulo.Text = aEntidad.ValorAtributo("Titulo");
TxtAutor.Text = aEntidad.ValorAtributo("Autor");
TxtEditorial.Text = aEntidad.ValorAtributo("Editorial");
TxtAgno.Text = aEntidad.ValorAtributo("Agno");
}
//-----------------------------------------------------------
//-- Iniciar los atributos clave y no clave en blanco
public override void InicializarAtributoClave()
{
TxtCodLibro.Text="";
}
public override void InicializarAtributosNoClave()
{
TxtTitulo.Text = "";
TxtAutor.Text = "";
TxtEditorial.Text = "";
TxtAgno.Text = "";
}
//-----------------------------------------------------------
//-- Listar los registros y mostrarlos en el datagrid
public override void ListarRegistros()
{ //-- Mostrar todos los libros de la tabla en el grid
DgvLibros.DataSource = aEntidad.ListaGeneral();

}
//-----------------------------------------------------------
//-- verificar los campos obligatorios(codigo y titulo) estén llenos
public override bool EsRegistroValido()
{
if (TxtCodLibro.Text.Trim() != "" && TxtTitulo.Text.Trim() != "")
return true;
else
return false;

Ing. Robert Alzamora Paredes Página 10

 }
// ================= EVENTOS ==============================
private void TxtCodLibro_Leave(object sender, EventArgs e)
{
ProcesarClave();
}

private void FrmLibro_Load(object sender, EventArgs e)

{
ListarRegistros();
}

}
}

LA APLICACIÓN PRINCIPAL
En el formulario de la aplicación (FrmPrincipal), agregue la referencia a la librería LibFormularios, tal cual se hizo
en el proyecto anterior. Agregue al formulario un menú y desde éste una opción que permita instanciar un
formulario del tipo FrmLibro, y verifique su funcionamiento.
El aspecto final de la solución debe ser la que sigue:

Ing. Robert Alzamora Paredes Página 11

 TRATAMIENTO DE LAS CLAVES FORANEAS

MANTENIMIENTO DE EJEMPLARES DE LIBRO

Para el caso de la tabla Ejemplar, debemos recordar que esta tabla se encuentra relacionada a la tabla TLibro, por
lo cual se presenta una clave foránea: CodLibro. Además la clave principal de TEjemplar es autonumérica.

Para realizar el mantenimiento de esta tabla, realice las siguientes modificaciones:

a) En CEntidad: cambiar el nivel de accesibilidad del atributo aConexion a protegido.
protected CConexion aConexion;

b) En CEntidad: Agregar un atributo que permita el tratamiento de claves autonuméricas

private bool aClaveAutonumerica;

c) Esta última modificación afecta al constructor de la clase que ahora debe contemplar un nuevo parámetro para
inicializar este atributo.

public CEntidad(string pNombreTabla, bool pClaveAutonumerica)

{ // inicializar los atributos
aNuevo = true;
aNombreTabla = pNombreTabla;
aConexion = new CConexion();
aNombres = NombresAtributos();
aValores = null;
aClaveAutonumerica = pClaveAutonumerica;
}
Ing. Robert Alzamora Paredes Página 12
 d) En los herederos de CEntidad también cambia el constructor. Así por ejemplo:
En CLibro el constructor queda así:

public CLibro(): base ("TLibro", false)

{
}

Y en CEjemplar quedará así:

public CEjemplar(): base ("TEjemplar", true)

{
}

e) Luego, modificar el método Insertar dentro de CEntidad para que soporte claves autonuméricas.

public virtual void Insertar(params string[] Atributos)

{ //-- Permite insertar informacion de un registro en la tabla

//-- Recuperar los valores de los atributos

aValores = Atributos;
//-- Formar la cadena de insercion
string CadenaInsertar = "insert into " + aNombreTabla + " values ('";
int IndiceInicial = (aClaveAutonumerica==true? 1: 0);
for (int k = IndiceInicial; k < aValores.Length; k++)
{ //-- incluir los atributos en la consulta
CadenaInsertar += aValores[k];
if (k == aValores.Length - 1)
//-- se concatenó el ultimo atributo. Terminar la consulta.
CadenaInsertar += "')";
else //-- dejar la consulta lista para el siguiente atributo
CadenaInsertar += "', '";
}

// Ejecutar la consulta para insertar el registro

aConexion.EjecutarComando(CadenaInsertar);
aNuevo = false;
}

f) Finalmente, en CEntidad corregir el siguiente método para hacerlo tolerante a errores (cuando la tabla CERO no
tiene registro)

public string ValorAtributo(string pNombreCampo)

{ //-- Recupera el valor de un atributo del dataset
if (aConexion.Datos.Tables[0].Rows.Count > 0)
return aConexion.Datos.Tables[0].Rows[0][pNombreCampo].ToString();
else
return "";
}

LA CLASE CEJEMPLAR

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace LibClases
{
public class CEjemplar: CEntidad
{ //=============== ATRIBUTOS =======================
Ing. Robert Alzamora Paredes Página 13
 //-- Todos heredados de CEntidad ----

//================ METODOS ========================

//-------------- Constructores --------------------
public CEjemplar(): base ("TEjemplar", true)
{
}
//------ Implementación de metodos abstractos -----
public override string[] NombresAtributos()
{
return new string[] {"CodEjemplar", "FechaIngreso", "Estado", "CodLibro"};
}
//------ Métodos especificos de Ejemplares ----------------
public DataTable ListaEjemplaresDeLibro(string pCodLibro)
{ //-- lista los ejemplares que le corresponden a un libro determinado
string Consulta = "select * from TEjemplar where CodLibro= '"
+ pCodLibro + "'";
aConexion.EjecutarSelect(Consulta);
return aConexion.Datos.Tables[0];
}
}
}

EL FORMULARIO FrmEjemplar

Ing. Robert Alzamora Paredes Página 14

Consideraciones previas a la implementación:

- Cada ejemplar le corresponde a un libro, por lo que necesitaremos un objeto del tipo CLibro para manipular
la información correspondiente. Este objeto se encargará de mostrar toda la información necesaria en el
group box de Libro. El formulario debe tener los métodos y eventos necesarios para este fin.
- El datagridview debe mostrar los ejemplares que están relacionados con el libro seleccionado en el combo. Si
no se tiene ningún libro seleccionado, el grid permanece vacío. Para ello, necesitaremos en la clase
CEjemplar un método que devuelva la lista de ejemplares relacionados a un libro especifico
(ListaEjemplaresDeLibro).
- El código de un ejemplar es autonumérico, por lo cual no hay posibilidad que una clave exista al momento de
insertar un nuevo ejemplar. En ese sentido necesitaremos redefinir el método Grabar para que inserte sin
hacer la validación de clave duplicada.

El código del formulario es el que sigue:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using LibClases;

namespace LibFormularios
{
public partial class FrmEjemplar : FrmPadre
{ //=================== ATRIBUTOS ==========================
private CLibro aLibro;

//================== CONSTRUCTORES =======================

public FrmEjemplar()
{
InitializeComponent();
IniciarEntidad(new CEjemplar());
aLibro = new CLibro();
}
//============= REDEFINICION DE LOS METODOS VIRTUALES ====================

//-- Establecer los valores que iran a la tabla

public override string[] AsignarValoresAtributos()
{
//-- recuperar el codigo del ejemplar (de la fila seleccionada en el grid)
string Codigo = "";
if (DgvEjemplares.Rows.Count > 0)
Codigo = DgvEjemplares[0,
DgvEjemplares.CurrentCell.RowIndex].Value.ToString();
return new string[] {Codigo, DtpFechaIngreso.Value.ToShortDateString(),
CboEstado.Text, LblCodLibro.Text};
}
//----------------------------------------------------------
public override void InicializarAtributosNoClave()
{
DtpFechaIngreso.Value = DateTime.Now;
CboEstado.SelectedIndex = -1;
}
//-----------------------------------------------------------
public override void ListarRegistros()
{ //-- Mostrar los ejemplares relacionados con el libro seleccionado
DgvEjemplares.DataSource =
(aEntidad as CEjemplar).ListaEjemplaresDeLibro(LblCodLibro.Text);
}
Ing. Robert Alzamora Paredes Página 15
 //-----------------------------------------------------------
public override bool EsRegistroValido()
{
if (LblCodLibro.Text!=""&& CboEstado.Text!="")
return true;
else
return false;
}
//-----------------------------------------------------------
public override void Grabar()
{ //-- al grabar un nuevo ejemplar, el formulario queda listo para
//-- INSERTAR el siguiente registro
try
{
if (EsRegistroValido())
{ //-- Recuperar atributos, el primer atributo es la clave
string[] Atributos = AsignarValoresAtributos();
//-- Se realiza la inserciòn sin verificar si existe la clave
//-- primaria, ya que en este caso la clave es autonumerica.
aEntidad.Insertar(Atributos);
//-- Inicializar el formulario
MessageBox.Show("OPERACION REALIZADA EXITOSAMENTE", "CONFIRMACION");
InicializarAtributos();
ListarRegistros();
}
else
MessageBox.Show("DEBE COMPLETAR EL LLENADO DEL FORMULARIO",
"ALERTA");
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "ERROR AL REALIZAR LA OPERACION");
}
}

// ===== METODOS PARA MANEJAR LA INFORMACION DEL LIBRO ==========

public void LlenarListaLibros()
{ //-- muestra la lista de libros en el combo
CboLibro.DataSource = aLibro.ListaGeneral();
CboLibro.DisplayMember = "Titulo";
CboLibro.ValueMember = "CodLibro";
//-- dejar el combo sin libro seleccionado
CboLibro.SelectedIndex = -1;
}
// --------------------------------------------------------------------
public void MostrarDatosLibro()
{ //-- al seleccionar un libro en el combo, mostrar el resto de datos

//-- recuperar el codigo del libro seleccionado

string CodLibro = (CboLibro.SelectedValue==null? "":
CboLibro.SelectedValue.ToString());
//-- solicitar a la base de datos la informacion del libro
aLibro.Registro(new string[] { CodLibro });
//-- mostrar el resto de informacion
LblCodLibro.Text = aLibro.ValorAtributo("CodLibro");
LblAutor.Text = aLibro.ValorAtributo("Autor");
LblEditorial.Text = aLibro.ValorAtributo("Editorial");
LblAgno.Text = aLibro.ValorAtributo("Agno");
}

// =========================== EVENTOS ==============================

private void FrmEjemplar_Load(object sender, EventArgs e)
{
LlenarListaLibros();
}
Ing. Robert Alzamora Paredes Página 16
 //---------------------------------------------------------------------
private void CboLibro_SelectedIndexChanged(object sender, EventArgs e)
{ //-- mostrar informacion del libro seleccionado y de ejemplarese relacionados
MostrarDatosLibro();
ListarRegistros();
}
}

Ing. Robert Alzamora Paredes Página 17