FACULTAD INGENIERIA COORDINACION DE COMPUTACIÓN › udb_files › recursos_guias ›...

Guía #5: Conectando a Fuentes de Datos con LINQ

Lenguaje de Programación II 1

UNIVERSIDAD DON BOSCO

FACULTAD INGENIERIA

COORDINACION DE COMPUTACIÓN

Ciclo 1/2020

GUIA DE LABORATORIO # 5

Nombre de la Práctica:

Lugar de Ejecución:

Tiempo Estimado:

MATERIA:

Conectando a Fuentes de Datos con LINQ

Centro de cómputo

2 horas con 30 minutos

Lenguaje de Programación II

II. OBJETIVOS

Que el estudiante:

1. Conozca los fundamentos teóricos sobre LINQ en ASP.NET

2. Implemente clases de LINQ a SQL en una aplicación web

3. Manipule datos y el control de operaciones desde una página web

II. INTRODUCCIÓN TEÓRICA

LINQ Language Integrated Query (LINQ, pronunciado “link”)

Es un componente de la plataforma Microsoft .NET que agrega capacidades de consulta a datos de manera nativa a los lenguajes .NET, si bien existen implementaciones para Java, PHP, JavaScript y ActionScript.

LINQ extiende el lenguaje a través de las llamadas expresiones de consulta, que son parecidas a las

sentencias SQL y pueden ser usadas para extraer y procesar convenientemente datos de arrays, clases

enumerables, documentos XML, bases de datos relacionales y fuentes de terceros. Otros usos, que

utilizan expresiones de consulta como plataforma general para la composición de expresiones más

legibles, incluyen la construcción de manejadores de eventos.

LINQ además define un conjunto de nombres de métodos (llamados operadores de consulta estándar), y un conjunto de reglas de traducción, que son usadas por el compilador para traducir las expresiones

de consulta en expresiones normales del lenguaje, usando estos nombres de métodos, expresiones lambda y tipos anónimos. Muchos de los conceptos que LINQ ha introducido, fueron probados

inicialmente en el proyecto de investigación Microsoft Cω. LINQ fue lanzado como un componente principal de .NET Framework 3.5 el 19 de noviembre de 2007.

Operadores de consulta estándar

En la siguiente sección, las descripciones de los operadores están basados en la aplicación de trabajar con colecciones. El conjunto de operadores de consulta definido por LINQ se expone al usuario como

la Standard Query Operator (SQO) API. Los operadores soportados por la API son:



Select Realiza una proyección de la colección y selecciona los aspectos deseados de los elementos. El usuario especifica una función arbitraria, como un delegado o una expresión lambda, que es la que proyecta los

elementos.

Where Permite la definición de un conjunto de predicados que son evaluados para cada objeto en la colección, de manera que los objetos que no cumplan el predicado son excluidos del resultado. El predicado se

especifica al operador como un delegado.

SelectMany Mapea de elementos de una colección a colecciones. Semánticamente, se realizan dos pasos. Primero, cada elemento se mapea a su colección correspondiente. Después, el resultado del primer paso se mezcla

en un mismo nivel. Nota: Select y Where son ambos implementables usando SelectMany.

Sum / Min / Max / Average Estos operadores reciben un parámetro opcional lambda, que toma un valor de cada elemento en la colección y lo usa para encontrar la suma, el mínimo, el máximo o el promedio respectivamente de todos los elementos en la colección.

Aggregate Una versión generalizada de Sum/Min/Max. Este operador recibe una expresión lambda que especifica cómo serán combinados los valores para formar un resultado intermedio o final. De manera opcional,

se puede especificar un valor inicial, permitiendo que el tipo de la agregación pueda ser cualquiera. Además, una función de finalización, convirtiendo el resultado de la agregación en otro valor, que

puede ser especificado.

Join Realiza un inner join entre dos colecciones, basado en llaves coincidentes para los objetos de cada

colección. Recibe dos funciones como delegados, una para cada colección, que se ejecutará sobre cada

elemento de la colección para extraer su llave.

GroupJoin Al igual que el anterior, pero realiza un GroupJoin.

Take / TakeWhile El operador Take selecciona los n primeros objetos de una colección, mientras que el operador

TakeWhile, que recibe un predicado, selecciona solo los n primeros objetos que cumplan con este.

Skip / SkipWhile

Son los complementos de Take y TakeWhile respectivamente, se ignoran los primeros n elementos o los primeros n que cumplan el predicado especificado.

OfType Para seleccionar solo los elementos de cierto tipo.



Concat Concatena dos colecciones.

OrderBy / ThenBy El operador OrderBy se utiliza para especificar el ordenamiento primario de los elementos en una

colección de acuerdo con alguna llave. El orden por defecto es en orden ascendente, para invertir el

orden se utiliza el operador OrderByDescending. ThenBy y ThenByDescending especifica el

subsiguiente orden de los elementos. La función para extraer el valor de llave del objeto debe ser

especificada por el usuario como un delegado.

Reverse

El operador Reverse invierte una colección.

GroupBy El operador GroupBy toma un delegado que extrae un valor de llave y devuelve una colección de objetos de tipo IGrouping<Key, Values>, para cada valor de llave distinta. Los IGrouping objetos pueden entonces utilizar para enumerar todos los objetos de un valor de llave en particular.

Distinct El operador Distinct elimina instancias duplicadas de un valor de llave en una colección. La función para recuperar el valor de llave que se retornará es un delegado.

Union / Intersect / Except Estos operadores se utilizan para realizar una operación de unión, intersección y diferencia entre dos

secuencias, respectivamente.

SequenceEqual El operador SequenceEqual determina si todos los elementos de dos colecciones son iguales y tienen el mismo orden.

First / FirstOrDefault / Last / LastOrDefault

Estos operadores reciben como parámetro un predicado. El operador First devuelve el primer elemento para el cual se satisface el predicado o lanza una excepción, si este no se satisface.

El operador FirstOrDefault es como el primer operador, excepto que devuelve el valor predeterminado para el tipo de elemento (por lo general una referencia null) en caso de que no se satisfaga con el predicado.

El operador Last recupera el último elemento para el cual se satisface el predicado, o se produce una

excepción, si este no se satisface.

El operador LastOrDefault devuelve el valor predeterminado si no existe tal elemento.

Single El operador Single recibe como parámetro un predicado y devuelve el elemento que satisface con el

predicado. Se produce una excepción, si ninguno o más de un elemento satisface con el predicado.



ElementAt El operador ElementAt devuelve el elemento situado en un índice especificado de una colección.

Any / All / Contains El operador Any determina si ninguno de los elementos de la colección satisface con el predicado. El operador All determina, si todos los elementos de la colección satisfacen con el predicado. El operador Contains determina si una colección contiene un elemento especificado.

Count El operador Count cuenta el número de elementos en la colección dada. En la API de los (SQO) operadores de consulta estándar también se definen algunos operadores

para convertir una colección a otro tipo:

AsEnumerable: convierte una colección en un IEnumerable<T>.

AsQueryable: convierte una colección en un IQueryable<T>.

ToArray: convierte una colección en un array.

ToList: convierte una colección en un IList<T>.

ToDictionary: convierte una colección en un IDictionary<K, T>, indexado por la llave K.

ToLookup: convierte una colección en un ILookup<K, T>, indexado por la llave K.

Cast: convierte una colección no genérica en un IEnumerable<T>, convirtiendo cada elemento al

tipo T. Lanza una excepción para los tipos incompatibles.

OfType: convierte la colección no genérica en un IEnumerable<T>. Sólo los elementos de tipo T

están incluidos.

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 #10: Conectando a Fuentes de Datos con LINQ 1

2 Computadora con Microsoft Visual Studio 2012 y Microsoft SQL Server instalados.

1

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 de Microsoft SQL Server Management Studio instalada en su

computadora.

Una vez cargada, confirme que existe la base de datos “EmpresaPlazaLibre”. Si no existe, debe

crearla desde los recursos.



Ejercicio #2 – Creación de conexión desde Visual Studio con el origen de datos a través del

asistente.

1. Proceda a iniciar Microsoft Visual Studio desde su computadora. Una vez cargado el

IDE en pantalla procederemos a crear la conexión de tal manera que esta se encuentre activa desde nuestra ventana. De esta manera se podrá administrar los

objetos de bases de datos desde el IDE. Para ello, proceda a iniciar el explorar de

servidores, desde el menú “Ver”, “Explorador de Servidores”. Podrá observar que se

carga una nueva ventana listando los diferentes servidores asociados a la aplicación. El que nos interesa por el momento es el que indica “Conexiones de datos”. Desde este

punto procederemos a agregar una nueva conexión, para ello proceda a dar clic derecho sobre el icono asociado a servidores de base datos, automáticamente verá un

menú emergente del cual deberá seleccionar la opción de “Agregar conexión”.

2. Se nos mostrará una ventana donde se nos 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. Procederemos a llenar el formulario presentado de la siguiente forma: del campo de servidor, seleccione el servidor asociado a su instancia de SQL Server instalada en su computadora. Para la conexión al servidor se debe usar conexión con autenticación de Windows. Posteriormente seleccione la base de datos que creo usted en el inicio de esta guía. 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 y si esta ha sido satisfactoria y luego de clic en Aceptar.



3. Una vez creada la conexión, procederemos a configurar 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 derecho sobre la conexión antes establecida y proceda a dar clic en “Propiedades” del menú emergente. Una vez se carguen las propiedades de la conexión, proceda a copiar la propiedad “Cadena de conexión” de la ventana de propiedades. Debe conservar los datos en memoria. Verifique la siguiente imagen.



4. Ahora, proceda a editar el archivo web.config de su sitio web, para agregar las siguientes líneas de código. En la etiqueta “connectionString” debe colocar el valor de la cadena de conexión copiada en el punto anterior. Para una mejor referencia consulte los

pasos de la guía número 5. Al final debe quedarle como se muestra a continuación:

<connectionStrings> <add name="conexion" connectionString="Data Source=localhost;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.

5. Una vez creado nuestro sitio web, procederemos a configurar las condiciones de

trabajo del mismo mediante la creación de carpetas y archivos. Para ello cree 4 carpetas en la raíz del sitio según el detalle de la siguiente tabla. El contenido de cada carpeta se encuentra como recurso de esta guía, por lo que debe de proceder a adicionar el contenido de cada una de las carpetas como ya lo ha realizado anteriormente.

Carpeta

Css

Fonts

Images

Js

6. Procederemos ahora a crear la lógica de nuestra aplicación, para ello se trabajará una

parte con el acceso desconectado, proceda a agregar una nueva clase con el nombre

“ConexionDesconectada.cs” que es donde se alojará todo el código que gestionará los

procesos con la base de datos. Proceda a digitar el siguiente código, tomando en cuenta

las instrucciones “using” adicionales que se han cargado:

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Data.SqlClient; using System.Configuration; using System.Data; using System.Web.UI.WebControls;

public class ConexionDesconectada { //Declaramos los objetos que utilizaremos en toda nuestra clase



string connectionString; SqlConnection conexionSql; DataSet dataSetPrincipal; SqlDataAdapter dataAdapterEspecifico; public ConexionDesconectada() { //Configuramos la conexion y obtenemos la cadena de conexion desde el web.config connectionString = ConfigurationManager.ConnectionStrings["conexion"].ConnectionString; conexionSql = new SqlConnection(connectionString); dataSetPrincipal = new DataSet(); conexionSql.Open(); //Inicializamos el adaptador especifico que se utilizará en la gestión de registros de producto dataAdapterEspecifico = new SqlDataAdapter(); dataAdapterEspecifico.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 traves 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; //Llenamos 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 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 void LlenarCombo(ref DropDownList comboBox, String nombreTabla, String campoValor, String campoTexto) { //Asociamos al control de combobox la fuente de datos desde donde obtendrá su información nombreTabla = nombreTabla.Trim(); comboBox.DataSource = dataSetPrincipal; comboBox.DataMember = nombreTabla; comboBox.DataValueField = campoValor; comboBox.DataTextField = campoTexto; comboBox.DataBind(); } public object[] GetDataRow(int productID) { //Obtenemos un arreglo genérico con los datos de una fila en específico a la que se le pasa como parametro //el ID a seleccionar desde la tabla object[] datosRetorno = new object[8]; DataRow[] filaSeleccionada; filaSeleccionada = dataSetPrincipal.Tables["Products"].Select("ProductID=" + productID); if (filaSeleccionada.Length == 1) { datosRetorno[0] = filaSeleccionada[0]["ProductID"]; datosRetorno[1] = filaSeleccionada[0]["ProductName"]; datosRetorno[2] = filaSeleccionada[0]["SupplierID"]; datosRetorno[3] = filaSeleccionada[0]["CategoryID"]; datosRetorno[4] = filaSeleccionada[0]["QuantityPerUnit"]; datosRetorno[5] = filaSeleccionada[0]["UnitPrice"]; datosRetorno[6] = filaSeleccionada[0]["UnitsInStock"]; datosRetorno[7] = filaSeleccionada[0]["UnitsOnOrder"]; } return datosRetorno; }



public void CargarProductosEnTabla(ref GridView grid, string categoria, string proveedor) { grid.Columns.Clear(); //Cargamos un dataview ya que es el que nos permite hacer filtros sobre la tabla seleccionada DataView vistaFiltro = new DataView(dataSetPrincipal.Tables["Products"]); if (categoria != "0") { vistaFiltro.RowFilter = "CategoryID = " + categoria; } if(proveedor != "0") { vistaFiltro.RowFilter = "SupplierID = " + proveedor; } //Configuramos el gridView que es pasado por referencia para que su fuente de datos sea el dataview //Configurado y poblado anteriormente, ademas establecemos que el campo principal sea la columna ProductID grid.DataSource = vistaFiltro; grid.DataBind(); grid.AllowPaging = true; grid.DataKeyNames = new String[1] { "ProductID" }; //Configuramos un boton de editar el cual será añadido al grid ButtonField columnaEditar = new ButtonField(); columnaEditar.HeaderText = "Editar"; columnaEditar.HeaderStyle.HorizontalAlign = HorizontalAlign.Center; columnaEditar.ButtonType = ButtonType.Button; columnaEditar.Text = "Editar"; columnaEditar.CommandName = "Seleccionar"; columnaEditar.ControlStyle.CssClass = "button special"; grid.Columns.Add(columnaEditar); //Configuramos un boton de eliminar que será añadido al grid ButtonField columnaEliminar = new ButtonField(); columnaEliminar.HeaderText = "Eliminar"; columnaEliminar.HeaderStyle.HorizontalAlign = HorizontalAlign.Center; columnaEliminar.ButtonType = ButtonType.Button; columnaEliminar.Text = "Eliminar"; columnaEliminar.CommandName = "Eliminar"; columnaEliminar.ControlStyle.CssClass = "button special"; grid.Columns.Add(columnaEliminar); //Recargamos el grid y seteamos los nombres de las columnas grid.DataBind(); grid.HeaderStyle.HorizontalAlign = HorizontalAlign.Center; grid.HeaderRow.Cells[2].Text = "ID"; grid.HeaderRow.Cells[3].Text = "Producto"; grid.HeaderRow.Cells[4].Text = "Proveedor"; grid.HeaderRow.Cells[5].Text = "Categoría"; grid.HeaderRow.Cells[6].Text = "Cant/Unidad"; grid.HeaderRow.Cells[7].Text = "Precio"; grid.HeaderRow.Cells[8].Text = "Disponibles"; grid.HeaderRow.Cells[9].Text = "Ordenadas"; grid.PagerStyle.CssClass = "pager"; } public int ActualizarProducto(int productID, object[] datosActualizados)



{ DataRow fila2Update; DataTable tablaProductos; tablaProductos = dataSetPrincipal.Tables["Products"]; try { fila2Update = tablaProductos.Rows.Find(productID); fila2Update["ProductName"] = datosActualizados[0].ToString(); fila2Update["SupplierID"] = int.Parse(datosActualizados[1].ToString()); fila2Update["CategoryID"] = int.Parse(datosActualizados[2].ToString()); fila2Update["QuantityPerUnit"] = datosActualizados[3].ToString(); fila2Update["UnitPrice"] = double.Parse(datosActualizados[4].ToString()); fila2Update["UnitsInStock"] = int.Parse(datosActualizados[5].ToString()); fila2Update["UnitsOnOrder"] = int.Parse(datosActualizados[6].ToString()); if (dataSetPrincipal.HasChanges()) { SqlCommandBuilder comando = new SqlCommandBuilder(dataAdapterEspecifico); int filasAfectadas = dataAdapterEspecifico.Update(dataSetPrincipal, "Products"); dataSetPrincipal.AcceptChanges(); return filasAfectadas; } return 0; } catch (Exception e) { return 0; } } public int EliminarProducto(int ProductID) { DataRow fila2Delete; DataTable tablaProductos; tablaProductos = dataSetPrincipal.Tables["Products"]; try { fila2Delete = tablaProductos.Rows.Find(ProductID); fila2Delete.Delete(); if (dataSetPrincipal.HasChanges()) { SqlCommandBuilder comando = new SqlCommandBuilder(dataAdapterEspecifico); int filasAfectadas = dataAdapterEspecifico.Update(dataSetPrincipal, "Products"); dataSetPrincipal.AcceptChanges(); return filasAfectadas; } return 0; } catch(Exception e) { return 0; } } }

7. Ahora, proceda a agregar un nuevo Web Form con nombre “Default.aspx”, y luego digite el siguiente marcado.

<html> <head> <title>Control de Productos</title> <meta http-equiv="content-type" content="text/html; charset=utf-8" />  <script src="js/jquery.min.js"></script> <script src="js/jquery.scrolly.min.js"></script> <script src="js/jquery.dropotron.min.js"></script> <script src="js/jquery.scrollex.min.js"></script> <script src="js/skel.min.js"></script> <script src="js/skel-layers.min.js"></script> <script src="js/init.js"></script> <noscript> <link rel="stylesheet" href="css/skel.css" /> <link rel="stylesheet" href="css/style.css" /> <link rel="stylesheet" href="css/style-xlarge.css" /> </noscript>   </head> <body>  <header id="header" class="skel-layers-fixed"> <h1 id="logo"><a href="/">Página Principal</a></h1> <nav id="nav"> <ul> <li><a href="" class="button special">Nuevo Producto</a></li> </ul> </nav> </header> <style> .pager table { width: auto !important; } </style>  <div id="main" class="wrapper style1"> <div class="container">  <section> <form id="form1" runat="server"> <div class="row uniform 50%"> <div class="5u 12u$(xsmall)"> Categoría <div class="select-wrapper"> <asp:DropDownList ID="ddlCategorias" runat="server"></asp:DropDownList></div> </div> <div class="5u 12u$(xsmall)"> Proveedor <div class="select-wrapper"> <asp:DropDownList ID="ddlProveedor" runat="server"></asp:DropDownList></div> </div> <div class="2u 12u$(xsmall)"> <br />

<asp:Button ID="btnBuscar" runat="server" Text="Buscar" Width="100%" CssClass="special" /> </div> <div class="12u 12u$(xsmall)"> <asp:GridView ID="GridView1" Width="100%" CssClass="alt" runat="server"></asp:GridView> </div> </div> </form> </section> </div> </div>  <footer id="footer"> <ul class="icons"> <li><a href="#" class="icon alt fa-twitter"><span class="label">Twitter</span></a></li> <li><a href="#" class="icon alt fa-facebook"><span class="label">Facebook</span></a></li> <li><a href="#" class="icon alt fa-envelope"><span class="label">Email</span></a></li> </ul> <ul class="copyright"> <li>© 2018. All rights reserved.</li> </ul> </footer> </body>

</html>

8. En la página de código subyacente, agregue una nueva variable de tipo “ConexionDesconectada” que corresponde a la clase que creamos anteriormente. El

nombre de la variable debe ser “nuevaConexion”.

9. En el evento “Page_Load”, proceda a digitar el siguiente código, verifique además como se declaró la variable del punto anterior, posterior a ello, proceda a ejecutar su página y observe lo que se carga en el navegador.

ConexionDesconectada nuevaConexion; protected void Page_Load(object sender, EventArgs e) { nuevaConexion = new ConexionDesconectada(); if (!Page.IsPostBack) { nuevaConexion.CopiarBaseDatos(); nuevaConexion.LlenarCombo(ref ddlCategorias, "Categories", "categoryID", "CategoryName"); nuevaConexion.LlenarCombo(ref ddlProveedor, "Suppliers", "SupplierID", "CompanyName"); ddlCategorias.Items.Insert(0, new ListItem("Ver Todos", "0")); ddlProveedor.Items.Insert(0, new ListItem("Ver Todos", "0")); nuevaConexion.CargarProductosEnTabla(ref GridView1, "0", "0"); nuevaConexion.Desconectar(); } }



10. Ahora, procederemos a programar el evento asociado a la paginación del GridView, para ello, siempre en la misma página de Default.aspx.cs proceda a digitar el siguiente código teniendo especial cuidado en el nombre del método.

protected void GridView1_PageIndexChanging(object sender, GridViewPageEventArgs e) { nuevaConexion = new ConexionDesconectada(); nuevaConexion.CopiarBaseDatos(); GridView1.PageIndex = e.NewPageIndex; nuevaConexion.CargarProductosEnTabla(ref GridView1, ddlCategorias.SelectedValue, ddlProveedor.SelectedValue); nuevaConexion.Desconectar();

}

11. Ahora, programaremos el evento asociado a los botones de eliminar y editar creados mediante código y que son añadidos al GridView en uso, para ello, proceda a digitar el

siguiente código.

protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e) { int index = Convert.ToInt32(e.CommandArgument); GridViewRow filaSeleccionada = GridView1.Rows[index]; TableCell celdaIdProducto = filaSeleccionada.Cells[2]; if(e.CommandName == "Seleccionar") { Response.Redirect("EditarRegistro.aspx?ProductID=" + celdaIdProducto.Text); }else if(e.CommandName == "Eliminar") { nuevaConexion = new ConexionDesconectada(); nuevaConexion.CopiarBaseDatos(); if(nuevaConexion.EliminarProducto(int.Parse(celdaIdProducto.Text)) < 1) { ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "error_msg", "alert('Error al eliminar el registro seleccionado');", true); } else { nuevaConexion.Desconectar(); Response.Redirect("Default.aspx"); } }

}

12. Ahora, lo único que nos resta es enlazar dichos eventos con el grid original, para ello, ubíquese en la página Default.aspx en la vista de código y añada los siguientes atributos AL GRIDVIEW, tal y como se mostrará en la figura. Luego proceda a

ejecutar la página nuevamente y verifique la paginación de la tabla, así como también

si es posible eliminar un registro de los mostrados en la tabla.

<asp:GridView ID="GridView1" Width="100%" CssClass="alt" runat="server" OnPageIndexChanging="GridView1_PageIndexChanging"

OnRowCommand="GridView1_RowCommand"></asp:GridView>

13. Ahora, en la vista de diseño, de doble clic al botón de buscar para que se cree el respectivo método de OnClick asociado al botón, y luego proceda a digitar el siguiente código.

protected void btnBuscar_Click(object sender, EventArgs e) { nuevaConexion = new ConexionDesconectada(); nuevaConexion.CopiarBaseDatos(); nuevaConexion.CargarProductosEnTabla(ref GridView1, ddlCategorias.SelectedValue, ddlProveedor.SelectedValue); nuevaConexion.Desconectar();

}

Proceda a ejecutar nuevamente la página y realice cambios en los filtros de búsqueda para determinar el funcionamiento del mismo.

14. Ahora, cree un nuevo WebForm con el nombre de “EditarRegistro.aspx” y añada el siguiente

código.

<html> <head> <title>Edición de Producto</title> <meta http-equiv="content-type" content="text/html; charset=utf-8" />  <script src="js/jquery.min.js"></script> <script src="js/jquery.scrolly.min.js"></script> <script src="js/jquery.dropotron.min.js"></script> <script src="js/jquery.scrollex.min.js"></script> <script src="js/skel.min.js"></script> <script src="js/skel-layers.min.js"></script> <script src="js/init.js"></script> <noscript> <link rel="stylesheet" href="css/skel.css" /> <link rel="stylesheet" href="css/style.css" /> <link rel="stylesheet" href="css/style-xlarge.css" /> </noscript>   </head> <body>  <header id="header" class="skel-layers-fixed"> <h1 id="logo"><a href="/">Página Principal</a></h1> </header> <style> .pager table { width: auto !important; } </style>  <div id="main" class="wrapper style1">

<div class="container">  <section> <form id="form1" runat="server"> <section> <h3>Edición de Registros</h3> <div class="row uniform 50%"> <asp:HiddenField ID="ProductID" runat="server" /> <div class="6u 12u$(xsmall)"> <asp:Label runat="server" Text="Nombre de Producto"></asp:Label> <asp:TextBox ID="ProductName" runat="server"></asp:TextBox> </div> <div class="6u 12u$(xsmall)"> Proveedor <div class="select-wrapper"> <asp:DropDownList ID="SupplierID" runat="server"></asp:DropDownList></div> </div> <div class="6u 12u$(xsmall)"> Categoría <div class="select-wrapper"> <asp:DropDownList ID="CategoryID" runat="server"></asp:DropDownList></div> </div> <div class="6u 12u$(xsmall)"> <asp:Label runat="server" Text="Cantidad por Unidad"></asp:Label> <asp:TextBox ID="QuantityPerUnit" runat="server"></asp:TextBox> </div> <div class="6u 12u$(xsmall)"> <asp:Label runat="server" Text="Precio Unitario"></asp:Label> <asp:TextBox ID="UnitPrice" runat="server"></asp:TextBox> </div> <div class="6u 12u$(xsmall)"> <asp:Label runat="server" Text="Existencias"></asp:Label> <asp:TextBox ID="UnitsInStock" runat="server"></asp:TextBox> </div> <div class="6u$ 12u$(xsmall)"> <asp:Label runat="server" Text="Unidades Ordenadas"></asp:Label> <asp:TextBox ID="UnitsOnOrder" runat="server"></asp:TextBox> </div> <div class="2u 12u$(xsmall)"> <br /> <asp:Button OnClientClick="return confirm('¿Desea proceder con la actualización del registro?');" ID="btnModificar" runat="server" Text="Actualizar" Width="100%" CssClass="special" /> </div> </div> </section> </form> </section> </div>

</div>  <footer id="footer"> <ul class="icons"> <li><a href="#" class="icon alt fa-twitter"><span class="label">Twitter</span></a></li> <li><a href="#" class="icon alt fa-facebook"><span class="label">Facebook</span></a></li> <li><a href="#" class="icon alt fa-envelope"><span class="label">Email</span></a></li> </ul> <ul class="copyright"> <li>© 2018. All rights reserved.</li> </ul> </footer> </body>

</html>

15. En la página de código subyacente, agregue una nueva variable de tipo “ConexionDesconectada” que corresponde a la clase que creamos anteriormente. El nombre de la variable debe ser “nuevaConexion”.

16. En el evento “Page_Load”, proceda a digitar el siguiente código, verifique además como se

declaró la variable del punto anterior, posterior a ello, proceda a ejecutar su página y observe lo que se carga en el navegador.

ConexionDesconectada nuevaConexion; protected void Page_Load(object sender, EventArgs e) { nuevaConexion = new ConexionDesconectada(); if (!Page.IsPostBack) { nuevaConexion.CopiarBaseDatos(); nuevaConexion.LlenarCombo(ref CategoryID, "Categories", "categoryID", "CategoryName"); nuevaConexion.LlenarCombo(ref SupplierID, "Suppliers", "SupplierID", "CompanyName"); object[] datosRetornados = nuevaConexion.GetDataRow(int.Parse(Request.QueryString["ProductID"])); nuevaConexion.Desconectar(); if(datosRetornados != null) { ProductID.Value = datosRetornados[0].ToString(); ProductName.Text = datosRetornados[1].ToString(); SupplierID.SelectedValue = datosRetornados[2].ToString(); CategoryID.SelectedValue = datosRetornados[3].ToString(); QuantityPerUnit.Text = datosRetornados[4].ToString(); UnitPrice.Text = datosRetornados[5].ToString(); UnitsInStock.Text = datosRetornados[6].ToString(); UnitsOnOrder.Text = datosRetornados[7].ToString(); } } }



17. Ahora, en la vista de diseño, de doble clic al botón de buscar para que se cree el respectivo método de OnClick asociado al botón de modificar, y luego proceda a digitar el siguiente código.

protected void btnModificar_Click(object sender, EventArgs e) { nuevaConexion = new ConexionDesconectada(); nuevaConexion.CopiarBaseDatos(); object[] datosActualizados = new object[7] { ProductName.Text, SupplierID.SelectedValue, CategoryID.SelectedValue, QuantityPerUnit.Text, UnitPrice.Text, UnitsInStock.Text, UnitsOnOrder.Text }; int filasActualizadas = nuevaConexion.ActualizarProducto(int.Parse(ProductID.Value.ToString()), datosActualizados); nuevaConexion.Desconectar(); if (filasActualizadas > 0) { Response.Redirect("Default.aspx"); } else { ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "error_msg", "alert('Error al actualizar los datos ingresados. Verifique que la información ingresada es corrcta el registro seleccionado');", true); }

}

18. Proceda a ejecutar la página Default.aspx y luego seleccione un registro para editar, modifique algún dato y posteriormente guarde los cambios.



Ejercicio #3 – Creación de conexión desde Visual Studio con el origen de datos

1. Con la conexión creada en el ejercicio anterior, despliegue el listado de tablas y corrobore

que posee las tres tablas de la base de datos.

2. Agregue un nuevo archivo al proyecto. El tipo de archivo a adicionar será una “Clase de LINQ to SQL”, la cual deberá ubicar dentro del nodo de C#. Colóquele como nombre

“LinqDB.dbml”. Guíese por la siguiente figura.

3. Una vez realizado lo anterior, se le deberá desplegar un área de diseño en el cual deberá

construir su esquema de modelamiento.

De la pestaña Explorador de Servidores, expanda la nueva conexión creada en el paso anterior

hasta ubicar y abrir la carpeta Tables.



4. Arrastre una a una a todas las tablas del nodo al espacio de trabajo al centro. Observe el resultado en la siguiente imagen:

Deberá observar que se ha realizado un esquema de la base de datos, y con ello, se han generado una

clase por cada una de las tablas que se encuentran en el diseñador.

Además, verifique sin modificar, el contenido del archivo “LinqDB.designer.cs”.

Una vez hecho esto, podemos examinar el visor de clases, y veremos que se han añadido las siguientes

clases a nuestro proyecto:

Una clase DataContext - Que representa el contexto de la conexión.

Una clase por cada tabla que hayamos seleccionado. Cada clase tendrá una propiedad por cada

campo de la tabla a la que representa.

Ahora, procederemos con la programación de la implementación de las clases antes creadas.

Cree una nueva clase con el nombre “PruebaLINQ.cs”. Esta clase es la que se encargara de la manipulación de la tabla de productos. Agregue la referencia al espacio de nombres System.Web.UI.WebControls:

using System.Web.UI.WebControls;

5. Luego redactar el siguiente código dentro de la definición de la clase PruebaLINQ. public class PruebaLINQ { LinqDBDataContext dc = new LinqDBDataContext();



public int agregarProducto(string nombreProducto, int proveedor, int categoria, string cantidadPorUnidad, decimal precio, short unidadesStock, short unidadesOrdenadas) { Products nuevoProducto = new Products(); nuevoProducto.ProductName = nombreProducto; nuevoProducto.SupplierID = proveedor; nuevoProducto.CategoryID = categoria; nuevoProducto.QuantityPerUnit = cantidadPorUnidad; nuevoProducto.UnitPrice = precio; nuevoProducto.UnitsInStock = unidadesStock; nuevoProducto.UnitsOnOrder = unidadesOrdenadas; dc.Products.InsertOnSubmit(nuevoProducto); dc.SubmitChanges(); return nuevoProducto.ProductID; } public Products obtenerProductoPorID(int ID) { var producto = from tableProduct in dc.Products where tableProduct.ProductID == ID select tableProduct; if (producto.Count() > 0) return producto.First(); else return null; } public bool actualizarProducto(int ID, string nombreProducto, int proveedor, int categoria, string cantidadPorUnidad, decimal precio, short unidadesStock, short unidadesOrdenadas) { var queryActualiza = from registroActualiza in dc.Products where registroActualiza.ProductID == ID select registroActualiza; foreach (Products Producto in queryActualiza) { Producto.ProductName = nombreProducto; Producto.SupplierID = proveedor; Producto.CategoryID = categoria; Producto.QuantityPerUnit = cantidadPorUnidad; Producto.UnitPrice = precio; Producto.UnitsInStock = unidadesStock; Producto.UnitsOnOrder = unidadesOrdenadas; } try { dc.SubmitChanges(); return true; } catch (Exception e) { Console.WriteLine(e); return false; } }

}

6. Ahora, agregue una nueva página con el nombre “AgregarRegistroLINQ.aspx”. Proceda a

ingresar el siguiente marcado (reemplazando al segmento <html> inicial).

<html> <head> <title>Bolsa de Trabajo en Línea - Universidad Don Bosco</title> <meta http-equiv="content-type" content="text/html; charset=utf-8" />  <script src="js/jquery.min.js"></script> <script src="js/jquery.scrolly.min.js"></script> <script src="js/jquery.dropotron.min.js"></script> <script src="js/jquery.scrollex.min.js"></script> <script src="js/skel.min.js"></script> <script src="js/skel-layers.min.js"></script> <script src="js/init.js"></script> <noscript> <link rel="stylesheet" href="css/skel.css" /> <link rel="stylesheet" href="css/style.css" /> <link rel="stylesheet" href="css/style-xlarge.css" /> </noscript>   </head> <body>  <header id="header" class="skel-layers-fixed"> <h1 id="logo"><a href="/">Página Principal</a></h1> </header> <style> .pager table { width: auto !important; } </style>  <div id="main" class="wrapper style1"> <div class="container">  <section> <form id="form1" runat="server"> <section> <h3>Edición de Registros</h3> <div class="row uniform 50%"> <asp:HiddenField ID="ProductID" runat="server" /> <div class="6u 12u$(xsmall)"> <asp:Label ID="Label1" runat="server" Text="Nombre de Producto"></asp:Label> <asp:TextBox ID="ProductName" runat="server"></asp:TextBox> </div> <div class="6u 12u$(xsmall)"> Proveedor <div class="select-wrapper"> <asp:DropDownList ID="SupplierID" runat="server"> </asp:DropDownList> </div> </div> <div class="6u 12u$(xsmall)"> Categoría <div class="select-wrapper">

<asp:DropDownList ID="CategoryID" runat="server"> </asp:DropDownList> </div> </div> <div class="6u 12u$(xsmall)"> <asp:Label ID="Label2" runat="server" Text="Cantidad por Unidad"></asp:Label> <asp:TextBox ID="QuantityPerUnit" runat="server"></asp:TextBox> </div> <div class="6u 12u$(xsmall)"> <asp:Label ID="Label3" runat="server" Text="Precio Unitario"></asp:Label> <asp:TextBox ID="UnitPrice" runat="server"></asp:TextBox> </div> <div class="6u 12u$(xsmall)"> <asp:Label ID="Label4" runat="server" Text="Existencias"></asp:Label> <asp:TextBox ID="UnitsInStock" runat="server"></asp:TextBox> </div> <div class="6u$ 12u$(xsmall)"> <asp:Label ID="Label5" runat="server" Text="Unidades Ordenadas"></asp:Label> <asp:TextBox ID="UnitsOnOrder" runat="server"></asp:TextBox> </div> <div class="2u 12u$(xsmall)"> <br /> <asp:Button OnClientClick="return confirm('¿Desea agregar un nuevo registro?');" ID="btnAgregar" runat="server" Text="Agregar" Width="100%" CssClass="special" /> </div> </div> </section> </form> </section> </div> </div>  <footer id="footer"> <ul class="icons"> <li><a href="#" class="icon alt fa-twitter"> <span class="label">Twitter</span></a></li> <li><a href="#" class="icon alt fa-facebook"> <span class="label">Facebook</span></a></li> <li><a href="#" class="icon alt fa-envelope"> <span class="label">Email</span></a></li> </ul> <ul class="copyright"> <li>© 2015. All rights reserved.</li> </ul> </footer> </body>

</html>



7. Ahora programara el evento PageLoad de la pagina anterior. Para ello, ubique dicho método y

digite el siguiente código.

Recuerde que antes de este método PageLoad se ha agregado una variable de tipo “conexion”

(ya vista en la guía 4)

ConexionDesconectada nuevaConexion; protected void Page_Load(object sender, EventArgs e) { nuevaConexion = new ConexionDesconectada(); if (!Page.IsPostBack) { nuevaConexion.CopiarBaseDatos(); nuevaConexion.LlenarCombo(ref CategoryID, "Categories", "CategoryID", "CategoryName"); nuevaConexion.LlenarCombo(ref SupplierID, "Suppliers", "SupplierID", "CompanyName"); nuevaConexion.Desconectar(); } }

8. Ahora, procederemos a programar el evento click del botón de agregar, para ello digite el

siguiente código.

protected void btnAgregar_Click(object sender, EventArgs e) { PruebaLINQ obj = new PruebaLINQ(); int IdProductoInsertado = obj.agregarProducto(ProductName.Text, int.Parse(SupplierID.SelectedValue.ToString()), int.Parse(CategoryID.SelectedValue.ToString()), QuantityPerUnit.Text, Decimal.Parse(UnitPrice.Text.ToString()), short.Parse(UnitsInStock.Text.ToString()), short.Parse(UnitsOnOrder.Text.ToString())); if (IdProductoInsertado != 0) { Response.Redirect("Default.aspx"); } else { ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "error_msg", "alert('Error al registrar producto. Verifique la información ingresada es correcta');", true); }

}



9. Modifique el evento PageLoad de la página “EditarOferta.aspx” (creada en el ejercicio anterior) y actualice dicho método con el siguiente código.

nuevaConexion = new ConexionDesconectada(); PruebaLINQ obj = new PruebaLINQ(); if (!Page.IsPostBack) { nuevaConexion.CopiarBaseDatos(); nuevaConexion.LlenarCombo(ref CategoryID, "Categories", "categoryID", "CategoryName"); nuevaConexion.LlenarCombo(ref SupplierID, "Suppliers", "SupplierID", "CompanyName"); nuevaConexion.Desconectar(); Products producto = obj.obtenerProductoPorID(int.Parse(Request.QueryString["ProductID"])); if (producto != null) { ProductID.Value = producto.ProductID.ToString(); ProductName.Text = producto.ProductName.ToString(); SupplierID.SelectedValue = producto.SupplierID.ToString(); CategoryID.SelectedValue = producto.CategoryID.ToString(); QuantityPerUnit.Text = producto.QuantityPerUnit.ToString(); UnitPrice.Text = producto.UnitPrice.ToString(); UnitsInStock.Text = producto.UnitsInStock.ToString(); UnitsOnOrder.Text = producto.UnitsOnOrder.ToString(); }

}

10. Y finalmente modifique el código de implementación del botón de actualización. Proceda a

digitar el siguiente código.

PruebaLINQ obj = new PruebaLINQ(); if (obj.actualizarProducto(int.Parse(ProductID.Value), ProductName.Text, int.Parse(SupplierID.SelectedValue.ToString()), int.Parse(CategoryID.SelectedValue.ToString()), QuantityPerUnit.Text, Decimal.Parse(UnitPrice.Text.ToString()), short.Parse(UnitsInStock.Text.ToString()), short.Parse(UnitsOnOrder.Text.ToString()))) { Response.Redirect("Default.aspx"); } else { ScriptManager.RegisterStartupScript(this.Page, this.Page.GetType(), "error_msg", "alert('Error al actualizar los datos ingresados. Verifique que la información ingresada es corrcta el registro seleccionado');", true);

}



11. Modifique en la sección de header, del webform “Default.aspx y actualice la propiedad href, como se me muestra en la siguiente imagen:

12. Proceda a ejecutar la página Default.aspx y luego seleccione un registro para editar, modifique algún dato y posteriormente guarde los cambios. Pruebe además agregando un nuevo

producto.

IV. Análisis de Resultados

1. Modifique la opción de eliminar para que la eliminación de registros se haga por medio del acceso con LINQ.

2. Investigue como llenar el GridView mediante datos recuperados con el acceso LINQ.

V. BIBLIOGRAFÍA

Thierry GROUSSARD. (2013). C# 5: Los fundamentos del lenguaje – Desarrollar con Visual Studio 2012

. Barcelona: ENI.

FACULTAD INGENIERIA COORDINACION DE COMPUTACIÓN › udb_files › recursos_guias ›...

Documents

Transcript of FACULTAD INGENIERIA COORDINACION DE COMPUTACIÓN › udb_files › recursos_guias ›...