En VS JavaScript y Bootstrap
En VS JavaScript y Bootstrap
con
ASP.NET es un entorno para aplicaciones web desarrollado y comercializado por Microsoft. Los programadores
o también diseñadores pueden utilizar este framework para construir sitios web dinámicos, aplicaciones web y
servicios web. Apareció en enero de 2002 con la versión 1.0 del .NET Framework, y es la tecnología sucesora
de la tecnología Active Server Pages (ASP). ASP.NET está construido sobre el Common Language Runtime,
permitiendo a los programadores escribir código ASP.NET usando cualquier lenguaje admitido por el .NET
Framework.
El primer conjunto de controles de ASP.NET se conoce como controles HTML. Dichos controles están definidos
en el espacio de nombres System.Web.UI.HtmlControls y derivan, directa o indirectamente, de la clase base
HtmlControl.
De forma predeterminada, el servidor no tiene acceso a los elementos HTML de una página web
ASP.NET, lo cual supone que simplemente sean tratados como código de formato que se pasa al explorador.
Por ejemplo:
Sin embargo, si se agrega un atributo id y el atributo runat="server", ASP.NET reconoce los elementos
como controles en la página y se pueden programar mediante código basado en el servidor. Por ejemplo, el
siguiente código HTML crea un objeto HtmlInputText llamado Text1:
Este control, a diferencia del anterior, admitiría código como el de la línea siguiente, que se ejecutaría
en el servidor por ser visible en él como un objeto de una clase exponiendo los atributos HTML como
propiedades:
string s = Text1.Value.ToString();
La siguiente tabla lista los controles HTML y las etiquetas HTML a los que corresponden:
Estos controles son útiles para guardar la compatibilidad con ASP, facilitando la transferencia de
páginas ASP existentes a páginas ASP.NET.
I.S.C. Martín García Martínez 3
ASP.NET / Bootstrap
Controles de servidor web
El otro conjunto de controles de servidor de ASP.NET se conoce como controles de servidor web. Dichos
controles están definidos en el espacio de nombres System.Web.UI.WebControls y derivan, directa o
indirectamente, de la clase base WebControl.
En este grupo se incluyen controles con formato tradicional, como TextBox y Button, y controles con un nivel
de abstracción mayor como Calendar, GridView, ListView o EntityDataSource. Los controles web simplifican
los esfuerzos de desarrollo porque:
El modelo de objeto, de tipos muy estrictos, implementado por estos componentes ayuda a reducir los
errores de programación. La clase base WebControl implementa las propiedades comunes a todos los
controles.
Detectan automáticamente las funciones del cliente web (por ejemplo, Microsoft Internet Explorer) y
así el usuario puede personalizar su procesamiento para aprovechar al máximo dichas funciones.
En una página web ASP.NET, cualquier propiedad de un control se puede enlazar a datos. Además,
existen varios controles web que se pueden usar para procesar el contenido de un origen de datos.
Los controles web aparecen en el formato HTML como etiquetas de espacios de nombres; es decir, etiquetas
con un prefijo. El prefijo se usa para asignar la etiqueta al espacio de nombres del componente durante la
ejecución, y el resto de la etiqueta es el nombre de la clase. Al igual que los controles HTML, estas etiquetas
deben contener un atributo runat="server". A continuación, se muestra un ejemplo de declaración:
El resto de este apartado describe otros controles web de uso bastante común.
<asp:TextBox ID="CajaTexto1"
runat="server">Caja de texto </asp:TextBox>
La propiedad TextMode de un TextBox vale, por omisión, SingleLine (una sola línea). Otros valores que
puede tomar esta propiedad son MultiLine (múltiples líneas) y Password (muestra asteriscos).
CheckBox. Utilizando varias casillas de verificación, se puede proporcionar un conjunto de opciones de las que
se pueden elegir varias.
Una alternativa a las casillas de verificación es la utilización del control CheckBoxList que se indica a
continuación:
RadioButton. Utilizando varios botones de opción, se puede proporcionar un conjunto de opciones que se
excluyen mutuamente.
Obsérvese la propiedad GroupName de los RadioButton; tiene el mismo valor: Grupo1. De esta forma se
indica que ambos controles pertenecen al mismo grupo; así, cuando se selecciona uno, el que lo estaba deja
de estarlo. La propiedad Checked de un RadioButton vale, por omisión, false.
Una alternativa a los botones de opción es la utilización del control RadioButtonList que se indica a
continuación:
ListBox. Permite a los usuarios seleccionar uno o más elementos de una lista predefinida.
DropDownList. Es igual que ListBox, excepto en que ahora la lista de elementos permanece oculta hasta que
los usuarios hacen clic en el botón que la despliega. Además, este control no admite el modo de selección
múltiple.
<asp:DropDownList ID="ListaDesp1"
runat="server">
<asp:ListItem Value="1">Elemento 1
</asp:ListItem>
<asp:ListItem Value="2">Elemento 2
</asp:ListItem>
</asp:DropDownList>
LinkButton. De manera predeterminada, un control LinkButton es un botón de envío, aunque se puede crear
también un botón de órdenes (propiedades CommandName y CommandArgument).
ImageButton. Este control también puede ser empleado para enviar páginas. Se procesa como una imagen y
puede proporcionar las coordenadas (x, y) del clic del usuario. Si lo que se necesita solo es mostrar imágenes
en la página web, puede utilizarse también el control Image.
Exploración
HyperLink.Permite crear vínculos en una página web para que los usuarios puedan moverse por las páginas de
una aplicación. La ventaja de estos controles es que permiten establecer las propiedades de los vínculos en el
servidor.
Table. Este control, junto con los controles asociados TableRow y TableCell, permite crear tablas y diseños
tabulares.
Selección de fechas
Calendar. Se utiliza para poder explorar fechas y hacer selecciones de fechas, incluyendo rangos de fechas.
<asp:Calendar ID="Calendar1"
runat="server"
...
</asp:Calendar>
Controles de validación
Los controles de validación simplifican la tarea de validar las entradas del usuario. Generan automáticamente
un script para el cliente para que los exploradores de nivel superior ejecuten validaciones en la máquina del
usuario antes de una devolución, originando páginas de mayor interactividad y facilidad. Al mismo tiempo,
funcionan de forma idéntica en el servidor como mecanismo de arranque tras un error. A continuación, se
indica cuáles son estos controles:
RequiredFieldValidator. Sirve para garantizar que el usuario rellena los controles de entrada de datos
que requieren una entrada.
RangeValidator. Se emplea para comprobar que la entrada del usuario está dentro del rango válido de
valores. Esta opción es útil en las entradas numéricas o de fechas.
CompareValidator. Sirve para comprobar la entrada en un control respecto a la de otro.
RegularExpressionValidator. Permite comprobar la entrada de datos del usuario. Para ello emplea
como criterio una expresión regular (o un modelo de cadenas).
CustomValidator. Permite proporcionar una lógica personalizada de validación de cliente y de
servidor.
ValidationSummary. Proporciona un resumen de los mensajes de error producidos por todos los
controles de validación.
La propiedad CausesValidation del control que origina la petición al servidor tiene que valer true.
Primero se va a diseñar un pequeño formulario simulando un Sign-in con datos estáticos, es decir son
interacción a base de datos, para esto se va a seleccionar en el menú la opción Archivo - Nuevo - Proyecto.
En la siguiente ventana se va a buscar seleccionar trabajar con una aplicación asp.net c#. Vacía para programar
en C#, una vez seleccionada dar doble click sobre esta.
Después aparecerá una ventana como la siguiente, en esta ventana se seleccionará la opción Vacio y después
dar click en el botón Crear.
Así en la siguiente ventana se seleccionarán las opciones Web Foms – Formulario Web Forms y se asignará el
nombre al archivo, por último, se dará click en el botón Agregar.
Antes de empezar a diseñar es recomendable instalar las siguientes extensiones por medio del menú
Extensiones – Administrar Extensiones (Se recomienda instalar todas las extensiones relacionadas con
Bootstrap y HTML 5).
Al haber reiniciado el proyecto ahora se va a insertar de forma precompilada los archivos de Bootstrap para
eso iremos a su página oficial y los descargaremos.
Para eso nos vamos a la página oficial de jQuery, Ya que se tiene la página se dará click en el botón de
Download jQuery.
Ya que se ha dado click en el enlace de Download the compressed, production jQuery 3.5.1 se abrirá una
página como la que se muestra a continuación, en esta página se dará click derecho al ratón y después se
seleccionará la opción de Guardar como…
Ya que la hemos arrastrado al nombre del proyecto Capa de presentación, nos cercioramos que efectivamente
se ha agregado al Explorador de soluciones.
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
</div>
</form>
</body>
</html
Ahora para empezar a incluir ejemplos propios de Bootstrap y trabajar sobre ellos, nos vamos nuevamente a la
página oficial de Bootstrap y seleccionamos el menú Ejemplos.
Abriremos el archivo descomprimido y buscaremos la carpeta sign-in este tipo de archivo hace referencia a un
formulario de registro tipo Login.
C:\Users\Martin\Documents\ASP.NET\SistemaWebClinica\Capa de presentación\bootstrap-4.5.2-dist\css
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
</div>
</form>
</body>
</html>
Pegándolo y remplazándolo por el cuerpo de nuestro código que tenemos en el entorno de visual
estudio .NET. de igual forma a partir del body.
Para poder interactuar directamente con el formulario sign-in de Bootstrap debemos validar sus controles
para que los tome nativos de C# (declarándolo mediante la instrucción asp:TextBox) dentro del entorno
Visual Studio .NET. eso lo haremos sustituyendo las líneas de código de las cajas de texto.
Por
Por
Por
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body class="text-center">
<form class="form-signin">
<img class="mb-4" src="../assets/brand/bootstrap-solid.svg" alt="" width="72"
height="72">
<h1 class="h3 mb-3 font-weight-normal">Please sign in</h1>
<label for="inputEmail" class="sr-only">Email address</label>
<form id="form1" runat="server">
<asp:TextBox ID="txtUsuario" runat="server" class="form-control"
placeholder="Ingresa el usuario" required autofocus></asp:TextBox>
<label for="inputPassword" class="sr-only">Password</label>
<asp:TextBox type="password" ID="txtPass" runat="server" class="form-control"
placeholder="Ingresa el password" required autofocus></asp:TextBox>
<div class="checkbox mb-3">
<label>
<input type="checkbox" value="remember-me"> Remember me
</label>
</div>
<asp:Button ID="btnIngresar" runat="server" Text="Iniciar sesion" class="btn btn-lg
btn-primary btn-block" OnClick="btnIngresar_Click"/>
<p class="mt-5 mb-3 text-muted">© 2017-2020</p>
</form>
</body>
</html>
Ahora daremos click sobre el botón Diseño que se encuentra en la parte inferior.
Nótese como inmediatamente estas acciones nos envía a entorno de desarrollo de C#.
Basado en el la página anterior referente al formulario de registro se modificará un poco el diseño del mismo
añadiendo una caja de texto para realizar una operación básica de suma de dos números.
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body class="text-center">
<form class="form-signin">
<img class="mb-4"
src="https://i.pinimg.com/originals/24/6e/2b/246e2bd91a8111a822f33a911ce0c8b3.jpg"
alt="" width="72" height="72">
<h1 class="h3 mb-3 font-weight-normal">Suma de dos numeros</h1>
<label>
</html>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace Capa_de_presentacion
{
public partial class Login : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
txtres.Text = total.ToString();
}
}
}
Para poder añadir componentes de la página Oficial de Bootstrap obviamente vamos a ir a la página oficial
dentro del menú Documentación.
En desarrollo web con tecnología Microsoft es ampliamente manejado, para entender mejor veamos que es el
postback en ASP.Net.
El postback hace posible la comunicación entre el cliente con el servidor en la ejecución de eventos.
Por lo tanto, cuando inicias un evento se ejecuta el Page_Load, provocando el reinicio de la página.
Por esta razón en muchas aplicaciones web, se realiza una validación que posiblemente haz visto, IsPostBack.
IsPostBack
Es una variable de tipo bool para identificar si la página ha sido cargada por primera vez o es una recarga.
Prácticamente evita que la información se elimine de la página y cargue solo la información que será
actualizada.
Dentro del Page_Load del archivo C# de una página aspx, debemos de colocar un validador como lo siguiente.
Sin embargo, en una página todo el contenido se carga en la primera ejecución, por lo tanto, debemos hacer lo
siguiente.
Con el símbolo (!) invertimos el valor booleano del postback, por lo tanto, si inicia en false se convierte en
True.
En la primera ejecución se carga toda la página, en la segunda solo los datos de actualización.
De esta manera evitamos descargar todo el contenido de la página en cada acción en el formulario.
Haciendo que la página tenga un mejor rendimiento y evitando utilizar mucha memoria para guardar
información.
El ViewState (ver estado) de una página ASP.NET es lo que permite la "magia" de los PostBack. Se trata de un
campo oculto que se envía con el formulario que introduce ASP.NET en todas las páginas ASPX y contiene
información sobre el estado de los controles de la misma.
Para este ejercicio vamos a tener agregados dos controles uno referente a un textBox de texto y el otro a un
Button.
El control Textbox se va a declarar en la propiedad ID con el nombre de txtConteo y el Button con el nombre
de btnIncrementa en la propiedad ID y en la propiedad Text con el nombre de Incrementar, debiéndose de ver
como se muestra a continuación en la parte de la su estructura.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace ViewState
{
public partial class Incrementa : System.Web.UI.Page
{
// ViewState nos permite preservar los datos entre requests (solicitud)
// El ViewState viaja con la petición y la respuesta, de esa manera se
conserva el dato
// Tenemos que colocar el nombre de la variable para el ViewState
// Sin no se ha usado previamente tiene el valor null
// Cuando lo leamos es importante hacer el typecast correspondiente
// Actualizamos el textbox
txtConteo.Text = conteo.ToString();
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace ViewState
{
public partial class Incrementa : System.Web.UI.Page
{
// Los controles ASP.NET usan internamente a viewstate para guardar su estado
// Pero eso no nos quita de la responsabilidad de guardar los datos.
// correctamente en el viewstate
}
}
}
En este ejercicio veremos lo que son Variables de aplicación, Envió de respuesta y No usar cookies, lo primero
que haremos será inicial un proyecto a nivel de Windows Forms.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace WebApplication1
{
public partial class WebForm1 : System.Web.UI.Page
{
Dando doble click sobre el archivo Global.asax.cs nos va a llevar al siguiente documento, Este documento va a
servir para llevar a cabo todo ese tipo de acciones que nos interesan que sucedan a nivel de aplicación como
tal.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Optimization;
using System.Web.Routing;
I.S.C. Martín García Martínez 51
ASP.NET / Bootstrap
using System.Web.Security;
using System.Web.SessionState;
namespace WebApplication1
{
public class Global : HttpApplication
{
// Este handler se ejecuta cuando se crea una instanca de la aplicacion.
void Application_Start(object sender, EventArgs e)
{
// Código que se ejecuta al iniciar la aplicación
// RouteConfig.RegisterRoutes(RouteTable.Routes);
// BundleConfig.RegisterBundles(BundleTable.Bundles);
// Incrementamos
Application["Aplicaciones"] = (int)Application["Aplicaciones"] + 1;
}
}
}
Después de haber terminado con estas líneas de código del archivo Global.asax.cs, dentro del Explorador de
soluciones seleccionaremos el archivo WebForm1.aspx y correremos nuestra aplicación (esto dentro del
explorador de chrome).
Ahora si abrimos la sesión con otro navegador, con Microsoft Edge nos percataremos que en Cantidad de
sesiones de usuario es 2, esto sucede porque el navegador Microsoft Edge y Chrome no están compartiendo
el mismo cookie, entonces van a tener sesiones de usuario diferentes
De igual forma si abrimos otro navegador en este caso Firefox, al ser otro cookie este tendrá la misma
instancia pero en cantidad de usuario dirá 3.
Aquí vamos añadir las siguientes líneas de código debajo de la instruccion <compilation debug="true"
targetFramework="4.7.2"/>, las líneas de código serán las siguiente.
<httpRuntime targetFramework="4.7.2"/>
<pages>
<namespaces>
<add namespace="System.Web.Optimization"/>
</namespaces>
<controls>
<add assembly="Microsoft.AspNet.Web.Optimization.WebForms"
namespace="Microsoft.AspNet.Web.Optimization.WebForms" tagPrefix="webopt"/>
</controls>
</pages>
</system.web>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Antlr3.Runtime" publicKeyToken="eb42632606e9261f"/>
<bindingRedirect oldVersion="0.0.0.0-3.5.0.2" newVersion="3.5.0.2"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed"/>
<bindingRedirect oldVersion="0.0.0.0-12.0.0.0" newVersion="12.0.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="WebGrease" publicKeyToken="31bf3856ad364e35"/>
<bindingRedirect oldVersion="0.0.0.0-1.6.5135.21930"
newVersion="1.6.5135.21930"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
<system.codedom>
<compilers>
<compiler language="c#;cs;csharp" extension=".cs"
type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider,
Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=2.0.1.0, Culture=neutral,
PublicKeyToken=31bf3856ad364e35"
warningLevel="4" compilerOptions="/langversion:default
/nowarn:1659;1699;1701"/>
<compiler language="vb;vbs;visualbasic;vbscript" extension=".vb"
type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider,
Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=2.0.1.0, Culture=neutral,
PublicKeyToken=31bf3856ad364e35"
warningLevel="4" compilerOptions="/langversion:default /nowarn:41008
/define:_MYTYPE=\"Web\" /optionInfer+"/>
</compilers>
</system.codedom>
</configuration>
Si abrimos ahí mismo una nueva ventana en el navegador e insertamos esa misma dirección nos aparecerá el
mismo número de instancias con el mismo número de sesión de usuario, pues tiene el mismo número de ID.
Eventos de aplicación, Eventos de ciclo de vida de una página, para este ejemplo deberá iniciarse directamente
como Windows Forms.
Los eventos pueden ocurrir en tres niveles, Nivel de aplicación, Nivel de página, Nivel de control.
Eventos de aplicación
Se usan para inicializar datos que estarán disponibles para todas las sesiones actuales de la aplicación.
Eventos de Sesión
Se usan para inicializar datos que estarán disponibles para la sesión individual en particular.
Se guardar en Global.asax
Application_Start
Application_End
Application_Error
Session_Start
Session_End
Eventos de controles
Después del evento Load y son los eventos de cada control
Unload.-
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace EventosPagina003
{
public partial class WebForm1 : System.Web.UI.Page
{
}
}
El orden en el cual van a ir sucediendo y se van llevando a cabo los diferentes eventos, así es el ciclo de vida de
la página.
La variable de sesión es compartida entre los diferentes WebForm que pertenezcan a la misma sesión.
Una vez que se tenga el diseño se agregara el siguiente código al archivo WebForm1.aspx.
namespace variablesSesion04
{
public partial class WebForm1 : System.Web.UI.Page
{
private int conteo = 1;
protected void Page_Load(object sender, EventArgs e)
{
if (IsPostBack)
{
TxtConteo.Text = "0";
}
if (Session["click"] != null)
{
TxtConteo.Text = ((int)Session["click"]).ToString();
}
}
//Actualizamos el textbox
TxtConteo.Text = conteo.ToString();
Da igual forma este mismo código exactamente el mismo se agregara ahora al WebForm2.aspx junto con el
mismo diseño respecto a los controles igual al WebForm1.
namespace variablesSesion04
{
public partial class WebForm2 : System.Web.UI.Page
{
private int conteo = 1;
protected void Page_Load(object sender, EventArgs e)
{
if (IsPostBack)
{
TxtConteo.Text = "0";
}
if (Session["click"] != null)
{
TxtConteo.Text = ((int)Session["click"]).ToString();
}
}
//Actualizamos el textbox
TxtConteo.Text = conteo.ToString();
Esto significa que la variable de sesión va a ser compartida entre el WebForm1 y WebForm2, es decir si en la
sesión del navegador 1 se incrementa a 4 y si se abre otro navegador 2 y se da click en el botón Incrementar,
Eventos de controles
Ahora en estos ejercicios vamos a ejemplificar los eventos que pueden tener los controles ente los que
veremos los Eventos de PostBack, Eventos Cached y Eventos de Validación, Así como la página, el webform
que tenemos va a tener una serie de eventos, los controles también van a tener sus propios eventos.
Cuando se trabaja con ASP se consideran tres tipos de eventos que pueden suceder con los controles
(PostBack, Eventos Cached y Eventos de Validación)
Para este ejemplo agregaremos un nuevo webform con el nombre que traer por default de WebForm1.
ID lblMensajePB
Text Antes de PostBack
ID lblMensajeCached
Text No ha sucedido el evento
Cached
ID txtChanged
Y al correr el programa.
Al correr el programa y escribir en la caja de texto de Cached nos damos cuenta que este no cambia al escribir
en la caja de texto y no ha cambiado porque ese evento se ha quedao guardado y cuando regrese el webform
es cuando va a suceder.
Ahora para ejemplificar la Validación, vamos a buscar dentro del cuadro de herramientas una seccion que se
llama Validacion y aho vamos agregar un control que se llama RequiredFielValidator.
ID RFVtxtValidacion
ControlToValidate txtValidacion
ErrorMessage Mi mensaje de error
Lo que hace este control de validación es que manda un mensaje de error si el textbox no tiene ningún
contenido, es decir que si el textbox no tiene ningún contenido va a mandar un mensaje de error, en la
propiedad Error Message ahí se puede declarar un mensaje en particular en el cual hemos establecido "Mi
mensaje de error"
TextBox
En este ejercicio veremos algunas de las propiedades más comunes del control TextBox, como son SingleLine,
ToolTip, ReadOnly, MaxLeng, Columns, Rows, MultiLine, Password lo primero que haremos será diseñar la
siguiente página con sus propiedades señaladas.
ID txtSingleLine
ToolTip TextBox de línea
ID txtReadOnly
ReadOnly True
ID txtMaxLeng
MaxLength 5
ID txtColumnas
Columns 5
ID txtPassword
TextMode Password
Una vez que se ha definido el diseño se definirán dos líneas de código que se establecerán desde el archivo
WebForm1.aspx.cs
using System.Web.UI;
using System.Web.UI.WebControls;
namespace Boton06
{
public partial class WebForm1 : System.Web.UI.Page
{
// Las tres formas en las que el textbox se despliega usualmente
// Single, Multiline, Password
// Inicializamos el readonly
txtReadOnly.Text = "Hola a todos";
En esta lección vamos a trabajar con el Radio Button, veremos su uso con una aplicación de ASP.NET,
propiedades más importantes que tiene y también el AutoPostBack.
Se va a iniciar generando una nueva aplicación en para este ejemplo se le pondrá el nombre de RadioBtn07.
Ya que se tiene el Web Form limpio y vacío ahora se agregará el control RadioButton del cuadro de
herramientas, como ya se sabe el RadioButton es un control que va a permitir hacer una selección entre
diferentes opciones, de varias opciones solo una va a poder ser seleccionada, en este ambiente RadioButton
trabaja de una forma muy similar a como trabaja en plataforma de escritorio.
De igual forma se agregarán los siguientes controles con sus respectivas propiedades.
ID rbtnVerduras
GroupName Alimentos
Text Verduras
ID btnProcesa
Text Procesa
Ya que se han declarado las propiedades de los controles ahora se dará click sobre el botón de Procesa para
entrar al su handler en el cual se escribirá el siguiente código.
if (rbtnPizza.Checked == true)
Response.Write("Te recomiendo la hawaiana <br>");
if (rbtnFrutas.Checked == true)
Response.Write("Te recomiendo la manzana <br>");
if (rbtnVerduras.Checked == true)
Response.Write("Te recomiendo espinacas <br>");
}
}
Hasta aquí ya se tiene la primer del programa al correrlo se ejecutará de la siguiente forma.
Al seleccionar la opción Pizza y después al darle click al botón Procesa cambiara la etiqueta de recomendación.
Al seleccionar la opción Frutas y después al darle click al botón Procesa cambiara la etiqueta de
recomendación.
Ahora seguiremos diseñando nuestra página dándole incluyendo más controles como se muestra a
continuación.
Ya que este el diseño se dará click sobre el botón Combustible para así poder ingresar a su handler y codificar.
if (rbtnDiesel.Checked == true)
Response.Write("Tu auto usa diesel <br>");
if (rbtnEtanol.Checked == true)
Response.Write("Tu auto usa etanol <br>");
}
Al correr este programa nos podemos dar cuenta que cada RadioButton trabaja y response de acuerdo al
grupo al que pertenece es decir cuando se da click en el botón Procesa o Combustible este dirá en la etiqueta
que tipo se recomienda o qué tipo de Combustible dirá que tipo de combustible utiliza el vehículo. Esta parte
del ejercicio básicamente muestra la aplicación de dos grupos diferentes de la propiedad GroupName del
RadioButton.
Ahora vamos a trabajar con la propiedad de CheckedChanged para eso nos vamos a las Propiedades y
teniendo seleccionado el control de RadioButton de Gasolina seleccionaremos el botón de Eventos.
Por último, debemos cambiar la propiedad de AutoPostBack a True, esto para que el cambio al seleccionar el
radioButton Gasolina o RadioButton Diesel se haga de forma inmediata en la etiqueta.
CheckBox
En esta lección veremos el CheckBox, veremos la forma más fácil de utilizarlo, sus propiedades más
importantes, y también el uso de AutoPostBack.
El CheckBox es un tipo de botón el cual va a tener dos estados ya se ha marcado o desmarcado, para esto se va
a tener una propiedad que es la propiedad de Checked la cual ya conocemos del RadioButtons, cuando esta
propiedad tiene el valor de True significa que significa que el CheckBox está marcado, y cuando tiene el valor
de False significa que no ha sido marcado, a diferencia del RadioButtons nosotros podemos seleccionar
múltiples CheckBox a la vez, esa es la principal diferencia que se tiene con el RadioButtons.
Ahora se iniciará con el diseño de la interfaz del programa, este programa va a calcular la cantidad a pagar
dependiendo de los CheckBox seleccionados, y deberá quedar de la siguiente forma.
Control: CheckBox
ID ChkQueso
Text Extra queso
Control: CheckBox
ID ChkBebida
Text Bebida
Control: Label
Text Total
Control: Label
ID btnCalcular ID lblTotal
Text Calcular Text $0
Una vez que ya se tiene definido el diseño vamos a entrar al handler del botón Calcular dándole doble click.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace CheckBox
{
public partial class CheckBox : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
if (ChkPapas.Checked == true)
cantidad += 20;
if (ChkBebida.Checked == true)
cantidad += 18;
//Mostrar el total
lblTotal.Text = "$" + cantidad.ToString();
}
}
}
Este programa pretende agregar precio extra a partir de una cantidad a pagar como dato de entrada.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace CheckBox
{
public partial class CheckBox : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
if (ChkPapas.Checked == true)
cantidad += 20;
if (ChkBebida.Checked == true)
cantidad += 18;
//Mostrar el total
lblTotal.Text = "$" + cantidad.ToString();
}
Estos controles nos van a ayudar a tener links o ligas hacia otras páginas ya sean que forme parte de nuestra
aplicación o que sean externas.
Pequeña pero principal diferencia entre HyperLink y LinkButton, la diferencia es sencilla pero muy
importante, mediante el control LinkButton se puede generar código que se ejecuta del lado del cliente, es
decir de lado de la computadora que está viendo ese Web Forms independientemente de ese código que nos
interesa que se ejecute del lado del servidor, ese código que se va a ejecutar del lado del cliente puede estar
escrito en cualquier lenguaje que soporte HTML, para el ejemplo del siguiente ejercicio se va a utilizar
JavaScript (El código de JavaScript se ejecutaría del lado del cliente y el código de c# se ejecutaría del lado del
servidor).
Ahora se iniciará con el diseño de la interfaz del programa, el cual quedará de la siguiente forma.
Control: HyperLink
La propiedad Target con el atributo ID: hlkTres
_blank es la que abrirá la página en NavigateUrl: ~/WebForm2.aspx
otra pestaña Target: _blank
Text: Ir al webform2 Text: Ir a webform2 en otra pestaña
Cabe destacar que una de las formas de establecer la dirección en la propiedad NavigateUrl tratandose de
manejo interno de links es dar click en la parte derecha (…) de la propiedad en donde se abrirá una ventana
para seleccionar con comodidad el Web Forms que se desea abrir.
Control: LinkButton
ID: lkbUno
PostBackUrl: ~/WebForm2.aspx
Text: Ir a webform2
Control: LinkButton
ID: lkbScript
OnClientClick: return Funcion();
PostBackUrl: ~/WebForm2.aspx
Text: Tiene un Script
Se recomienda siempre usar la propiedad Text del control HiperLink ya que, si por alguna razón no jala la
imagen, la propiedad Text mantendrá el vinculo del link.
<script type="text/javascript">
function Funcion() {
alert("Soy una funcion de JavaScript")
return true;
</script>
Lo primero que se va a ser será tener una imagen lista y arrastrarla al explorador de soluciones.
ImageButton
Una vez que se ha agregado el control ImageButton se le agregara la imagen que anteriormente se arrastró al
Explorador de soluciones, mediante su Propiedad ImageUrl.
Como el control ImageButton es un botón, nosotros podemos hacer las cosas que hacemos normalmente con
los botones, por ejemplo, el evento click, entonces, vamos a Propiedades, seleccionamos la lista de Eventos
Como prueba solo escribiremos un mensaje como respuesta al evento click que diga “Botón de imagen”
Response.Write("Botón de imagen");
Una vez que se procede a ejecutar este pequeño programa se dará click en el botón ImageButton y el mensaje
se desplegará como a continuación muestra la siguiente imagen.
Evento Command
Ahora veremos el tema del evento Evento Command, el evento Command es importante porque es un evento
que nos va a permitir tener un Handler que sea utilizado por múltiples controles, es decir, en lugar de tener
que cada botón tenga un Handler, se puede tener un solo Handler que sea compartido por varios botones, y
vamos a trabajar sobre de eso.
ID: txtA
Text: 0 ID: txtB
Text: 0 ID: btnSuma
CommandName: suma
Text: Suma
ID: btnResta
CommandName: resta
Text: Resta
ID: btnMult
CommandName: mult
Text: Mult
ID: btnDiv
CommandName: div
I.S.C. Martín García Martínez Text: Div 95
ASP.NET / Bootstrap
Una vez que ya tenemos nuestras Propiedades de los controles definidos, nos vamos a seleccionar el control
del botón Suma y dentro de la pestaña de Eventos en la Propiedad Command escribiremos operaciones.
Después de haber escrito operación en la propiedad Command daremos doble click sobre la palabra
operaciones para entrar a su Handler, y en dicho Handler escribiremos las siguientes líneas de código, líneas
que representan las operaciones que se ejecutaran de acuerdo al botón que corresponde cada operación.
operaciones
Por medio de CommandName, nosotros podemos saber cuál fue el botón o el control que está haciendo la
invocación al Handler (operaciones), una vez que ya se estableció la opción operaciones en cada uno de los
botones vamos a correr el programa y probaremos cada una de las operaciones.
SUMA RESTA
MULTIPLICACIÓN
DIVISIÓN
Ahora vamos hacer otro ejemplo con Evento Command usando un mismo Handler, pero ahora con
parámetros, para lo que vamos a diseñar una interfaz como la que se ve a continuación.
Ya que está diseñada la interfaz, Cuando usamos el evento Command, no solamente nosotros podemos indicar
por medio de CommandName, cual fue el objeto que está haciendo uso de ese Handler, sino que también
vamos a tener CommandArgument es decir nosotros podemos pasar un parámetro, un argumento junto con
el CommandName.
Mensaje, en la Propiedad
Command
Una vez ya establecida la palabra mensaje en el evento Command del botón Suma vamos a darle enter para
entrar a su Handler y escribir las siguientes líneas de código.
Ya que se tiene todo, las propiedades a cada botón y el Handler compartido, vamos a correr este ejercicio, y
dependiendo del botón que se cliquee se va a colocar un saludo o una despedida ya sea en español o en inglés.
En esta ocasión vamos a trabajar con el DropDownList, es la primera lección en la cual nos enfocamos a este
control, aunque posteriormente vamos a tener otras lecciones.
Que es lo que va hacer esta aplicación, vamos a tener el DropDownList, y el DropDownList nos va a presentar
una lista de opciones de las cuales nosotros podremos hacer una selección, ya que le demos clic al botón de
prueba, vamos a ver que opción selecciono el usuario.
Entonces para eso vamos a ver como nosotros en esta etapa de diseño de WebForm podemos colocar los
elementos al DropDownList
Entonces ahora vamos a ver como nosotros en esta etapa de diseño del WebForm podemos colocar los
elementos al DropDownList, esto lo vamos hacer teniendo seleccionado el control DropDownList, vamos a
buscarle su propiedad Items, Realmente lo que es Items, no es otra cosa más que una colección de elementos
de lista, entonces ahí es donde nosotros vamos a ir colocando cada uno de los elementos que deseamos,
aunque desde luego hay otros mecanismos por medio de los cuales podemos ir colocando esos elementos en
la colección, entonces Items es una colección y ahí van ir los elementos del DropDownList.
Para poder ir agregando los elementos al Editor de la colección ListItem, simplemente vamos ir dando clic al
botón agregar, y al crearse el nuevo elemento, en este nuevo elemento nosotros podemos ir colocando
diferentes propiedades, por ejemplo, en la propiedad del Texto (Text) va a ser el texto que se va a mostrar en
el WebForm. (Lo que se escriba en la Propiedad Text va a ser el valor que desplegara el control DropDownList)
La Propiedad Value es el valor que está relacionado con la base de datos, ahorita no se tiene ninguna
conectividad con la base de datos, por ahora en este ejemplo no se tiene ninguna conectividad con la base de
datos, pero cuando tengamos esa conectividad en Value vamos a tener ese valor relacionado con la base de
datos.
Hasta ahora hemos visto cómo podemos adicionar elementos en forma de diseño y a través del Editor de la
colección ListItem, ahora veremos como ir adicionando elementos de manera programática, es decir mediante
código, para esto tenemos que modificar el código, para esto vamos a dar clic derecho al ratón sobre el diseño
de WebForm1 y aparecerá un menú contextual, en este menú seleccionaremos la opción Ver código.
Ya que estamos situados en el Handler del evento Load, teclearemos las siguientes líneas de código para
*adicionar mas Items desde código, en el evento Load es un buen lugar para adicionar dichos elementos pues
cada que se cargue la pagina ejecutara el código que radica en el evento Load.
El siguiente código adicionara más Items, aparte de los que ya se tienen precargados en el Editor de la
colección ListItem.
ddlFrutas.Items.Add(fresa);
ddlFrutas.Items.Add(naranja);
}
}
En primer lugar se está verificando que no sea un PostBack, ¿porque se verificar esto?, porque se desea que
los elementos nuevos solamente se adicionen una vez, entonces se van adicionar cuando se cargue el
WebForm por primera vez, si no colocamos es if (!IsPostBack) entonces cada vez que se genere el evento
Load (se cargue la página) y se ejecute el Handler pues se va a tener la edición de los nuevos elemento y se
estarán agregando cada que cargue la pagina, es decir se van estar repitiendo, por eso se hace de de esta
manera y se recomienda que siempre que sea el caso se haga de esta forma.
Explicación del código: Esta cuando se crean las instancias de ListItem, que es el elemento que se guarda en la
colección para el DropDownList, entonces se crea un elemento que se llama fresa, y en el constructor se tiene
que colocar el Texto (Text) y el Valor que le corresponde (Value), entonces el Texto va a ser fresa y el valor que
le corresponde va a ser 4, Luego se tiene naranja el Texto va a ser Naranja, y el Value será 5.
Ya que se tienen todos los elementos que se quieren adicionar programáticamente, ahora simplemente se
adicionan al DropDownList, en donde en su propiedad de Item y como Item es una colección se usa el método
Add, por lo tanto, se adiciona el ListItem de Fresa y el ListItem de naranja.
ddlFrutas.Items.Add(fresa);
ddlFrutas.Items.Add(naranja);
Entonces cuando se cargue la pagina por primera vez van a aparecer ellos, al ejecutar el resultado será el
siguiente.
Ahora vamos hacer algo útil como saber cuál es el elemento que selecciono el usuario, ya para esto vamos
hacer uso de nuestro botón y desde luego de nuestras etiquetas, ahora haciendo doble clic en el Botón prueba
entraremos a su Handler y escribiremos el siguiente código.
//blSeleccionado.Text = ddlFrutas.Items[ddlFrutas.SelectedIndex].ToString();
}
}
Aquí vamos a ver la información del elemento seleccionado, tenemos entonces nuestro DropDownList
ddlFrutas, y tenemos también una serie de propiedades que podremos utilizar, si utilizamos las propiedades
del SelectedIndex, se obtiene el índice del elemento que esta seleccionado, luego en la parte de
SelectedValue, este es el valor del elemento seleccionado, obviamente se está leyendo y se coloca el
resultado en la etiqueta de lblValor, ahora si queremos conocer el elemento seleccionado como tal, hacemos
uso nada más del SelectedItem, entonces aquí se obtiene el elemento como tal, el valor de Text y se está
colocando en la etiqueta de lblSeleccionado, Entonces todo esto va a suceder cuando se le dé clic al botón
Prueba.
Vemos que al seleccionar manzana y dando clic al botón Prueba nos aparecerá, Manzana, su índice y su value,
y así se verá reflejado el resultado del índice y valor de cada una de los elementos agregados.
El código comentado es una alternativa en la cual nosotros podemos obtener el elemento, en este caso se
está obteniendo el elemento vía un índice, como al fin y al cabo Item es una coleccion, se puede utilizar un
indice para acceder al elemento en particular, ahora el índice que se desea, será el índice que ha sido
seleccionado por el usuario, por eso se está utilizando ddlFrutas.SelectedIndex como el indice, de esta
manera se llega al elemento que se encuentra en ese índice y ya se puede hacer con él lo que se necesite, en
este caso simplemente se convierte a cadena para poderlo colocar en la etiqueta lblSeleccionado, esta linea
practicamente hace lo mismo, pero lo importante de esta línea es que se puede ver que podemos trabajar con
esa colecciona a través de índices también si es que lo necesitamos y esto va a darle flexibilidad a la lógica que
nosotros necesitemos proveer en nuestras aplicaciones.
En esta lección aprenderemos como podemos rellenar un DropDownList usando los contenidos de un archivo
XML.
Para hacer esto lo primero que debemos hacer es entender otro concepto importante, y es que lo archivos van
a tener un Path, van a tener una ruta física, y también van a tener un Path con una ruta lógica.
Para comenzar lo primero que debemos hacer es adicionar al igual que los ejemplos anteriores nuestro
WebForm1, como vamos hacer que el control este lleno, gracias a los contenidos de un archivo XML,
entonces vamos adicionar DropDownList enseguida adicionaremos un archivo XML.
La forma de adicionar un archivo XML, es muy similar a como se agrega un elemento WebForm, dando click
derecho sobre el nombre de nuestro proyecto en este caso DropDownList_II, posteriormente la opción
Agregar y enseguida la opción Nuevo elemento.
<Fruta>
<FrutaID>2</FrutaID>
<FrutaNombre>Pera</FrutaNombre>
</Fruta>
<Fruta>
<FrutaID>3</FrutaID>
<FrutaNombre>Naranja</FrutaNombre>
</Fruta>
<Fruta>
<FrutaID>4</FrutaID>
<FrutaNombre>Sandia</FrutaNombre>
</Fruta>
</Frutas>
Ahora que sucede si en el Explorador de soluciones, seleccionamos con clic derecho Frutas.xml y le damos Ver
en el Explorador.
Para lo cual tenemos un método que nos va a permitir colocar la ruta de forma adecuada, es decir que vamos
a poder indicar la ruta física que tiene el archivo y la va a traducir para que el servidor pueda tomar la ruta
lógica y no tengamos un problema.
//Necesario
using System.Data;
namespace DropDownList_II
{
public partial class WebForm1 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
DataSet DS = new DataSet();
DS.ReadXml(Server.MapPath("Frutas.xml"));
ddlFrutas.DataSource = DS;
ddlFrutas.DataValueField = "FrutaID";
ddlFrutas.DataTextField = "FrutaNombre";
ddlFrutas.DataBind();
}
Al correr el programa nos mostrara satisfactoriamente el resultado como el que a continuación se muestra en
la siguiente hoja.
DS.ReadXml(Server.MapPath("Frutas.xml"));
DS.ReadXml("Frutas.xml");
Vemos que nos marca una Excepción, la Excepción nos está indicando de que no se pudo encontrar el archivo
FileNotFoundException, esto se debe a que el servidor esta tratando de encontrar esa ruta, pero
realmente no puede poque el servidor esta trabajando con esas rutas lógicas, entonces nosotros tenemos que
llevar a cabo el cambio necesario para que pueda funcionar, para eso nosotros vamos a tener un método que
es el método de MapPath, este método de MapPath realmente lo que va hacer es esa traducción entre la ruta
física a la ruta lógica de tal manera que el servidor lo pueda hacer correctamente.
Para este Handler del evento Load, lo primero que hacemos es adicionar el using System.Data, es
necesario adicionar el using System.Data porque vamos hacer uso de la clase DataSet, y DataSet
necesita de System.Data entonces se crea una instancia de DataSet que se llama DS y ahora si DS y
ahora si DS.ReadXml, aquí estamos usando el método que nos permite leer un Xml y colocar esos
contenidos adentro del DataSet, ahora estamos haciendo uso del Server.MapPath para que la ruta física
quede mapeada a una ruta lógica y no se tenga ningún problema al leerlo, ya que se tiene el DataSet se le
indica al DropDownList que su fuente de datos su DataSource va a ser ese DataSet que leyó el Xml,
entonces aquí se esta conectando el DropDownList al DataSet, entonces el DataSet ya contiene la
información, ahora se tiene que indicar de donde se va a obtener el valor y de donde nosotros vamos a
obtener el Texto, recordemos que el DropDownList tiene una colección de elementos y cada uno de estos
elementos tiene entre sus propiedades una propiedad que es Text y una propiedad que es Value,
ddlFrutas.DataValueField = "FrutaID", ddlFrutas.DataTextField = "FrutaNombre", tal y
como se muestra en el código de nuestro archivo Xml.
<Fruta>
<FrutaID>1</FrutaID>
<FrutaNombre>Manzana</FrutaNombre>
I.S.C. Martín García Martínez 117
ASP.NET / Bootstrap
</Fruta>
FrutaID es el que se va estar usando para Value y FrutaNombre es el que vamos a utilizar para Text,
una vez que ya se tiene todo debidamente configurado es decir el código fuente de Handler del Load, bueno
pues hacemos la parte del DataBind, este DataBind representa la parte del enlace, ya con eso ya va a
poder funcionar correctamente y nuestro DropDownList va a rellenar con la información que tiene el archivo
Xml.
Ahora vamos a ver un poco más acerca de las Rutas, cabe hacer menciona que podemos crear carpetas
dentro de nuestro proyecto, esto para tener más organizado nuestro proyecto, la forma de crear una carpeta
es haciendo lo siguiente., seleccionado en el icono damos clic derecho en nuestro proyecto en el Explorador
de soluciones, damos agregar y damos clic en nueva carpeta.
Ya teniendo nuestro WebForm de nombre EnCarpetaB dentro de la carpeta CarpetaB, ahora vamos a editarlo,
quedando de la siguiente forma, al agregarle el control DropDownList en su propiedad ID le daremos el
nombre de ddlFrutas, y todas sus demás propiedades las dejaremos en Default.
Cuando nosotros estamos utilizando punto, (".") se refiere a la locacion actual, es decir a la ruta actual que
nosotros tenemos, al ejecutar nos va a dar la ruta actual en la cual nos encontramos, recordemos que el
WebForm lo metimos adentro de las carpetas que creamos.
Entonces si nosotros estamos utilizando el punto ("."), este nos indica cual es nuestra ruta actual.
Ahora vamos ver que es lo que sucede si ponemos dos puntos (".."), con los dos puntos nos va a indicar, cual
es el padre de esa carpeta en la cual se encuentra el documento.
Recordemos que nuestro WebForm se encuentra en Carpeta B, entonces la ruta de su padre es la siguiente:
C:\Users\iscma\source\repos\DropDownList_II\DropDownList_II\CarpetaA
Ahora, como vamos a saber cual es el Path, cual es la ruta cuando tenemos que trabajar con el root o con el
directorio raíz, para eso vamos hacer uso de la tilde ~
C:\Users\iscma\source\repos\DropDownList_II\DropDownList_II\
Entonces con esto nosotros podemos ayudarnos y navegar adentro de la estructura de directorios para llegar
al documento que realmente nos interesa.
Ahora vamos a aprovechar esto para rellenar el DropDownList con información que se encuentra en
frutas.xml, pero hay que recordar que frutas.xml y el WebForm EnCarpetaB no están en la misma carpeta, es
decir que no están en el mismo directorio.
if (!IsPostBack)
{
DataSet DS = new DataSet();
DS.ReadXml(Server.MapPath("~/Frutas.xml"));
ddlFrutas.DataSource = DS;
ddlFrutas.DataValueField = "FrutaID";
ddlFrutas.DataTextField = "FrutaNombre";
Ya que sabemos que frutas.xml se encuentra al nivel de nuestro root, de nuestro directorio raíz.
Esto es importante. entonces porque gracias a esto nosotros podemos especificar correctamente la locación
del recurso que se desea utilizar en nuestra aplicación de asp.
Tenemos la parte de la impresión de las diferentes rutas y también tenemos nuestro DropDownList cargado
con la información que esta en frutas.xml y desde luego correctamente direccionado el archivo frutas.xml.
Después procederemos a realizar una instalación más, referente a los conectores de MySQL, para esto vamos
a dirigirnos el siguiente sitio web.
https://dev.mysql.com/downloads/installer/
Posteriormente aparecerá una página como la siguiente, en esta pagina vamos a seleccionar el Release que
vamos a estar utilizando, en este caso este que dice 230 mb
Aparecerá una página como la que a continuación se muestra y daremos clic en la liga No thanks, just start
my download.
Ya que se tenga el instalador descargado, se va a dar doble clic para empezar a instalarlo.
En esta ventana nos percatamos que tenemos seleccionados ya por default los checklist de Conector/ODBC y
Conector/NET, y daremos clic al botón Next.
Una vez que henos instalado los conectores Conector/ODBC y Conector/NET, vamos a nuestro Visual Studio,
en donde crearemos un nuevo proyecto, en este ejemplo le llamaremos DropDownList3
Entonces nos aparecerá una lista de todo aquello que nosotros podemos agregar.
Ya que se han filtrado nuestras extensiones de MySQL seleccionaremos la que dice MySQL.Data y daremos clic
en el botón Aceptar.
Lo que vamos hacer a continuación como siempre vamos adicionar a nuestro proyecto un WebForm para que
podamos nosotros hacer nuestra prueba ahí, a este WebForm le vamos adicionar un DropDownList para tener
con que poder trabajar.
Ahora lo que vamos hacer es crear nuestra base de datos para este ejemplo crearemos nuestra base de datos
con el nombre de frutas y con una tabla de nombre comestibles, utilizaremos el gestor de MySQL Workbench,
nuestra tabla solamente constara de 2 campos, id y nombre, de las cuales los registros son PIÑA, MANZANA,
MANGO y PLATANO, nuestra base de datos y tabla tendrá la apariencia como la que se muestra a
continuación.
Al ejecutarse este programa vemos como se visualiza en DropDownList la información de nuestra base de
datos
Para este ejercicio vamos a crear un proyecto con el nombre de ListBox y su respectivo WebForm1.
ID: BtnSeleccionar
SelectionMode: Single
ID: LBFrutas
SelectionMode: Single
Una vez que ya tenemos la interfaz de usuario ahora vamos a rellenar el ListBox, hay diferentes formas por
medio de las cuales nosotros podemos rellenar el ListBox, la forma de rellenar un ListBox es prácticamente
igual a como se llena un DropDownList, escribiremos el siguiente código para agregar elementos al ListBox.
Hasta aquí, si nos vamos a la parte de diseño ya nos deben aparecer estos elementos (Banana, Pera, Mango).
Ahora en el código del WebForm1.aspx programaremos el botón, de tal manera que cuando demos clic a
seleccionar obtengamos la información del elemento que este seleccionado, el botón lo vamos a programar
dando doble clic sobre este en la vista de diseño.
Ya que hemos dado doble clic sobre el botón Seleccionar, nos abrirá su Handler, en el cual vamos a escribir el
siguiente código.
Explicación del código: Primero veremos el código de la selecciona sencilla, que es lo primero que nosotros
tenemos que hacer, es verificar que se tenga seleccionado un elemento, ya que si nosotros le damos clic al
botón seleccionar y no hay un elemento seleccionado , al momento del cual tratamos de adquirir las
propiedades del elemento, bueno pues vamos a tener ahí una excepción, porque vamos a tratar de trabajar
con un objeto que no ha sido referenciado, entonces vamos a tener ahí una excepción, que finalizara nuestro
programa de manera abrupta, Entonces lo primero que tenemos que hacer es verificar que se tenga el
elemento seleccionado, entonces lo hacemos de la siguiente manera, hacemos un if y tenemos que decir la
propiedad SelectedItem del LBFrutas que es nuestro ListBox no es igual a null, eso significa que si tengo
cuando menos un elemento seleccionado, SelectedItem va a tener el valor de null si no hay elementos
I.S.C. Martín García Martínez 143
ASP.NET / Bootstrap
seleccionados, si tiene algún elemento ya seleccionado , bueno el valor va a ser diferente de null, después se
crean tres variables, indice para guardar el indice del elemento seleccionado, elemento para guardar el
valor que tiene en la propiedad de texto ese elemento seleccionado, y valor para guardar lo que tiene la
propiedad de Value ese elemento seleccionado, índices de tipo int pero elementos y valor son de tipo
string, ¿cómo obtenemos el índice? Bueno el indice es muy fácil simplemente en el ListBox que nosotros
tenemos punto SelectedIndex, de esta manera obtenemos el índice del elemento, recordemos que el
indice está basado en cero, luego para obtener como tal el texto que hemos colocado, pues del ListBox el
elemento seleccionado y del elemento seleccionado su propiedad de Text, para obtener el valor es algo muy
similar, el ListBox que tenemos de ahí el elemento seleccionado y del elemento seleccionado la propiedad
de Value.
Luego se hace Response.Write para mostrar estos valores que hemos obtenido, entonces tenemos
Response.Write, luego se hace una concatenación y se pone seleccionaste y luego el contenido de la
variable elemento, y luego se concatena con que tiene el valor el contenido de la variable valor, se concatena
con el indice y el contenido de la variable indice, de tal manera que se tiene los datos más importantes de ese
elemento que es como tal el texto que se tiene, el valor asociado a ese elemento y el indice que esta utilizando
o que está ocupando adentro del ListBox.
Response.Write("Seleccionaste " + elemento + " que tiene el valor " + valor + " en el indice
" + indice);
}
}
Ahora vamos hacer la parte del código para selecciones múltiples, lo primero que haremos será mediane vista
de Diseño, seleccionar el ListBox, y en la propiedad SelectionMode elegir la opción Multiple.
Response.Write("Seleccionaste " + elemento + " que tiene el valor " + valor + " en el
indice " + indice);
Response.Write("<br>");
}
}
A continuación, se ejecutará el programa en el cual se podrán seleccionar múltiples ítems mediante el puntero
del ratón y teniendo presionado la tecla ctrl, para por último dar clic en el botón de seleccionar y aparecerá
nuestra el siguiente resultado.
En esta lección veremos cómo utilizar el RadioButtonList, llevaremos a cabo la edición de elemento por código,
veremos como podemos seleccionar y obtener la información del elemento seleccionado, limpiar la selección y
también diferentes formas en las cuales podremos mostrar.
Para este ejercicio vamos a crear un proyecto con el nombre de RadioButtonList y su respectivo WebForm1.
I.S.C. Martín García Martínez 148
ASP.NET / Bootstrap
Con el control RadioButtonList vamos a tener una lista y esta lista va estar compuesta por elementos de tipo
RadioButton, recordemos que cuando se tiene el RadioButton solamente podemos seleccionar uno de los
elementos que tenemos, pero a diferencia del RadioButton normal que hemos utilizado, pues el
RadioButtonList va a tener la característica de que todos sus elementos forman parte de una lista, es decir
que adentro del control realmente tenemos una colección conformada por los diferentes RadioButton y al
tener una colección conformada por los diferentes RadioButton pues se va atener la ventaja de realizar
operaciones sobre esa colección, como que? Bueno como poder adicionar o eliminar RadioButton según
nosotros lo vayamos necesitando, eso es algo bastante útil, ahora bien para que nosotros podamos rellenar un
RadioButtonList pues se podrá hacer de diferentes formas, se va a poder hacer directamente en el código, que
es como se va hacer en esta lección o también se podrá hacer leyendo un archivo xml o incluso bajando
información de una tabla en una base de datos, en ese caso el código va a ser prácticamente el mismo, va a ser
código muy similar a lo que ya se hizo en las lecciones anteriores donde se vio la parte de MYSQL con ASP y
también la parte de leer un archivo xml desde ASP, entonces la forma de rellenar un RadioButtonList es muy
similar a como ya se ha visto en paginas anteriores.
Ahora lo primero que haremos será diseñar una interfaz como la siguiente
ID: rblColores
Ya que se tiene definida la interfaz, ahora nos vamos a ir al código para rellenar los RadioButtonList
directamente desde código, esto lo haremos seleccionando la pestaña inferior de Código.
Una vez que hemos identificado nuestros Tab de apertura y de cierre de RadioButtonList escribiremos las
siguientes líneas de código, estas líneas representan la lista de opciones del RadioButtonList. (Nota aún no se
van a programar los botones)
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
</div>
<asp:RadioButtonList ID="rblFrutas" runat="server">
<asp:ListItem Text ="Manzana" Value ="1"></asp:ListItem>
<asp:ListItem Text ="Pera" Value ="2"></asp:ListItem>
<asp:ListItem Text ="Durazno" Value ="3"></asp:ListItem>
<asp:ListItem Text ="Platano" Value ="4"></asp:ListItem>
<asp:ListItem Text ="Ananas" Value ="5"></asp:ListItem>
<asp:ListItem Text ="Mango" Value ="6"></asp:ListItem>
</asp:RadioButtonList>
<br />
<asp:Button ID="btnSeleccionar" runat="server" Text="Seleccionar" Width="165px" />
<p>
---</p>
<p style="margin-bottom: 19px">
</p>
<p style="margin-bottom: 19px">
<asp:RadioButtonList ID="rblColores" runat="server">
<asp:ListItem Text ="Rojo" Value ="1"></asp:ListItem>
<asp:ListItem Text ="Naranja" Value ="2"></asp:ListItem>
<asp:ListItem Text ="Amarillo" Value ="3"></asp:ListItem>
<asp:ListItem Text ="Verde" Value ="4"></asp:ListItem>
<asp:ListItem Text ="Azul" Value ="5"></asp:ListItem>
<asp:ListItem Text ="Violeta" Value ="6"></asp:ListItem>
</asp:RadioButtonList>
</p>
<p>
<asp:Button ID="btnSeleccionarLimpiar" runat="server" Text="Seleccionar y limpiar"
Width="166px" />
</p>
</form>
<p>
</p>
<p>
</p>
</body>
</html>
Ahora vamos a empezar a colocar algo de código con relación a los botones, para esto vamos a ir al botón
Seleccionar haciendo doble click en este.
if (rblFrutas.SelectedItem != null)
//MOSTRAMOS
Response.Write(texto + ", " + valor + ", " + indice + "<br>");
}
Cada uno de los datos que se han escrito en el handler, determinara el nombre de la opción seleccionada, el
valor de la selección y el número de índice en la selección, la línea Response, nos mostrara cada una de las
propiedades y valores de cada valor, en lugar del Reponse, y dependiendo de cada valor también podremos
poner condicionales u otro tipo de información que dependiendo al resultado realice determinada acción.
Al correr y ejecutar el botón veremos el siguiente resultado, Manzana es el Texto, el uno es el valor, es decir
que es el primer elemento de la lista, y el cero, se refiere al índice, este inicia a partir de cero.
Una vez que ya entramos al handler del botón Seleccionar y limpiar, vamos el siguiente código quedando de la
siguiente forma.
Este bloque de handler es muy similar al anterior, lo que cambia un poco es que esta cuenta al final con la
siguiente línea de código, rblColores.SelectedIndex = -1; esta línea de código hace que al darle click el botón
Seleccionar y limpiar, limpie el RadioButton seleccionado.
La forma de añadir elementos al BulletedList es muy similar a como ya lo hemos visto en los controles
anteriores, esto se puede hacer directamente a través de código, leyendo un archivo de XML, o también
leyendo una tabla de una base de datos, Podemos hacerlo directamente e código(como se hizo con el control
RadioButtonList), simplemente adicionando el ListItem, para cada uno de los elementos que nosotros
queremos que contenga ese BulletedList, sin embargo también podemos hacerlos Vía Editar elementos, como
se muestra en la siguiente imagen.
Entre unas de las propiedades que tiene el control BulletedList, es la propiedad esta la propiedad BulletStyle,
la cual nos puede numerar, poner en orden alfabético, círculos, cuadrados e incluso imágenes, a un lado del
elemento de lista.
Ahora tomaremos otro control BulletedList y lo arrastraremos debajo de este que ya tenemos,
Aquí los elementos van a consistir en nombres de páginas web, y como valor, vamos a escribir la dirección web
de cada una de estas.
Y así lo veremos como se muestra en la siguiente imagen, y ahora cada uno de los elementos van a funcionar
como si fueran ligas a la dirección web que se le indico previamente.
Una vez que hayamos agregado los miembros a la lista(Azul y Rojo), daremos click en el botón Aceptar.
Ahora lo que vamos hacer es irnos a nuestro BulletedList3, después a sus propiedades y a los Eventos (Icono
del rayo) y ahí daremos click en la propiedad del Evento doble Click, esto para entrar a su handler.
Response.Write("Texto: " + texto + ", valor: " + valor + ", indice: " + indice);
}
Por último vamos a correr nuestro programa, y vemos como al darle click a Rojo nos envía el texto, Rojo, el
valor 2 y el índice 1.
Enseguida de igual forma vamos a agregar el objeto Button, este botón va a ser el que nos ayudara a subir al
servidor el archivo que previamente se haya seleccionado con el botón Examinar, a este botón en su
propiedad ID le pondremos btnSubir y en la propiedad Text llevara el nombre de Subir.
else
I.S.C. Martín García Martínez 174
ASP.NET / Bootstrap
{
Response.Write("Seleccione un archivo a subir");
}
}
Calendar
En esta lección trabajaremos con los elementos más importantes del control Calendar, veremos cómo saber la
fecha o fechas seleccionadas, ocultarlo y mostrarlo.
Iniciaremos creando nuestro proyecto vacío, mismo que le vamos a agregar su respectivo WebForm1.
Ahora vamos arrastrar al diseño de nuestro proyecto un botón, el control calendario y una caja de texto.
En el ID de las propiedades del botón vamos a poner btnCalendario, y en su propiedad Text Calendario.
Después se abrirá una ventana como la siguiente de autoformato, en donde al gusto seleccionaremos
cualquier esquema.
Al ejecutar nuestro programa por primera vez, nuestro control Calendar, no aparecerá visible por estar en
estado False.
Esto lo haremos mediante un Evento que existe en nuestro control Calendar, entonces seleccionaremos el
control Calendar y una vez seleccionado nos vamos a nuestra lista de eventos, en la lista seleccionaremos la
propiedad SelectionChanged y vamos a dar doble click en este campo para que nos mande a su handler.
Una vez que ya hemos escrito el código ejecutamos el programa y al seleccionar cualquier día del calendario
este nos mostrara el día de la semana en forma de string (cadena) dentro de nuestro TextBox.
Para esto vamos a seleccionar nuestro control Calendar, y de ahi nos vamos a ir a su lista de propiedades y en
SelectionMode vamos a seleccionar la opción DayWeek.
Notaremos que, al momento de establecer la propiedad, DayWeek la apariencia del calendario cambiara un
poco con una especie de picos del lado izquierdo, los cuales nos van ayudar a llevar a cabo toda la selección de
una semana completa.
Y al ejecutar nuestro programa y dar click en alguno de los bloques de la semana de las flechas de la izquierda
nos mostrara el siguiente resultado, en donde al inicio de la página nos visualizara las múltiples fechas.
Al ejecutar nuestro programa, nos damos cuenta que el día actual lo ha personalizado con la palabra “Hoy”
Para hacer que no se puedan seleccionar los fines de semana se añadira el siguiente codigo.
if (e.Day.IsWeekend)
{
e.Day.IsSelectable = false;
}
}
Lo primero que haremos será crear un nuevo proyecto vacío, al cual se le va añadir su WebForm1.
Enseguida vamos a crear un archivo xml este archivo va a contener información acerca de los Ads, para crear
el xml nos vamos a ir a situar encima del proyecto AdRotator que está dentro del Explorador de soluciones, y
con el botón derecho del mouse seleccionaremos del menú la opción Agregar y enseguida Nuevo elemento…
Después de haber creado nuestro Archivo XML vamos a dar click al botón Agregar, y se nos estará viendo de la
siguiente forma.
</Advertisements>
A la carpeta creada la vamos a llamar Imágenes, en esta carpeta será donde almacenaremos las imágenes que
deseamos visualizar mediante AdRotator.
Ya casi para terminar ahora nos vamos a ir a nuestro Diseño de nuestro WebForm y del cuadro de
herramientas vamos arrastrar el control AdRotator.
Y daremos click en el botón de los tres puntos, ahí nos aparecerá el archivo XML que recientemente creamos,
lo seleccionamos y damos click en el botón Aceptar.
Y como se mencionó en líneas anteriores, podemos filtrar los banners que deseamos es decir esto mediante
según la palabra que contenga el keyword. En este ejemplo dos banners tienen el keyword aprender y
uno tiene el keyword socializar.
<keyword>aprender</keyword>
Ahora veremos un control que puede guardar un valor entre llamadas al servidor.
Este control es bastante útil porque nos va a permitir colocar en su interior un valor, este
valor no va a ser desplegado adentro de del form como tal, no lo vamos a ver nosotros, sin
embargo, el valor va a poder ser guardado ahí.
Cuando nosotros tenemos el HiddenFiel, el valor que tiene en su interior se conserva entre
los diferentes PostBack que nosotros podamos tener, y eso es algo que es bastante útil para
nosotros.
Una de las aplicaciones principales de este control, es cuando estamos trabajando a una
conexión a base de datos y por ejemplo nosotros obtenemos algo importante que vamos
estar utilizando entre múltiples llamadas, digamos podría ser en la llave principal de algún
elemento que nos interesa en esa base de datos y de esa manera nosotros lo podemos
guardar ahí, conservarlo y aunque hagamos diferentes PostBack mantenerlo para poder
seguir accediendo a esa información de manera fácil y rápida.
El valor que vamos a colocar va a ser de tipo string, los valores numéricos debemos de
convertirlos a cadena.
Lo primero que haremos será crear un nuevo proyecto vacío con su respectivo WebForm.
El control Label lo dejaremos así con darle nombre a si ID, solo en su propiedad Text le escribiremos Dato, y en
la propiedad ID del TextBox le pondremos txtDato, este control de TextBox nos va a servir para que nosotros
podamos colocar un valor, ese valor guardarlo en HiddenFiel y luego poder hacer otras cosas con la
forma y en el momento el cual nosotros lo deseemos lo vamos a poder leer de HiddenFiel y
mostrarlo nuevamente en la forma.
Posteriormente vamos a colocar dos botones, en donde declararemos las Propiedades ID’s y
Text, ID = btnLeer y Text = Leer y ID = btnMostrar y Text = Mostrar, respectivamente
Ahora vamos a correr nuestro programa, En donde lo primero que haremos será escribir un dato, en este
ejemplo escribiremos Martin.
Mientras la información se tiene almacenada y no se está viendo, se podrían hacer otras cosas dentro del
Form, todo lo que se desee y sea necesario.
Y después al darle click Al botón Mostrar, cuando le damos click Mostrar, nuevamente se va al servidor, el
servidor lleva a cabo el procesamiento, y nos va a regresar algo, y en este caso nos va a regresar el valor que
inicialmente habíamos colocado en la caja de texto, en este caso Martin, conformando que el valor dentro del
HiddenFiel se ha conservado.
Este control puede resultar muy útil, en particular cuando se trabaja con bases de datos
En que consiste este control, bueno pues vamos a tener un WebForm que puede tener
diferente desplegados, es decir el mismo webform se puede mostrar de diferentes formas
dependiendo de cuál sea la vista o el view que nosotros estemos seleccionando en ese
momento.
Entonces lo primero que haremos será crear un proyecto Vacío mismo que le vamos añadir
un WebForm1 como se puede ver en el Explorador de soluciones.
Enseguida nuevamente nos vamos a ir a nuestro Cuadro de herramientas y vamos a ubicar el control View,
este control lo vamos a arrastrar dentro del control MultiView como se muestra en la siguiente
imagen.
Enseguida vanos a seleccionar nuestro View1 en su propiedad ID vamos a ponerme VDatos, ya que este View
se encargará de recoger los datos iniciales con los que se va a trabajar en este ejercicio.
ID: txtA
ID: txtB
ID: btn0a1
Text: ->
ID: btn1a0
Text: <-
I.S.C. Martín García Martínez 215
ASP.NET / Bootstrap
ID: rbMulti
GroupName: operaciones ID: btn1a2
Text: Multi Text: ->
ID: rbResta
GroupName: operaciones
Text: Resta
Por último, vamos a agregar en el VResultado una etiqueta que dice Resultado y un TextBox al cual estaremos
llamando a su ID: txtResultado.
ID: txtResultado
Text: Resultado
Después de terminar nuestro diseño, ahora vamos empezar a colocar el código, este código que vamos hacer
nos va a permitir llevar a cabo los cambios de Views, indicar cual el View con el que estamos iniciando, y desde
luego hacer las operaciones correspondientes que nosotros necesitemos.
if (!Page.IsPostBack)
Después de esto vamos empezar a dale funcionabilidad a los botones, para esto nos vamos nuevamente a
diseño y damos doble click sobre el botón btn0a1.
Ahora nos vamos al Diseño y daremos doble click sobre el botón regresar de View de VOperaciones.
Este botón no solamente va hacer la función de pasar de un índex a otro, sino que va a llevar una lógica de las
operaciones, Por lo que escribiremos las siguientes líneas de código.
txtResultado.Text = r.ToString();
MultiView1.ActiveViewIndex = 2;
}
Después nos aparecerá una ventana como la que se muestra a continuación y finalmente seleccionaremos la
plantilla Vacio, y finalmente daremos click en el botón Crear.
Posteriormente lo primero que haremos será integrar Bootstrap vía externa a nuestro entorno de desarrollo
de Visual Studio 2022, para lo que nos vamos a ir a la página oficial de Booostrap, en esta página vamos hacer
click en el botón Download.
Una vez que dimos click se empezara a descargar la carpeta compilada con los archivos CCS y JS, Esta descarga
se refiere al código compilado listo para usar para Bootstrap en este caso es la versión v5.1.3 para colocarlo
fácilmente en el proyecto, que incluye:
Posteriormente también descargaremos la biblioteca jQuery, para incluirla dentro de los archivos js que se
encuentran dentro de la carpeta de bootstrap-5.1.3-dist, lo primero que haremos será ir a la página oficial de
jQuery, una vez que ya estamos en la página, dar click en el botón Download JQuery
Después nos abrirá une pagina como la siguiente en la cual daremos click derecho al ratón y nos saldrá un
menú contextual en el cual seleccionaremos la opción Guardar como…
Ya que se de click en el botón Guardar nos percataremos que nuestro archivo jquery-3.6.0.min ya se
encuentra dentro de la carpeta js.
Enseguida aparecerá una ventana en donde agregaremos un Formulario Web Form, para este ejemplo le
dejaremos el nombre que sugiere por default WebForm1.aspx y daremos click en el botón Agregar.
Ya para acabar de instalar Bootstrap adicionaremos tres líneas de código, estas líneas se refieren a la ruta para
trabajar con los archivos css y js que se encuentran dentro de la carpeta bootstrap-5.1.3-dist.
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
</head>
<body>
<form id="form1" runat="server">
<div>
</div>
</form>
</body>
</html>
Debemos tener bien en cuenta que el inicio de la ruta de para llegar a los archivos css y js, inician con el
nombre de la carpeta de bootstrap-5.1.3-dist, por lo que esta deberá estar bien escrita.
De esta manera ya tenemos listo nuestro Bootstrap instalado en nuestro ID de Visual Studio 2022 y por lo
tanto ya podemos copiar y pegar Documentación directamente de la página oficial de Bootstrap
https://getbootstrap.com/
Posteriormente Bootstrap nos mostrara en la página, la sección de las ventanas Modales y para este ejemplo
ubicaremos la que dice Live Demo, ya que este ejemplo contiene un botón para mandar llamar la ventana
Modal, y daremos click en el botón de Copy para mandar al portapapeles todo el contenido de ejemplo.
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body>
Una vez que ya hemos pegado el código del botón y del Modal a nuestro código del WebForm1.aspx,
correremos y ejecutaremos la aplicación.
Partiendo del ejemplo anterior lo primero que vamos hacer va a ser agregar un control TextBox a nuestra vista
de diseño de nuestro WebForm1.aspx.
Después de haber agregado este control, en la vista de código nos aparecerá de la siguiente forma.
<br />
<asp:TextBox ID="TextBox1" runat="server" Width="166px"></asp:TextBox>
</div>
<br />
<asp:TextBox class="form-control" ID="copy" runat="server" Width="166px"></asp:TextBox>
</div>
Añadiendo la clase a nuestro control TextBox de asp class="form-control" será posible que nuestra caja
de texto desprenda el efecto propio de Bootstrap.
Ahora vamos a adicionar un TextBox dentro de nuestro Modal para esto copiaremos un TextBox de la página
de Bootstrap, ya que las ventanas Modales son propias de Bootstrap estas deben de tener sus controles
también de Bootstrap, es decir si le copiamos la línea de código propia de asp o le añadimos un control
TextBox de asp este no lo reconocerá. A esta línea, a su ID de le pondremos le pondremos el nombre de paste.
Una vez que ya hemos establecido las dos cajas de texto ahora adicionaremos el código JavaScript donde
llamara a la función de copiar lo que escribamos en la primera caja de texto a la segunda caja de texto que está
dentro del Modal.
</script>
Como ya sabemos la función de JavaScript la posicionaremos al nivel del head, así como se muestra a
continuación.
Por ultimo y para poder mandar llamar la función copiar de Java Script, añadiremos en el botón que abre el
modal la instrucción con el evento onclick="copiar()” en donde se hace referencia al nombre de la función
copiar y quedara de la siguiente forma.
Posteriormente después de escribir, daremos click en el botón y veremos como se ha copiado en el primer
TextBox y se ha pegado en el segundo TextBox texto del Modal.
Partiendo del ejemplo anterior de como mandar llamar un Modal desde un botón y una vez que este nuestro
modal abierto podamos hacer una suma por medio de tres TextBox que adicionaremos a nuestro Modal¸ cada
uno con sus respectivos nombres de ID, num1, num2 y res
onclick="sumar()"
<script type="text/javascript">
function sumar() {
var num1 = Number(document.getElementById('num1').value);
var num2 = Number(document.getElementById('num2').value);
}
</script>
Ya que se ha ejecutado la aplicación la vamos a correr y enseguida estaremos haciendo la suma de dos TexBox,
y un resultado.
Dicho botón se agregará mediante el siguiente código, en este código ya se estará referenciando la llamada a
la función JavaScript Limpiar onclick="Limpiar('num1', 'num2', 'res');" también se enuncian los nombres de
los id de las cajas de texto num1, num2 y res.
Ya que se tiene el diseño y código de llamada en el botón LIMPIAR, ahora solo agregaremos nuestro código
JavaScript, Limpiar
<script type="text/javascript">
function Limpiar(num1, num2, res)
{
document.getElementById(num1).value = '';
document.getElementById(num2).value = '';
document.getElementById(res).value = '';
}
</script>
Una vez que se han introducido números a las cajas de texto dándole click al botón LIMPIAR estos borraran las
cajas de Texto.
Un login se encarga de la autenticación del usuario (comprobando que el nombre de usuario y contraseña sean
correctos), y establece un entorno inicial para el usuario, a los login se les puede retroalimentar con funciones
como la activando permisos por privilegios.
Lo primero que haremos será diseñar nuestro esquema de base de datos, para este ejemplo a nuestra base de
datos le daremos el nombre de testing_mysql y a nuestros campos le pondremos los nombres de:
A continuación, para este ejemplo se vara un login sencillo, para esto lo primero que haremos será crear un
nuevo proyecto.
En la parte inferior izquierda daremos click en el botón Diseño para que nos aparezca en modo de diseño el
archivo login.aspx
ID: txtUser
ID: txtPass
TextMode: Password
Posteriormente agregaremos la referencia MySql.Data.DLL para poder acceder a los procesos relacionados
con conexión y navegación de base de datos MySQL, esta referencia la vamos agregar como archivo de la
siguiente forma, en el Explorador de soluciones vamos a dar click derecho sobre las Referencias, dicha
referencia la vamos a poder descargar de la siguiente liga.
https://drive.google.com/drive/folders/1SWsaXHl8VwQbqQ1v81teydZZEaWmubTf?usp=sharing
Y al dar click en el botón Aceptar nos estaría agregando la referencia a nuestro proyecto.
Para entrar a su handler es decir al evento click del botón Aceptar. En el cual vamos a escribir las siguientes
líneas de código.
try
{
{
// MessageBox.Show("Error de conexion", "ERROR");
Console.WriteLine("Standard Numeric Format Specifiers");
}
conexion.Close();
lblMen.Text = "Contraseña incorrecta";
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace inicio
{
public partial class general : System.Web.UI.Page
}
}
}
Una vez que ya hemos creado nuestro archivo logout.aspx nos vamos a ir a su handler de este dando clic a
botón derecho del ratón y en el menú contextual seleccionaremos la opción Ver código.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace login
{
public partial class logout : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Session.Clear();
Response.Redirect("login.aspx");
}
}
}
ddlFrutas.Items.Add(fresa);
ddlFrutas.Items.Add(naranja);
}
}
https://www.youtube.com/watch?v=mYlJxJRafCo&list=PLM-p96nOrGcb3aQ2zh8jGzRugtuKUNJdo
https://developer.mozilla.org/es/docs/Web/JavaScript
https://juanalbertogt.wordpress.com/tag/ejecutar-javascript-desde-el-code-behind-visual-basic-asp-net/
https://www.kyocode.com/2019/01/ejecutar-funciones-javascript-con-onclick/
https://www.tutorialesprogramacionya.com/