Programación de Aplicaciones Distribuidas Con Visual Studio 2015 (Práctico 1)

Programacion de Apliciones Distribuidas
Programación de Aplicaciones Distribuidas

con Visual Studio 2015 (Práctico 1).
Seleccionar un tema y desarrollarlo.
Para que el tema quede asignado a un grupo, colocar el nombre en donde dice “Autores”.
No se puede reservar un tema sin por lo menos empezar el desarrollo del mismo.
Mínimo 2 páginas por título.
Máximo 6 páginas por título.
Máximo 2 autores por título (grupo).
No se puede copiar texto ni imágenes de internet (material original).
No puede desarrollar más de un título de este documento.
Formato:
Texto: Arial 11.
Código: Courier New 11.
Fuente título: Trebuchet: MS 16.
Subtítulo dentro de un tema desarrollado: Trebuchet MS 13.
Se puede solicitar agregar un nuevo título al profesor, una vez agotados los títulos actuales.
Fecha límite para completar el documento 16/09/2015.
1 - Instalación y prueba de Visual Studio 2015, incluyendo Hola Mundo

Consola, Hola Mundo Windows, Hola Mundo Web Form (Autores: Espeche
Maximiliano - Emanuel Francisco Gomez) CamStudio: (Amenta Luciano -
Peralta Facundo).
Instalación:
Ingresar a la página de Visual Studio y seleccionar la versión de Visual Studio que desea
bajar, en el caso de nosotros tenemos la opción
Enterprise: El profesor los tiene q haber registrado
Community: Esta versión es gratuita.
Una vez descargado el archivo lo ejecutamos y le damos a ‘INSTALL’.
Por último esperamos que termine la instalación.

Console:
Para crear una
aplicación de Windows:
Vamos a
“Archivo”,“Nuevo”
“Proyecto…”:
En “Plantillas” elegimos “Visual C#”, ”Windows” y luego “Aplicación de Consola”
En la pestaña de Program.cs vamos a escribir el siguiente código:

Luego ponemos en iniciar y se ejecuta el programa de Hola mundo en Terminal de

Windows.
WinForm
Para crear una

aplicación de Windows:
Vamos a
“Archivo”,“Nuevo”
“Proyecto…”:
En “Plantillas” elegimos “Visual C#”, ”Windows” y luego “Aplicación de Windows Forms”

En la pestaña Form1.cs [Diseño], en la caja de herramientas elegimos e insertamos una

herramienta de tipo Label, TextBox y Button:
Cambiamos el nombre al Label, TextBox y al

button en sus respectivas propiedades (en el
caso que no te aparezcan las propiedades,
hacemos clic derecho y luego propiedades) en
la opción Text:
Dejándolo de la siguiente manera, después

de poner el nombre de “Ingresa tu nombre”
al Label, y “Aceptar” al button:
En la pestaña de Form1.cs vamos a escribir el siguiente código:

Luego ponemos en iniciar y se ejecuta el programa de Hola mundo para aplicaciones de

Windows.
Para crear un Sitio Web:
Vamos a “Archivo”,
“Nuevo”, “Sitio web…”.
Luego elegimos la
opción de “Sitio web

vacío de ASP.NET”:
Después nos vamos a

Explorador de
soluciones, ubicado a la
derecha. Hacemos clic
derecho en
WebSite1(1), ponemos
“Agregar”, “Agregar
nuevo elemento…” :
Nos aparecerá la
siguiente ventana,
donde elegimos
“Formulario Web
Forms”. Podemos
poner un nombre que
por defecto es
Default.aspx. Y luego
hacemos clic en
Agregar:
En la siguiente pantalla vemos cómo armar la página web, donde primero vamos a poner la
opción de “Dividir”(1) para que nos muestre la pantalla de la página web. En el cuadro de
Herramientas vamos a arrastrar el tipo Label (2) hacia la página web y a la derecha en su
respectiva propiedad en la opción de Text pondremos su nombre (3) y así con el TextBox
(4), Button (5):
Después de hacer el paso anterior, hacemos doble clic en el Button y nos lleva al código del
evento Button_Click donde escribimos el siguiente código:
Luego hacemos clic en iniciar y nos abrirá el explorador web por defecto, en el caso que no
tengan configurado otro y van a ver la página web creada donde ingresamos el nombre y
presionamos el botón aceptar y nos mostrará Hola “el nombre ingresado”.
2 - Creación de una aplicación Windows con múltiples

formularios/ventanas, utilizando menúes e incluyendo ventana de Login
(Autores: Palacios, Lisa E.). (CamStudio-Autores: Yohana Paez, Julio
Rueda).

Creación de una aplicación Windows con múltiples
formularios/ventanas, con menúes e incluyendo ventana de
Login
Para iniciar creamos un nuevo proyecto con plantillas del tipo Visual C#, allí seleccionamos
entre las plantillas de Windows, la llamada Windows Forms Application
Obtendremos así entonces nuestro primer formulario llamado Form1
Sobre nuestro formulario agregamos dos botones para que nos lleven a los otros
formularios y un label para el título
Desde las propiedades de los botones y el label modificamos el texto que muestran
Ahora agregaremos el menú con el que también nos desplazamos de una ventana a otra,
para ello seleccionamos un MenuStrip
Se nos habilitará en nuestro formulario un menú que deberemos completar con las opciones
que nos permitirán ir de una ventana a otra
También podemos en lugar de agregar texto, seleccionar en la flecha del borde derecho, un
elemento de menú como una barra separadora
Ahora nos queda agregar las ventanas hacia donde navegaran los botones y barra de
menú, para ello desde la barra de menú seleccionamos Proyect y allí Add Windows Form…
Y así nos aparecerá una nueva pestaña con el Form2
De esta forma creamos el formulario VentanaClientes, el VentanaProductos, y el Login que

serán las ventanas a las cuales nos desplazamos y donde colocaremos Labels y botones
para poder regresar a la ventana principal
Ya teniendo nuestras ventanas, Se crea la clase Ventanas
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EjemloVentanas
{
class Ventanas
{
static Form1 form1 = new Form1();
static VentanaProductos vp = new VentanaProductos ();
static VentanaClientes vc = new VentanaClientes ();
static Login lg = new Login();
public static void mostrarPrincipal() {
form1.Show();
vp.Hide();
vc.Hide();
lg.Hide();
}
public static void mostrarProductos() {
form1.Hide(); vp.Show(); vc.Hide();
}
public static void mostrarClientes() {
ocultarVentanas();
vc.Show();
}
public static void ocultarVentanas() {
form1.Hide(); vp.Hide(); vc.Hide(); lg.Hide();
}
public static System.Windows.Forms. Form getPrincipal() {
return lg;
}
}
}
Colocamos el código para el botón Aceptar de la ventana Login

using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace EjemloVentanas
{
public partial class Login : Form
{
public Login()
{
InitializeComponent();
}
private void button1_Click( object sender, EventArgs e)

{
String usuario = textBox1.Text;
String password = textBox2.Text;
if (usuario.Equals( "admin") && password.Equals( "1234"))
{
Ventanas .mostrarPrincipal();
}
else
{
MessageBox .Show("Usuario o password incorrecto" );
}
}
}
}
Código para el botón Ventana de Clientes

private void button1_Click(object sender, EventArgs e)
{
Ventanas .mostrarClientes();
}
Código para el botón Ventana de productos

{
Ventanas .mostrarProductos();
}
Código para la opción Clientes del Menú

private void clientesToolStripMenuItem_Click( object sender,
EventArgs e)
{
Ventanas .mostrarClientes();
}
Codigo para la opción Productos del Menu

private void ProductosToolStripMenuItem_Click( object sender,
EventArgs e)
{
Ventanas .mostrarProductos();
}
Codigo para la opción Salir del menú
private void salirToolStripMenuItem_Click( object sender, EventArgs
e)
{
Application .Exit();
}
Código para Salir del formulario Form1 y Cerrar la aplicación
private void Form1_FormClosed( object sender, FormClosedEventArgs
e)
{
Application .Exit();
}
Código para el botón Volver a la ventana Principal tanto en la ventanas MostrarProductos
como en MostrarClientes
{
Ventanas .mostrarPrincipal();
}
3 - Creación de un archivo de base de datos local, con las siguientes
tablas y datos de ejemplo. Agregar ejemplos de instrucciones sql de
select/join, insert, update y delete (Autor: José De la Cruz). CamStudio:
(Gomez Francisco Emanuel, Espeche Maximiliano)
CREATE TABLE cliente(

id_cliente int primary key identity,
nombre varchar(50),
apellido varchar(50),
direccion varchar(50),
fecha_nacimiento date,
telefono int,
email varchar(50)
)
insert into cliente(nombre) values ('pucho');

insert into cliente(nombre) values ('hijitus');
insert into cliente(nombre) values ('profesor neurus');
insert into cliente(nombre) values ('larguirucho');
CREATE TABLE factura (

numero INT NOT NULL PRIMARY KEY IDENTITY,
fecha DATE NOT NULL,
id_cliente INT NOT NULL,
CONSTRAINT fk_factura_cliente
FOREIGN KEY (id_cliente) REFERENCES cliente(id_cliente)
);
INSERT INTO factura (fecha, id_cliente) VALUES ('2015-08-27', 1);

CREATE TABLE categoria (

id_categoria INT PRIMARY KEY IDENTITY,
nombre VARCHAR(50),
descripcion VARCHAR(200)
);
INSERT INTO categoria(nombre) VALUES('Tablets');

INSERT INTO categoria(nombre) VALUES('Celulares');
INSERT INTO categoria(nombre) VALUES('Notebooks');
CREATE TABlE producto(

id_producto INT not null PRIMARY KEY IDENTITY,
nombre VARCHAR(30),
precio FLOAT,
stock INT,
id_categoria INT FOREIGN KEY REFERENCES categoria(id_categoria)
);
INSERT INTO producto(nombre, precio, id_categoria)

VALUES ('TABLET LG ', '5000', 1);
VALUES ('NOTEBOOK LENOVO', '12000', 3);
VALUES ('LG G3', '10000', 2);
CREATE TABLE [dbo].[Detalle] (
[num_detalle] INT NOT NULL IDENTITY,

[id_factura] INT NOT NULL,
[id_producto] INT NOT NULL,
[cantidad] INT NULL,
[precio] FLOAT (53) NULL,
PRIMARY KEY CLUSTERED ([num_detalle] ASC),
CONSTRAINT [FK_Detalle_id_factura] FOREIGN KEY ([id_factura]) REFERENCES
[dbo].[Factura] ([numero]),
CONSTRAINT [FK_Detalle_id_producto] FOREIGN KEY ([id_producto])
REFERENCES [dbo].[Producto] ([id_producto])
);
INSERT INTO Detalle(id_factura, id_producto, cantidad, precio)

VALUES (1,2,'2','15.34');
INSERT INTO Detalle(id_factura, id_producto, cantidad, precio) VALUES
(1,2,'2','15.34');
(2,2,'2','15.34');
(3,3,'2','15.34');
4 - Creación de aplicación de consola que utilice el archivo de base de
datos local creado en el punto 3, y realice ABMC sobre la tabla de Cliente
utilizando ADO.NET - SQLConnection, SqlCommand, SqlDataReader.
(Autores: Rivadeneira).CamStudio: (Brizuela Carlos Alfredo).
https://gist.github.com/ezekielriva/dd3512eb114f69b973ec
5 - Creación de aplicación de Ventanas que utilice el archivo de base de
utilizando ADO.NET - SQLConnection, SqlCommand, SqlDataReader.
(Autores: Díaz Falcao, Gutiérrez). CamStudio: (Veliz Juan, Sale Carlos
Gabriel)
Creación del proyecto e importación de la base de datos
Creamos un nuevo proyecto, en este caso una aplicación de Windows Forms. Luego, lo
primero que haremos en nuestro proyecto es importar la base de datos del punto 3. Para
ello necesitaremos tener el archivo de la base de datos (.mdf):
Elegimos “Base de datos” como el origen de datos y presionamos Siguiente:
Luego elegimos “Conjunto de datos” como modelo de base de datos a usar y presionamos
Siguiente. Ahora elegimos la conexión de datos. Para ello crearemos una nueva conexión:
Aquí agregaremos el archivo .mdf de la

base de datos del punto 3, damos
aceptar y volvemos a la ventana anterior,
presionamos Siguiente hasta llegar a la
instancia de elegir qué objetos
necesitamos de la base de datos:
Elegimos las tablas de la base de datos, que luego utilizaremos en la aplicación.
Creación de la clase Conexión
Lo que haremos a continuación es agregar a nuestro proyecto una clase “Conexión” donde
definiremos la conexión a la base de datos y un método para ejecutar los query sobre la
base de datos:
class Conexion
{
//creamos un objeto conexion con la cadena de conexion a la //base de datos
SqlConnection con = new SqlConnection("Data Source =

(LocalDB)\\MSSQLLocalDB; AttachDbFilename = |Datadirectory|\\BDpto3.mdf;
Integrated Security = True; Connect Timeout = 30" );
//creamos un objeto command para poder interactuar con el //motor de base de
datos
SqlCommand sql = new SqlCommand();
public Conexion()
{
sql.Connection = con;
}
//creamos un método para ejecutar los query
public void ejecutarQuery(string query)
{
con.Open();
sql.CommandText = query;
try
{
sql.ExecuteNonQuery();
MessageBox.Show("Operación completada con éxito");
}
catch (SqlException)
{
MessageBox.Show("Error en la operación");
}
con.Close();
}
}

Formularios
Agregaremos ahora a nuestro proyecto los formularios necesarios. En este caso tenemos la
ventana principal, un formulario para Nuevo cliente, uno para Listar los clientes y otro para
Editar los datos de un cliente:
En la ventana principal
agregaremos un
MenuStrip desde el
cuadro de herramientas.
A éste le agregaremos
los ítems para poder
acceder a los otros
formularios (Nuevo
cliente y Listar clientes).
En la ventana Nuevo Cliente tenemos labels y textBoxs para cargar los datos del cliente,
también tenemos los botones para guardar, borrar los datos o cancelar. El botón guardar
realizará la acción de crear un nuevo cliente en la base de datos con los campos que
ingresemos en esta ventana.
En la ventana
Listar Clientes
tenemos un
DataGridView (que
agregamos del
cuadro de
herramientas)
donde se
mostrarán los
datos de los
clientes que
existen en la base
de datos.
Para esto, debemos asignarle un

origen de datos a nuestro
DataGridView:
Seleccionaremos nuestra tabla
Cliente de la base de datos.
Al seleccionar un elemento de esta tabla

podremos: editar los datos de un cliente y
guardarlo en la base de datos; eliminar un cliente
de la base de datos.
Clase Controlador
Creamos una clase “Controlador” que será la que contenga todos los métodos del manejo
de las ventanas y las acciones que realicen los componentes de las mismas.
En esta clase instanciaremos los formularios a utilizar y un objeto conexión para poder
ejecutar los query:
static Principal principal = new Principal();

static NuevoCliente nc = new NuevoCliente();
static ListarClientes lc = new ListarClientes();
static Conexion con = new Conexion();
El método guardarCliente es el que realizará el botón Guardar de la ventana Nuevo Cliente:
tatic void guardarCliente()

public s
{
string fecha = "" + nc.Tb8.Text + "-" + nc.Tb7.Text + "-" +

nc.Tb6.Text;
string guardar = "insert into cliente(nombre, apellido,
direccion, fecha_nacimiento,telefono,email) values" +
"('" + nc.Tb1.Text + "','" + nc.Tb2.Text + "','" + nc.Tb3.Text +
"','" + fecha + "','" + nc.Tb4.Text + "','" + nc.Tb5.Text + "')";
con.ejecutarQuery(guardar);
lc.actualizarTabla();
}
Donde Tb1, Tb2, etc. son propiedades que obtienen el valor ingresado en los textBox.
El botón Editar en la ventana de Listar clientes lo que hará es llamar a un método que
obtenga los datos de la tabla y los envíe al formulario Editar Cliente, donde Dgv1 es la
propiedad del DataGridView que permite obtener los datos del mismo:
tatic void editarCliente()

public s
{
string id = lc.Dgv1.SelectedRows[0].Cells[0].Value.ToString();
string nombre =
lc.Dgv1.SelectedRows[0].Cells[1].Value.ToString();
string apellido =
string direccion =
string fec_nac =
string anio = fec_nac.Substring(6, 4);
string mes = fec_nac.Substring(3, 2);
string dia = fec_nac.Substring(0, 2);
string telefono =
string email =
EditarCliente ec = new
EditarCliente(id,nombre,apellido,direccion,dia,mes,anio,telefono,email);
ec.Show();
}
Luego en la ventana Editar Cliente, el botón Guardar actualizará los datos en la base de
datos:
public static void actualizarCliente(string id, string nombre, string

apellido, string direccion, string telefono, string email, string dia, string
mes, string anio)
{
string actualizar = "update cliente set nombre= '" + nombre +
"',apellido = '" +
apellido + "',direccion = '" + direccion +
"',fecha_nacimiento = '" + anio + "-" +
mes + "-" + dia + "',telefono = '" + telefono + "',email =
'" + email + "'" +
"where id_cliente = '" + id + "'";
con.ejecutarQuery(actualizar);
}
Finalmente, con el botón Eliminar en la ventana Listar Clientes, eliminaremos un cliente de

la base de datos:
tatic void eliminarCliente(string id)

public s
{
string message = "Está seguro que desea eliminar este cliente?"
;
string caption = "Eliminar cliente";
MessageBoxButtons buttons = MessageBoxButtons.YesNo;
DialogResult result;
result = MessageBox.Show(message, caption, buttons);
if (result == System.Windows.Forms.DialogResult.Yes)

{
string eliminar = "delete from cliente where id_cliente = '" +
id + "'";
con.ejecutarQuery(eliminar);
}
}
6 - Creación de aplicación Web Forms que utilice el archivo de base de
datos local creado en el punto 3, y realice ABMC sobre la tabla de
Producto utilizando - SQLConnection, SqlCommand, SqlDataReader.
(Autores:PALACIO ALBERTO FEDERICO). CamStudio: (Barrientos Gabriel -
Pasteris Lucas)
Creación de la página web Forms
Usando lo que aprendimos del ejercicio 2 crearemos un nuevo Sitio web y le agregamos un
nuevo item
Elegimos Web Form y la llamamos Defaul.aspx.
Lo que genera un form con este contenido.
Lo primero que haremos es colocar la tabla con el contenido de productos

Pasamos la forma de ver la form de source a Desing.
Abrimos el “server explore” y buscamos la tabla de productos y la arrastramos hasta la form.

Lo que generará una tabla en nuestra form con el contenido de la base de datos de la tabla
productos.
A Partir de aquí trabajaremos con el ABMC.
Alta de Producto
Agregamos un link debajo de la tabla, con el nombre “Agregar Producto” y Creamos una
nueva form llamada Alta.aspx a la cual será el destino del link que creamos.
En la form Alta.aspx le agregaremos labels y textBox hasta que nos quede así.
Al botón “Agregar Producto” le asignamos un evento, haciendo doble clic sobre él, al cual le
agregaremos el siguiente código el cual se conecta con la base de datos y agrega el
contenido de los textBox.
Se guardará el nuevo producto y regresará a la form Default.aspx que es nuestra página

principal.
Modificar un Producto
En la form Default.aspx hago clic en la tabla para seleccionar las opciones “GridView Taks”
y habilitó el “enable selection”, el cual agrega una columna a la tabla “select” sobre
cualquiera hago doble clic, para generar un evento que contendrá la fila de la tabla
seleccionada en Defaul.aspx.cs.
De la fila extraigo la columna que tiene el id del producto y lo envió a una nueva form que
crearemos con el nombre “Modificar.aspx”.
En la Form “Modificar.aspx” que tendrá el mismo aspecto que la form alta, salvo que tendrá
el botón “Modificar Producto” en vez del de “agregar Producto”, dicho botón tendrá el
siguiente código.
Nota* copie y pegue el form Alta en el Solución y le cambie el nombre de Modificar por lo
cual aparece como class Alta al comienzo del codigo.
Una vez ingresado los nuevos datos re direcciona a la página Defalut.aspx.
Borrar
En nuestra form Default.aspx agregamos un textBox y un botón “Borrar Producto”
El cual le generamos un evento haciendo doble clic en él, el cual contendrá el siguiente
código
lo que borrara el registro con el id_producto que sea igual a que ingresamos.
Consulta
Agregamos a Default.aspx las siguientes modificaciones
El botón “consulta” tendrá un evento haciendo doble clic en él, el cual contendrá el siguiente
código
el cual devolverá los valores del producto consultado en labels de la form Default.aspx.
7 - Creación de aplicación de consola que utilice el archivo de base de
utilizando DataSets No Tipados. (Autores: Carlos Brizuela ).
8 - Creación de aplicación de Ventanas que utilice el archivo de base de
utilizando DataSets Tipados. (Autores: Julio Rueda - Yohana Paez ).
CamStudio: (Flores Zarate Mariano - Duarte Ernesto).
“ABMC en la tabla de Cliente utilizando DataSets Tipados”
- En primer lugar creamos un nueva solución en Visual Studio, que contendrá dos
proyectos: uno que llamaremos “PUNTO8”, será el que contenga nuestros forms y la BD
creada en el punto 3 de este práctico, el proyecto llamado CAD (Capa de Acceso a Datos)
tendrá una clase CAD, por cada tabla que forme parte de nuestro DATASET, y en cada una
de estas clases definiremos los métodos para manipular nuestras tablas. Pasamos a
detallar los pasos para la resolución de este punto.
1. Crear nuevo proyecto, del tipo windows forms.
2. Dentro de la misma solución, crear una biblioteca de clases, a la que llamaremos CAD
(capa de acceso a datos).
3. Crear conexión con la Base de Datos desde “Explorador de Servidores”.
4. Dentro del proyecto CAD, crear un nuevo elemento, lo que haremos en este punto es
crear el DATASET.
5. En el explorador de servidores, despliega las tablas que contiene la BD, arrastra las
tablas que quieras que formen parte de tu DATASET al archivo de extensión .xsd (funciona
como un editor gráfico de nuestro dataset), de esta manera acotamos las tablas sobre las
que se trabajara. En nuestro caso solo arrastramos la tabla “Clientes”.
- Podemos ver que la tabla cliente se generó con un sector llamado ew, este permite
manipular la tabla, en el podemos ver definidos ya unos métodos, que son sentencias SQL
para operar sobre la tabla, muchas de estas operaciones ya están definidas, pero también
podemos agregar nuevas consultas ajustándose a nuestras necesidades.
6. Si observamos nuestro proyecto CAD, veremos que tiene una clase CAD.cs creada por
defecto. Tomando esta clase, cambiamos su nombre por CADCliente.cs, desde aquí
llamaremos a los métodos definidos en nuestro tableAdapter.
7. Lo siguiente será asociar el proyecto CAD, a nuestro proyecto PUNTO8 donde están los
forms y la BD. Para poder hacerlo, en nuestro explorador de soluciones nos ubicamos en la
opción REFERENCIAS y haciendo clic derecho elegimos “Agregar referencias”.
- Tildamos el proyecto que queremos referenciar
- Con esto habremos asociado el proyecto CAD con el proyecto “PUNTO8”.
8. Dentro del proyecto “PUNTO8” encontramos un form1, creado por defecto, este nos
servirá para preparar la interfaz, a través de la cual el usuario podrá interactuar con el
DATASET, que será el encargado de operar sobre la BD física. Para poder responder a
operaciones básicas como son las altas, bajas y modificaciones, agregamos al windows
forms, un par de controles.
- Esto se agregara sobre Form1.cs [diseño], mientras que en Form1.cs [clase-código]

tendremos la definición de los eventos asociados a nuestros controles.
Dentro de los controles añadidos tenemos uno especial para los dataset, llamado
DATAGRIDVIEW, el cual tomamos desde el “cuadro de herramientas”, opción “DATOS”.
Simplemente lo arrastramos hasta nuestro Form1.
- Luego agregamos labels y textfields, que nos servirán para insertar nuevos clientes, o
modificarlos. También nuestro form1 presenta botones : AGREGAR, BORRAR,
MODIFICAR, cada uno de los cuales tiene un evento click asociado definido en FORM1.cs,
que lo que hará es tomar los datos del form1 y llamar a los métodos que se encuentran
definidos en la capa de acceso de datos.
- Para poder relacionar nuestro DATAGRIDVIEW con nuestra tabla “Cliente”, hacemos clic
sobre la fecha ubicada en la parte superior derecha del GRID, y buscamos en “Elegir origen
de datos”, nuestra tabla.
- Esta acción rellena nuestro DATAGRIDVIEW de forma automática, autocompletando el

método Form1_Load con el siguiente código:
- Fill es un método ya definido en nuestra clienteTableAdapter, y nos devolverá todos los

registros de la tabla.
- Asi se vera nuestro FORM1 al ejecutar la solución:
ALTA, BAJA Y MODIFICACIÓN:
- Nuestro form está listo, pero para agregarle funcionalidad solo tenemos que agregar unas
líneas de código.
ALTA:

1. Hacemos doble clic sobre el botón “AGREGAR”, esto creará un método asociado al
mismo.
“button1” es el nombre del botón “AGREGAR”, dentro del método agregamos dos líneas de
código. La primera línea llama al método “InsertarCliente” , para esto primero hace
referencia a la biblioteca de clases “CAD”, y luego a la clase CADCliente, ambas creadas

anteriormente. - Este método toma lo que encuentra dentro de los TextFields del FORM1 y
lo pasa por parámetro a “InsertarCliente”.
2. Para ver la definición de este método, accedemos a “CADCliente.cs”.
- Esto hace referencia al objeto “adapter” que contiene métodos, que en realidad son
consultas SQL, que están definidas ya por defecto, por ejemplo Insert.
- Además existen definidas por defecto consultas “Delete”y “Update”. Una de las fortalezas
de los DATASET, es que nos permiten definir nuestras propias consultas personalizadas. Lo
que veremos más adelante para el caso de Delete y Update.
- Simplemente con esto, ya podremos realizar altas sobre la tabla cliente desde nuestro
form.
BAJA:

1.Hacemos doble clic sobre el botón “BORRAR”, esto creará un método asociado al mismo.
“button2” es el nombre de nuestro “BORRAR”, el código que le agregamos al método

cumple la siguiente función, la primera línea toma el valor contenido en la celda
seleccionada. Se debe seleccionar las celdas de la columna id_cliente, asi el id se guardara
en nuestra variable indice.
- Hacemos referencia a la capa de acceso de datos, y a la clase CADCliente, para llamar a
su método “EliminarCliente”, pasandole el índice, que no es otra más que el id del cliente.
2. Para ver la definición de este método, accedemos a “CADCliente.cs”.
- Podemos ver que el método que llamamos del tableadapterCliente, no es el definido por
defecto “Delete”, sino uno creado por nosotros. Para hacerlo debemos ir a nuestro DataSet,
en nuestro caso se llama “DataSetPunto8.xsd”, en la parte inferior donde está nuestro

“clienteTableAdapter” seleccionamos “Agregar Consulta”.

- Como nosotros ya tenemos la consulta creada se puede ver en la imagen “DeleteQuery” y
“Update Query”. Pero para lograr eso en la opción “Agregar Consulta” hicimos lo siguiente
- Tildamos “Crear un nuevo procedimiento almacenado”, damos “Siguiente”, y se abrirá la

siguiente ventana:
- Como en este caso queremos hacer un borrado, seleccionamos “Delete”, y damos

siguiente.
- Lo resaltado en azul se crea por defecto, ahora podemos manipular estas sentencias
SQL, para obtener la consulta deseada, en nuestro caso lo reducimos a esto:
- Que se lee como, “borrar cliente cuando el id_cliente (atributo de la tabla) sea igual al
@Original_id_cliente(dato que pasamos por parámetro)”.
- Lo siguiente que nos pedirá será un nombre para nuestro procedimiento, esto es
importante recordar, ya se con ese nombre lo llamaremos desde CADCliente.cs.
- Vemos cómo al dar finalizar el procedimiento “DeleteQuery1” se agregó al tableAdapter
- Recordemos que “DeleteQuery1” solo fue agregado a modo de prueba, el que usamos en
nuestro proyecto es “DeleteQuery”
MODIFICACIÓN:

1. Al hacer doble clic en el botón “MODIFICAR” se generará lo siguiente:
“button3” es el nombre de nuestro botón modificar, el código toma el valor del id_cliente, por
lo cual es importante seleccionar dicha celda antes de dar clic sobre el botón
“MODIFICAR”.
Llama al método ModificarCliente definido en la capa de acceso a datos.
2. La definicion del metodo es la siguiente:
en este caso el método llamará al proceso UpdateQuery que modificará el registro con los
nuevos datos ingresados, siempre que el id almacenado en la variable índice coincida con
uno existente en la tabla
- Para crear este procedimiento seguimos los mismos pasos que en el caso de
“DeleteQuery”.
- Este es el código SQL del procedimiento “UpdateQuery”
- Con esto ya tenemos nuestro windows forms con dataset tipados. También queremos
agregar que si la BD se encuentra fuera de Visual Studio se puede conectar con el servidor,
y crear dataset con tablas de la BD, y luego seguir los mismos pasos aquí especificados.
9 - Creación de aplicación Web Forms que utilice el archivo de base de
datos local creado en el punto 3, y realice ABMC sobre la tabla de
Producto utilizando DataSets Tipados. (Autores: Páez Paz, Matías).TP2
CamStudio: Apaza Leonardo
Primero se crea un nuevo proyecto Aplicación web ASP.NET:
Luego se agrega una base de datos SQL Server
Y se completa la tabla haciendo una consulta SQL con el código del punto 3.
Luego, se agrega un nuevo elemento Conjunto de datos, o Data Set.
Aparecerá el diseñador de DataSet:
Hay que seleccionar las tablas
Y arrastrarlas al diseñador de DataSet, donde se mostrarán las tablas de la siguiente

manera:
Para el alta, baja y modificación de producto, se crea un Formulario Web Forms
Para el alta, llenamos el formulario, en este caso con una tabla que contiene el texto, los
TextBox y el Button, hacemos doble click en el Button para que se genere el código del
evento click, en el que usamos el siguiente código para realizar el alta:
var adaptador = new DataSet1TableAdapters.productoTableAdapter();
adaptador.Insert(TextBox1.Text,double.Parse(TextBox2.Text),int.Parse(TextBox
3.Text),int.Parse(TextBox4.Text));
DataSet1 es el nombre del DataSet usado, TextBox1, 2, 3 y 4 son los TextBox que se
ingresan el nombre, precio, stock y categoría respectivamente.
Para la baja y modificación se puede usar un elemento GridView, que se encuentra en la
parte de Datos del Cuadro de herramientas. Se puede asignarle el DataSet como origen de
datos directamente desde el diseño:
Poniendo <Nuevo origen de datos…> aparecerá la siguiente ventana:
Donde seleccionamos “Objeto” y se le puede especificar un identificador al origen de datos,

click en Aceptar, pasará a otra ventana,
En la que seleccionamos productoTableAdapter, click en siguiente, y luego en finalizar.

Después, en donde seleccionamos el origen de datos tildamos las opciones de habilitar
edición y eliminación, y si se quiere las demás.
Y como resultado queda algo así

10 - Creación de aplicacion Windows Form que utilice el archivo de base
de datos local creado en el punto 3 y que permita realizar realizar una
venta. (Autores: Veliz Juan Agustin, Sale Carlos Gabriel ). (CamStudio:
Diaz Falcao Alejandra, Gutiérrez Andrea)
Creación del proyecto con windows form
Lo primero que hay que hacer al abrir Visual Studio es ir a la pestaña Archivo y seleccionar
Nuevo. Se abrira un menu desplegable donde elegiremos la opción Proyecto…
A partir de ahí nos saldrán una serie de opciones, de las cuales a la izquierda elegiremos
Visual C# y a la derecha Aplicación de Windows Forms. Debajo, al lado de la etiqueta
nombre, podemos nombrar nuestro proyecto como queramos. Hacemos click en aceptar.
Con nuestro proyecto creado vamos a ver un Windows Form vacio, al cual le vamos a
agregar elementos arrastrandolos del cuadro de herramientas que aparece a la izquierda.
Luego de agregarle los elementos nos debería quedar un Windows form asi:
Creación de la clase Conexion
Hacemos click derecho en nuestro proyecto, dentro del explorador de soluciones y elegimos
la opción Agregar… y luego Clase…
La clase conexion posee dos atributos, un SqlConnection que será el string de la conexión a
la base de datos y un SqlCommand que posee la cadena de conexión y recibe los querys
para ejecutarlos luego.
class Conexion
{
SqlConnection con = new SqlConnection("Data
Source=(LocalDB)\\MSSQLLocalDB;"
+
"AttachDbFilename=|DataDirectory|\\Venta.mdf;Integrated
Security=True");
SqlCommand sql = new SqlCommand();
public Conexion()
{
sql.Connection = con;
}
Como podemos ver es dentro del constructor donde le asignamos al SqlCommand la
cadena de conexión.
Conexion tambien posee 4 métodos que son los que van a ejecutar distintos tipos de querys
y uno para cerrar la conexión.
public void ejecutarNonQuery(string query)

{
con.Open();
try
{
sql.ExecuteNonQuery();
MessageBox.Show("Operacion completada con exito");
con.Close();
}
catch (SqlException)
{
MessageBox.Show("Error en la operacion " +query);
con.Close();
}
public SqlDataReader ejecutarQuery(string query)

{
con.Open();
try
{
SqlDataReader resultado = sql.ExecuteReader();
return resultado;
}catch(SqlException)
{
MessageBox.Show("Error en la operacion "+query);
return null;
}
}
public void CerrarConexion()

{
con.Close();
public string GetIdFactura(string query)

{
con.Open();
try
{
string idFactura = sql.ExecuteScalar().ToString();
return idFactura;
}catch(SqlException)
{
MessageBox.Show("Error en la operacion "+query);
return null;
}
}
Clase Controlador
Es la clase que recibe y maneja todos los eventos del Form principal. Posee 3 atributos
estáticos que son el propio form, la conexión, y una colección de detalles.
class Controlador
{
static Ventana v = new Ventana();
static Conexion con = new Conexion();
static List<Detalle> detalles = new List<Detalle>();
Los métodos de la clase se listan a continuación
public static System.Windows.Forms.Form obtenerVista()

{
return v;
}
public static void AgregarLineaVenta(string id, string
cantidad)
{
SqlDataReader resultado = con.ejecutarQuery("SELECT *
FROM producto WHERE id_producto ='" + id + "'");
resultado.Read();
string nombreProd = resultado.GetString(1);
double precio = resultado.GetDouble(2);
int idCategoria = resultado.GetInt32(4);
CerrarConexion();
SqlDataReader resultado2 = con.ejecutarQuery("SELECT *

FROM categoria WHERE id_categoria ='" + idCategoria + "'");
resultado2.Read();
string nombreCat = resultado2.GetString(1);
CerrarConexion();
v.dgv.Rows.Add(id, nombreProd, nombreCat, precio,
precio * int.Parse(cantidad));
Detalle det = new Detalle(int.Parse(id),

int.Parse(cantidad), precio);
detalles.Add(det);
}
public static void BuscarCliente(string id)

{
SqlDataReader resultado = con.ejecutarQuery("SELECT *

FROM cliente WHERE id_cliente ='" + id + "'");
resultado.Read();
string nombre = resultado.GetString(1);
string apellido = resultado.GetString(2);
string domicilio = resultado.GetString(3);
v.tbNombreCli.Text = nombre + " " + apellido;
v.tbDomicilioCli.Text = domicilio;
CerrarConexion();
public static void CerrarConexion()

{
con.CerrarConexion();
}
public static void FinalizarVenta(string idCli)

{
string idFac = con.GetIdFactura("INSERT INTO
factura(fecha,id_cliente) VALUES('2015-09-16','"+ idCli
+"');SELECT SCOPE_IDENTITY();");
CerrarConexion();
for (int i=0; i<detalles.Count;i++)

{
con.ejecutarNonQuery("INSERT INTO
Detalle(id_factura,id_producto,cantidad,precio) VALUES('" +
idFac +"','" + detalles[i].Id_producto + "','"
+ detalles[i].Cantidad + "','" + detalles[i].Precio +"')");
CerrarConexion();
}
}
Clase Detalle
Esta clase se define como una auxiliar, Detalle es parte del modelo de BD, y se la usa para
armar la colección de Detalles de la clase controladora y luego poder agregar varios detalles
relacionados a una sola factura en la BD.
class Detalle
{
private int id_producto;
private int cantidad;
private double precio;
public Detalle(int id_producto, int cantidad, double

precio)
{
this.id_producto = id_producto;
this.cantidad = cantidad;
this.precio = precio;
}
11 - Creación de aplicación con Web Forms que utilice el archivo de base

de datos local creado en el punto 3 y que permita realizar una venta.
(Autores: Flores Zarate Mariano).
12 - Creación de procedimientos almacenados en la base de datos del
punto 3 para realizar las operaciones de Alta, Baja y Modificación de la
tabla de Cliente, y crear una aplicación ADO.NET que utilize dichos
procedimientos almacenados. (Autores: Barrientos Gabriel - Pasteris
Lucas). CamStudio: Montero Mauricio Alejandro
p
Creacion de Procedimientos Almacenados en Base de Datos con aplicacion
ADO.NET
Una aplicacion ADO.NET es un conjunto de clases que exponen servicios de acceso a

datos para programadores de .NET Framework. En nuestro caso, realizaremos una
aplicación de Windows Forms, que se caracterizará por no utilizar librerías externas para la
conexión con la base de datos, sino en una simple declaración.
Using System.Data.SqlClient;
Primero crearemos un nuevo proyecto de Windows Forms, explicado ya en tutoriales

anteriores.
En nuestro caso, una vez creado el proyecto, primero deberíamos cargar la tabla cliente
realizada en el punto 3, o bien crearla nuevamente siguiendo los pasos declarados en el
mismo.
Para cargarla de nuestro directorio, tenemos que hacer click derecho en nuestro proyecto
Luego en Agregar -> Elemento existente..
Aquí cargamos el directorio en donde guardamos nuestra base de datos.

Siempre que tenga la extensión .mdf
En nuestro caso se llama Empresa.mdf
Una vez cargada nuestra DB Empresa.mdf, hacemos click derecho en ella en el explorador
de soluciones de nuestro proyecto y se nos abrirá el explorador de servidores en donde
muestra todo lo que contiene nuestra DB.
Para la creación de un procedimiento almacenado, hacemos click derecho en la carpeta

Procedimientos Almacenados y luego en Agregar nuevo procedimiento almacenado.
Se nos abrirá una pestaña en donde podemos realizar una consulta SQL, pero en este caso
viene predefinida con la sintaxis para la creación de un procedimiento almacenado.
ombre del procedimiento

en donde [dbo].[Procedure] corresponde al n
@param corresponde a los parámetros que ingresan al procedimiento, que son

utilizados para la consulta SQL declarada posterior al AS.
por ejemplo SELECT @param1, @param2.. aquí utilizaremos los parámetros que recibe el
procedimiento.
Al fin y al cabo, es una sintaxis parecida a la de un método, salvo con la excepción que sirve
para consultas SQL.
Una vez que entendimos esto, crearemos procedimientos almacenados para Alta, Baja y
Modificaciones de nuestra tabla cliente.
Procedimiento Almacenado Alta Cliente

Para realizar el alta de un cliente, tenemos que declarar los parámetros que recibirá el
procedimiento que en este caso son los atributos del cliente, declarados con un @ seguidos
por el tipo.
La sintaxis BEGIN - consulta - END, es opcional, sirve para estructurar un poco más el
procedimiento, al fin y al cabo se podría obviar ingresando solamente la consulta.
Procedimiento Almacenado Baja Cliente
En este caso el parámetro que recibimos para realizar la eliminación es el ID del cliente.
Procedimiento Almacenado Modificar Cliente

Es parecido a un Insert(Alta) solo que se utiliza el comando UPDATE, y el ID en este caso

se utilizará para buscar el cliente que debemos modificar . WHERE id_cliente=@id_cliente
Ahora vamos a crear una ventana en donde se carguen los datos del cliente en un
DataGridView (tabla) y luego podemos agregar, modificar o eliminar clientes de la misma
utilizando los procedimientos que creamos anteriormente.
En realidad hay varias maneras de hacerlo, quizás este caso es el más sencillo.
En nuestra ventana ya creada, vamos a los componentes y agregamos un DataGridView.
Luego en el margen superior derecho de nuestro Grid hacemos click y se nos abrirán las
opciones del mismo.
Elegimos nuestro origen de dato, en este caso no nos aparece ninguno porque todavia no
creamos el origen de datos para este grid.
Procedemos a crearlo
Hacemos click en agregar origen de datos y se nos abrirá el Asistente para la configuración
del origen de datos
Elegimos Base de Datos y clickeamos siguiente. Luego Conjunto de datos y siguiente.
Aquí el asistente nos pedirá que agreguemos nuestra conexión. En el caso de que no les
aparezca ya la conexión de la DB, hacemos click en Nueva Conexión.
Luego click en examinar y buscamos nuestra DB Empresa.mdf.
Y listo ahora iniciemos la aplicación se nos cargarán los clientes que tenemos en nuestra
DB en el DataGridView.
Ahora vamos a utilizar los procedimientos almacenados.
Agregaremos botones para un Nuevo Cliente, Modificar y Eliminar.
Además crearemos otro WinForm para la hora de agregar un cliente o modificar sus datos,
es decir, hacemos click en Nuevo o bien seleccionamos un cliente (fila) de la tabla y se nos
abrirá el mismo form para modificar sus datos.
El evento del boton agregar estará referenciado para el Insert de un nuevo cliente, en este
caso el procedimiento almacenado altaCliente. Para su utilizacion procedemos a crear un
método o bien en el mismo evento del boton, haciendo doble click en el mismo.
Evento en Botón Agregar

Obtenemos los parámetros que utilizaremos en el procedimiento almacenado y los

mandamos a otro método nuevo Cliente creado en la clase principal, que es la que se
conectará con la DB, para eso tenemos que hacer una serie de declaraciones, tales como
librerías a utilizar, instancias de clases sql, cadena de conexión, etc.
La cadena de conexiones la podemos encontrar en el archivo app.config de nuestro

proyecto
Volviendo al método nuevo Cliente

Los pasos son los mismo para una consulta SQL que para un procedimiento almacenado.
Con la excepcion que a la hora de declarar la consulta, la sintaxis para la utilizacion del
procedimiento es la siguiente
“EXEC nombre del procedimiento ‘parametroCadena’, parametroNumérico;”
Ahora veamos un ejemplo de cómo sería la modificación sin procedimiento y con

procedimiento almacenado.
Seleccionamos una fila de nuestra tabla Clientes y hacemos click en modificar.
El evento relacionado al botón Modificar es el siguiente.
Se nos abrirá la ventana Datos Clientes con los TextField cargados con sus datos. De tal
manera los podemos modificar y hacemos click en el botón Guardar.
El evento del boton Guardar.
También hace referencia a un método que se conecta con la DB, que se encuentra en la
clase principal.
Método guardarModificacionCliente
Aquí vemos como sería la modificación del cliente de forma normal (en comentarios) y la
modificación del cliente utilizando el procedimiento modificacionCliente.
Ahora, para la baja de un cliente, podemos seleccionar una fila y hacemos click en el botón
eliminar.
El evento del boton eliminar.

Este método nos muestra una ventana de alerta de que si estamos seguros de eliminar,
como una confirmación.
En caso de proceder hacemos referencia al evento bajaCliente ubicado en la clase principal.
Y así podemos realizar una aplicacion ADO.NET que utilice procedimientos

almacenados.
13 - Creación de triggers en la base de datos del punto 3 que auditen las
operaciones de eliminación de la tabla de Clientes. (Autores: ).
14 - Creación de un web service que permita obtener los datos de un
clientes en particular, listado de clientes, datos de un producto y listado
de productos. (Autores: Apaza Leonardo ).(CamStudio-Autores: Cano José
Manuel - Molina Luis )
Un web service es un conjunto de protocolos y estándares que sirven para intercambiar
datos entre aplicaciones. Distintas aplicaciones de software desarrolladas en lenguajes de
programación diferentes, y ejecutadas sobre cualquier plataforma.
De una manera más clara se podría decir que un web service es una función que diferentes
servicios o equipos utilizan; es decir, solo se envían parámetros al servidor (lugar donde
está alojado el web service) y éste responderá la petición.
Ahora vamos a crear un web service en visual studio 2015 para obtener:
· Datos de un cliente en particular
· Listado de clientes
· Datos de un producto particular
· Listado de productos
Abrimos nuestro visual studio 2015 y creamos un nuevo proyecto del tipo Web->Aplicación
web ASP:NET y lo llamamos “WebService”

Seleccionamos un plantilla vacía “Empty” y luego aceptar
Ponemos cancelar en la configuración de Azure

Nos creará un proyecto vacío, luego agregamos un nuevo elemento haciendo click derecho
en nuestro proyecto y agregamos lo siguiente:
Y nos mostrará lo siguiente:

Luego nos aseguramos que tenemos nuestra base de datos de los ejemplos anteriores en
nuestro explorador de servidores ->Conexiones de datos -> bdfacturacion.mdf
Un WebMethod no es más que un método en un archivo .cs que se coloca como

[WebMethod] y por tanto se comporta como un webservice, y puede ser llamado desde el
código .NET.
Nos Saluda. Ahora agregamos las siguientes variables:

cadenaconexion: Variable que define la cadena de conexión a la base de datos.

conexion: Variable de tipo SqlConnection; permitirá establecer una conexión a la base de
datos.
comando: Variable de tipo SqlCommand; permitirá la ejecución de consultas y el paso de
parámetros para la ejecución de las mismas.
adaptador: Variable de tipo SqlDataAdapter; con un funcionamiento parecido al de
comando, con la salvedad de que además permitirá llenar un conjunto de datos (DataSet)
con los datos obtenidos de una consulta.
resultado: Variable de tipo DataSet; nos permitirá mostrar los registros de una tabla.
Los siguientes métodos:
Para abrir y cerrar una conexión con la base de datos.
Ahora agregamos nuestros métodos para obtener: Datos de un cliente en particular,

Listado de clientes, Datos de un producto particular, Listado de productos.
Luego ejecutamos el proyecto
Y en el navegador web se cargará lo siguiente:

Hacemos click en listadoClientes
Luego en invocar
Si todo salio bien nos devuelve un archivo xml con la información de la tabla.
De manera similar con los otros métodos:
obtenerCliente
listadoProducto
obtenerProducto
15 - Creación de un cliente de web service que utilice los servicios
creados en el punto 14. (Autores: ).
16 - Validación de datos de entrada en aplicaciones Windows y Web
(valor número, correo electrónico, CUIT/CUIL, fecha). (Autores: Montero
Mauricio Alejandro, Ibarra César Augusto) (TP2: Páez Paz, Matías José).
Si desea exigir que los usuarios especifiquen datos en un formato bien definido, como un
número de teléfono o un número de serie, puede llevarlo a cabo rápidamente y con una mínima
cantidad de código mediante el control MaskedTextBox. Una máscara es una cadena formada
por caracteres de un lenguaje de enmascaramiento que especifica qué caracteres se pueden
especificar en una posición determinada del cuadro de texto. El control muestra un conjunto de
indicadores al usuario. Si el usuario especifica una entrada incorrecta, por ejemplo, escribe una
letra cuando se requiere un dígito, el control rechazará automáticamente la entrada.
El lenguaje de enmascaramiento que utiliza MaskedTextBox es muy flexible. Permite especificar

caracteres necesarios, opcionales y literales, como guiones y paréntesis, caracteres de divisa y
separadores de fechas. El control también funciona bien cuando se enlaza a un origen de datos.
El evento Format en un enlace de datos se puede utilizar para dar formato de nuevo a los datos
de entrada de modo que cumplan con la máscara, y el evento Parse puede utilizarse para dar
formato de nuevo a los datos de salida de modo que cumplan las especificaciones del campo de
datos.
Para agregar un control MaskedTextBox al formulario
1. Abra el formulario en el que desea colocar el control MaskedTextBox.

2. Arrastre un control MaskedTextBox desde el Cuadro de herramientas hasta el
formulario.
3. Haga clic con el botón secundario del mouse en el control y elija Propiedades. En la
ventana Propiedades, seleccione la propiedad Mask y haga clic en el botón .... (puntos
suspensivos) junto al nombre de propiedad.
4. En el cuadro de diálogo Máscara de entrada, seleccione la máscara de Fecha corta y
haga clic en Aceptar.
5. En la ventana Propiedades, establezca la propiedad BeepOnError en true. Esta
propiedad hace que suene un bip corto cada vez que el usuario intenta introducir un
carácter que infringe la definición de máscara.
Para obtener un resumen de los caracteres que la propiedad Mask admite, vea la sección
Comentarios de la propiedad Mask.
Avise al usuario de los errores de entrada

Agregue un globo de información para entradas de máscara rechazadas
1. Vuelva al Cuadro de herramientas y agregue ToolTip al formulario.

2. Cree un controlador de eventos para el evento MaskInputRejected que muestre el texto
de ToolTip cuando se produce un error de entrada. El globo de información permanece
visible durante cinco segundos o hasta que el usuario hace clic en él.
Código en C#:
public void Form1_Load(Object sender, EventArgs e)

{
... // Other initialization code
maskedTextBox1.Mask = "00/00/0000";
maskedTextBox1.MaskInputRejected += new
MaskInputRejectedEventHandler(maskedTextBox1_MaskInputRejected)
}
void maskedTextBox1_MaskInputRejected(object sender, MaskInputRejectedEventArgs e)

{
toolTip1.ToolTipTitle = "Invalid Input";
toolTip1.Show("We're sorry, but only digits (0-9) are allowed in dates.", maskedTextBox1,
maskedTextBox1.Location, 5000);
}
Avise al usuario de que tipo no es válido

Agregue un globo de información para los tipos de datos no válidos
1. En el controlador de eventos Load del formulario, asigne un objeto Type que representa
el tipo DateTime en la propiedad ValidatingType del control MaskedTextBox:
private void Form1_Load(Object sender, EventArgs e)

{
// Other code

maskedTextBox1.ValidatingType = typeof(System.DateTime);
maskedTextBox1.TypeValidationCompleted += new
TypeValidationEventHandler(maskedTextBox1_TypeValidationCompleted);
}
2. Agregue un controlador de eventos para el evento TypeValidationCompleted:
C#
public void maskedTextBox1_TypeValidationCompleted(object sender, TypeValidationEventArgs
e)
{
if (!e.IsValidInput)
{
toolTip1.ToolTipTitle = "Invalid Date Value";
toolTip1.Show("We're sorry, but the value you entered is not a valid date. Please change the
value.", maskedTextBox1, 5000);
e.Cancel = true;
}
}
17 - Creación de aplicación con una base de datos similar a la del punto
3, utilizando Entity Framework - Code First. (Autor: Mattivi Alfredo
).camstudio(vanesa celiz)
1. Paso:
Necesitará tener instalados Visual Studio
Si usa Visual Studio 2013, también debe tener NUGET instalado.
2. Para mantener la simplicidad, vamos a generar una aplicación de consola básica
que use Code First para el acceso a los datos.
3. Abra Visual Studio

4. Archivo -> Nuevo -> Proyecto
5. Seleccione Windows en el menú de la izquierda y aplicación de consola
6. Escribir el nombre
7. Seleccione Aceptar
Vamos a definir un modelo muy sencillo con clases. Solo vamos a definirlas en el archivo
Program.cs
4) Ahora es el momento de definir un contexto derivado que representa una sesión con la
base de datos, lo que nos permite consultar y guardar los datos. Definimos un contexto que
deriva de System.Data.Entity.DbContext y expone un DbSet<TEntity> con tipo para cada
clase en nuestro modelo.
Ahora vamos a comenzar a usar tipos de Entity Framework de modo que necesitamos
agregar el paquete de EntityFramework NuGet.
Proyecto –> Administrar paquetes de NuGet
Nota: si no dispone de la opción Administrar paquetes de NuGet, debe instalar la versión
más reciente de NuGet

Seleccione la pestaña En línea Seleccione el paquete EntityFramework
Haga clic en Instalar
Agregue una instrucción using para System.Data.Entity al principio de Program.cs.

using System.Data.Entity;
Implemente el método Main en Program.cs como se muestra a continuación.

using System;
using System.Linq;
using System.Text;
using System.Data.Entity;
namespace EmpresaV1
{
class Program
{
static void Main(string[] args)
{
using (var db = new BloggingContext())
{
//datos de prueba
Console.Write("Ingrese el NUEVO CLIENTE:");

Console.WriteLine();
Console.Write("Ingrese Apellido:");
var Apellidoc = Console.ReadLine();
Console.Write("Ingrese Nombre:");
var Nombrec = Console.ReadLine();
Console.Write("Ingrese Direccion:");
var Direccionc = Console.ReadLine();
Console.Write("Ingrese Nacimiento(ddmmaaaa):");
var Ddmmaaaac = Console.ReadLine();
Console.Write("Ingrese Correo Electronico:");
var Mailc = Console.ReadLine();
//datos de guardar
var cliente = new Cliente
{
Apellido=Apellidoc,
Nombre=Nombrec,
Direccion=Direccionc,
Ddmmaaaa= Convert.ToDateTime(Ddmmaaaac),
Email =Mailc
};
db.Clientes.Add(cliente);
db.SaveChanges();
var query = from b in db.Clientes
orderby b.Apellido
select b;
foreach (var item in query)
{
Console.WriteLine(item.Apellido);
}
}
}
}
Las clases
public class Detalle

{
public int DetalleId { get; set; }
public int Id_Factura { get; set; }
public int Id_Producto { get; set; }
public int Cantidad { get; set; }
public int Precio { get; set; }
public virtual Factura Factura { get; set; }

public virtual List<Producto> Productos { get; set; }
}
public class Factura
{
public int FacturaId { get; set; }
public int Id_Cliente { get; set; }
public DateTimeKind Fecha { get; set; }
public virtual Cliente Cliente { get; set; }

public virtual List<Detalle> Detalles { get; set; }
}
public class Cliente
{
public int ClienteId { get; set; }
public string Apellido { get; set; }
public string Nombre { get; set; }
public string Direccion { get; set; }
public DateTime Ddmmaaaa { get; set; }
public int Telefono { get; set; }
public string Email { get; set; }
public virtual List<Factura> Facturas { get; set; }
}
public class Producto
{
public int ProductoId { get; set; }
public int Precio { get; set; }
public int Stock { get; set; }
public int Id_Categorio { get; set; }
public int Id_Detalle { get; set; }

public virtual Detalle Detalle { get; set; }
public virtual List<Categoria> Categorias { get; set; }
}
public class Categoria
{
public int CategoriaId { get; set; }
public string Descripciones { get; set; }
public int Id_Producto { get; set; }

public virtual Producto Producto { get; set; }
}
public class BloggingContext : DbContext
{
public DbSet<Cliente> Clientes { get; set; }
public DbSet<Factura> Facturas { get; set; }
public DbSet<Detalle> Detalles { get; set; }
public DbSet<Producto> Productos { get; set; }
public DbSet<Categoria> Categorias { get; set; }
}
18 - Creación de aplicación Web utilizando la base de datos del punto 3,
con AMBC de la tabla Cliente y Producto utilizando el Framework MVC.
(Autores: ).
19 - Creación de un archivo de base de datos local, con las tablas
necesarias para un sistema de préstamo de alquileres de películas en un
videoclub. Agregar ejemplos de instrucciones sql de select/join, insert,
update y delete (Autores:Molina Reinoso Luis, Jose Cano ).
Modelo de Clases
-Procedimiento Mostrar
create proc spMostrar_Empleado
as
select * from Empleado
order by Id desc
go
-- Procedimiento Buscar Empleado Nombre

create proc spBuscar_Empleado_nombre
@textobuscar varchar(50)
as
select * from Empleado
where ApyNom like @textobuscar + '%'
go
-- Procedimiento Insertar Empleado

create proc spInsertar_Empleado
@Id int output,
@ApyNom varchar(50),
@Turno varchar(10)
as
insert into Empleado(ApyNom,Turno)
values (@ApyNom,@Turno)
go
-- Procedimiento Editar Empleado

create proc spEditar_Empleado
@Id int,
@ApyNom varchar(50),
@Turno varchar(10)
as
update Empleado set ApyNom=@ApyNom,
Turno=@Turno
where Id=@Id
go
-- Procedimiento Eliminar Empleado

create proc spEliminar_Empleado
@Id int
as
delete from Empleado
where Id=@Id
go
//ingreso
--Procedimiento Mostrar
alter proc spMostrar_Ingreso_Pelicula
as
SELECT top 100 i.Id,i.Id_Empleado,e.ApyNom as Empleado, i.Fecha, i.Estado,
sum(d.Precio_Compra * d.Stock_Inicial)as Total
from Detalle_Ingreso_Pelicula d inner join Ingreso_Pelicula i
on d.Id_Ingreso_Pelicula= i.Id
inner join Empleado e
on i.Id_Empleado= e.Id
group by
i.Id,i.Id_Empleado, e.ApyNom , i.Fecha, i.Estado
order by i.Id desc
go
-- Mostrar Ingreso por Fecha--

create proc spBuscar_Ingreso_fecha
@textobuscar varchar(20),
@textobuscar2 varchar(20)
as
SELECT i.Id,i.Id_Empleado,e.ApyNom as Empleado, i.Fecha, i.Estado,
sum(d.Precio_Compra * d.Stock_Inicial)
from Detalle_Ingreso_Pelicula d inner join Ingreso_Pelicula i
on d.Id_Ingreso_Pelicula= i.Id
inner join Empleado e
on i.Id_Empleado= e.Id
group by
i.Id,i.Id_Empleado, e.ApyNom ,
i.Fecha, i.Estado
having i.Fecha >=@textobuscar and i.Fecha <= @textobuscar2
go
--Ingresar un Ingreso--
alter proc spInsertar_Ingreso_Pelicula
@Id int= null output,
@Id_Empleado int,
@Fecha date,
@Estado varchar(7)
as
insert into Ingreso_Pelicula(Id_Empleado,Fecha,Estado)
values(@Id_Empleado,@Fecha,@Estado)
--obtener el codigo autogenerado--
set @Id = @@IDENTITY

go
--Procedimiento Anular Ingreso

create proc spAnular_Ingreso
@Id int
as
update Ingreso_Pelicula set Estado= 'ANULADO'
WHERE Id = @Id
go
--Insetar los detalles de ingresoo--
create proc spInsertar_Detalle_Ingreso

@Id int output,
@Id_Ingreso_Pelicula int,
@Id_Pelicula int,
@Stock_Inicial int,
@Stock_Actual int,
@Precio_Compra money,
@Precio_Venta money
as
insert into Detalle_Ingreso_Pelicula(Id_Ingreso_Pelicula,

Id_Pelicula, Stock_Inicial, Stock_Actual,
Precio_Compra, Precio_Venta)
values (@Id_Ingreso_Pelicula,
@Id_Pelicula, @Stock_Inicial, @Stock_Actual,
@Precio_Compra, @Precio_Venta)
go
-- Mostrar Detalle de Ingreso --
create proc spMotrar_Detalle_Ingreso

@textobusscar int
as
select d.Id,p.Nombre as Pelicula, d.Precio_Compra,
d.Precio_Venta,d.Stock_Inicial,(d.Stock_Inicial * d.Precio_Compra)as SubTotal
from Detalle_Ingreso_Pelicula d inner join Pelicula p
on d.Id_Pelicula= p.Id
where d.Id_Ingreso_Pelicula= @textobusscar
go
Programacion por Capaz

Clase conexion
Clases de la capa Datos
Codificacion Clases de la Capa Datos
using System;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace CapDatos
{
public class DGenero
{
//declaracion de Variables
private int vId;

private string vDescripcion;
private string vtextobuscar;
//Get and Set

#region Get and Set
public int VId
{
get
{
return vId;
}
set
{
vId = value;
}
}
public string VDescripcion

{
get
{
return vDescripcion;
}
set
{
vDescripcion = value;
}
}
public string Vtextobuscar

{
get
{
return vtextobuscar;
}
set
{
vtextobuscar = value;
}
}
#endregion
public DGenero()
{}
public DGenero(int Id, string Descripcion)

{
this.vId = Id;
this.vDescripcion = Descripcion;
#region Metodos
//Insertar
public string Insertar(DGenero Genero)

{
string resp = "";
SqlConnection SqlConex = new SqlConnection();
try
{
SqlConex.ConnectionString = Conexion.Conex;
SqlConex.Open();
//comando
SqlCommand SqlCmd = new SqlCommand();//inicio los comandos
SqlCmd.Connection = SqlConex; //conexion con la bases
SqlCmd.CommandText = "spInsertar_Genero";//nombre del sp
SqlCmd.CommandType = CommandType.StoredProcedure;//tipo de comando
//parametro
SqlParameter ParId = new SqlParameter();
ParId.ParameterName = "@Id";//nombre
ParId.SqlDbType = SqlDbType.Int;//tipo
ParId.Direction = ParameterDirection.Output;//variable de salida
SqlCmd.Parameters.Add(ParId);//agregar
SqlParameter ParDescripcion = new SqlParameter();

ParDescripcion.ParameterName = "@Descripcion";
ParDescripcion.SqlDbType = SqlDbType.VarChar;
ParDescripcion.Value = Genero.vDescripcion;
SqlCmd.Parameters.Add(ParDescripcion);
resp = SqlCmd.ExecuteNonQuery() == 1 ? "Ok" : "No Ingreso al Registro";

}
catch (Exception ex)
{
resp = ex.Message;
finally
{
if (SqlConex.State== ConnectionState.Open)
{
SqlConex.Close();
}
}
return resp;
}
//Editar
public string Editar (DGenero Genero)
{
string resp = "";
try
{
SqlConex.Open();
SqlCommand SqlCmd = new SqlCommand();

SqlCmd.Connection = SqlConex;
SqlCmd.CommandText = "spEditar_Genero";
SqlCmd.CommandType = CommandType.StoredProcedure;

ParId.ParameterName = "@Id";
ParId.SqlDbType = SqlDbType.Int;
ParId.Value = Genero.vId;
SqlCmd.Parameters.Add(ParId);
SqlParameter ParDescripcion = new SqlParameter();

ParDescripcion.ParameterName = "@Descripcion";
ParDescripcion.SqlDbType = SqlDbType.VarChar;
ParDescripcion.Value = Genero.vDescripcion;
SqlCmd.Parameters.Add(ParDescripcion);
resp = SqlCmd.ExecuteNonQuery() == 1 ? "Ok" : "No Actualizo el Registro";

}
{
resp = ex.Message;
finally
{
if (SqlConex.State == ConnectionState.Open)
{
SqlConex.Close();
}
}
return resp;
}
//Eliminar
public string Eliminar(DGenero Genero)
{
string resp = "";
try
{
SqlConex.Open();

SqlCmd.CommandText = "spEliminar_Genero";

ParId.ParameterName = "@Id";
ParId.SqlDbType = SqlDbType.Int;
ParId.Value = Genero.vId;
SqlCmd.Parameters.Add(ParId);
resp = SqlCmd.ExecuteNonQuery() == 1 ? "Ok" : "No se elimino el Registro";

}
{
resp = ex.Message;
}
finally
{
if (SqlConex.State == ConnectionState.Open)
{
SqlConex.Close();
}
}
return resp;
//Mostrar tablas
public DataTable Mostrar()
{
DataTable DtbResp = new DataTable("Genero");
try
{
SqlCmd.CommandText = "spMostrar_Genero";
SqlDataAdapter SqlData = new SqlDataAdapter(SqlCmd);

SqlData.Fill(DtbResp);
}
catch (Exception )
{
DtbResp = null;
}
return DtbResp;
//Busqueda Por Nombre de Genero

public DataTable BuscarNombre (DGenero Genero)
{
DataTable DtbResp = new DataTable("Genero");
try
{

SqlCmd.CommandText = "spBuscar_Genero_nombre";
SqlParameter ParText = new SqlParameter();

ParText.ParameterName = "@textobuscar";
ParText.SqlDbType = SqlDbType.VarChar;
ParText.Size =50;
ParText.Value = Genero.vtextobuscar;
SqlCmd.Parameters.Add(ParText);

}
catch (Exception)
{
DtbResp = null;
}
return DtbResp;
#endregion
Clases especial para ingresar DETALLES
using System;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace CapDatos
{
public class DDetalle_Alquiler
{
private int vId;
private int vId_Alquiler;
private int vId_Detalle_Ingreso;
private int vCantidad;
private DateTime vFecha_Alq;
private DateTime vFecha_Dev;
private decimal vPrecioVenta;
private decimal vDescuento;
#region gwt and set

public int VId
{
get
{
return vId;
}
set
{
vId = value;
}
}
public int VId_Alquiler

{
get
{
return vId_Alquiler;
}
set
{
vId_Alquiler = value;
}
}
public int VId_Detalle_Ingreso

{
get
{
return vId_Detalle_Ingreso;
}
set
{
vId_Detalle_Ingreso = value;
}
}
public int VCantidad

{
get
{
return vCantidad;
}
set
{
vCantidad = value;
}
}
public DateTime VFecha_Alq

{
get
{
return vFecha_Alq;
}
set
{
vFecha_Alq = value;
}
}
public DateTime VFecha_Dev

{
get
{
return vFecha_Dev;
}
set
{
vFecha_Dev = value;
}
}
public decimal VPrecioVenta

{
get
{
return vPrecioVenta;
}
set
{
vPrecioVenta = value;
}
}
public decimal VDescuento

{
get
{
return vDescuento;
}
set
{
vDescuento = value;
}
}
#endregion
public DDetalle_Alquiler()
{}
public DDetalle_Alquiler(int Id, int Id_Alquiler, int Id_Detalle_Alquiler,

int Cantidad, DateTime Fecha_Alq , DateTime Fecha_Dev, decimal PrecioVenta,
decimal Descuento)
{
this.VId = Id;
this.VId_Alquiler = Id_Alquiler;
this.VId_Detalle_Ingreso = Id_Detalle_Alquiler;
this.VCantidad = Cantidad;
this.VFecha_Alq = Fecha_Alq;
this.VFecha_Dev = Fecha_Dev;
this.VPrecioVenta = PrecioVenta;
this.VDescuento = Descuento;
}
//Metodo especial para insertar detalle en una Grilla
public string Insertar(DDetalle_Alquiler Detalle_Alquiler,

ref SqlConnection SqlConex, ref SqlTransaction SqlTran)

{
string resp = "";
try
{
//comando
SqlCommand SqlCmd = new SqlCommand();//inicio los comandos
SqlCmd.Connection = SqlConex; //conexion con la bases
SqlCmd.Transaction = SqlTran; //establecemo la transaccion
SqlCmd.CommandText = "spInsertar_Detalle_Alquiler";//nombre del sp
SqlCmd.CommandType = CommandType.StoredProcedure;//tipo de comando
//parametro
ParId.ParameterName = "@Id";//nombre
ParId.SqlDbType = SqlDbType.Int;//tipo
ParId.Direction = ParameterDirection.Output;//variable de salida
SqlCmd.Parameters.Add(ParId);//agregar
SqlParameter ParId_Alquiler = new SqlParameter();

ParId_Alquiler.ParameterName = "@Id_Alquiler";
ParId_Alquiler.SqlDbType = SqlDbType.Int;
ParId_Alquiler.Value = Detalle_Alquiler.VId_Alquiler;
SqlCmd.Parameters.Add(ParId_Alquiler);
SqlParameter ParDetalle_Ingreso_Pel = new SqlParameter();

ParDetalle_Ingreso_Pel.ParameterName = "@Id_Detalle_Ingreso_Pelicula";
ParDetalle_Ingreso_Pel.SqlDbType = SqlDbType.Int;
ParDetalle_Ingreso_Pel.Value = Detalle_Alquiler.VId_Detalle_Ingreso;
SqlCmd.Parameters.Add(ParDetalle_Ingreso_Pel);
SqlParameter ParCantidad = new SqlParameter();

ParCantidad.ParameterName = "@Cantidad";
ParCantidad.SqlDbType = SqlDbType.Int;
ParCantidad.Value = Detalle_Alquiler.VCantidad;
SqlCmd.Parameters.Add(ParCantidad);
SqlParameter ParFecha_Alq = new SqlParameter();

ParFecha_Alq.ParameterName = "@Fecha_Alq";
ParFecha_Alq.SqlDbType = SqlDbType.Date;
ParFecha_Alq.Value = Detalle_Alquiler.VFecha_Alq;
SqlCmd.Parameters.Add(ParFecha_Alq);
SqlParameter ParFecha_Dev = new SqlParameter();

ParFecha_Dev.ParameterName = "@Fecha_Dev";
ParFecha_Dev.SqlDbType = SqlDbType.Date;
ParFecha_Dev.Value = Detalle_Alquiler.VFecha_Dev;
SqlCmd.Parameters.Add(ParFecha_Dev);
SqlParameter ParPrecio_Venta = new SqlParameter();

ParPrecio_Venta.ParameterName = "@PrecioVenta";
ParPrecio_Venta.Precision = 4;
ParPrecio_Venta.Scale = 2;
ParPrecio_Venta.SqlDbType = SqlDbType.Money;
ParPrecio_Venta.Value = Detalle_Alquiler.VPrecioVenta;
SqlCmd.Parameters.Add(ParPrecio_Venta);
SqlParameter ParDescuento = new SqlParameter();

ParDescuento.ParameterName = "@Descuento";
ParDescuento.Precision = 4;
ParDescuento.Scale = 2;
ParDescuento.SqlDbType = SqlDbType.Money;
ParDescuento.Value = Detalle_Alquiler.VDescuento;
SqlCmd.Parameters.Add(ParDescuento);
resp = SqlCmd.ExecuteNonQuery() == 1 ? "Ok" : "No Ingreso al Registro";

}
{
resp = ex.Message;
return resp;
}
}
}
Métodos Especiales
//Metodo para buscar entre fechas

public DataTable BuscarFecha(string TextoBuscar, string TextoBuscar2)
{
DataTable DtbResp = new DataTable("Alquiler");
try
{
SqlCmd.CommandText = "spBuscar_Alquiler_Fecha";

ParText.ParameterName = "@textobuscar1";
ParText.SqlDbType = SqlDbType.VarChar;
ParText.Size = 50;
ParText.Value = TextoBuscar;
SqlParameter ParText2 = new SqlParameter();

ParText2.ParameterName = "@textobuscar2";
ParText2.SqlDbType = SqlDbType.VarChar;
ParText2.Size = 50;
ParText2.Value = TextoBuscar2;
SqlCmd.Parameters.Add(ParText2);

}
catch (Exception)
{
DtbResp = null;
}
return DtbResp;
//Metodo para mostrar detalles

public DataTable Mostrar_Detalle(string TextoBuscar)//int
{
DataTable DtbResp = new DataTable("Detalle_Alquiler");
try
{
SqlCmd.CommandText = "spMostrar_Detalles_Alquiler";

ParText.ParameterName = "@textbuscar";
ParText.SqlDbType = SqlDbType.VarChar;//int
ParText.Size = 50;////
ParText.Value = TextoBuscar;/////c

}
catch (Exception)
{
DtbResp = null;
}
return DtbResp;
Capa Negocio
Codificacion de la clase de la Capa de Negocios
using System;
using System.Linq;
using System.Text;
using CapDatos;
using System.Data;
namespace CapNegocios
{
public class NGenero
{
//LLAMAMOS A LOS METODOS QUE SE ENCUENTRAN EN LA CAPA DATOS
public static string Insertar(string Descripcion)
{
DGenero Gene = new DGenero();
Gene.VDescripcion = Descripcion;
return Gene.Insertar(Gene);
public static string Editar(int Id,string Descripcion)

{
Gene.VId = Id;
Gene.VDescripcion = Descripcion;
return Gene.Editar(Gene);
public static string Eliminar(int Id)

{
Gene.VId = Id;
return Gene.Eliminar(Gene);
public static DataTable Mostrar()

{
return new DGenero().Mostrar();
public static DataTable BuscarPorNombre(string TextBuscar)

{

Gene.Vtextobuscar = TextBuscar;
return Gene.BuscarNombre(Gene);
}
}
}
//Metodo Especial para Insertar Los Detalles

public static string Insertar(int Id_Empleado, DateTime Fecha, string Estado,
DataTable dtDetalle)//para los detalles
{
DIngreso Ing = new DIngreso();
Ing.VId_Empleado = Id_Empleado;
Ing.VFecha = Fecha;
Ing.VEstado = Estado;
//los detalles
List<DDetalle_Ingreso> Detalles = new List<DDetalle_Ingreso>();
foreach (DataRow row in dtDetalle.Rows)
{
DDetalle_Ingreso Det = new DDetalle_Ingreso();
Det.VId_Pelicula = Convert.ToInt32(row["Id_Pelicula"].ToString());
Det.VStock_Inicial =Convert.ToInt32( row["Stock_Inicial"].ToString());
Det.VStock_Actual =Convert.ToInt32( row["Stock_Inicial"].ToString());//al princcipo
siempre igual al stock incial
Det.VPrecio_Compra= Convert.ToDecimal(row["Precio_Compra"].ToString());
Det.VPrecio_Venta = Convert.ToDecimal(row["Precio_Venta"].ToString());
Detalles.Add(Det);
return Ing.Insertar(Ing, Detalles);
Capa Presentacion
ABM Simples (Diseño)

Codificación Clase Presentación
using System;
using System.Data;
using System.Linq;
using System.Text;
using CapNegocios;
using CapDatos;
using CapPresentacion;
namespace CapPresentacion
{
public partial class PPelicula : Form
{
//Declarion de variables auxiliares
private bool IsNuevo = false;
private bool IsModificar = false;
int aux = 0;
int aux2 = 0;
public PPelicula()
{
this.ttMensaje.SetToolTip(this.txtNombre, "Ingrese el Nombre de la Pelicula");
this.ttMensaje.SetToolTip(this.cmbGenero, "Seleccione el Genero");
//Para mostrar mensaje de confirmación

private void MensajeOK(string Mensaje)
{
MessageBox.Show(Mensaje, "Video Club", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
//Para mostrar mensaje de error
private void MensajeError(string Mensaje)
{
MessageBoxIcon.Error);
}
//Metodos
//Limpiar
private void Limpiar()
{
this.txtNombre.Text = string.Empty;
this.cmbGenero.SelectedIndex= 0;
}
//Habilitar TextBox and Combobox

private void Habilitar(bool valor)
{
this.txtNombre.ReadOnly = !valor;
this.cmbGenero.Enabled = !valor;
}
//Metodos para Habilitar los botones, dependiendo de su funcion.

private void Botones()
{
if (this.IsNuevo || this.IsModificar)
{
this.Habilitar(true);
this.btnNuevo.Enabled = false;
this.btnGuardar.Enabled = true;
this.btnModificar.Enabled = false;
this.btnCancelar.Enabled = true;
this.cmbGenero.Enabled = true;
this.btnGenero.Enabled = true;
}
else
{
this.Habilitar(false);
this.btnNuevo.Enabled = true;
this.btnGuardar.Enabled = false;
this.btnModificar.Enabled = true;
this.btnCancelar.Enabled = false;
this.cmbGenero.Enabled = false;
this.btnGenero.Enabled = false;
}
/// <summary>
/// Metodos Funcionales
/// </summary>
///
//Mostrar Columnas
private void Mostrar()
{
this.dgvGrilla.DataSource = NPelicula.Mostrar();
this.OcultarColumnas();
lblTotal.Text = "Total Registros: " + Convert.ToString(dgvGrilla.Rows.Count);
}
//Buscar por Nombres en grilla

private void BuscarNombre()
{
this.dgvGrilla.DataSource = NPelicula.BuscarPorNombre(this.txtBuscar.Text);

}
//Ocultar columnas y Formato de las mismas

private void OcultarColumnas()
{
this.dgvGrilla.Columns[0].Visible = false;
this.dgvGrilla.Columns[2].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
this.dgvGrilla.Columns[4].HeaderText = "Genero";
}
//Metodo para traer datos al Combobox

public void CargarCombo()

{
cmbGenero.DataSource = NGenero.Mostrar();
cmbGenero.ValueMember = "Id";
cmbGenero.DisplayMember = "Descripcion";
private void PPelicula_Load(object sender, EventArgs e)

{
this.Mostrar();
this.CargarCombo();
this.Botones();
}
private void btnBuscar_Click(object sender, EventArgs e)

{
this.BuscarNombre();
}
private void txtBuscar_TextChanged(object sender, EventArgs e)

{
this.BuscarNombre();
}
private void btnNuevo_Click(object sender, EventArgs e)

{
this.IsNuevo = true;
this.IsModificar = false;
this.Botones();
this.Limpiar();
this.cmbGenero.Text = string.Empty;
this.txtNombre.Focus();
}
//Guardar un Resgitro Nuevo

private void btnGuardar_Click(object sender, EventArgs e)
{
DPelicula NuevaPelicula = new DPelicula();//entidad nueva
try
{
string Resp = "";
if (this.txtNombre.Text == String.Empty || this.cmbGenero.Text == String.Empty)

{
MensajeError("Falta Ingresar algunos valores serán remarcados");
errorAdver.SetError(txtNombre, "Ingrese Nombre.");
errorAdver.SetError(cmbGenero, "Seleccione un genero.");
}
else
{
if (this.IsNuevo)
{
Resp = NPelicula.Insertar(this.txtNombre.Text.ToUpper().TrimStart(),
Convert.ToInt32(this.cmbGenero.SelectedValue));
}
else
{
NuevaPelicula.VId = aux;
NuevaPelicula.VId_Genero = aux2;
Resp = NPelicula.Editar(NuevaPelicula.VId,
this.txtNombre.Text.ToUpper().TrimStart(),
Convert.ToInt32(this.cmbGenero.SelectedValue));
}
if (Resp.Equals("Ok"))
{
if (this.IsNuevo)
{
this.MensajeOK("Se Cargo el registro Correctamente.");
}
else
{
this.MensajeOK("Se Modifico el registro Correctamente.");
}
}
else
{
this.MensajeError(Resp);
}
IsNuevo = false;
IsModificar = false;
Botones();
Limpiar();
Mostrar();
this.txtNombre.Text = "";
this.cmbGenero.SelectedIndex = 0;
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message + Ex.StackTrace);
}
}
private void btnModificar_Click(object sender, EventArgs e)

{
if (!this.txtNombre.Text.Equals(""))
{
this.IsModificar = true;
Botones();
}
else
{
this.MensajeError("Seleccione un registro para Modificar");
}
}
private void btnCancelar_Click(object sender, EventArgs e)

{
IsNuevo = false;
Botones();
Limpiar();
this.cmbGenero.SelectedIndex = 0;
}
private void dgvGrilla_DoubleClick(object sender, EventArgs e)

{
aux = Convert.ToInt32(this.dgvGrilla.CurrentRow.Cells["Id"].Value);
aux2 = Convert.ToInt32(this.dgvGrilla.CurrentRow.Cells["Id_Genero"].Value);
this.txtNombre.Text =
Convert.ToString(this.dgvGrilla.CurrentRow.Cells["Nombre"].Value);
this.cmbGenero.SelectedValue =
Convert.ToString(this.dgvGrilla.CurrentRow.Cells["Id_Genero"].Value);
this.tbcPrincipal.SelectedIndex = 1;
private void ckbEliminar_CheckedChanged(object sender, EventArgs e)

{
if (ckbEliminar.Checked)
{
this.dgvGrilla.Columns[0].Visible = true;
}
else
{
}
}
private void dgvGrilla_CellContentClick(object sender, DataGridViewCellEventArgs e)

{
if (e.ColumnIndex == dgvGrilla.Columns["Eliminar"].Index)//verifico si la columna esta
activada
{
DataGridViewCheckBoxCell ckbEliminar =
(DataGridViewCheckBoxCell)dgvGrilla.Rows[e.RowIndex].Cells["Eliminar"];//obtiene la
posicio
ckbEliminar.Value = !Convert.ToBoolean(ckbEliminar.Value);//si esta marcado o
no
}
}
//Eliminar Registro
private void btnEliminar_Click(object sender, EventArgs e)
{
try
{
DialogResult opcion;
opcion = MessageBox.Show("¿Desea Eliminar Registro?", "Video Club",
MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
if (opcion == DialogResult.OK)
{
string Codigo;
string Resp = "";
foreach (DataGridViewRow filas in dgvGrilla.Rows)

{
if (Convert.ToBoolean(filas.Cells[0].Value))
{
Codigo = Convert.ToString(filas.Cells[1].Value);
Resp = NPelicula.Eliminar(Convert.ToInt32(Codigo));
{
this.MensajeOK("Se Elimino el registro Correctamente.");
}
else
{
}
}
}
this.Mostrar();
}
{
MessageBox.Show(ex.Message);
}
}
private void btnGenero_Click(object sender, EventArgs e)

{
PGenero formulario = new PGenero();
formulario.ShowDialog();
CargarCombo();
}
}
}
ABM Complejo (diseño)

Vista para elegir opciones
Codificación del ABM
using System;
using System.Data;
using System.Linq;
using System.Text;
using CapNegocios;
using CapDatos;
{
public partial class PAlquiler : Form
{
//Variables
public static PAlquiler _Instancia;

private bool IsNuevo = false;

private bool IsModificar = false;
private decimal TotalPagado = 0;

private DataTable dtDetalle;
int aux = 0;
public int vId_Socio;

public int vId_detallePelicula;
//Metodo para ver si hay una instancia Generada

public static PAlquiler GetInstancia()
{
if (_Instancia == null)
{
_Instancia = new PAlquiler();
}
return _Instancia;
}
//Metodos para Traer datos de las distintas VISTAS

public void setSocio(int Id_Socio, string nombre)
{
vId_Socio = Id_Socio;
this.txtSocio.Text = nombre;
}
public void setDetallePelicula(int Id_detalle_peli, string Pelicula_nom,

int Stock, decimal Precio_Com, decimal Precio_Ven)
{
vId_detallePelicula = Id_detalle_peli;
this.txtNombre.Text = Pelicula_nom;
this.txtStockActual.Text = Convert.ToString(Stock);
this.txtPrecioCom.Text = Convert.ToString(Precio_Com);
this.txtPrecioVen.Text = Convert.ToString(Precio_Ven);
}
public PAlquiler()
{
this.txtNombre.ReadOnly = true;
this.txtSocio.ReadOnly = true;
this.txtPrecioCom.ReadOnly = true;
this.txtStockActual.ReadOnly = true;
ttMensaje.SetToolTip(txtCantidad, "Ingrese cantidad");

}
//Para mostrar mensaje de OK

private void MensajeOK(string Mensaje)
{
MessageBoxIcon.Information);
}
//Para mostrar mensaje de error
private void MensajeError(string Mensaje)
{
MessageBoxIcon.Error);
}
/// <summary>
/// Metodos Funcionales
/// </summary>
private void Limpiar()
{
this.txtSocio.Text = string.Empty;
this.cmbEmpleado.SelectedIndex = 0;
this.lblTotalPagar.Text = "0.0";
this.crearTabla();
}
private void LimpiarDetalle()

{
this.txtPrecioCom.Text = string.Empty;
this.txtPrecioVen.Text = string.Empty;
this.txtStockActual.Text = string.Empty;
this.txtCantidad.Text = string.Empty;
this.txtDescuento.Text = "0";
}
private void Habilitar(bool valor)

{
this.txtNombre.ReadOnly = !valor;
this.txtSocio.ReadOnly = !valor;
this.txtCantidad.ReadOnly = !valor;
this.txtDescuento.ReadOnly = !valor;
this.dtpFechaAlq.Enabled = valor;
this.dtpFechaVen.Enabled = valor;
this.cmbEmpleado.Enabled = valor;
this.txtStockActual.ReadOnly = !valor;
this.txtPrecioCom.ReadOnly = !valor;
this.txtPrecioVen.ReadOnly = !valor;
this.btnPelicula.Enabled = valor;
this.btnEmpleado.Enabled = valor;
this.btnSocio.Enabled = valor;
this.btnAgregar.Enabled = valor;
this.btnQuitar.Enabled = valor;
this.btnGuardar.Enabled = valor;
this.btnCancelar.Enabled = valor;
}
//BOTONES
private void Botones()
{
if (this.IsNuevo || this.IsModificar)
{
this.btnNuevo.Enabled = false;
this.btnGuardar.Enabled = true;
this.btnCancelar.Enabled = true;
this.cmbEmpleado.Enabled = true;
this.btnEmpleado.Enabled = true;
this.btnPelicula.Enabled = true;
this.btnAgregar.Enabled = true;
this.btnQuitar.Enabled = true;
this.btnSocio.Enabled = true;
this.btnSocio.Enabled = true;
}
else
{
this.btnNuevo.Enabled = true;
this.btnGuardar.Enabled = false;
this.btnCancelar.Enabled = false;
this.cmbEmpleado.Enabled = false;
this.btnEmpleado.Enabled = false;
this.btnPelicula.Enabled = false;
this.btnAgregar.Enabled = false;
this.btnQuitar.Enabled = false;
this.btnSocio.Enabled = false;
}
}

{
this.dgvGrilla.DataSource = NAlquiler.Mostrar();
}
private void BuscarFecha()

{
this.dgvGrilla.DataSource =
NAlquiler.Buscar_Fecha(this.dtpFec_Inicio.Value.ToString("dd/MM/yyyy"),
this.dtpFec_Final.Value.ToString("dd/MM/yyyy"));

}

{
private void MostrarDetalles()

{
this.dgvDetalle.DataSource = NAlquiler.Mostrar_Detalle(Convert.ToString(aux));
}
private void crearTabla()

{
//Crea la tabla con el nombre de Detalle
this.dtDetalle = new DataTable("Detalle");
//Agrega las columnas que tendra la tabla
this.dtDetalle.Columns.Add("Id_Detalle_Ingreso_Pelicula",
System.Type.GetType("System.Int32"));
this.dtDetalle.Columns.Add("Pelicula", System.Type.GetType("System.String"));
this.dtDetalle.Columns.Add("Fecha_Alq",
System.Type.GetType("System.DateTime"));
this.dtDetalle.Columns.Add("Fecha_Dev",
System.Type.GetType("System.DateTime"));
this.dtDetalle.Columns.Add("Cantidad", System.Type.GetType("System.Int32"));
this.dtDetalle.Columns.Add("PrecioVenta",
System.Type.GetType("System.Decimal"));
this.dtDetalle.Columns.Add("Descuento", System.Type.GetType("System.Decimal"));
this.dtDetalle.Columns.Add("Stock_Actual", System.Type.GetType("System.Int32"));
this.dtDetalle.Columns.Add("SubTotal", System.Type.GetType("System.Decimal"));
//Relacionamos nuestro datagridview con nuestro datatable
this.dgvDetalle.DataSource = this.dtDetalle;
//EVENTOS
private void PAlquiler_FormClosing(object sender, FormClosingEventArgs e)

{
_Instancia = null;
}
private void btnSocio_Click(object sender, EventArgs e)

{
PVistaSocio form = new PVistaSocio();
form.ShowDialog();
setSocio(form.AuxSocio_Id, form.ApyNom);
}
private void btnPelicula_Click(object sender, EventArgs e)

{
PVistaDetallePelicula form = new PVistaDetallePelicula();
form.ShowDialog();
setDetallePelicula(form.Id_detalle_Pelicula,form.Pelicula_nom,
form.Stock, form.Precio_Com,form.Precio_Ven);
}
public void CargarCombo()

{
cmbEmpleado.DataSource = NEmpleado.Mostrar();
cmbEmpleado.ValueMember = "Id";
cmbEmpleado.DisplayMember = "ApyNom";
}
private void txtCantidad_KeyPress(object sender, KeyPressEventArgs e)

{
if (char.IsNumber(e.KeyChar))
{
e.Handled = false;
}
else
{
if (char.IsControl(e.KeyChar))
{
e.Handled = false;
}
else
{
if (char.IsSeparator(e.KeyChar))
{
e.Handled = false;
}
else
{
e.Handled = true;
}
}
}
}
private void btnEmpleado_Click(object sender, EventArgs e)

{
PEmpleado formulario = new PEmpleado();
formulario.ShowDialog();
CargarCombo();
}
private void PAlquiler_Load(object sender, EventArgs e)

{
Mostrar();
Habilitar(false);
crearTabla();
CargarCombo();
}

{
this.BuscarFecha();
}
private void btnEliminar_Click(object sender, EventArgs e)

{
try
{
DialogResult Opcion;
Opcion = MessageBox.Show("Realmente Desea Elimnar los registros", "Sistema
de Ventas", MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
if (Opcion == DialogResult.OK)
{
string Codigo;
string Rpta = "";
foreach (DataGridViewRow row in dgvGrilla.Rows)

{
if (Convert.ToBoolean(row.Cells[0].Value))
{
Codigo = Convert.ToString(row.Cells[1].Value);
Rpta = NAlquiler.Eliminar(Convert.ToInt32(Codigo));
if (Rpta.Equals("OK"))
{
this.MensajeOK("Se Elimino Correctamente el registro");
}
else
{
this.MensajeError(Rpta);
}
}
}
this.Mostrar();
}
}
{
MessageBox.Show(ex.Message + ex.StackTrace);
}
}

{
aux = Convert.ToInt32(this.dgvGrilla.CurrentRow.Cells["Id"].Value);
this.dtpFecha.Value =
Convert.ToDateTime(this.dgvGrilla.CurrentRow.Cells["Fecha"].Value);
this.txtSocio.Text =
Convert.ToString(this.dgvGrilla.CurrentRow.Cells["Socio"].Value);
this.cmbEmpleado.SelectedValue =
Convert.ToString(this.dgvGrilla.CurrentRow.Cells["Id_Empleado"].Value);
this.lblTotalPagar.Text =
Convert.ToString(this.dgvGrilla.CurrentRow.Cells["Total"].Value);
MostrarDetalles();
this.tbcPrincipal.SelectedIndex = 1;
}
private void ckbEliminar_CheckedChanged(object sender, EventArgs e)

{
if (ckbEliminar.Checked)
{
this.dgvGrilla.Columns[0].Visible = true;
}
else
{
}
}
private void dgvGrilla_CellContentClick(object sender, DataGridViewCellEventArgs e)

{
if (e.ColumnIndex == dgvGrilla.Columns["Eliminar"].Index)//verifico si la columna esta
activada
{
DataGridViewCheckBoxCell ckbEliminar =
(DataGridViewCheckBoxCell)dgvGrilla.Rows[e.RowIndex].Cells["Eliminar"];//obtiene la
posicio
ckbEliminar.Value = !Convert.ToBoolean(ckbEliminar.Value);//si esta marcado o
no
}
}
private void btnNuevo_Click(object sender, EventArgs e)

{
this.IsNuevo = true;
this.Botones();
this.Limpiar();
this.LimpiarDetalle();
}
private void btnCancelar_Click(object sender, EventArgs e)

{
this.IsNuevo = false;
this.Botones();
this.Limpiar();
}
private void btnGuardar_Click(object sender, EventArgs e)

{
DAlquiler NuevoIngreso = new DAlquiler();//entidad nueva
try
{
string Resp = "";
if (this.cmbEmpleado.Text == string.Empty
|| this.txtSocio.Text== string.Empty)
{
MensajeError("Falta Ingresar algunos valores serán remarcados");
errorAdver.SetError(cmbEmpleado, "Seleccione un genero.");

errorAdver.SetError(txtSocio, "Ingrese Nombre.");
}
else
{
if (this.IsNuevo)
{
Resp =
NAlquiler.Insertar(Convert.ToInt32(this.cmbEmpleado.SelectedValue),vId_Socio,
dtpFecha.Value,
"EMITIDO", dtDetalle);
}
{
if (this.IsNuevo)
{
this.MensajeOK("Se Cargo el registro Correctamente.");
}
else
{
this.MensajeOK("Se Modifico el registro Correctamente.");
}
}
else
{
}
IsNuevo = false;
Botones();
Limpiar();
Mostrar();
this.cmbEmpleado.SelectedIndex = 0;
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message + Ex.StackTrace);
}
}
private void btnAgregar_Click(object sender, EventArgs e)

{
try
{
if (this.txtNombre.Text == string.Empty || this.txtStockActual.Text == string.Empty ||

txtCantidad.Text == string.Empty || txtPrecioVen.Text == string.Empty)
{
MensajeError("Falta ingresar algunos datos, serán remarcados");
errorAdver.SetError(txtNombre, "Seleccione un Pelicula");
errorAdver.SetError(txtStockActual, "Ingrese el stock inicial");
errorAdver.SetError(txtCantidad, "Ingrese el precio de Cantidad");
errorAdver.SetError(txtPrecioVen, "Ingrese el precio de Venta");//faltan las
fechas
}
else
{
//Variable que va a indicar si podemos registrar el detalle
bool registrar = true;

foreach (DataRow row in dtDetalle.Rows)
{
if (Convert.ToInt32(row["Id_Detalle_Ingreso_Pelicula"]) ==
vId_detallePelicula)
{
registrar = false;
this.MensajeError("Ya se encuentra el artículo en el detalle");
}
}
//Si podemos registrar el producto en el detalle
if (registrar && Convert.ToInt32(this.txtCantidad.Text) <=
Convert.ToInt32(this.txtStockActual.Text))
{
//Calculamos el sub ttotal del detalle sin descuento
decimal subTotal = Convert.ToDecimal(this.txtPrecioVen.Text) *
Convert.ToDecimal(txtCantidad.Text);
decimal desc= Convert.ToDecimal(this.txtDescuento.Text);
TotalPagado = TotalPagado + (subTotal - desc);
this.lblTotalPagar.Text = TotalPagado.ToString("#0.00#");
//Agregamos al fila a nuestro datatable
DataRow row = this.dtDetalle.NewRow();
row["Id_Detalle_Ingreso_Pelicula"] = vId_detallePelicula;
row["Pelicula"] = this.txtNombre.Text;
row["Fecha_Alq"] = this.dtpFechaAlq.Value;
row["Fecha_Dev"] = this.dtpFechaVen.Value;
row["Cantidad"] = Convert.ToInt32(this.txtCantidad.Text);
row["PrecioVenta"] = Convert.ToDecimal(this.txtPrecioVen.Text);
row["Descuento"] = Convert.ToDecimal(this.txtDescuento.Text);
row["Stock_Actual"] = Convert.ToInt32(this.txtStockActual.Text);
row["SubTotal"] = subTotal;
this.dtDetalle.Rows.Add(row);
}
else
{
MensajeError("No hay stock suficiente.");
}
}
}

{
MessageBox.Show(ex.Message + ex.StackTrace);
}
}
private void btnQuitar_Click(object sender, EventArgs e)

{
try
{
//Indice dila actualmente seleccionado y que vamos a eliminar
int indiceFila = this.dgvDetalle.CurrentCell.RowIndex;
//Fila que vamos a eliminar
DataRow row = this.dtDetalle.Rows[indiceFila];
//Disminuimos el total a pagar
this.TotalPagado = this.TotalPagado -
Convert.ToDecimal(row["SubTotal"].ToString());
this.lblTotalPagar.Text = TotalPagado.ToString("#0.00#");
//Removemos la fila
this.dtDetalle.Rows.Remove(row);
}
{
MensajeError("No hay fila para remover" + ex);
}
}
}
}
Configuración Vista
using System;
using System.Data;
using System.Linq;
using System.Text;
using CapNegocios;
{
public partial class PVistaSocio : Form
{
public int AuxSocio_Id;

public string ApyNom;
public PVistaSocio()
{
}

{
this.dgvGrilla.DataSource = NSocio.Mostrar();
}
private void BuscarNombre()

{
this.dgvGrilla.DataSource = NSocio.BuscarPorNombre(this.txtBuscar.Text);

}

{
private void PVistaSocio_Load(object sender, EventArgs e)

{
Mostrar();
OcultarColumnas();

{
BuscarNombre();
}

{
PAlquiler form = PAlquiler.GetInstancia();
AuxSocio_Id = Convert.ToInt32(this.dgvGrilla.CurrentRow.Cells["Id"].Value);
ApyNom = Convert.ToString(this.dgvGrilla.CurrentRow.Cells["ApyNom"].Value);
this.Hide();
}
}
}
Vista Principal
using System;
using System.Data;
using System.Linq;
using System.Text;
namespace VideoClub
{
public partial class formPrincipal : Form
{
public formPrincipal()
{
}
private void empleadoToolStripMenuItem_Click(object sender, EventArgs e)

{
PEmpleado form = new PEmpleado();
form.ShowDialog();
}
private void socioToolStripMenuItem_Click(object sender, EventArgs e)

{
PSocio form = new PSocio();
form.ShowDialog();
}
private void listaToolStripMenuItem_Click(object sender, EventArgs e)

{
PPelicula form = new PPelicula();
form.ShowDialog();
}
private void generoToolStripMenuItem_Click(object sender, EventArgs e)

{
PGenero form = new PGenero();
form.ShowDialog();
}
private void alquilerToolStripMenuItem_Click(object sender, EventArgs e)

{
PIngreso form = new PIngreso();
form.ShowDialog();
}
private void transaccionToolStripMenuItem_Click(object sender, EventArgs e)

{
PAlquiler form = new PAlquiler();
form.ShowDialog();
}
}
}
Clase Program
using System;
using System.Linq;
namespace VideoClub
{
static class Program
{
/// <summary>
/// Punto de entrada principal para la aplicación.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new formPrincipal());
}
}
}
necesarias para un sistema de préstamo de libros en una biblioteca.
Agregar ejemplos de instrucciones sql de select/join, insert, update y
delete (Autores: Facundo Javier Gelatti, Gustavo Gabriel Mera)
(Camstudio: Reyes Jorge- Gomez Emmanuel).
Modelo Relacional

Para crear una nueva base de datos en nuestro Proyecto
Posicionar el cursor en el proyecto, hacer click derecho, Agregar y luego Nuevo elemento
Se abrirá un cuadro de diálogo para agregar nuevos elementos al proyecto. Realizar los
siguientes pasos
1) Seleccionar desde el menú elementos, ubicado a la izquierda, “Datos”.
2) Seleccionar “Base de datos basada en servicio” en la lista de plantillas disponibles.
3) Elegir el nombre deseado para la tabla
4) Hacer click en el Botón aceptar
Luego de crear la base de datos, se procede a crear las tablas que tendrá la misma. Para
ello posicionarse en la base de datos que agregamos al proyecto. Ubicado en el explorador
de soluciones. Hacer click derecho y luego click en abrir
Nos aparecerá el Explorador de Servidores en la parte superior izquierda.
.
Para agregar una nueva tabla posicionarse en “Tablas” hacer click derecho y presionar
Agregar nueva tabla
Se abrirá el diseñador de tablas. Donde

A. Es el diseñador de las tablas
B. El código sql autogenerado
Para cambiar el nombre a la tabla es necesario realizar una modificación en la sentencia sql
Para crear las columnas de la tabla, se debe ingresar en (1) los nombres de las columnas,
en (2) el tipo de dato y en (3) si la columna permitir valores NULL o vacio.
Para hacer autoincremental una columna, es necesario dirigirse a la ventana propiedades y

en su propiedad Especificación de identidad poner el valor TRUE
Para agregar una clave foránea hacer click derecho en Claves externas que se ubica en el
panel contexto y seleccione agregar nueva clave externa.
Luego hacer clic en el panel de scripts y reemplazar la definición predeterminada de la

referencia de clave externa con los datos correspondientes.
Para ejecutar el código SQL en el explorador de servidores, hacer click derecho en la

carpeta tablas y presionar Nueva consulta
Pegar las sentencias SQL y presionar el botón Ejecutar
SQL
CREATE TABLE [dbo].[Socios]
(
[Id] INT NOT NULL PRIMARY KEY IDENTITY,
[Nombre] VARCHAR(MAX) NOT NULL,
[Apellido] VARCHAR(MAX) NOT NULL,
[Dni] VARCHAR(8) NOT NULL,
[Domicilio] VARCHAR(MAX) NOT NULL,
[FechaNacimiento] DATE NOT NULL
)

CREATE TABLE [dbo].[Libros]
(
[Isbn] VARCHAR(13) NOT NULL,
[Titulo] VARCHAR(MAX) NOT NULL
)

CREATE TABLE [dbo].[Autores]
(
[Nombre] VARCHAR(MAX) NOT NULL,
[Apellido] VARCHAR(MAX) NOT NULL
)

CREATE TABLE [dbo].[Autores_Libros]
(
[Id_Autor] INT NOT NULL,
[Id_Libro] INT NOT NULL,
PRIMARY KEY ([Id_Libro], [Id_Autor]),
CONSTRAINT [FK_Autor] FOREIGN KEY ([Id_Autor]) REFERENCES
[Autores]([Id]),
CONSTRAINT [FK_Libro] FOREIGN KEY ([Id_Libro]) REFERENCES
[Libros]([Id])
)

CREATE TABLE [dbo].[Ejemplares]
(
[Codigo] INT NOT NULL PRIMARY KEY,
[Id_Libro] INT NOT NULL,
CONSTRAINT [FK_Ejemplares_Libros] FOREIGN KEY ([Id_Libro])
REFERENCES [Libros]([Id])
)

CREATE TABLE [dbo].[Prestamos]
(
[Fecha] DATETIME NOT NULL,
[Id_Socio] INT NOT NULL,
[Codigo_Ejemplar] INT NOT NULL,
[Devuelto] BIT NOT NULL,
CONSTRAINT [FK_Prestamos_Socios] FOREIGN KEY ([Id_Socio])
REFERENCES [Socios]([Id]),
CONSTRAINT [FK_Prestamos_Ejemplares] FOREIGN KEY
([Codigo_Ejemplar]) REFERENCES [Ejemplares]([Codigo])
)

INSERT INTO [dbo].[Autores] ([Nombre], [Apellido]) VALUES ('Robert
C', 'Martin')
INSERT INTO [dbo].[Autores] ([Nombre], [Apellido]) VALUES ('Martin',
'Fowler')
INSERT INTO [dbo].[Autores] ([Nombre], [Apellido]) VALUES ('Kent',
'Beck')
INSERT INTO [dbo].[Autores] ([Nombre], [Apellido]) VALUES ('Craig',
'Larman')

INSERT INTO [dbo].[Libros] ([Isbn], [Titulo]) VALUES
('9780132350884', 'Clean Code')
('0076092046981', 'The Clean Coder')
('9780201485677', 'Refactoring')
('9788420534381', 'UML y Patrones')

INSERT INTO [dbo].[Socios] ([Nombre], [Apellido], [Dni],
[Domicilio], [FechaNacimiento]) VALUES ('Facundo Javier', 'Gelatti',
'37935919', 'Congreso 853', '1994-05-23')

INSERT INTO [dbo].[Autores_Libros] ([Id_Autor], [Id_Libro]) VALUES
(1, 1)
(1, 2)
(2, 3)
(3, 3)
(4, 4)

INSERT INTO [dbo].[Ejemplares] ([Codigo], [Id_Libro]) VALUES (1, 4)

INSERT INTO [dbo].[Prestamos] ([Fecha], [Id_Socio],
[Codigo_Ejemplar], [Devuelto]) VALUES (1, '2015-08-29 22:45:00', 1,
1, 0)

Listado de préstamos
SELECT
CAST(p.Fecha AS date) AS 'Fecha',
s.Dni AS 'DNI',
s.Nombre + ' ' + s.Apellido AS 'Socio',
e.Codigo AS 'Código',
l.Titulo AS 'Libro',
CASE WHEN p.Devuelto = 1
THEN
'Devuelto'
ELSE
'Pendiente'
END
AS 'Estado'

FROM Prestamos p
JOIN Socios s
ON p.Id_Socio = s.Id
JOIN Ejemplares e
ON p.Codigo_Ejemplar = e.Codigo
JOIN Libros l
ON e.Id_Libro = l.Id

ORDER BY p.Fecha;
Listado de ejemplares con estado
SELECT
e.Codigo,
l.Titulo,
CASE WHEN EXISTS (SELECT p.Devuelto FROM Prestamos p WHERE
p.Codigo_Ejemplar = e.Codigo AND p.Devuelto = 0)
THEN
'Pendiente'
ELSE
'Devuelto'
END
AS 'Estado'
FROM Ejemplares e
JOIN Libros l
ON e.Id_Libro = l.Id
ORDER BY Estado DESC;
Listado de socios con estado
SELECT
s.*,
CASE WHEN EXISTS (SELECT p.Devuelto FROM Prestamos p WHERE
p.Id_Socio = s.Id AND p.Devuelto = 0)
THEN
'SI'
ELSE
'NO'
END
AS 'Debe algún libro?'
FROM Socios s;

Listado de libros con cantidad de ejemplares
SELECT l.Isbn, l.Titulo, COUNT(e.Codigo) AS 'Cantidad de Ejemplares'
FROM Libros l
LEFT JOIN Ejemplares e
ON l.Id = e.Id_Libro
GROUP BY l.Id, l.Isbn, l.Titulo
ORDER BY [Cantidad de Ejemplares] DESC;
necesarias para un sistema de un restaurante. Agregar ejemplos de
instrucciones sql de select/join, insert, update y delete (Autores: Grosse
Iván, Cerutti De la Cruz Jorge Facundo).
Imágen 1: Para crear un nuevo proyecto seleccionamos en la Barra de Herramientas la

opción Nuevo > Nuevo Proyecto. Esto despliega una nueva ventana en donde
seleccionamos Windows Form Application.
Imágen 2: Para adicionar una base de datos al proyecto, hacemos click derecho en el
proyecto que se encuentra en el Explorador de Soluciones, en el desplegable
seleccionamos Agregar > Nuevo Item.
Imagen 3: Esta opción despliega una nueva ventana donde seleccionamos Base de Datos
basada en Servicio.
Imagen 4: Para agregar una nueva tabla, en Tablas de las nueva base de datos creada
hacemos click derecho y seleccionamos Agregar Nueva Tabla.
Imagen 5: Se deben agregar los atributos correspondientes a la tabla, con su respectivo

formato (indicando además si estos pueden aceptar valores nulos).
Imagen 6: Una vez creadas las tablas, debemos crear la tabla para normalizar la relación n
a m y en ella colocar los atributos que representaran las foreign keys de las tablas
relacionadas.
Imagen 7: Se deben agregar las claves foráneas (una por cada tabla relacionada).
Imagen 8: Modificamos el script generado indicando el atributo creado en la imagen 6 e

indicando la tabla relacionada junto con su Primary Key.
Imagen 9: Hacemos click derecho a la solución y añadimos un nuevo item.

Imagen 10: Añadimos un ADO.NET EDM

Imagen 11: Seleccionamos la primera opción
Imagen 12: Damos click a siguiente

Imagen 13: Seleccionamos tables y damos click a finalizar.

Imagen 14: EDM generado por visual studio

Imagen 15: realizamos los “inserts” necesarios.
Imagen 16: realizamos 2 selects, 2 updates y 1 delete.
Imagen 16.1: resultado primer select.

Imagen 16.2: resultado del segundo select (despues de los updates).
Imagen 16.3: resultado después del delete.
necesarias para un sistema de pago de matrículas y cuotas de colegio.
Agregar ejemplos de instrucciones sql de select/join, insert, update y
delete (Autores:).
necesarias para un sistema de Hotelería que contemple la reserva de
habitaciones. Agregar ejemplos de instrucciones sql de select/join,
insert, update y delete (Autores: Cerutti De la Cruz Jorge Facundo,
Gerez Edgardo Martin).
Imágen 1: Para crear un nuevo proyecto seleccionamos en la Barra de Herramientas la

opción Nuevo > Nuevo Proyecto. Esto despliega una nueva ventana en donde
seleccionamos Windows Form Application.
Imágen 2: Para adicionar una base de datos al proyecto, hacemos click derecho en el
proyecto que se encuentra en el Explorador de Soluciones, en el desplegable
seleccionamos Agregar > Nuevo Item.
Imagen 3: Esta opción despliega una nueva ventana donde seleccionamos Base de Datos
basada en Servicio.
Imagen 4: Creamos el modelo relacional del problema con MySQL Workbench.

Imagen 5: Para agregar una nueva tabla, en Tablas de las nueva base de datos creada
hacemos click derecho y seleccionamos Agregar Nueva Tabla.
Imagen 6: Agregamos atributos a la tabla Cliente.
Imagen 7: Agregamos atributos a la tabla Empleado.

Imagen 8: Agregamos atributos a la tabla Pago.
Imagen 9: Agregamos atributos a la tabla Habitacion.
Imagen 10: Agregamos atributos a la tabla Reserva.
Imagen 11: Agregamos atributos a la tabla Servicio.

Imagen 12: Agregamos atributos a la tabla Pasajero.
Imagen 13: Poblamos las tablas a través de INSERT.
Imagen 14: Poblamos las tablas a través de INSERT.

SELECT * FROM Reserva;
UPDATE Reserva SET Reserva.fecha = '2016-2-17' WHERE Reserva.idReserva = 1;

DELETE FROM Reserva WHERE Reserva.idReserva = 1;

24 - Creación de una aplicación Windows con reportes (RDLC), utilizando

la base de datos de ejemplo del punto 3(Autores:Amenta Augusto
Luciano, Peralta Facundo) (TP2: Facundo Javier Gelatti, Gustavo Gabriel
Mera).
Primero creamos un proyecto llamado “Ejer24Reportes”.
Dentro del proyecto creado usaremos la Base de Datos realizada en clases (punto 3 del
TP1)
A nuestro Form1 creado junto con el proyecto le agregaremos un DateTimePicker (lo

llamaremos dtpFecha) y un Button (lo llamaremos btnGenerar) que nos servirán para
seleccionar una fecha y luego mostrar el reporte de la venta realizada en la fecha elegida y
a que cliente fue realizada esa venta
Luego haremos click derecho sobre nuestro proyecto, iremos a la opción “agregar” y
después a la opción “nuevo elemento” y elegiremos crear un Windows Forms que lo
llamaremos “MostrarReporte”
En nuestro diseño windows Forms “MostrarReporte” le agregaremos del cuadro de

herramienta una llama “ReportViewer” y la arrastraremos a nuestro diseño, luego de eso
daremos click sobre “acoplar en contenedor primario” para que el ReportViewer tome la
forma de la ventana ya sea cualquiera el tamaño de la misma.
En nuestra base de datos “DBFacturacion” vamos a crear un procedimiento almacenado

que lo llamaremos “Cliente_Factura” que hará la relación de las tablas cliente y la tabla
factura para nuestro reporte, pero para realizar este procedimiento necesitamos un valor
antes, que será nuestra fecha que la tomara del DateTimePicker que usamos en la ventana
Form1
Después de escribir el código, le damos al botón actualizar y en la siguiente pestaña que se

abre le damos a “actualizar base de datos”.
Haremos click derecho sobre nuestro proyecto y agregaremos otro elemento más, este
elemento lo conseguiremos de “elementos de Visual C#”, “Datos” se llama Conjunto de
datos y le pondremos de nombre “DataSetFacuras”.
En la pestaña DataSetFacturas lo que haremos sera de nuestra Base de Datos

“DBFacturacion” en la carpeta procedimientos almacenados arrastraremos el procedimiento
creado anteriormente hacia la pestaña DataSetFacturas.xsd y nos tendría que quedar como
en la imagen de abajo:
Ahora vamos a crear otro nuevo elemento que será de tipo “Informe” y lo llamaremos
“InformeFacturas” (Archivo .rdlc).
En la pestaña InformeFacturas.rdlc daremos click derecho, luego “insertar” y despues

“tabla”
Aquí seleccionaremos el origen de datos que tendrá nuestra Tabla, y elegiremos nuestro
DataSet creado anteriormente.
Después pasaremos a Diseñar Nuestro InformeFacturas

En nuestro diseño de MostrarReporte.cs , en las opciones de nuestro reporteviewer nos

vamos elegir informe y seleccionamos el creado recientemente (“InformeFacturas.rdlc”).
Después de esto presionamos f7 para irnos a la parte del codigo.
En la pestaña código hay que agregarle el parámetro que va a recibir nuestro reporte, que
será el public DateTime Fecha y cómo sería una propiedad llevaría su get y su set.
También modificamos la linea de codigo donde recibe al Dataset creado, ya que también
recibiría una Fecha, por lo que hay q agregarle
ahora solo nos queda generar el evento para el botón “Generar Reporte” de nuestro Form1
Al ejecutar la aplicación y seleccionar una fecha podemos ver como quedaría nuestro
Reporte
25 - Creación de una aplicación Web Form con reportes (RDLC),
utilizando la base de datos de ejemplo del punto 3(Autores: ).
26 - Instalación de Sql Server 2014 Enterprise/Developer, creación de

una base de datos y conexión desde una aplicación Windows/Web
(Autores: Reyes Jorge - Emanuel Gomez ).
1. Al
momento de instalar asegurarse de tener suficiente espacio en disco. Seleccionamos
Nueva instalación para que el asistente nos guíe.
2. Seleccionamos la opción de evaluación la cual nos durará 180 dias. Luego nos pedirá la
activación.
3. Aceptar términos de licencia y presionar siguiente.
4. El programa verificará los requisitos para la instalación y continuamos.
5. Seleccionamos para instalar las características de SQL Server o bien seleccionar Todas
las características con valores predeterminados.
6. Seleccionamos todas las características y si queremos cambiamos la ruta en donde se

instalaran .
7. Dejamos como está si es que queremos utilizar el nombre de ruta de acceso

predeterminado.
8. Vemos los distintos servicios y la posibilidad de configurarlos , por ahora dejamos

predeterminado y seguimos.
9. Luego nos pide el modo de autenticación en este caso agregamos el usuario administrador
actual , pero si queremos podemos agregar a varios.
10. L
o mismo con los servicios.
11. S
eleccionamos instalar y configurar.
12. S
imilar al paso 9 y 10.
13. S
iguiente.
14. N
os muestra lo que se va a instalar y presionamos para hacerlo.
Conexión desde una Aplicación de Visual Estudio

1. Creamos el proyecto.
2. Creamos una base de datos nueva en SQL Server 2014.
3. Para conectar es necesario configurar el siguiente archivo de nuestro proyecto. (Crear la
cadena de conexión).
4. Para esto nos vamos a propiedades – Configuracion y definimos el nombre (Conexion), El

tipo (cadena de conexion), y la cadena propiamente dicha :
5. En App.config nos muestra la cadena de conexión creada:

6. Definimos el servidor, el modo de autenticación y El nombre de la BD a la cual quiero

conectarme. Luego podemos comprobar la conexión mediante una prueba. Si es exitosa
nos mostrará un mensaje.
Aceptamos y continuamos
7. Agregar el dataviewgrid
8. Establecer el origen de datos BD-->origendeDatos-->conexion definida

anteriormente.
9. Establecer que tabla se verá.

Instalacion de Visual Studio 2015
1- Ingresar a la pagina de www.microsoft.com/visualstudio/11/es/-en para descargar el

visual studio
2- Se instala visual studio community
3-una vez descargado se presiona “aceptar”
4-Por ultimo esperamos hasta que se descargue
5- Console:
Para crear una aplicación de Windows: Vamos a “Archivo”,“Nuevo” “Proyecto…”:
6- En “Plantillas” elegimos “Visual C#”, ”Windows” y luego “Aplicación de Consola”
7- En la pestaña de Program.cs vamos a escribir el siguiente código:
8- Luego ponemos en iniciar y se ejecuta el programa de Hola mundo en Terminal de

Windows.
Para realizar la aplicación de Windows form se realiza de la siguiente manera
1-Se ingresa en archivo ->nuevo->se selecciona Windows Form Application
3- Luego se ingresa y se procede a realizar en pantalla la Forma de la visual atraves

de la barra de menú donde se selecciona Button y label se arrastra hasta la pantalla
y luego se le cambia el nombre para luego realizar la codificación a la instancia del
botón el cual es
4- Se presiona ejecutar y queda de la siguiente manera
1-Se realiza la pagina web de la siguiente manera
2- Se ingresa a la pantalla principlan web el cual se selecciona Split para tener la visión del
código y la imagen de la pagina web en donde vamos agregar elementos de la siguiente
manera
4- Ahora se realiza la función para el botón y la conexión con la pag web se toma
automáticamente
Instalacion de Visual Studio
1-Ingresar a la pagina www.microsoft.com/visualstudio11/es/-en para descargar el visual

studio
2-Se instala el visual Studio de la siguiente manera:
3- una vez descarga se presiona acepta y se espera hasta que se termine de descargar
4-Hola mundo por consola:

5- En “plantilla” seleccionamos c· windows y luego por consola
6- En el programa de c escibrimos el siguiente codigo:

7- Luego presionamos ejecutar
Para realizar la siguiente Aplicacion Window Form se realiza de la siguiente manera:

1- Se ingresa de la siguiente manera
2- Se ingresa en la pantalla label button para realizar la interfaz para luego que queda de la
siguiente manera
3- se presiona en el boton aceptar y se genera el siguiente codigo

4- Luego se ejecuta y queda de la siguiente manera
Se realizar ahora pagina de la siguiente manera:

1- Se realiza la conexion con la pagina de la siguiente manera:
2- Se ingresa a la pantalla principal y se selecciona split para que la pantalla se divida y se

puede mostrar la codificación con el formato de la página
3- Ahora se genera las funcion del boton y es el siguiente codigo


Programación de Aplicaciones Distribuidas Con Visual Studio 2015 (Práctico 1)

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programación de Aplicaciones Distribuidas Con Visual Studio 2015 (Práctico 1)

Încărcat de

Drepturi de autor:

Formate disponibile

Programacion de Apliciones Distribuidas

Programación de Aplicaciones Distribuidas

1 - Instalación y prueba de Visual Studio 2015, incluyendo Hola Mundo

Una vez descargado el archivo lo ejecutamos y le damos a ‘INSTALL’.

Por último esperamos que termine la instalación.

En “Plantillas” elegimos “Visual C#”, ”Windows” y luego “Aplicación de Consola”

En la pestaña de Program.cs vamos a escribir el siguiente código:

Luego ponemos en iniciar y se ejecuta el programa de Hola mundo en Terminal de

Para crear una

En “Plantillas” elegimos “Visual C#”, ”Windows” y luego “Aplicación de Windows Forms”

En la pestaña Form1.cs [Diseño], en la caja de herramientas elegimos e insertamos una

Cambiamos el nombre al Label, TextBox y al

Dejándolo de la siguiente manera, después

En la pestaña de Form1.cs vamos a escribir el siguiente código:

Luego ponemos en iniciar y se ejecuta el programa de Hola mundo para aplicaciones de

opción de “Sitio web

Después nos vamos a

2 - Creación de una aplicación Windows con múltiples

De esta forma creamos el formulario VentanaClientes, el VentanaProductos, y el Login que

Ya teniendo nuestras ventanas, Se crea la clase Ventanas

Colocamos el código para el botón Aceptar de la ventana Login

private​ ​void​ button1_Click( ​object​ sender, ​EventArgs ​ e)

Código para el botón Ventana de Clientes

Código para el botón Ventana de productos

Código para la opción Clientes del Menú

Codigo para la opción Productos del Menu

CREATE TABLE cliente(

insert into cliente(nombre) values ('pucho');

CREATE TABLE factura (

INSERT INTO factura (fecha, id_cliente) VALUES ('2015-08-27', 1);

CREATE TABLE categoria (

INSERT INTO categoria(nombre) VALUES('Tablets');

CREATE TABlE producto(

INSERT INTO producto(nombre, precio, id_categoria)

CREATE TABLE [dbo].[Detalle] (

[num_detalle] INT NOT NULL IDENTITY,

INSERT INTO Detalle(id_factura, id_producto, cantidad, precio)

Elegimos “Base de datos” como el origen de datos y presionamos Siguiente:

Aquí agregaremos el archivo .mdf de la

Elegimos las tablas de la base de datos, que luego utilizaremos en la aplicación.

SqlConnection con = ​new ​SqlConnection​(​"Data Source =

Para esto, debemos asignarle un

Al seleccionar un elemento de esta tabla

static​ ​Principal​ principal = ​new​ ​Principal​();

El método ​guardarCliente​ es el que realizará el botón ​Guardar​ de la ventana ​Nuevo Cliente​:

​ tatic​ ​void​ guardarCliente()

string fecha = ​"" + nc.Tb8.Text + ​"-" + nc.Tb7.Text + ​"-" +

​ tatic​ ​void​ editarCliente()

public ​static ​void actualizarCliente(​string id, ​string nombre, ​string

Finalmente, con el botón ​Eliminar en la ventana ​Listar Clientes​, eliminaremos un cliente de

​ tatic​ ​void​ eliminarCliente(​string​ id)

result = ​MessageBox​.Show(message, caption, buttons);

if​ (result == System.Windows.Forms.​DialogResult​.Yes)

Lo que genera un form con este contenido.

Lo primero que haremos es colocar la tabla con el contenido de productos

Abrimos el “server explore” y buscamos la tabla de productos y la arrastramos hasta la form.

A Partir de aquí trabajaremos con el ABMC.

Se guardará el nuevo producto y regresará a la form Default.aspx que es nuestra página

Una vez ingresado los nuevos datos re direcciona a la página Defalut.aspx.

1. ​Crear nuevo proyecto, del tipo windows forms.

3. ​Crear conexión con la Base de Datos desde “Explorador de Servidores”.

- Tildamos el proyecto que queremos referenciar

- Con esto habremos asociado el proyecto CAD con el proyecto “PUNTO8”.

private void button1_Click( object sender, EventArgs e)

SqlConnection con = new SqlConnection("Data Source =

static Principal principal = new Principal();

El método guardarCliente es el que realizará el botón Guardar de la ventana Nuevo Cliente:

tatic void guardarCliente()

string fecha = "" + nc.Tb8.Text + "-" + nc.Tb7.Text + "-" +

tatic void editarCliente()

public static void actualizarCliente(string id, string nombre, string

Finalmente, con el botón Eliminar en la ventana Listar Clientes, eliminaremos un cliente de

tatic void eliminarCliente(string id)

result = MessageBox.Show(message, caption, buttons);

if (result == System.Windows.Forms.DialogResult.Yes)

1. Crear nuevo proyecto, del tipo windows forms.

3. Crear conexión con la Base de Datos desde “Explorador de Servidores”.

2. Para ver la definición de este método, accedemos a “CADCliente.cs”.

2. Para ver la definición de este método, accedemos a “CADCliente.cs”.

2. La definicion del metodo es la siguiente:

ombre del procedimiento

@param corresponde a los parámetros que ingresan al procedimiento, que son

Un web service es un conjunto de protocolos y estándares que sirven para intercambiar

· Datos de un cliente en particular

· Datos de un producto particular