Menu
To add a control to an ASP.NET Web page programmatically Because the Controls property is a collection, you can use the AddAt method to place the new control at a specific location — for example, in front of other controls. However, this can introduce errors into the page.
ASP.NET uses five types of web controls, which are: HTML controls. HTML Server controls. ASP.NET Server controls.
These high-level custom controls provide rich user interface and functionality. This release of ASP.NET includes two rich controls: the Calendar control and the AdRotator control.
This solution will give you programmatic access to the controls in their entirety including all attributes on the controls. Also, only the text box values will appear in the URL upon submission so your GET request URL will be more "meaningful"
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="JonSkeetForm.aspx.cs" Inherits="JonSkeetForm" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Jon Skeet's Form Page</title>
</head>
<body>
<form action="JonSkeetForm.aspx" method="get">
<div>
<input type="text" ID="text1" runat="server" />
<input type="text" ID="text2" runat="server" />
<button type="submit">Submit</button>
<asp:Repeater ID="Repeater1" runat="server">
<ItemTemplate>
<div>Some text</div>
</ItemTemplate>
</asp:Repeater>
</div>
</form>
</body>
</html>
Then in your code-behind you can do everything you need on PageLoad
public partial class JonSkeetForm : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
text1.Value = Request.QueryString[text1.ClientID];
text2.Value = Request.QueryString[text2.ClientID];
}
}
If you don't want a form that has runat="server", then you should use HTML controls. It's easier to work with for your purposes. Just use regular HTML tags and put runat="server" and give them an ID. Then you can access them programmatically and code without a ViewState.
The only downside is that you won't have access to many of the "helpful" ASP.NET server controls like GridViews. I included a Repeater in my example because I'm assuming that you want to have the fields on the same page as the results and (to my knowledge) a Repeater is the only DataBound control that will run without a runat="server" attribute in the Form tag.
You're definitely (IMHO) on the right track by not using runat="server" in your FORM tag. This just means you'll need to extract values from the Request.QueryString directly, though, as in this example:
In the .aspx page itself:
<%@ Page Language="C#" AutoEventWireup="true"
CodeFile="FormPage.aspx.cs" Inherits="FormPage" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>ASP.NET with GET requests and no viewstate</title>
</head>
<body>
<asp:Panel ID="ResultsPanel" runat="server">
<h1>Results:</h1>
<asp:Literal ID="ResultLiteral" runat="server" />
<hr />
</asp:Panel>
<h1>Parameters</h1>
<form action="FormPage.aspx" method="get">
<label for="parameter1TextBox">
Parameter 1:</label>
<input type="text" name="param1" id="param1TextBox" value='<asp:Literal id="Param1ValueLiteral" runat="server" />'/>
<label for="parameter1TextBox">
Parameter 2:</label>
<input type="text" name="param2" id="param2TextBox" value='<asp:Literal id="Param2ValueLiteral" runat="server" />'/>
<input type="submit" name="verb" value="Submit" />
</form>
</body>
</html>
and in the code-behind:
using System;
public partial class FormPage : System.Web.UI.Page {
private string param1;
private string param2;
protected void Page_Load(object sender, EventArgs e) {
param1 = Request.QueryString["param1"];
param2 = Request.QueryString["param2"];
string result = GetResult(param1, param2);
ResultsPanel.Visible = (!String.IsNullOrEmpty(result));
Param1ValueLiteral.Text = Server.HtmlEncode(param1);
Param2ValueLiteral.Text = Server.HtmlEncode(param2);
ResultLiteral.Text = Server.HtmlEncode(result);
}
// Do something with parameters and return some result.
private string GetResult(string param1, string param2) {
if (String.IsNullOrEmpty(param1) && String.IsNullOrEmpty(param2)) return(String.Empty);
return (String.Format("You supplied {0} and {1}", param1, param2));
}
}
The trick here is that we're using ASP.NET Literals inside the value="" attributes of the text inputs, so the text-boxes themselves don't have to runat="server". The results are then wrapped inside an ASP:Panel, and the Visible property set on page load depending whether you want to display any results or not.
Okay Jon, the viewstate issue first:
I haven't checked if there's any kind of internal code change since 2.0 but here's how I handled getting rid of the viewstate a few years ago. Actually that hidden field is hardcoded inside HtmlForm so you should derive your new one and step into its rendering making the calls by yourself. Note that you can also leave __eventtarget and __eventtarget out if you stick to plain old input controls (which I guess you'd want to since it also helps not requiring JS on the client):
protected override void RenderChildren(System.Web.UI.HtmlTextWriter writer)
{
System.Web.UI.Page page = this.Page;
if (page != null)
{
onFormRender.Invoke(page, null);
writer.Write("<div><input type=\"hidden\" name=\"__eventtarget\" id=\"__eventtarget\" value=\"\" /><input type=\"hidden\" name=\"__eventargument\" id=\"__eventargument\" value=\"\" /></div>");
}
ICollection controls = (this.Controls as ICollection);
renderChildrenInternal.Invoke(this, new object[] {writer, controls});
if (page != null)
onFormPostRender.Invoke(page, null);
}
So you get those 3 static MethodInfo's and call them out skipping that viewstate part out ;)
static MethodInfo onFormRender;
static MethodInfo renderChildrenInternal;
static MethodInfo onFormPostRender;
and here's your form's type constructor:
static Form()
{
Type aspNetPageType = typeof(System.Web.UI.Page);
onFormRender = aspNetPageType.GetMethod("OnFormRender", BindingFlags.Instance | BindingFlags.NonPublic);
renderChildrenInternal = typeof(System.Web.UI.Control).GetMethod("RenderChildrenInternal", BindingFlags.Instance | BindingFlags.NonPublic);
onFormPostRender = aspNetPageType.GetMethod("OnFormPostRender", BindingFlags.Instance | BindingFlags.NonPublic);
}
If I'm getting your question right, you also want not to use POST as the action of your forms so here's how you'd do that:
protected override void RenderAttributes(System.Web.UI.HtmlTextWriter writer)
{
writer.WriteAttribute("method", "get");
base.Attributes.Remove("method");
// the rest of it...
}
I guess this is pretty much it. Let me know how it goes.
EDIT: I forgot the Page viewstate methods:
So your custom Form : HtmlForm gets its brand new abstract (or not) Page : System.Web.UI.Page :P
protected override sealed object SaveViewState()
{
return null;
}
protected override sealed void SavePageStateToPersistenceMedium(object state)
{
}
protected override sealed void LoadViewState(object savedState)
{
}
protected override sealed object LoadPageStateFromPersistenceMedium()
{
return null;
}
In this case I seal the methods 'cause you can't seal the Page (even if it isn't abstract Scott Guthrie will wrap it into yet another one :P) but you can seal your Form.
Have you thought about not eliminating the POST but rather redirecting to a suitable GET url when the form is POSTed. That is, accept both GET and POST, but on POST construct a GET request and redirect to it. This could be handled either on the page or via an HttpModule if you wanted to make it page-independent. I think this would make things much easier.
EDIT: I assume that you have EnableViewState="false" set on the page.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With