The interface requires that a single method be implemented:

RaisePostBackEvent is called on the IPostBackEventHandler control that raised the postback to the server. If an argument was passed to the server during the postback, it will be passed to the eventArgument parameter of the RaisePostBackEvent() method. But how does the server know which control raised the postback and how are any arguments passed back to the page? Let’s take a step back and look at how forms are submitted in HTML/JavaScript and how ASP.NET abstracts this behavior to provide us with the postback.

Submitting a Form

There are two mechanisms by which a form can be submitted to the server: an HTML submit button element or JavaScript. In order to use an HTML submit button, you must add the following markup to your form:

This will render a simple button element which will display the text “Submit Form.” When clicked, the button will submit the form back to the server using an HTTP POST request. To do the same in JavaScript you simply need to retrieve the form DOM element and call its submit() function:

This will also cause the form to be submitted back to the server using an HTTP POST request.

ASP.NET Postbacks

The two methods described above are all that is required to create web applications that require any kind of interaction between client and server. ASP.NET provides many different kinds of controls which we can use to post our forms back to the server, but underneath all the layers of abstraction lie those two fundamental mechanisms.

For a page that uses any control except the Button and ImageButton (which we’ll take a look at momentarily), ASP.NET generates a simple JavaScript function and two hidden <input /> elements to handle form submissions:

Any time you interact with an ASP.NET control in a way the should cause a postback, this function is called. The two hidden fields, __EVENTTARGET and __EVENTARGUMENT, are used to keep track of the control which caused the postback and any data that should be associated with the control, respectively. These two fields can be access on the server in either the Page.Form or Page.Params collection. The first contains a collection of all form variables posted back to the server, and the second is a combined collection of form variables, query string variables, server variables, and cookies. The following code snippets are identical:

This is how the server knows which control raised the postback and can call its RaisePostBackEvent() method, passing in the __EVENTARGUMENT data to the expected parameter.

The only exceptions to this rule are the Button and ImageButton controls. These controls are rendered as HTML submit button elements and therefore do not require any JavaScript to post the form and its data back to the server. These controls can still be identified when a postback is received by the server because they will be the only Button controls represented in the form collection.

Enabling a Server Control to Cause a Postback

So now that we know how postbacks work in ASP.NET, we need to add this functionality to the control that we want to implement the IPostBackEventHandler interface. After all, if the control doesn’t actually cause a postback, then the functions we implement as a part of that interface will be useless because they will never be called. Lucky for us, adding the client script necessary to cause a postback is pretty easy.

There are really two ways you can force your control to initiate a postback to the server. The first is to simply add a client event handler which fires off the __doPostBack() function, like so:

Here we’ve overridden the control’s AddAttributesToRender() method and added our own onclick client event handler to call __doPostBack(). I don’t really like this method because it feels clumsy. And remember, if you don’t have any other ASP.NET controls on your page that cause __doPostBack() to be rendered to the page, then you will see JavaScript exceptions when your control tries to call that function.

A better way to add the onclick client event handler would be to use the Page.ClientScriptManager’s GetPostBackEventReference() method:

Not only will this add the event handler for us, but it will also ensure the __doPostBack() function is inserted into our page for us.

Bringing it all Together

Now that we’ve taken a look at how this all works, let’s build a control so we can see these concepts in action. For this example I’m going to extend the Panel control to create a simple ClickablePanel, which will fire off a postback to the server any time a user clicks inside the panel. The class should implement the IPostBackEventHandler interface by defining a RaisePostBackEvent() method. It will also define a single Click event, and will override the Panel’s AddAttributesToRender() method as demonstrated above. Here’s what the implementation should look like:

Now you can add a ClickablePanel to any ASP.NET page or user control and handle its Click event to add your own logic.

Now when we run this, we’ll see the following markup when the page is rendered to the browser:

Notice the control is rendered as a <div> element with an onclick event handler that calls __doPostBack(). And if we click on the panel, the form is posted back to the server, the Click event is raised, and the message below the panel is updated.

Wrap Up

Implementing an interface with a single method should be a pretty simple task. I went a little overboard describing how to implement the IPostBackEventHandler interface, but hopefully now you have all the why’s and how’s to take with you when building your own ASP.NET server controls. If you’re interested in taking this knowledge even further, then I recommend checking out the IPostBackDataHandler, which you must implement if your control needs to examine any data that is posted back by the client.

So to avoid this it’s a best practise to disable the button at client side once the user clicks the button and reenable it after the processing is complete. Disabling the button can be achieved through simple javascript function and an attribute. But the problem is the server side event doesn’t get fired once the button is disabled using javascript.

I found a cool feature to overcome this in ASP.NET 2.0 ClientScript.GetPostBackEventReference. The main function of ClientScript.GetPostBackEventReference is that it returns a string that can be used in a client event to cause postback to the server. http://msdn2.microsoft.com/en-us/library/system.web.ui.clientscriptmanager.getpostbackeventreference.aspx

Code

 
protected void Page_Load(object sender, EventArgs e)
{
btnClick.Attributes.Add(“onclick”, ClientScript.GetPostBackEventReference(btnClick, “”) + “;this.value=’Processing Credit Card Payment…’;this.disabled = true;”);
}
protected void btnClick_Click(object sender, EventArgs e)
{
System.Threading.Thread.Sleep(2000);
}

ASPX Page

<%@ Page Language=”C#” AutoEventWireup=”true” CodeFile=”Default.aspx.cs” Inherits=”_Default” %>

<!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>Untitled Page</title>

</head>

<body>

<form id=”form1″ runat=”server”>

<div>

<asp:Button ID=”btnClick” runat=”server” Text=”ClickMe” OnClick=”btnClick_Click” />

</div>

</form>

</body>

</html>

<h2>
This would do the job perfectly!
</h2>

PPT Contents

• What is ASP.NET? 
• ASP.NET Versions
• Difference Between ASP and ASP.NET
• ASP.NET Architecture Overview
• ASP.NET IIS life cycle Overview
• ASP.NET Page life cycle Overview
• ASP.NET State Management Overview
• ASP.NET Security
• JavaScript, CSS file
• Walkthrough Creating Webpage in ASP.NET
• Ajax- Introduction

JavaScript Code:

function ClearAllFields() {

The Fileupload control does not automatically save a file to server after user have selects files to upload. you must explicit provide a control to allow user to upload specified file.For example , you can provide button that the user click to upload the file.

Write below code in update button click

Protected void btnUpload_Click(object sender, EventArgs e)

{

if (( FileUpload1.PostedFile!=null) &&  FileUpload1.PostedFile.ContentLength >0)

{

String fileName = System.IO.Path.GetFileName(FileUpload1.PostedFile.FileName);

// Create folder in server and name it as “Upload files”. so the user can upload their file in this location

String saveLocation = String.Concat(Server.MapPath(“Upload files”), “\\”, fileName);

}

         try     { 

                 if (FileUpload1.HasFile)   {

                 FileUpload1.PostedFile.SaveAs(saveLocation);

                 Response.Write(“The file has been uploaded.”);

                }

              catch (Exception ex) { Response.Write(“Error: ” + ex.Message);}

}

Before calling SaveAs method to save the file to the server, use the HasFileproperties to verfiy that the fileupload contains a file. if the HasFile return true,call the saveas method,it return false means fileupload does not contain file.

SaveAs method writes the upload file to specified directory, so that create directory for example “Upload files” give the directory path in SaveAs method as parameter. application must have writing access to the directory on the server.

limit the size of the files that can be uploaded by using the FileUpload control. You should set a size limit that is appropriate for the types of files that you expect to be uploaded. The default size limit is 4096 kilobytes (KB), or 4 megabytes (MB). To increase the maximum allowable file size for the entire application, set the maxRequestLengthattribute in the Web.config file. To increase the maximum allowable file size for a specified page, set the maxRequestLength attribute inside the locationelement in Web.config.

For Example

<system.web><httpRuntime maxRequestLength =“90000“/> </system.web>

Download Files Coding

 Response.Clear()

Response.AddHeader(“Content-Disposition”, “attachment;filename=” & file.Name)

Response.WriteFile(file.FullName)

 DownLoadSampleCode: System.Data.Common               

string array rapidly.   

What is XSD?

XSD provides the syntax and defines a way in which element and attributes can represent in Xml Documents.

Below sample code based on XSD file XML file will be validate. In case any error validationEventHandler will invoke and display the error

 // path’s to xml/xsd    

const stringxmlPath = @”\sample.xml”;

const stringxsdPath = @”\sample.xsd”;

// Create a new validating reader

XmlValidatingReader reader = new XmlValidatingReader(newXmlTextReader(newStreamReader(xmlPath)));

// Create a schema collection, add the xsd to it                  XmlSchemaCollection schemaCollection = new XmlSchemaCollection();

schemaCollection.Add(“http://detail.franchise.scarlett”,xsdPath);

// Add the schema collection to the XmlValidatingReader

reader.Schemas.Add(schemaCollection);

Console.Write(“Validating….”);

// Wire up the call back.  The ValidationEvent is fired when the

// XmlValidatingReader hits an issue validating a section of the xml

reader.ValidationEventHandler += new ValidationEventHandler (reader_ValidationEventHandler);

// Iterate through the xml document

while(reader.Read())

{Console.Write(reader.Value);}

Console.WriteLine(“\n”);

Console.ReadLine();}

private void reader_ValidationEventHandler(object sender, ValidationEventArgs e)

{Console.WriteLine(“Error”);

Console.WriteLine(e.Exception.Message);

Console.WriteLine(e.Exception.LineNumber);}}}