Existen distintas formas de enviar información o datos entre páginas y cada una tiene sus ventajas e inconvenientes. Por lo tanto, debemos evaluar estas consideraciones para determinar como implementar esta funcional en cada caso concreto.
En este artículo vamos a a hablar de un método que estaba disponible en las páginas ASP de antaño y que dejó de estarlo en las versiones ASP.NET 1.x. Con la llegada de ASP.NET 2.0 Microsoft puso a nuestra disposición otra vez la técnica bautizada como Cross Page PostBack (¡telita con el nombre!).
La técnica consiste en hacer que un formulario no se envíe sobre si mismo, es decir, que haga un Submit sobre otra página. Esto se consigue por medio de la propiedad PostBackUrl que implementan los siguientes controles.
<asp:Button ID="Button1" runat="server" Text="Button" PostBackUrl="~/PaginaDestino.aspx" />
<asp:ImageButton ID="ImageButton1" ImageUrl="~/img/enviar.png" runat="server" PostBackUrl="~/PaginaDestino.aspx" />
<asp:LinkButton ID="LinkButton1" runat="server" PostBackUrl="~/PaginaDestino.aspx">LinkButton</asp:LinkButton>
Estos controles estarán insertados en nuestra página de origen y como vemos la propiedad PostBackUrl apuntará a la página de destino sobre la que se quiere enviar los datos de la página actual.
Suponiendo que en la página de origen tenemos un campo de texto sobre el que el usuario escribe un texto que será enviado a la página de destino, en el código de esta, obtendremos el valor del campo de texto y lo mostraremos de la siguiente forma.
if (PreviousPage != null)
{
TextBox ControlEncontrado = (TextBox)PreviousPage.FindControl("TextBox1");
if (ControlEncontrado != null)
{
sptexto.InnerText = ControlEncontrado.Text;
}
}
La propiedad PreviousPage de la página de destino nos devuelve una referencia a la página de origen y mediante su método FindControl() buscaremos el control sobre el que escribió el usuario.
Es muy importante, como hemos visto, hacer las comprobaciones oportunas sobre la propiedad PreviousPage y el método FindControl() para evitar sorpresas del tipo System.NullReferenceException.
Existe otra forma de utilizar esta técnica que es recomendable si tenemos pensado diseñar la página de origen exclusivamente para compartir información con otras páginas. Consiste en exponer los datos que se quieren compartir o enviar como propiedades públicas. Es decir, en la página de origen haremos algo como esto:
public string NombrePropiedadTexto
{
get
{
return TextBox1.Text;
}
}
public TextBox NombrePropiedadControl
{
get
{
return TextBox1;
}
}
En primer lugar, en la página de destino deberemos escribir la directiva PreviousPageType apuntando a la página de origen.
<%@ PreviousPageType VirtualPath="~/PaginaOrigen.aspx" %>
O también así.
<%@ PreviousPageType TypeName="EspacioDeNombres.PaginaOrigen" %>
Al colocar esta directiva en nuestra página de destino, obtenemos una referencia con establecimiento inflexible de tipos (¡bonito palabro!) a nuestra página de origen. Esta directiva tiene dos posibles atributos que son mutuamente excluyentes, VitualPath y TypeName. Es decir, solo podemos utilizar uno de ellos al mismo tiempo.
Ahora, en el code behind de la página de destino tendremos a nuestra disposición la propiedades anteriormente implementadas de forma muy natural y que recuperaremos respectivamente de la siguiente forma dependiendo como las hemos implementado.
if (PreviousPage != null)
{
if (PreviousPage.IsCrossPagePostBack)
{
sptexto.InnerText = PreviousPage.NombrePropiedadTexto;
}
}
if (PreviousPage != null)
{
if (PreviousPage.IsCrossPagePostBack)
{
sptexto.InnerText = PreviousPage.NombrePropiedadControl.Text;
}
}
Ni que decir tiene, que no es necesario que las propiedades que exponen los datos a compartir deban necesariamente devolver un control de servidor como hemos visto en este ejemplo. Podemos implementar una propiedad del tipo que necesitemos y recuperarla igualmente por medio de la propiedad PreviousPage.
Veamos ahora una pequeña comparativa de los métodos más usuales para enviar datos entre páginas ASP.NET y tener una visión más general que nos permita elegir adecuadamente en cada caso.
- Compartir datos mediante estado de sesión.
- Cuando utilizamos la sesión para compartir los datos, estos están disponibles para todas las páginas de nuestra aplicación.
- Debemos tener en cuenta que esto supone un consumo relativo de la memoria del servidor.
- Los datos permanecen en memoria hasta que el usuario cierra el explorador y quizás no necesitemos tanta disponibilidad.
- Enviar datos como parámetros en la URL
- Permite enviar datos entre páginas de distintas aplicaciones e incluso entre distintas plataformas.
- Se pueden derivar algunos problemas de seguridad al ser siempre visible la información a los usuarios.
- Cantidad de datos limitada por la longitud máxima de la cadena URL.
- Se puede utilizar tanto con controles de servidor como controles HTML.
- Los datos pueden ser enviados programativamente por medio del método Redirect().
- Solo se puede utilizar para enviar información a páginas de nuestra aplicación.
- La información enviada no es visible para los usuarios.
- Se pueden enviar grandes cantidades de datos contenidas en propiedades o en controles, por ejemplo un GridView complento.
- Solo es accesible para controles se servidor.
- Programativamente se pueden transferir los datos mediante el método Transfer().