LABs de Prg3 C

Guía de Laboratorios
Disciplina de Algoritmos y Programación

Materia: Programación III
Mar – 2011
Programación II Guía de Laboratorios 2
Elaborado por Ing. Rolando Gonzales docente UTEPSA
Elaborado por erick valverde docente UTEPSA

Carrera de Informática y Sistemas

Guía de Laboratorios
Materia: Programación III
Contenido págin
a
Laboratorio Nro. 1: ADO.NET

Ejercicio 1 Creando una Aplicación Simple con acceso a bases de datos sql server 3
Laboratorio Nro. 2: DEFINIENDO UNA ESTRUCTURA DE TRABAJO
Ejercicio 1 Implementación de la arquitectura de trabajo en tres capas 6
Laboratorio Nro. 3: UTILIZANDO LA ESTRUCTURA DE TRABAJO EN TRES CAPAS
Ejercicio 1: Programación en las capas necesarias todo lo necesario para tener la 13
funcionalidad de una interfaz grafica de usuario que permita Adicionar, Modificar, eliminar,
Buscar, Almacenes de una aplicación de gestión de inventarios.
Laboratorio Nro. 4: DEFINIENDO EL MANEJO DE CONTROLES MEDIANTE TECLADO
Ejercicio 1: En la interfaz grafica de usuario realizada en el laboratorio nro, 3 (Gestión de 26
almacenes) programar las opciones necesarias para que el usuario pueda manejar los
comandos nuevo, modificar, eliminar, aceptar, cancelar, buscar mediante el teclado (Sin
utilización de mouse)
Laboratorio Nro. 5: Programación en Tres Capas – Creando Tablas Para la

programación de Ingreso a Inventario (Maestro Detalle)
Ejercicio 1: Crear la tablas necesaria en la base de datos bdinventario en sql server, para la 28
gestión de ingresos a inventario
Laboratorio Nro. 6: Programación en Tres Capas – Creando Procedimientos
almacenados Para la programación de Ingreso a Inventario (Maestro Detalle)
Ejercicio 1: Crear los procedimientos almacenados necesarios en la base de datos 31
bdinventario en sql server, para la gestión de ingresos a inventario.
Laboratorio Nro. 7: Reportes Con Crystal Report 40
Ejercicio 1: Crear un reporte en Crystal Report Sobre el modelo de proyecto en tres capas.
Agregando una cuarta capa para la gestión de reportes

LABORATORIO Nro. 1 ADO.NET
Objetivos:
Creación de una aplicación Windows con acceso a base de datos en la cual se emplee los componentes
ADO.NET: Controles de acceso a datos como SqlConnection, Dataset, SqlDataAdapter.
Creación de habilidades en el manejo de Clases de ADO.NET en aplicaciones Windows con C# y ql
Server.
EJERCICIO 1:
Crear una aplicación denominada buscar productos el cual permita buscar productos en una base de
datos permitiendo introducir un criterio de búsqueda como ser una parte del nombre de algún
producto y la aplicación debe consultar la tabla producto de la base de datos bdinventario y mostrar
los productos que coincidan con el criterio de búsqueda introducido por el usuario.
PRIMERA PARTE: PREPARANDO LA BASE DE DATOS
 Comience Microsoft SQL Server management studio

 Cree una nueva base de datos con el nombre bdinventario
 En la nueva base de datos bdinventario cree una nueva consulta
 En la ventana de comandos de consulta escriba:

 Seleccione el texto sql escrito y presione F5 para ejecutar el comando sql escrito. (Asegúrese
que muestre un mensaje Comandos completados con éxito
 Insertando registros a la tabla producto, Cree una nueva consulta
 Seleccione todos los comandos escritos y presione F5 para ejecutar
SEGUNDA PARTE: CREANDO LA APLICACIÓN EN C#
 Comience la aplicación de C#.Net

 Creando una nueva aplicación
• En la página de inicio (Start Page) seleccione la opción Create Project…
• Cuando se muestre la ventana de plantillas seleccione una aplicación Windows (Windows
Application)
• En la caja de texto del nombre identifique el proyecto como: Consulta de productos
• Haga clic en Accept
 Creando la Interfaz de Usuario
(TextBox, Button, DataGridView)

 Adicionar la referencia al espacio de nombres System.Data.SqlClient, en el archvo
de codigo asociado
 En el botón buscar escribir el siguiente código:

Ejecutar la aplicación
LABORATORIO Nro. 2 Programación en Tres Capas
Objetivos:
Preparar los proyectos necesarios en c# para la implementación de una aplicación Windows bajo la
arquitectura en tres capas, reutilizando la capa de acceso a datos implementado en el proyecto
Servicios, y un proyecto denominado utilitarios con funcionalidades generales en la aplicación.
EJERCICIO 1:
Crear una solución en C# con un proyecto de tipo Aplicación de Windows (Con el nombre
CapaDePresentacion, Un proyecto de tipo Biblioteca de clases (con el nombre CapaDeNegocio)
Un proyecto de tipo Biblioteca de clases Servicios (Este debe ser agregado como proyecto
existente, al igual que el proyecto Utilitarios. Para este laboratorio requiere los proyectos Servicios
y Utilitarios.
SEGUNDA PARTE: CREANDO LA APLICACIÓN EN C#

 Comience la aplicación de C#.Net

 Creando una nueva solución en blanco
• Archivo -> Nuevo Proyecto
• Otros tipos de proyectos (Soluciones de Visual Studio)
• Solución en blanco
 Click derecho sobre la solución Creada en el explorador de Soluciones Agregar Nuevo

Prouecto Visual C# Aplicación para Windows con el nombre CapaDePresentacion
 Click derecho sobre la solución Creada en el explorador de Soluciones Agregar Nuevo

proyecto de tipo Biblioteca de Clases con el nombre CapaDeNegocio
 Hasta aquí tenemos dos proyectos en nuestra solución, ahora agregaremos la tercera capa, la
capa de Acceso a datos que esta implementada en el proyecto Servicios, asi como también el
proyecto utilitarios, Oberve en el explorador de Windows como queda distribuida las carpetas de
su solución.
Dentro de la solución inventario tenemos las carpetas de los dos proyectos CapaDeNegocio,
CapaDePresentacion, ahora copiaremos en la carpeta inventario las dos carpetas adjuntas a este
laboratorio (Servicios y Utilitario) de modo tal que quede distribuida de la siguiente manera:
En el explorador de soluciones de Visual Estudio Agregaremos a la solución los dos proyectos

existentes uno por uno, primero el proyecto Servicios

Seleccionar los proyectos de la misma carpeta de trabajo

Seleccionar el proyecto dentro de la carpeta Servicios (Servicios.csproj) y abrir.
Con lo cual en el explorador de soluciones tenemos:
Repetir el mismo proceso para agregar el proyecto Utilitario

Finamente tenemos lista nuestra solución con los proyectos necesarios para programar el modelo
en tres capas, para finalizar agregamos las referencias entre los distintos proyectos de la solución.
Click derecho en references del Proyecto CapaDeNegocio Agregar referencia

Elegir el proyecto Servicios y aceptar

Repetir el mismo proceso para agregar otra referencia a Utilitario.
En la capa de presentación Agregar las siguientes referencias:

A la CapaDeNegocio, a Servicios y Utilitario.
En el proyecto Utilitario debe tener una referencia a Servicio, revisar si ya tiene en caso de no
tener agregar una referencia a Servicio.
Ahora si ya tenemos, todos los proyectos referenciados y solo queda empezar a programar en
diferentes proyectos los códigos que correspondan según el modelo de tres capas. (Este resultado
se utilizara para los demás proyectos.

LABORATORIO Nro. 3 Programación en Tres Capas

Objetivos:
Utilizar la arquitectura de programación en tres capas con acceso a base de datos con procedimientos
almacenados mediante tablas sin llaves foráneas.
EJERCICIO 1:
Implementar una interfaz grafica de usuario para gestionar Almacenes (Registrar, Modificar, Eliminar,
Buscar para la tabla almacén de la base de datos bdinventario.
Primera Parte Preparando la Base de datos
 Comience SQL Server, Seleccione la base de datos bdinventario, crear nueva consulta
 Ejecutar la consulta para que tengamos una tabla almacén en la base de datos.
 Crear una nueva consulta para crear el siguiente procedimiento almacenado

 Crear otro procedimiento almacenado SP_BuscarAlmacen
 Crear otro procedimiento almacenado SP_TraerAlmacen
SEGUNDA PARTE: Programando en C#

 Ejecutar C# o Visual Estudio
 Archivo Abrir ->Proyecto o solución (Abra la solución del laboratorio anterior)

Obtendrá la solución que contiene los 4 proyectos creados en el laboratorio anterior.

 Modificando la capa Servicios (gDatos.cs) para cambiar el nombre del servidor de base de
datos y la base de datos a la cual nos conectaremos.
Modificamos solo el constructor cambiando los atributos BaseDatos por el nombre de la base de
datos en este caso “bdinventario”, el nombre del servidor “.” Indicando que es servidor local.
Agregamos una nueva clase a la capa de negocio

Con el nombre Almacen.cs

Y modificar con el siguiente código:
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace CapaDeNegocio
{
public class Almacen : DAL.TDatosSql
{
#region "Atributos"
Int64 id_almacen;
string nombre;
#endregion
#region "Propiedades"
public Almacen()
{
id_almacen = 0;
nombre = "";
}
public Int64 pid_almacen
{
set{id_almacen = value;}
get{return id_almacen;}
}
public string pnombre
{
set{nombre = value;}
get{return nombre;}
}
#endregion
#region "Metodos"
int ABM(Utilitario.Utilitario._ABM tarea)
{
int resultado = 0;
System.Object[] P = new System.Object[5];
P[0] = tarea;
P[1] = pid_almacen;
P[2] = pnombre;
P[3] = resultado;
//llamar a un procedimiento almacenado
resultado = Ejecutar("SP_ABMAlmacen", P);
return resultado;
}
public int guardar()
{
return ABM(Utilitario.Utilitario._ABM.Guardar);
}
public int eliminar()
{
return ABM(Utilitario.Utilitario._ABM.Eliminar);
}
public int modificar()
{
return ABM(Utilitario.Utilitario._ABM.Modificar);
}
public DataTable buscarAlmacen(string criterio)
{
P[0] = criterio;
return TraerDataTable("SP_buscarAlmacen", P);
}
public DataTable traerAlmacen()
{
P[0] = pid_almacen;
return TraerDataTable("SP_traerAlmacen", P);
}
#endregion
}
}
Agregamos una nueva clase a la capa de negocio con el nombre CtrlAlmacen.cs con el siguiente
código:
using System;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace CapaDeNegocio
{
public class CtrlAlmacen : DAL.TDatosSql
{
public int guardar(Almacen objAlmacen)
{
return objAlmacen.guardar();
}
public int modificar(Almacen objAlmacen)
{
return objAlmacen.modificar();
}
public int eliminar(Almacen objAlmacen)
{
return objAlmacen.eliminar();
}
public DataTable buscarAlmacen(string criterio)
{
Almacen objAlmacen = new Almacen();
criterio = "%" + criterio + "%";
return objAlmacen.buscarAlmacen(criterio);
}
}
}
Agregamos un nuevo formulario a la capa de Presentación: con el nombre FrmAlmacen
Creamos la siguiente interfaz:

Utilizamos label, TextBox, ToolStrip(Para los botones Nuevo,Modificar,Eliminar, Aceptar…)
Modificar los nombres por defecto de los controles

tbId_Almacen,tbNombre_Almacen,lbEstado,btnNuevo,btnModificar,btnEliminar
,btnAceptar,btnCancelar,btnBuscar,btnSalir
Agregamos otro formulario al proyecto CapaDePresentacion con el nombre

FrmBuscarAlmacen.cs
Con la siguiente interfaz grafica
TextBox, DataGridView,Button
A Continuacion el código del formulario FrmBuscarAlmacen.cs

using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace CapaDePresentacion
{
public partial class FrmBuscarAlmacen : Form
{
public CapaDeNegocio.Almacen Registro = new
CapaDeNegocio.Almacen();
public FrmBuscarAlmacen()
{
InitializeComponent();
}
public void ProcesarBuscar(KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
CapaDeNegocio.CtrlAlmacen objCA = new
CapaDeNegocio.CtrlAlmacen();
dataGridView1.DataSource =
objCA.buscarAlmacen(tbCriterio.Text);
}
}
private void tbCriterio_KeyDown(object sender, KeyEventArgs e)

{
ProcesarBuscar(e);
}
private void btnAceptar_Click(object sender, EventArgs e)

{
ProcesarAceptar();
}
private void ProcesarAceptar()
{
if (dataGridView1.CurrentRow == null)
return;
int fila = dataGridView1.CurrentRow.Index;
Registro.pid_almacen = (Int64)dataGridView1[0, fila].Value;
Registro.pnombre = dataGridView1[1, fila].Value.ToString();
Close();
}
private void dataGridView1_DoubleClick(object sender, EventArgs

e)
{
ProcesarAceptar();
}
private void dataGridView1_KeyDown(object sender, KeyEventArgs

e)
{
if (e.KeyCode == Keys.Enter)
{
ProcesarAceptar();
}
}
private void btnCancelar_Click(object sender, EventArgs e)
{
Close();
}
}
}
Ahora que tenemos el formulario FrmBuscarAlmacen programado escribimos el código en el

formulario FrmAlmacen.cs
using System;
using System.Data;
using System.Text;
namespace CapaDePresentacion
{
public partial class FrmAlmacen : Form
{
Utilitario.Utilitario._ABM estado;
public FrmAlmacen()
{
}
private void btnSalir_Click(object sender, EventArgs e)

{
Close();
}
private void btnNuevo_Click(object sender, EventArgs e)

{
controlarNuevo();
}
public void controlarNuevo()
{
habilitarEntradas(true);
habilitarOperaciones(false);
habilitarAceptarCancelar(true);
estado = Utilitario.Utilitario._ABM.Guardar;
lbEstado.Text = "NUEVO";
tbId_Almacen.Focus();
}
public void habilitarEntradas(bool valor)
{
tbId_Almacen.Enabled = valor;
tbNombre_Almacen.Enabled = valor;
}
public void habilitarOperaciones(bool valor)
{
tsBarra.Items["btnNuevo"].Enabled = valor;
tsBarra.Items["btnModificar"].Enabled = valor;
tsBarra.Items["btnEliminar"].Enabled = valor;
tsBarra.Items["btnBuscar"].Enabled = valor;
}
public void habilitarAceptarCancelar(bool valor)
{
tsBarra.Items["btnAceptar"].Enabled = valor;
tsBarra.Items["btnCancelar"].Enabled = valor;
}
private void btnModificar_Click(object sender, EventArgs e)

{
controlarModificar();
}
public void controlarModificar()
{
if (tbId_Almacen.Text != "" )
{
habilitarEntradas (true);
tbId_Almacen.Enabled = false;
habilitarAceptarCancelar (true);
habilitarOperaciones (false);
estado = Utilitario.Utilitario._ABM.Modificar;
lbEstado.Text = "MODIFICAR";
tbNombre_Almacen.Focus();
}
else
MessageBox.Show("BUSQUE UN ALMACEN PARA MODIFICAR");
}
private void btnEliminar_Click(object sender, EventArgs e)

{
controlarEliminar();
}
public void controlarEliminar()
{
if (tbId_Almacen.Text != "")
{
habilitarAceptarCancelar(true);
habilitarOperaciones(false);
estado = Utilitario.Utilitario._ABM.Eliminar;
lbEstado.Text = "ELIMINAR";
}
else
MessageBox.Show("BUSQUE UN ALMACEN PARA ELIMINAR");
}
private void btnCancelar_Click(object sender, EventArgs e)

{
controlarConsulta();
}
public void controlarConsulta()
{
habilitarEntradas(false);
limpiarEntradas();
habilitarOperaciones(true);
habilitarAceptarCancelar(false);
estado = Utilitario.Utilitario._ABM.Consulta;
lbEstado.Text = "CONSULTA";
}
public void limpiarEntradas()
{
tbId_Almacen.Clear();
tbNombre_Almacen.Clear();
}
private void frmalmacen_Load(object sender, EventArgs e)

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

{
procesarAceptar();
}
public void procesarAceptar()
{
try
{
switch (estado)
{
case Utilitario.Utilitario._ABM.Guardar:
procesarGuardar();
break;
case Utilitario.Utilitario._ABM.Modificar:
procesarModificar();
break;
case Utilitario.Utilitario._ABM.Eliminar:
procesarEliminar();
break;
}
}
catch (Exception E)
{
MessageBox.Show(E.Message);
}
}
public void procesarGuardar()
{
CapaDeNegocio.Almacen objA = new CapaDeNegocio.Almacen();
objA.pid_almacen = Convert.ToInt64(tbId_Almacen.Text);
objA.pnombre = tbNombre_Almacen.Text;
if (objCA.guardar(objA) == 1)
MessageBox.Show("ALMACEN GUARDADO");
else
MessageBox.Show("NO SE PUDO GUARDAR EL NUEVO ALMACEN");
}
public void procesarModificar()
{
if (objCA.modificar(objA) == 1)
MessageBox.Show("ALMACEN MODIFICADO");
else
MessageBox.Show("NO SE PUDO MODIFICAR EL ALMACEN");
}
public void procesarEliminar()
{
if (objCA.eliminar(objA) == 1)
MessageBox.Show("ALMACEN ELIMINADO");
else
MessageBox.Show("NO SE PUDO ELIMINAR EL ALMACEN");
}
private void btnBuscar_Click(object sender, EventArgs e)

{
procesarBuscar();
}
private void procesarBuscar()
{
FrmBuscarAlmacen objFrmBuscar = new FrmBuscarAlmacen();
objFrmBuscar.ShowDialog();
if (objFrmBuscar.Registro.pid_almacen != 0)
{
tbId_Almacen.Text =
objFrmBuscar.Registro.pid_almacen.ToString();
tbNombre_Almacen.Text = objFrmBuscar.Registro.pnombre;
}
}
}
Finalmente Cambiamos el nombre del formulario Form1.cs el cual estaba por defecto en la capa
de Presentación le ponemos el nombre de FrmPrincipal.cs
Y diseñamos la siguiente interfaz. (Utilizamos un menuStrip)
A Continuación programamos en la opción Almacenes el siguiente código:
private void almacenesToolStripMenuItem_Click(object sender, EventArgs

e)
{
FrmAlmacen objFrmAlmacen = new FrmAlmacen();
objFrmAlmacen.ShowDialog();
}
Generamos la solución que no tenga errores:
Y Ejecutamos para probar el ABM de almacenes

LABORATORIO Nro. 4 Programación en Tres Capas – Control de Teclado

Objetivos:
Definir una estrategia de manejo de las interfaces de usuario mediante el teclado.
EJERCICIO 1:
En la interfaz grafica de usuario realizada en el laboratorio nro, 3 (Gestión de almacenes) programar las
opciones necesarias para que el usuario pueda manejar los comandos nuevo, modificar, eliminar,
aceptar, cancelar, buscar mediante el teclado (Sin mouse)
 Abrir el proyecto de trabajo (Inventario)

 Abrir en modo diseño el formulario de gestión de almacenes (frmAlmacen.cs)
 Cambiar la propiedad KeyPreview del formulario por el valor true.
 Programar el evento KeyDown del formulario por el siguiente código:
private void FrmAlmacen_KeyDown(object sender, KeyEventArgs e)

{
if (e.Control)
{
switch (e.KeyCode)
{
case Keys.N:
if (btnNuevo.Enabled)
controlarNuevo();
break;
case Keys.M:
if (btnModificar.Enabled)
controlarModificar();
break;
case Keys.E:
if (btnEliminar.Enabled)
controlarEliminar();
break;
case Keys.A:
if (btnAceptar.Enabled)
procesarAceptar();
break;
case Keys.C:
if (btnCancelar.Enabled)
break;
case Keys.B:
if (btnBuscar.Enabled)
procesarBuscar();
break;
case Keys.S:
if (btnSalir.Enabled)
Close();
break;
}
}
}

Cambiar la propiedad ToolTipText por un texto aclarativo sobre las teclas de acceso rápido para
cada uno de los botones de comandos como por ejemplo para el btnNuevo: Ctrl + N, para el
btnModificar: Ctrl + M y así sucesivamente para obtener cuando este en ejecución la siguiente
apariencia:

LABORATORIO Nro. 5 Programación en Tres Capas – Creando Tablas Para la programación

de Ingreso a Inventario (Maestro Detalle)
Objetivos:
Crear la tablas necesaria en la base de datos bdinventario en sql server, para la gestión de ingresos a
inventario.
EJERCICIO 1:
Crear la tablas del modelo relaciona seleccionado para la materia en sql server y poblar las tablas
básicas mediante la consola de sql server.
 Abrir Sql Server Management Studio

 Click derecho sobre la bdinventario y elegir nueva consulta
 En la consola de sql creada escribir el siguiente script para la creación de las tablas
--------------- TABLAS DE PROVEEDOR -------------------------

create table Pais
(
id_pais codigo primary key,
nombre_pais varchar(50)
)
go
create table Proveedor
(
id_proveedor codigo primary key,
direccion varchar(200) not null,
nit codigo,
id_pais codigo,
foreign key (id_pais) references pais(id_pais)
)
go
create table Juridico

(
id_proveedor codigo,
razon_social varchar(200) not null,
representante varchar(100) null,
primary key (id_proveedor),
foreign key (Id_Proveedor) references Proveedor(id_proveedor)
)
go
create table Natural

(
id_proveedor codigo,
nombre varchar(30) not null,
apellido_paterno varchar(30) not null,
apellido_materno varchar(30) not null,
fecha_nacimiento datetime not null,
primary key (id_proveedor),
foreign key (id_proveedor) references Proveedor(id_proveedor)
)
GO
-------------- TABLAS PARA PRODUCTO--------------------
create table TipoProducto
(
id_tipoproducto codigo primary key,
nombre_tipoproducto varchar(100) not null
)
GO
create table SubTipoProducto
(

id_subtipoproducto codigo primary key,

id_tipoproducto codigo,
nombre_subtipoproducto varchar(100) not null,
foreign key(id_tipoproducto) references
tipoproducto(id_tipoproducto)
)
GO
Create table Producto
(
id_producto codigo primary Key,
id_subtipoproducto codigo,
nombre_producto varchar(200) not null,
costo_producto float,
stock_minimo float,
stock_maximo float,
foreign key (id_subtipoproducto) references
subtipoproducto(id_subtipoproducto)
)
GO
------------ TABLA PARA EL CONTROL DE EXISTENCIA POR ALMACEN ----
Create Table Existencia
(
id_almacen codigo,
id_producto codigo,
stock_producto float not null,
primary key (id_almacen,id_producto),
foreign key (id_almacen) references Almacen(id_almacen),
Foreign key (id_producto) references Producto(id_producto)
)
GO
------------ TABLAS PARA EL INGRESO A INVENTARIO ---------------
Create Table Ingreso
(
id_ingreso codigo primary key,
fecha_ingreso datetime not null,
procesado char(1) not null check(procesado = 'S' OR procesado = 'N'),
id_proveedor codigo references Proveedor(Id_Proveedor),
id_almacen codigo references Almacen(Id_almacen)
)
GO
Create Table Detalle_Ingreso
(
id_ingreso codigo,
id_Producto codigo,
cantidad float not null,
precio_compra float not null,
constraint PKDetalle_Pedido primary key (Id_ingreso,Id_Producto),
constraint FkDetalle_Pedido1 foreign key (Id_ingreso) references
ingreso,
constraint FkDetalle_Pedido2 foreign key (Id_Producto) references
Producto
)
GO
 Seleccionar todo lo escrito (Ctrl + A) y ejecutar (F5)

 Asegúrese que despliegue el mensaje Comandos completados correctamente
 Ejecute las siguientes consultas para poblar tablas basicas

INSERT INTO Pais VALUES (1,'Argentina')

GO
INSERT INTO Pais VALUES (2,'Bolivia')
GO
INSERT INTO Pais VALUES (3,'Colombia')
GO
INSERT INTO Pais VALUES (4,'Paraguay')
GO
INSERT INTO PROVEEDOR VALUES (1,'AV. BENI # 325',4613708010,2)

INSERT INTO JURIDICO VALUES (1,'DISTRIBUIDORA AGROBOL SRL','LIC. BISMAR
MENDEZ')
GO
INSERT INTO PROVEEDOR VALUES (2,'AV. LAS AMERICAS # 500',6818703011,2)

INSERT INTO NATURAL VALUES (2,'JUAN','GONZALES','FUENTES','10/04/1976')
GO
INSERT INTO TIPOPRODUCTO VALUES(1,'LACTEOS')

INSERT INTO TIPOPRODUCTO VALUES(2,'FRUTAS')
INSERT INTO TIPOPRODUCTO VALUES(3,'VERDURAS')
INSERT INTO TIPOPRODUCTO VALUES(4,'CARAMELOS')
INSERT INTO TIPOPRODUCTO VALUES(5,'GASEOSAS')
INSERT INTO TIPOPRODUCTO VALUES(6,'CERVEZAS')
INSERT INTO TIPOPRODUCTO VALUES(7,'CHOCOLATES')
INSERT INTO TIPOPRODUCTO VALUES(8,'CEREALES')
GO
INSERT INTO SUBTIPOPRODUCTO VALUES(1,1,'LECHE')
INSERT INTO SUBTIPOPRODUCTO VALUES(2,1,'YOGURT')
INSERT INTO SUBTIPOPRODUCTO VALUES(3,2,'CITRICOS')
INSERT INTO SUBTIPOPRODUCTO VALUES(4,2,'BASICAS')
INSERT INTO SUBTIPOPRODUCTO VALUES(5,3,'TOMATES')
INSERT INTO SUBTIPOPRODUCTO VALUES(6,3,'CEBOLLA')
INSERT INTO SUBTIPOPRODUCTO VALUES(7,3,'BROKOLI')
GO
INSERT INTO PRODUCTO VALUES (1,1,'LECHE PIL BLANCA BOLSA 1
LTS.',2.5,10,100)
INSERT INTO PRODUCTO VALUES (2,1,'LECHE LA CAMPIÑA BLANCA BOLSA 1
LTS.',1.5,2,20)
INSERT INTO PRODUCTO VALUES (3,1,'LECHE DEL CAMPO BLANCA BOLSA 1
LTS.',1.5,2,20)
INSERT INTO PRODUCTO VALUES (4,2,'YOGURT PIL 90 CC VASITOS',1.20,10,100)
INSERT INTO PRODUCTO VALUES (5,2,'YOGURT PIL LIGTH 90 CC
VASITOS',2.50,10,20)
LABORATORIO Nro. 6 Programación en Tres Capas – Creando Procedimientos almacenados

Para la programación de Ingreso a Inventario (Maestro Detalle)
Objetivos:
Crear los procedimientos almacenados necesarios en la base de datos bdinventario en sql server, para
la gestión de ingresos a inventario.

EJERCICIO 1:
Crear procedimientos almacenados (AMB),(Traer, Busquedas), para cada una de las tablas creadas en
el ejercicio del laboratorio 5
 Abrir Sql Server Management Studio
 Click derecho sobre la bdinventario y elegir nueva consulta
 En la consola de sql creada escribir el siguiente script para la creación de los procedimientos
almacenados
-- PROCEDIMIENTOS ALMACENADOS AMB DE LAS TABLAS

CREATE Procedure SP_ABMProveedor
@tarea integer,--0=guardar 1=actualizar 2=Eliminar
@id_proveedor codigo,
@direccion varchar(200),
@nit codigo,
@id_pais codigo,
@resultado integer output --1=ok 0=error
AS
if (@tarea=0)
begin
insert into proveedor values (@id_proveedor
,@direccion,@nit,@id_pais)
end
if (@tarea=1)
begin
update proveedor set
direccion=@direccion,
nit=@nit,
id_pais = @id_pais
where id_proveedor=@id_proveedor
end
if (@tarea=2)
begin
delete from proveedor where id_proveedor=@id_proveedor
end
if (@@error <> 0)--Valor de control de transaccion
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMJuridico

@razon_social varchar(200),
@representante varchar(100),
AS
if (@tarea=0)
begin
insert into juridico values (@id_proveedor
,@razon_social,@representante)
end
if (@tarea=1)
begin
update juridico set

razon_social=@razon_social,
representante=@representante
end
if (@tarea=2)
begin
delete from juridico where id_proveedor=@id_proveedor
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMNatural

@nombre varchar(30),
@apellido_paterno varchar(30),
@apellido_materno varchar(30),
@fecha_nacimiento datetime,
AS
if (@tarea=0)
begin
insert into natural values (@id_proveedor
,@nombre,@apellido_paterno,@apellido_materno,@fecha_nacimiento)
end
if (@tarea=1)
begin
update natural set
nombre=@nombre,
apellido_paterno=@apellido_paterno,
apellido_materno=@apellido_materno,
fecha_nacimiento = @fecha_nacimiento
end
if (@tarea=2)
begin
delete from natural where id_proveedor=@id_proveedor
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMTipoProducto

@id_tipoproducto codigo,
@nombre_tipoproducto varchar(100),
AS
if (@tarea=0)
begin
insert into tipoproducto values (@id_tipoproducto
,@nombre_tipoproducto)
end
if (@tarea=1)
begin
update tipoproducto set
nombre_tipoproducto=@nombre_tipoproducto
where id_tipoproducto=@id_tipoproducto
end
if (@tarea=2)
begin
delete from tipoproducto where
id_tipoproducto=@id_tipoproducto
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMSubTipoProducto
@id_subtipoproducto codigo,
@id_tipoproducto codigo,
@nombre_subtipoproducto varchar(100),
AS
if (@tarea=0)
begin
insert into subtipoproducto values
(@id_subtipoproducto,@id_tipoproducto,@nombre_subtipoproducto)
end
if (@tarea=1)
begin
update subtipoproducto set
id_tipoproducto = @id_tipoproducto,
nombre_subtipoproducto=@nombre_subtipoproducto
where id_subtipoproducto=@id_subtipoproducto
end
if (@tarea=2)
begin
delete from subtipoproducto where
id_subtipoproducto=@id_subtipoproducto
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMProducto

@id_producto codigo,
@id_subtipoproducto codigo,
@nombre_producto varchar(200),
@costo_producto float,
@stock_minimo float,
@stock_maximo float,
AS
if (@tarea=0)
begin
insert into producto
values (@id_producto,@id_subtipoproducto,@nombre_producto,
@costo_producto,@stock_minimo,@stock_maximo)
end
if (@tarea=1)
begin
update producto set
id_subtipoproducto = @id_subtipoproducto,
nombre_producto=@nombre_producto,
costo_producto = @costo_producto,
stock_minimo = @stock_minimo,
stock_maximo = @stock_maximo
where id_producto=@id_producto
end
if (@tarea=2)
begin
delete from producto where id_producto=@id_producto
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMExistencia

@id_almacen codigo,
@stock_producto float,
AS
if (@tarea=0)
begin
insert into existencia
values (@id_almacen,@id_producto,@stock_producto)
end
if (@tarea=1)
begin
update existencia set
stock_producto= @stock_producto
where id_almacen = @id_almacen and id_producto=@id_producto
end
if (@tarea=2)
begin
delete from existencia
where id_almacen = @id_almacen and id_producto=@id_producto
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMIngreso

@id_ingreso codigo,
@fecha_ingreso datetime,
@procesado char(1),
@id_almacen codigo,
AS
if (@tarea=0)
begin
insert into ingreso
values (@id_ingreso,@fecha_ingreso,@procesado,
@id_proveedor,@id_almacen)
end
if (@tarea=1)
begin
update ingreso set
fecha_ingreso= @fecha_ingreso,
procesado = @procesado,
id_proveedor = @id_proveedor,
id_almacen = @id_almacen
where id_ingreso = @id_ingreso
end
if (@tarea=2)
begin
delete from ingreso
where id_ingreso = @id_ingreso
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
CREATE Procedure SP_ABMDetalle_Ingreso

@id_ingreso codigo,
@cantidad float,
@precio_compra float,
AS
if (@tarea=0)
begin
insert into detalle_ingreso
values (@id_ingreso,@id_producto,@cantidad,
@precio_compra)
end
if (@tarea=1)
begin
update detalle_ingreso set
cantidad= @cantidad,
precio_compra = @precio_compra
where id_ingreso = @id_ingreso and id_producto = @id_producto
end
if (@tarea=2)
begin
delete from detalle_ingreso
where id_ingreso = @id_ingreso and id_producto =
@id_producto
end
begin
set @resultado=0
return(0)
end
else
begin
set @resultado=1
return(0)
end
GO
-- PROCEDIMIENTOS PARA TRAER REGISTROS -------------------

Create Procedure SP_TraerProveedor
@id_proveedor codigo
AS
If(@id_proveedor = 0)
begin
SELECT * from proveedor
End
Else
Begin
SELECT * FROM proveedor
WHERE id_proveedor = @id_proveedor
End
GO
Create Procedure SP_TraerJuridico
AS
begin
SELECT * from juridico
End
Else
Begin
SELECT * FROM juridico
End
GO
Create Procedure SP_TraerNatural

AS
begin
SELECT * from natural
End
Else
Begin
SELECT * FROM natural
End
GO
Create Procedure SP_TraerTipoProducto

@id_tipoproducto codigo
AS
If(@id_tipoproducto = 0)
begin
SELECT * from tipoproducto
End
Else
Begin
SELECT * FROM tipoproducto
WHERE id_tipoproducto = @id_tipoproducto
End
GO
Create Procedure SP_TraerSubTipoProducto

@id_subtipoproducto codigo
AS
If(@id_subtipoproducto = 0)
begin
SELECT * from subtipoproducto
End
Else
Begin
SELECT * FROM subtipoproducto
WHERE id_subtipoproducto = @id_subtipoproducto
End
GO
Create Procedure SP_TraerProducto

@id_producto codigo
AS
If(@id_producto = 0)
begin
SELECT * from producto
End
Else
Begin
SELECT * FROM producto
WHERE id_producto = @id_producto
End
GO
Create Procedure SP_TraerExistencia

@id_almacen codigo,
@id_producto codigo
AS
If(@id_almacen = 0 and @id_producto = 0)
begin
SELECT * from existencia
End
Else
Begin
SELECT * FROM existencia
WHERE id_almacen = @id_almacen and id_producto = @id_producto
End
GO
Create Procedure SP_TraerIngreso

@id_ingreso codigo
AS
If(@id_ingreso = 0)
begin
SELECT * from ingreso
End
Else
Begin
SELECT * FROM ingreso
WHERE id_ingreso = @id_ingreso
End
GO
Create Procedure SP_TraerDetalle_Ingreso

@id_ingreso codigo
AS
If(@id_ingreso = 0)
begin
SELECT * from detalle_ingreso
End
Else
Begin
SELECT * FROM detalle_ingreso
WHERE id_ingreso = @id_ingreso
End
GO
-- PROCEDIMIENTOS ALMACENADOS PARA LAS BUSQUEDAS --------

CREATE PROCEDURE SP_BuscarProveedor
@criterio varchar(250)
as
(
SELECT p.Id_Proveedor,
(N.Nombre + ' ' + N.Apellido_Paterno + ' ' + N.Apellido_Materno)
as Nombre_proveedor,p.nit,p.direccion,'N' as tipo
FROM Proveedor p join Natural N on p.Id_Proveedor=N.Id_Proveedor
where
(N.Nombre + ' ' + N.Apellido_Paterno + ' ' + N.Apellido_Materno)
like @criterio
)
union
(
SELECT p.Id_Proveedor,j.Razon_Social as
NombreProveedor,p.nit,p.direccion,'J' as tipo
FROM Proveedor p join Juridico j on p.Id_Proveedor=j.Id_Proveedor
WHERE j.Razon_Social like @criterio
)
GO
CREATE PROCEDURE SP_BuscarProducto

@criterio varchar(200)
AS
Select * from producto
where nombre_producto like @criterio
GO
CREATE PROCEDURE SP_BuscarIngreso

@id_ingreso codigo
AS
Select * from Ingreso
where id_ingreso like @id_ingreso
GO
LABORATORIO Nro. 7 Reportes Con Crystal Report
Objetivos:
Crear un reporte en Crystal Report Sobre el modelo de proyecto en tres capas. Agregando una cuarta
capa para la gestión de reportes
EJERCICIO 1:
Crear un reporte bajo el modelo en tres capas que muestre una lista de empleados agrupados por
puesto de trabajo.
1.- Agregar a la solucion un nuevo proyecto de tipo class library (Librería de clases nueva)
con el nombre reportes
2.- Agregar un nuevo elemento al proyecto reportes de tipo (conjunto de datos) con el
nombre DSreportes.xsd (este almacenara los datos para los reportes)
Ver grafico ….

3.- Luego abres el DSreportes.xsd y haces click en eplorador de servidores en el enlace

que te mostrara el archivo
Veras las conexiones de bases de datos existentes con todas las tablas de la bd.
4.- Arrastra con el mouse cada tabla del explorador de soluciones encima del contenedor
del archivo DSreportes.xsd.

Si las tablas tienen alguna relación se mostrar la relación existente mediante una línea.
5.- Agregar una nueva clase al proyecto reportes con el nombre CtrlReportes.cs
Con el siguiente código:
using System;
using System.Text;
using System.Data;
namespace Reportes
{
public class CtrlReportes
{
public DataSet ListadoAlmacen(Int64 IdAlmacen)
{
DataSet dsReportes= new DataSet();
Negocio.Almacen objalmacen=new Negocio.Almacen();
objalmacen.pidAlmacen = IdAlmacen;
dsReportes.Tables.Add(objalmacen.Traer_Almacen ());
dsReportes.Tables[0].TableName = "Almacen";
return dsReportes;
}
public DataSet ListadoPedido(Int64 Idpedido)

{
DataSet dsReportes = new DataSet();
/*pedido*/Negocio.Gestion_de_pedidos.Pedido objpedido = new

Negocio.Gestion_de_pedidos.Pedido(); ;
objpedido.pId_Pedido = Idpedido;
dsReportes.Tables.Add(objpedido.Traer_Pedido ());

dsReportes.Tables[0].TableName = "Pedido";
/*detalle*/Negocio.Gestion_de_pedidos.Detalle_Pedido objdetalle = new
Negocio.Gestion_de_pedidos.Detalle_Pedido();
objdetalle.pId_Pedido = Idpedido;
dsReportes.Tables.Add(objdetalle.Traer_DetallePedido());
dsReportes.Tables[1].TableName = "Detalle_Pedido";
/*producto*/Negocio.Gestion_de_productos.Producto objproducto = new
Negocio.Gestion_de_productos.Producto();
dsReportes.Tables.Add(objproducto.Traer_producto ());
dsReportes.Tables[2].TableName = "Producto";
/*Proveedor*/Negocio.Gestion_de_proveedor.persistente.Proveedor
objproveedor= new Negocio.Gestion_de_proveedor.persistente.Proveedor();
dsReportes.Tables.Add(objproveedor.Traer_proveedor());
dsReportes.Tables[3].TableName = "Proveedor";
/*Proveedor*/Negocio.Gestion_de_proveedor.persistente.Natural
objnatural = new Negocio.Gestion_de_proveedor.persistente.Natural();
dsReportes.Tables.Add(objnatural.Traer_Natural ());
dsReportes.Tables[4].TableName = "Natural";
/*TipoProducto*/Negocio.Gestion_de_productos.TipoProducto
objtipoProducto = new Negocio.Gestion_de_productos.TipoProducto();
dsReportes.Tables.Add(objtipoProducto.Traer_TipoProducto
());
dsReportes.Tables[5].TableName = "TipoProducto";
/*TipoProducto*/Negocio.Gestion_de_productos.SubTipoProducto
objsubtipoProducto =new Negocio.Gestion_de_productos.SubTipoProducto();
dsReportes.Tables.Add(objsubtipoProducto.Traer_SubTipoProducto ());
dsReportes.Tables[6].TableName = "SubTipoProducto";
return dsReportes;
}
}
}
6.- Agregamos referencias al proyecto reportes con los demás proyectos capadenegocio,
utilitarios, servicios.
7.- Agregamos un nuevo elemento al proyecto reportes de tipo crystal report

Luego se presenta una confirmación elige reporte en blanco y obtienes el siguiente

grafico
Ahora hay que agregar las tablas y los campos que usaremos en el reporte para eso
utilizamos la conexión que ya hemos trabajado en el archivo xsd.
Click derecho sobre Campos de base de datos y luego Asistente de base de datos como en
el grafico anterior.

Seleccionas datos del proyecto y ADO.NET DATASETS y seleccionas las tablas que
necesites para el proyecto y lo pasas a tablas seleccionadas con el mouse (haciendo click
en … >)
Luego haces click en aceptar y te listo ahora solo falta arrastrar los campos disponibles
hasta las bandas del reporte donde se quiere que aparezcan.
Bueno luego el reporte tiene una parte que dice sesión detalle para este reporte
necesitaremos dos sesiones ya que se mostrara tipo maestro detalle empleados que
pertenecen a un determinado puesto por lo tango agregamos una nueva sesión de detalle


Finalmente arrastramos los campos de las tablas como se quiere que aparezcan en el
reporte
Puedes agregar etiquetas de texto haciendo click en

…
Finalmente el reporte te quedara:
Agregamos un nuevo formulario al proyecto reportes con el nombre

frmReportes
y agregamos un control del tipo:
Al objeto CrystalReportViewer 1 le pones el nombre de visor
En el código asociado al frmreportes programar lo siguiente:
using System;
using System.Data;
using System.Text;
namespace reportes
{
public partial class FrmReportes : Form
{
public FrmReportes()
{
}
public void MostrarReporte()

{
CtrlReportes CR1 = new CtrlReportes();
switch (Utilitario.Utilitario.Reporte)
{
case 1 :
rptempleadosporpuesto R1 = new
rptempleadosporpuesto();
R1.SetDataSource(CR1.ListadoEmpleadoPorPuesto(Utilitario.Utilitario.id_p
uesto));
visor.ReportSource = R1;
break;
case 2:
/* aqui los demas reportes
Reportes.Gestion_de_pedidos.RptPedido
objrptpedido=new Reportes.Gestion_de_pedidos.RptPedido();
objrptpedido.SetDataSource(objCtrlReporte.ListadoPedido(Utilitario.Utili
tario.Id_Pedido));
visor.ReportSource = objrptpedido;
*/
break;
}
}
private void FrmReportes_Load(object sender, EventArgs e)

{
MostrarReporte();
}
}
}
Luego declaras una variable gloval id_puesto en Utilitarios

namespace Utilitario
{
public static class Utilitario
{
#region"Variables Glovales"
// para reportes
public static Int64 IdAlmacen;
public static Int64 Id_Pedido;
public static int id_puesto;
public static int Reporte;
#endregion
#region "listas Enumeradas"
public enum _ABM
{
Guardar = 0,
Modificar = 1,
Eliminar = 2,
Consulta = 3,
}
public enum ListaReportes{
ListadoAlmacen = 0,
ListadoProveedor = 1,
ListadoPedido = 2,
}
#endregion
#region "metodos"
public static Int64 generarcodigo(DateTime dat)
{
String Hora;
String Minuto;
String Segundo;
if (dat.Hour.ToString().Length == 1)
{
Hora = "0" + dat.Hour.ToString();
}
else
{
Hora = dat.Hour.ToString();
}
if (dat.Minute.ToString().Length == 1)
{
Minuto = "0" + dat.Minute.ToString();
}
else
{
Minuto = dat.Minute.ToString();
}
if (dat.Second.ToString().Length == 1)
{
Segundo = "0" + dat.Second.ToString();
}
else
{
Segundo = dat.Second.ToString();
}
return Int64.Parse(dat.Year.ToString() +
dat.Month.ToString() + dat.Day.ToString() + Hora + Minuto + Segundo);
}
public static DateTime leerfecha()
{
DataTable dtfecha = new DataTable();
DAL.TDatosSql objs=new DAL.TDatosSql();
dtfecha =objs.TraerDataTable("SP_traer_fecha") ;
return DateTime.Parse (dtfecha.Rows[0]
[0].ToString());
}
#endregion
}
}
En el botón imprimir del formulario
namespace Capadepresentacion
{
public partial class Form1 : Form
{
public Form1()
{
}
public void imprimir()

{
Utilitario.Utilitario.id_puesto =
Convert.ToInt32(textBox1.Text);
reportes.FrmReportes F = new reportes.FrmReportes();
Utilitario.Utilitario.Reporte = 1;
F.Show();
}
private void button1_Click(object sender, EventArgs e)
{
imprimir();
}

}
}

LABs de Prg3 C

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

LABs de Prg3 C

Diunggah oleh

Hak Cipta:

Format Tersedia

Guía de Laboratorios

Disciplina de Algoritmos y Programación

Elaborado por Ing. Rolando Gonzales docente UTEPSA

Elaborado por erick valverde docente UTEPSA

Carrera de Informática y Sistemas

Laboratorio Nro. 1: ADO.NET

Laboratorio Nro. 5: Programación en Tres Capas – Creando Tablas Para la

Elaborado por erick valverde docente UTEPSA

LABORATORIO Nro. 1 ADO.NET

PRIMERA PARTE: PREPARANDO LA BASE DE DATOS

 Comience Microsoft SQL Server management studio

 En la nueva base de datos bdinventario cree una nueva consulta

 En la ventana de comandos de consulta escriba:

Elaborado por erick valverde docente UTEPSA

 Insertando registros a la tabla producto, Cree una nueva consulta

 Seleccione todos los comandos escritos y presione F5 para ejecutar

SEGUNDA PARTE: CREANDO LA APLICACIÓN EN C#

 Comience la aplicación de C#.Net

(TextBox, Button, DataGridView)

 En el botón buscar escribir el siguiente código:

LABORATORIO Nro. 2 Programación en Tres Capas

SEGUNDA PARTE: CREANDO LA APLICACIÓN EN C#

Elaborado por erick valverde docente UTEPSA

 Comience la aplicación de C#.Net

 Click derecho sobre la solución Creada en el explorador de Soluciones Agregar Nuevo

 Click derecho sobre la solución Creada en el explorador de Soluciones Agregar Nuevo

En el explorador de soluciones de Visual Estudio Agregaremos a la solución los dos proyectos

Elaborado por erick valverde docente UTEPSA

Seleccionar los proyectos de la misma carpeta de trabajo

Elaborado por erick valverde docente UTEPSA

Seleccionar el proyecto dentro de la carpeta Servicios (Servicios.csproj) y abrir.

Con lo cual en el explorador de soluciones tenemos:

Repetir el mismo proceso para agregar el proyecto Utilitario

Elaborado por erick valverde docente UTEPSA

Click derecho en references del Proyecto CapaDeNegocio Agregar referencia

Elaborado por erick valverde docente UTEPSA

Elegir el proyecto Servicios y aceptar

En la capa de presentación Agregar las siguientes referencias:

Elaborado por erick valverde docente UTEPSA

LABORATORIO Nro. 3 Programación en Tres Capas

Elaborado por erick valverde docente UTEPSA

 Crear otro procedimiento almacenado SP_BuscarAlmacen

 Crear otro procedimiento almacenado SP_TraerAlmacen

SEGUNDA PARTE: Programando en C#

Elaborado por erick valverde docente UTEPSA

Obtendrá la solución que contiene los 4 proyectos creados en el laboratorio anterior.

Elaborado por erick valverde docente UTEPSA

Con el nombre Almacen.cs

Agregamos un nuevo formulario a la capa de Presentación: con el nombre FrmAlmacen

Creamos la siguiente interfaz:

Elaborado por erick valverde docente UTEPSA

Utilizamos label, TextBox, ToolStrip(Para los botones Nuevo,Modificar,Eliminar, Aceptar…)

Modificar los nombres por defecto de los controles

Agregamos otro formulario al proyecto CapaDePresentacion con el nombre

Con la siguiente interfaz grafica

A Continuacion el código del formulario FrmBuscarAlmacen.cs

private void tbCriterio_KeyDown(object sender, KeyEventArgs e)

private void btnAceptar_Click(object sender, EventArgs e)

private void dataGridView1_DoubleClick(object sender, EventArgs

private void dataGridView1_KeyDown(object sender, KeyEventArgs

Ahora que tenemos el formulario FrmBuscarAlmacen programado escribimos el código en el

private void btnSalir_Click(object sender, EventArgs e)

private void btnNuevo_Click(object sender, EventArgs e)

/pedido/Negocio.Gestion_de_pedidos.Pedido objpedido = new