Guia 9

UNIVERSIDAD DON BOSCO
FACULTAD DE ESTUDIOS TECNOLÓGICOS

COORDINACION DE COMPUTACIÓN
GUIA DE LABORATORIO #9
Nombre de la Práctica: Conectando a Fuentes de Datos – Parte II
CICLO 02 Lugar de Ejecución: Centro de cómputo
Tiempo Estimado: 2 horas con 30 minutos
MATERIA: Desarrollo de aplicaciones con Software Propietario
I. OBJETIVOS
Que los estudiantes:

1. Conozcan los objetos y clases necesarias para trabajar con bases de datos en entornos desconectados.
2. Aplicar y comprender los pasos lógicos de creación de copias de bases de datos en caché de servidor
3. Comprender e implementar la forma de actualización de una copia de base de datos con relación a la
base de datos original
4. Crear buenas prácticas relacionadas a la gestión de la información en una página web de ASP.NET
II. INTRODUCCIÓN TEÓRICA
Entorno desconectado de ADO.NET

El segundo escenario de acceso a bases de datos relacionales se conoce como “Escenario Desconectado”, ya
que en él una parte de los datos del servidor central se copia localmente y puede luego ser consultada y
actualizada sin contar con una conexión abierta.
Luego si se desea puede establecerse una conexión con el servidor de base de datos para sincronizar los
cambios efectuados sobre la copia local y actualizar los datos. Este tipo de funcionalidad es particularmente
útil para escenarios de usuarios móviles, que salen de su oficina con una laptop, un SmartPhone o una
PocketPC y desean poder continuar trabajando por más que no tengan conectividad física con el servidor de
base de datos ubicado en la red interna de la empresa.
Algunas ventajas que provee un escenario de acceso a datos desconectado son:

 La posibilidad de trabajar sobre los datos independientemente del resto de los usuarios de la
aplicación.
 Mayor escalabilidad en el acceso a datos y utilización más óptima de recursos del servidor, ya que se
mantiene en un mínimo indispensable la cantidad y duración de conexiones abiertas.
 Mayor performance, al trabajar con una copia local de los datos.
Desarrollo de Aplicaciones con Software Propietario 1 / 25

Guía #9: Conectando a Fuentes de Datos – Parte II
Algunas Desventajas:
 Puede ocurrir que en un momento dado un usuario no esté accediendo a los datos más actualizados
del repositorio central
 Al momento de sincronizar los cambios efectuados localmente contra el repositorio central pueden
surgir conflictos, los cuales deben ser resueltos manualmente.
Clase DataSet
El DataSet de ADO.NET es el componente central de la arquitectura sin conexión de ADO.NET. El DataSet
está expresamente diseñado para el acceso a datos independientemente del origen de datos.
Como resultado, se puede utilizar con múltiples y distintos orígenes de datos, con datos XML o para
administrar datos locales de la aplicación. El DataSet contiene una colección de uno o más objetos DataTable
formados por filas y columnas de datos, así como información sobre claves principales, claves externas,
restricciones y relaciones relativas a los datos incluidos en los objetos DataTable.
 Objeto estrella en ADO.NET

 Representa una caché de datos en memoria
 Contiene DataTables
 Lee y escribe datos y esquemas en XML
 Puede ser tipado o no tipado.
o Ambos heredan de la clase DataSet
 El tipado se apoya en un esquema XML (.XSD) para generar la clase
 El tipado tiene ventajas:
o Expone estructura como propiedades y métodos: Intellisense
o Recoge la Primary key
Desarrollo de Aplicaciones con Software Propietario 2

Clase SQLAdapter
• Representa un conjunto de
Commands y una Connection
• Puente entre el DataSet y la BD
• Lee y actualiza la BD:
 SelectCommand
 UpdateCommand
 InsertCommand
 DeleteCommand
Clase DataTable
 Representa una tabla en memoria
 Lo rellena un DataAdapter o a mano
 Componente principal de los objetos DataSet y DataView
Clase DataView
 Vista personalizada de un objeto DataTable
 Filtros, ordenación, búsquedas
DataRelation
 Define relaciones entre tablas
 Utiliza columnas de un DataTable

III. MATERIALES Y EQUIPO
Para la realización de la guía de práctica se requerirá lo siguiente:

No. Requerimiento Cantidad
1 Guía de práctica #9: Conectando a Fuentes de Datos – Parte II 1
2 Computadora con Visual Studio 2012 instalado y una instancia de SQL 1
Server con Management Studio Express
3 Memoria USB o disco flexible 1
IV. PROCEDIMIENTO
Ejercicio #1 – Creación de base de datos usando SQL Server 2012 para que funcione como fuente de datos.
1. Proceda a iniciar la herramienta Microsoft SQL Server Management Studio instalada en su computadora.
2. Una vez cargada, desde el Explorador de objetos, de clic secundario sobre la carpeta Databases del
servidor SQL y cree la base de datos EmpresaPlazaLibre.
Luego, ejecute el script (SQLcreacionBDD_EmpresaPlazaLibre.sql) que se le proporciona en los
recursos de esta guía.
Cuando ya haya ejecutado todas las querys, elabore un diagrama de las tablas de la BDD y verifique
las relaciones entre las tablas, las cuales deben verse como se muestra a continuación:
3. Inicie Microsoft Visual Studio desde su computadora.

Cree un proyecto, del tipo Aplicación Web ASP, con el nombre SitioWeb9_CARNET (debe
reemplazar CARNET por su respectivo carnet).
De las plantillas de ASP.net disponibles, elija Vacio y en la sección de agregar carpetas y referencias…,
marque MVC.

Ejercicio #2 – Creación de conexión desde Visual Studio con el origen de datos a través del asistente.
4. Ahora creara una conexión de tal forma que esta se encuentre activa desde nuestra ventana. De esta
manera se podrá administrar los objetos de bases de datos desde el IDE.
5. Seleccione al menú “Ver” e inicie al “Explorador de Servidores”. Podrá observar que se carga la
ventana Explorador de servidores, la cual lista los diferentes servidores asociados a la aplicación.
El icono que nos interesa por el momento es el
que indica Conexiones de datos. Desde este punto,
agregara una nueva conexión.
Haga clic secundario sobre icono “Conexiones
de datos”. Luego, del menú emergente,
seleccione la opción “Agregar conexión”.
6. Se mostrará una ventana con un asistente, donde se solicita especificar los parámetros de conexión a
nuestro servidor. Estos parámetros son los que se explican en la introducción teórica de esta guía de
laboratorio.
Proceda a llenar el formulario presentado de la siguiente forma: del campo “Nombre del servidor”,
seleccione el servidor asociado a su instancia de SQL Server instalada en su computadora. Para
“conexión con el servidor”, debe usar conexión con autenticación de Windows. Posteriormente
seleccione la base de datos que usted creo en el inicio de este procedimiento.
La configuración anterior debe quedar como muestra la siguiente imagen. Finalmente, de clic en el
botón de probar conexión el cual nos indicara si se ha podido establecer la conexión. Si esta ha sido
satisfactoria, de clic en Aceptar.

7. Una vez creada la conexión, definirá la cadena de conexión en nuestro archivo web.config, ya que de
esta manera se podrá mantener una sola cadena de conexión en todo el sitio. Para ello, de clic
secundario sobre la conexión antes establecida y del menú emergente, dar clic en “Propiedades”. Una
vez se carguen las propiedades de la conexión en la ventana de propiedades, copia valor de la
propiedad “Cadena de conexión”. Debe conservar los datos en memoria. Verifique la siguiente
imagen.
8. Edite el archivo web.config de su sitio web, para agregar la sección <connectionsStrings> y su

contenido justo antes de la sección <runtime> (vea líneas de código en imagen del paso anterior).
En la etiqueta “connectionString” debe colocar el valor de la cadena de conexión copiada en el paso
anterior. Para una mejor referencia consulte los pasos de la guía número 8.
9. Al finalizar, la sección connectionStrings debe quedar un código similar al que se muestra a
continuación:
<connectionStrings>
<add name="conexion"
connectionString="Data Source=Local;Initial Catalog= EmpresaPlazaLibre;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
Lo que se acaba de realizar es la adición de las cadenas de conexión en el web.config de tal manera que se
encuentre disponible en todos nuestros archivos de código del proyecto. Esto es de suma utilidad ya que en
casos de que se necesite cambiar la cadena de conexión, únicamente se modifica este archivo a las nuevas
referencias de la fuente de datos, sin estar cambiando una a una las conexiones existentes.
La etiqueta de conexión describe una propiedad name, la cual establece el nombre con la que estableceremos
nuestra conexión desde el código en C#. La propiedad connectionString establece la ruta al servidor de base
de datos y la base de datos misma.
Finalmente, el providerName establece el espacio de nombres del proveedor de datos que utilizaremos para la
gestión de nuestra conexión.
10. Una vez creado nuestro sitio web, procederá a configurar las condiciones de trabajo del mismo
mediante la inclusión de carpetas y archivos.
Para ello, localice, seleccione y copie a las subcarpetas incluidas en los recursos de esta practica.
Luego, desde el Explorador de soluciones de su proyecto, haga clic secundario sobre el icono de su sitio

web y seleccione opción Pegar. Las carpetas de recursos y su contenido serán copiadas a la carpeta
raíz de archivos de su Sitio web.
11. Para continuar, creará la lógica de nuestra aplicación. Para ello, dentro de la carpeta Models del
proyecto, agregue una nueva clase con el nombre conexionDesconetada.cs, la cual alojará todo el
código que gestionará los procesos con la base de datos. Proceda a digitar el siguiente código.
Importante:
En los archivos restantes, tome en cuenta estas consideraciones:
 Determine las instrucciones “using” adicionales a las predeterminadas que deberá incluir en cada
clase.
 Cambie el namespace SitioWeb9_CARNET por el namespace de su propio proyecto web.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.Configuration;
using System.Data;
namespace SitioWeb9_CARNET.Models
{
public class conexionDesconetada
{
//Declaramos loss objetos que utilizaremos en toda nuestra clase
string coneccionString;
SqlConnection conexionSQL;
public DataSet DataSetPrincipal;
SqlDataAdapter DataAdapterEspecífico;
public conexionDesconetada(){
//Configuramos la conexion y obtenemos la cadena de conexion desde el Web.config
coneccionString =
ConfigurationManager.ConnectionStrings["conexion"].ConnectionString;
conexionSQL = new SqlConnection(coneccionString);
DataSetPrincipal = new DataSet();
conexionSQL.Open();
/*Inicializamos el adaptador específico que se utilizará en la gestión de
registros de producto*/
DataAdapterEspecífico = new SqlDataAdapter();
DataAdapterEspecífico.SelectCommand = new SqlCommand("SELECT * FROM Products",
conexionSQL);
}
public void conectar(){

conexionSQL.Open();
}
public void desconectar(){

conexionSQL.Close();
}

public void copiarBaseDatos()

{
//Cargamos las tablas al dataset a través del método cargarTabla
cargarTabla("Categories", "CategoryID");
cargarTabla("Suppliers", "SupplierID");
cargarTabla("Products", "ProductID");
/*Establecemos la relacion de llaves foraneas entre las tablas,

verifique la sintaxis de cada una de ellas*/
ForeignKeyConstraint fk1_cat_pro;
fk1_cat_pro = new
ForeignKeyConstraint(DataSetPrincipal.Tables["Categories"].Columns["CategoryID"],
DataSetPrincipal.Tables["Products"].Columns["CategoryID"]);
DataSetPrincipal.Tables["Products"].Constraints.Add(fk1_cat_pro);
ForeignKeyConstraint fk1_sup_pro;
fk1_sup_pro = new
ForeignKeyConstraint(DataSetPrincipal.Tables["Suppliers"].Columns["SupplierID"],
DataSetPrincipal.Tables["Products"].Columns["SupplierID"]);
DataSetPrincipal.Tables["Products"].Constraints.Add(fk1_sup_pro);
}
public void cargarTabla(String nombreTabla, String primaryKey)

{
nombreTabla = nombreTabla.Trim();
//Si la tabla no existe en el contexto actual, procederemos a adicionarla

if (DataSetPrincipal.Tables.IndexOf(nombreTabla) == -1)
{
/*Configuramos un control dataAdapter para que funcione como puente entre
dataset y base de datos */
SqlDataAdapter dataAdapter = new SqlDataAdapter();
dataAdapter.SelectCommand = new SqlCommand();
dataAdapter.SelectCommand.CommandText = "SELECT * FROM " + nombreTabla;
dataAdapter.SelectCommand.Connection = conexionSQL;
dataAdapter.SelectCommand.CommandType = CommandType.Text;
//Populamos el dataset con la tabla que acabamos de obtener

dataAdapter.FillSchema(DataSetPrincipal, SchemaType.Source, nombreTabla);
dataAdapter.Fill(DataSetPrincipal, nombreTabla);
dataAdapter.SelectCommand.Dispose();
dataAdapter.Dispose();
//Obtenemos la tabla actual y establecemos el campo que se utilizará como

llave primaria
DataTable tablaActual;
tablaActual = DataSetPrincipal.Tables[nombreTabla];
DataColumn[] columnasPrincipales = new DataColumn[1];

columnasPrincipales[0] = tablaActual.Columns[primaryKey];
tablaActual.PrimaryKey = columnasPrincipales;
}
}
public int insertarProducto(DataSet ds, string Categorias, string Proveedores,

string ProductName, string QuantityPerUnit, string UnitPrice, string UnitsInStock, string
UnitsOnOrder)

{
DataTable table = ds.Tables["Products"];
DataRow row = table.NewRow();

row["ProductName"] = ProductName;
row["SupplierID"] = Proveedores;
row["CategoryID"] = Categorias;
row["QuantityPerUnit"] = QuantityPerUnit;
row["UnitsInStock"] = UnitsInStock;
row["UnitPrice"] = UnitPrice;
row["UnitsOnOrder"] = UnitsOnOrder;
table.Rows.Add(row);
if (ds.HasChanges())
{
SqlCommandBuilder comando = new SqlCommandBuilder(DataAdapterEspecífico);

int filasAfectadas = DataAdapterEspecífico.Update(ds, "Products");
ds.AcceptChanges();
return filasAfectadas;
}
return 0;
}
public Product mostrardatos(int productID, DataSet ds)

{
DataView vistaFiltro = new DataView(ds.Tables["Products"]);
vistaFiltro.RowFilter = "ProductID = " + productID;
Product itemproduct = new Product();

foreach (DataRowView dr in vistaFiltro)
{
itemproduct.ProductID = dr["ProductID"].ToString();
itemproduct.ProductName = dr["ProductName"].ToString();
itemproduct.SupplierID = dr["SupplierID"].ToString();
itemproduct.CategoryID = dr["CategoryID"].ToString();
itemproduct.QuantityPerUnit = dr["QuantityPerUnit"].ToString();
itemproduct.UnitPrice = dr["UnitPrice"].ToString();
itemproduct.UnitsInStock = dr["UnitsInStock"].ToString();
itemproduct.UnitsOnOrder = dr["UnitsOnOrder"].ToString();
}
return itemproduct;
public int actualizarProducto( DataSet ds, int ProductID, string Categorias, string
Proveedores, string ProductName, string QuantityPerUnit, string UnitPrice, string
UnitsInStock, string UnitsOnOrder)
{
DataRow fila2Update;
DataTable tablaProductos;
tablaProductos = ds.Tables["Products"];
try
{
fila2Update = tablaProductos.Rows.Find(ProductID);

fila2Update["ProductName"] = ProductName;
fila2Update["SupplierID"] = int.Parse(Proveedores);
fila2Update["CategoryID"] = int.Parse(Categorias);
fila2Update["QuantityPerUnit"] = QuantityPerUnit;
fila2Update["UnitPrice"] = double.Parse(UnitPrice);
fila2Update["UnitsInStock"] = int.Parse(UnitsInStock);
fila2Update["UnitsOnOrder"] = int.Parse(UnitsOnOrder);
if (DataSetPrincipal.HasChanges())
{
SqlCommandBuilder comando = new

SqlCommandBuilder(DataAdapterEspecífico);
int filasAfectadas = DataAdapterEspecífico.Update(DataSetPrincipal,
"Products");
DataSetPrincipal.AcceptChanges();
}
return 0;
}
catch (Exception e)
{
return 0;
}
public int eliminarProducto(DataSet ds, int ProductID)

{
DataRow fila2Delete;
DataTable tablaProductos;
tablaProductos = ds.Tables["Products"];
try
{
fila2Delete = tablaProductos.Rows.Find(ProductID);
fila2Delete.Delete();
if (DataSetPrincipal.HasChanges())
{
SqlCommandBuilder comando = new

SqlCommandBuilder(DataAdapterEspecífico);
int filasAfectadas = DataAdapterEspecífico.Update(ds, "Products");
ds.AcceptChanges();
}
return 0;
}
catch
{
return 0;
}
}
}
}

12. Ahora, creara la lógica de nuestra aplicación. Para ello, dentro de nuestra carpeta Models, agregue
una nueva clase llamada “Category.cs”, la cual alojará todo el código que gestionará los procesos con
la base de datos.
Digite el siguiente código, tomando en cuenta las instrucciones “using” adicionales que se han
cargado:
using System;
using System.Linq;
using System.Web;
using System.Web.Mvc;
{
public class Category
{
public List<SelectListItem> Categorias { get; set; }
public string CategoryId { get; set; }
public string CategoryName { get; set; }
public string Description { get; set; }
}
}
13. Ahora, creara la lógica de nuestra aplicación. Para ello, agregue una nueva clase con el nombre
“Product.cs” dentro de nuestra carpeta Model, en donde se alojará todo el código que gestionará los
procesos con la base de datos.
cargado:
using System;
using System.Linq;
using System.Web;
{
public class Product
{
public List<Product> Productos { get; set; }
public string ProductID { get; set; }
public string ProductName { get; set; }
public string SupplierID { get; set; }
public string CategoryID { get; set; }
public string QuantityPerUnit { get; set; }
public string UnitPrice { get; set; }
public string UnitsInStock { get; set; }
public string UnitsOnOrder { get; set; }
}
}
14. Ahora, creara la lógica de nuestra aplicación. Para ello, agregue una nueva clase con el nombre
“Suppliers.cs” dentro de nuestra carpeta Models, en donde se alojará todo el código que gestionará
los procesos con la base de datos.
cargado:

using System;
using System.Linq;
using System.Web;
{
public class Suppliers
{
public List<SelectListItem> proveedores { get; set; }
public string SupplierID { get; set; }
public string CompanyName { get; set; }
public string ContactName { get; set; }
public string ContactTitle { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string Region { get; set; }
public string PostalCode { get; set; }
public string Country { get; set; }
public string Phone { get; set; }
public string Fax { get; set; }
public string HomePage { get; set; }
}
}
15. Ahora, creara el controlador de nuestra aplicación. Para ello, agregue un nuevo controlador con el
nombre “DefaultController” dentro de nuestra carpeta Controller, en donde se alojará todo el código
que gestionará los procesos con la base de datos y los enviara a la vista.
cargado:
using System;
using System.Linq;
using System.Web;
using SitioWeb9_CARNET.Models;
using System.Data;
namespace SitioWeb9_CARNET.Controllers
{
public class DefaultController : Controller
{
// GET: Default
public ActionResult Index()
{
conexionDesconetada datos = new conexionDesconetada();

datos.copiarBaseDatos();
Category listcat = new Category();

List<SelectListItem> itemscat = new List<SelectListItem>();

Suppliers listsup = new Suppliers();

List<SelectListItem> itemssupp = new List<SelectListItem>();
List<Product> itemproducts = new List<Product>();
foreach (DataRow dr in datos.DataSetPrincipal.Tables["Categories"].Rows)

{
itemscat.Add(new SelectListItem
{
Text = dr["CategoryName"].ToString(),
Value = dr["CategoryId"].ToString()
});
}
foreach (DataRow dr in datos.DataSetPrincipal.Tables["Suppliers"].Rows)

{
itemssupp.Add(new SelectListItem
{
Text = dr["CompanyName"].ToString(),
Value = dr["SupplierID"].ToString()
});
}
foreach (DataRow dr in datos.DataSetPrincipal.Tables["Products"].Rows)

{
itemproducts.Add(new Product{
ProductID = dr["ProductID"].ToString(),
ProductName = dr["ProductName"].ToString(),
SupplierID = dr["SupplierID"].ToString(),
CategoryID = dr["CategoryID"].ToString(),
QuantityPerUnit = dr["QuantityPerUnit"].ToString(),
UnitPrice = dr["UnitPrice"].ToString(),
UnitsInStock = dr["UnitsInStock"].ToString(),
UnitsOnOrder = dr["UnitsOnOrder"].ToString()
});
ViewBag.productos = itemproducts;
listsup.proveedores = itemssupp;
ViewBag.proveedores = listsup.proveedores;
listcat.Categorias = itemscat;
ViewBag.Categorias = listcat.Categorias;
return View();
}
[HttpPost]
public ActionResult Index(string Categorias, string Proveedores)
{



Product listprod = new Product();


{
{
});
}

{
{
});
}
//Cargamos un dataview ya que el nos permite hacer filtros sobre la tabla seleccionada
DataView vistaFiltro = new DataView(datos.DataSetPrincipal.Tables["Products"]);
if (Categorias != "0")
{
vistaFiltro.RowFilter = "CategoryID = " + Categorias;
}
if (Proveedores != "0")
{
vistaFiltro.RowFilter = "SupplierID = " + Proveedores;
}
foreach (DataRowView dr in vistaFiltro)

{
itemproducts.Add(new Product {
ProductName=dr["ProductName"].ToString(),
SupplierID= dr["SupplierID"].ToString(),
CategoryID= dr["CategoryID"].ToString(),
QuantityPerUnit= dr["QuantityPerUnit"].ToString(),
UnitPrice= dr["UnitPrice"].ToString(),
UnitsInStock= dr["UnitsInStock"].ToString(),
UnitsOnOrder= dr["UnitsOnOrder"].ToString()
});
}

listprod.Productos = itemproducts;
ViewBag.productos = listprod.Productos;
return View();
}
[HttpPost]
public ActionResult Ingresardatos(string Categorias, string Proveedores, string
ProductName,string QuantityPerUnit,string UnitPrice,string UnitsInStock,string UnitsOnOrder)
{

datos.insertarProducto(datos.DataSetPrincipal, Categorias, Proveedores, ProductName,

QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder);




{
{
});
}

{
{
});
}

{
itemproducts.Add(new Product
{

});
}
return View("Index");
}
[ActionName("Actualizar")]
public ActionResult Actualizar(string ProductID, string Categorias, string Proveedores, string
ProductName, string QuantityPerUnit, string UnitPrice, string UnitsInStock, string UnitsOnOrder)
{

datos.actualizarProducto(datos.DataSetPrincipal,int.Parse(ProductID), Categorias,
Proveedores, ProductName, QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder);




{
{
});
}


{
{
});
}

{
{
});
}
}
[HttpPost]
public ActionResult Add()
{



{

{
});
}

{
{
});
}
return View();
}
[ActionName("Edit")]
public ActionResult Edit(string ProductID)
{



{
{
});
}

{
{
});

return View(datos.mostrardatos(int.Parse(ProductID), datos.DataSetPrincipal));
}
[ActionName("Eliminar")]
public ActionResult Eliminar(string ProductID)
{
datos.eliminarProducto(datos.DataSetPrincipal, int.Parse(ProductID));




{
{
});
}

{
{
});
}

{
{

});
}
}
}
}
16. Ahora, creara las vistas de nuestra aplicación. Para ello, agregue una nueva vista con el nombre
“Index.cshtml” dentro de nuestra carpeta Views>Default, en donde se alojará todo el código que
gestionará los procesos con la base de datos y los enviara a la vista.
Digite el siguiente código:
@{
ViewBag.Title = "UNIVERSIDAD DON BOSCO";
}
<h2>LISTA DE PRODUCTOS</h2>
@using (Html.BeginForm("Add", "Default", FormMethod.Post))
{
<button type="submit" id="btnNuevo" class="btn btn-lg btn-primary top-right "
onclick="location.href('@Url.Action("Add","Default")')">Nueva Producto</button>
}
@using (Html.BeginForm("Index", "Default", FormMethod.Post))

{
<div class="form-inline" role="form">
<div class="form-group col-lg-4">
Categoria:
</div>
proveedores:
</div>
</div>
<div class="form-inline" role="form">
@Html.DropDownList("Categorias", null, new { @class = "form-control" })
</div>
@Html.DropDownList("proveedores", null, new { @class = "form-control" })
</div>
<br />
<button type="submit" id="btnBuscar" class="btn btn-lg btn-primary "
onclick="location.href('@Url.Action("Index","Default")')">BUSCAR</button>
</div>

<form id="exportWebGrid" action="Meeting/ExportHeade" method="post">

<div name="webView">
@{
var objweb = new WebGrid(ViewBag.productos, rowsPerPage: 15, canPage: true);
}
@objweb.GetHtml(
tableStyle: "table table-responsive table-hover",
fillEmptyRows: true,
headerStyle: "thead-dark",
footerStyle: "pie-grid",
mode: WebGridPagerModes.All,
firstText: "<< Primera",
previousText: "< Anterior",
nextText: "Siguiente >",
lastText: "Última >>",
columns:
objweb.Columns(
objweb.Column(columnName: "ProductID", header: "ID"),
objweb.Column(columnName: "ProductName", header: "Producto"),
objweb.Column(columnName: "SupplierID", header: "Proveedor"),
objweb.Column(columnName: "CategoryID", header: "Categoría"),
objweb.Column(columnName: "QuantityPerUnit", header: "Cant/Unidad"),
objweb.Column(columnName: "UnitPrice", header: "Precio"),
objweb.Column(columnName: "UnitsInStock", header: "Disponibles"),
objweb.Column(columnName: "UnitsOnOrder", header: "Ordenadas"),
objweb.Column(format: @<text>@Html.ActionLink("Editar", "Edit",
"Default", new { ProductID = item.ProductID }, null)|
@Html.ActionLink("Eliminar", "Eliminar",
"Default", new { ProductID = item.ProductID }, null)</text>))
)
</div>
</form>
“Add.cshtml” dentro de nuestra carpeta Views>Default, en donde se alojará todo el código que
gestionará los procesos con la base de datos y los enviara a la vista.
Digite el siguiente código:
@model SitioWeb9_CARNET.Models.Product
@{
ViewBag.Title = "Add";
}
<h2>Add</h2>
@using (Html.BeginForm("Ingresardatos", "Default", FormMethod.Post))
{
@Html.AntiForgeryToken()
<div class="form-horizontal">
<h4>Product</h4>
<hr />
@Html.ValidationSummary(true, "", new { @class = "text-danger" })
<div class="form-group">
@Html.Label("Nombre de Producto", new { @class = "control-label col-md-2" })

<div class="col-md-10">
@Html.EditorFor(model => model.ProductName, new { htmlAttributes = new {
@class = "form-control" } })
@Html.ValidationMessageFor(model => model.ProductName, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Proveedor", new { @class = "control-label col-md-2" })
@Html.ValidationMessageFor(model => model.SupplierID, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Categoria", new { @class = "control-label col-md-2" })
@Html.ValidationMessageFor(model => model.CategoryID, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Cantidad de unidades", new { @class = "control-label col-md-2"
})
@Html.EditorFor(model => model.QuantityPerUnit, new { htmlAttributes =
new { @class = "form-control" } })
@Html.ValidationMessageFor(model => model.QuantityPerUnit, "", new {
@class = "text-danger" })
</div>
</div>
@Html.Label("Precio por unidad", new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.UnitPrice, new { htmlAttributes = new {
@Html.ValidationMessageFor(model => model.UnitPrice, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Cantidad disponibles", new { @class = "control-label col-md-2"
})
@Html.EditorFor(model => model.UnitsInStock, new { htmlAttributes = new {
@Html.ValidationMessageFor(model => model.UnitsInStock, "", new { @class
= "text-danger" })
</div>
</div>

@Html.Label("Cantidad ordenadas", new { @class = "control-label col-md-2" })

@Html.EditorFor(model => model.UnitsOnOrder, new { htmlAttributes = new {
@Html.ValidationMessageFor(model => model.UnitsOnOrder, "", new { @class
= "text-danger" })
</div>
</div>
<div class="col-md-offset-2 col-md-10">
onclick="location.href('@Url.Action("Ingresar", "Default")')">Ingresar</button>
</div>
</div>
</div>
}
<div>
@Html.ActionLink("Regresar lista de productos", "Index")
</div>
Edit.cshtml dentro de nuestra carpeta Views>Default, en donde se alojará todo el código que
gestionará los procesos con la base de datos y los enviara a la vista. Digite el siguiente código:
@model SitioWeb9_CARNET.Models.Product
@{
ViewBag.Title = "Edit";
}
<h2>Edit</h2>
@using (Html.BeginForm("Actualizar", "Default", FormMethod.Post))

{
@Html.AntiForgeryToken()
<div class="form-horizontal">
<h4>Product</h4>
<hr />
@Html.ValidationSummary(true, "", new { @class = "text-danger" })
@Html.HiddenFor(model => model.ProductID)
@Html.Label("ID Producto", new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.ProductID, new { htmlAttributes = new { @class
= "form-control" } })
@Html.ValidationMessageFor(model => model.ProductID, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Nombre Producto", new { @class = "control-label col-md-2" })

@Html.EditorFor(model => model.ProductName, new { htmlAttributes = new {

@Html.ValidationMessageFor(model => model.ProductName, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Proveedores", new { @class = "control-label col-md-2" })
@Html.ValidationMessageFor(model => model.SupplierID, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Categoria", new { @class = "control-label col-md-2" })
@Html.ValidationMessageFor(model => model.CategoryID, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Cantidad", new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.QuantityPerUnit, new { htmlAttributes = new {
@Html.ValidationMessageFor(model => model.QuantityPerUnit, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Precio", new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.UnitPrice, new { htmlAttributes = new { @class
= "form-control" } })
@Html.ValidationMessageFor(model => model.UnitPrice, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Disponibles", new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.UnitsInStock, new { htmlAttributes = new {
@Html.ValidationMessageFor(model => model.UnitsInStock, "", new { @class =
"text-danger" })
</div>
</div>
@Html.Label("Ordenadas", new { @class = "control-label col-md-2" })

@Html.EditorFor(model => model.UnitsOnOrder, new { htmlAttributes = new {

@Html.ValidationMessageFor(model => model.UnitsOnOrder, "", new { @class =
"text-danger" })
</div>
</div>
<div class="col-md-offset-2 col-md-10">
onclick="location.href('@Url.Action("Actualizar","Default")')">Guardar</button>
</div>
</div>
</div>
}
<div>
@Html.ActionLink("Back to List", "Index")
</div>
19. Proceda a probar la aplicación, iniciando en la vista Index. Realice búsquedas, inserciones,
actualizaciones y eliminaciones de datos.
VI. BIBLIOGRAFÍA
1. Thierry GROUSSARD. (2013). C# 5: Los fundamentos del lenguaje – Desarrollar con Visual Studio 2012.
Barcelona: ENI

Guia 9

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia 9

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD DON BOSCO

FACULTAD DE ESTUDIOS TECNOLÓGICOS

Que los estudiantes:

II. INTRODUCCIÓN TEÓRICA

Entorno desconectado de ADO.NET

Algunas ventajas que provee un escenario de acceso a datos desconectado son:

Desarrollo de Aplicaciones con Software Propietario 1 / 25

 Objeto estrella en ADO.NET

Desarrollo de Aplicaciones con Software Propietario 2

Desarrollo de Aplicaciones con Software Propietario 3

III. MATERIALES Y EQUIPO

Para la realización de la guía de práctica se requerirá lo siguiente:

3. Inicie Microsoft Visual Studio desde su computadora.

Desarrollo de Aplicaciones con Software Propietario 4

Desarrollo de Aplicaciones con Software Propietario 5

8. Edite el archivo web.config de su sitio web, para agregar la sección <connectionsStrings> y su

Desarrollo de Aplicaciones con Software Propietario 6

public void conectar(){

public void desconectar(){

Desarrollo de Aplicaciones con Software Propietario 7

public void copiarBaseDatos()

/*Establecemos la relacion de llaves foraneas entre las tablas,

public void cargarTabla(String nombreTabla, String primaryKey)

//Si la tabla no existe en el contexto actual, procederemos a adicionarla

//Populamos el dataset con la tabla que acabamos de obtener

//Obtenemos la tabla actual y establecemos el campo que se utilizará como

DataColumn[] columnasPrincipales = new DataColumn[1];

public int insertarProducto(DataSet ds, string Categorias, string Proveedores,

Desarrollo de Aplicaciones con Software Propietario 8

DataRow row = table.NewRow();

SqlCommandBuilder comando = new SqlCommandBuilder(DataAdapterEspecífico);

public Product mostrardatos(int productID, DataSet ds)

Product itemproduct = new Product();

Desarrollo de Aplicaciones con Software Propietario 9

SqlCommandBuilder comando = new

public int eliminarProducto(DataSet ds, int ProductID)

SqlCommandBuilder comando = new

Desarrollo de Aplicaciones con Software Propietario 10

Desarrollo de Aplicaciones con Software Propietario 11

conexionDesconetada datos = new conexionDesconetada();

Category listcat = new Category();

Desarrollo de Aplicaciones con Software Propietario 12

Suppliers listsup = new Suppliers();

List<Product> itemproducts = new List<Product>();

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Categories"].Rows)

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Suppliers"].Rows)

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Products"].Rows)

Desarrollo de Aplicaciones con Software Propietario 13

Category listcat = new Category();

Suppliers listsup = new Suppliers();

Product listprod = new Product();

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Categories"].Rows)

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Suppliers"].Rows)

foreach (DataRowView dr in vistaFiltro)

Desarrollo de Aplicaciones con Software Propietario 14

conexionDesconetada datos = new conexionDesconetada();

datos.insertarProducto(datos.DataSetPrincipal, Categorias, Proveedores, ProductName,

Category listcat = new Category();

Suppliers listsup = new Suppliers();

Product listprod = new Product();

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Categories"].Rows)

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Suppliers"].Rows)

foreach (DataRow dr in datos.DataSetPrincipal.Tables["Products"].Rows)