Personally, I prefer to keep my javascript separate from the code-behind. This is how I structured my final solution:

Submit Button:

<asp:Button ID="btnSubmit" runat="server" Text="Submit" OnClick="btnSubmit_Click" OnClientClick="doSubmit(this)" />

Custom Javascript:

<script type="text/javascript"><--
function doSubmit(btnSubmit) {
    if (typeof(Page_ClientValidate) == 'function' && Page_ClientValidate() == false) { 
        return false;
    }    
    btnSubmit.disabled = 'disabled';
    btnSubmit.value = 'Processing. This may take some time...';
    <%= ClientScript.GetPostBackEventReference(btnSubmit, string.Empty) %>;    
}
-->
</script>

This handy function eliminates the need for unreliable disabling code. Simply add "return check_submit();" to the onclick handler of your submit buttons.

It's also important to include a hidden field to store the initial value of form_submitted as 0;

<input type="hidden" name="form_submitted" value="0">

function check_submit (){
            if (document.Form1.form_submitted.value == 1){
                alert("Please refrain from submitting multiple times. Kindly wait.");
                return false;
            }
            else{
                document.Form1.form_submitted.value = 1;
                return true;
            }
            return false;
    }

Make sure to deactivate the button once your submit function is complete. If the validation does not pass, make sure to prevent the button from being clicked before that point.

It's important to remember that relying solely on JavaScript for validation is not reliable. Implement a server-side check for duplicates to enhance the security of your application.

After the validation process is complete, the button will be disabled if the validation is successful. If the validation fails, the button will remain enabled.

function validationCheck(form) {
  // Validate the form inputs here
  if (isValid) {
    form.submitButton.disabled = true;
    return true;
  } else {
    return false;
  }
}

<form onsubmit="return validationCheck(this);">...</form>

Hide the button by setting its visibility to 'none';

btnSubmit.Attributes("onClick") = document.getElementById('btnName').style.display = 'none';

By doing this, you not only prevent the button from being clicked multiple times, but also communicate to the user that the action should only be performed once.

Perhaps you may find this information useful: there is an onsubmit event in the form. This event can be utilized whenever the form is submitted, regardless of which button or controls trigger it. For more information, you can visit:

To resolve this issue, one approach is to assign a hidden field with the value of 1 upon clicking the button.

Within the button click handler, the initial step is to verify the value of the hidden field. If it differs from 1, simply exit the function.

Another option is to utilize the onsubmit() javascript event on forms. This event triggers when the form is submitted and should not be blocked until validation is done.

Here is a simpler yet similar approach to what was suggested by rp:

function disableButton(button) {
        Page_ClientValidate(); 
        if(Page_IsValid)
        {
            button.disabled = true;
        }
}

 <asp:Button runat="server" ID="btnSubmit" OnClick="btnSubmit_OnClick" OnClientClick="disableButton(this)" Text="Submit Me" />

Please take note that rp's method may result in double form submission when using buttons with UseSubmitBehavior="false".

My customized version of rp's code is as follows:

public static void DisableButtonOnClick(Button button, string clientFunction)
{
    // Ensure page validation is successful if ASP.NET validators are present
    string script = "if (typeof(Page_ClientValidate) == 'function') { "
            + "if (!Page_ClientValidate()) { return false; } } ";

    // Disable the button
    script += "this.disabled = true; ";

    // Call secondary JavaScript function if provided and valid
    // Function name should be passed without parentheses
    if (!string.IsNullOrEmpty(clientFunction))
        script += string.Format("if (typeof({0}) == 'function') {{ {0}() }} ", clientFunction);

    // Post back only if button is using submit behavior
    if (button.UseSubmitBehavior)
        script += button.Page.GetPostBackEventReference(button) + "; ";

    button.Attributes.Add("onclick", script);
}

To ensure a user-friendly experience, it is recommended to disable the button using the OnClientClick attribute for client-side validation. Once the validation is successful, you can continue or re-enable the button accordingly.

It is important to note that server-side code should also be implemented to account for cases where JavaScript validation is not executed. If the server controls the button's state, preventing multiple form submissions becomes challenging. To address this issue, consider implementing logic to detect and prevent multiple submissions from the same user within a short timeframe (e.g., tracking identical values from the same Session).

Here is a solution that may work for you:

Start by adding the following script to the page_load function in your aspx file:

    HtmlGenericControl includeMyJava = new HtmlGenericControl("script");
    includeMyJava.Attributes.Add("type", "text/javascript");
    includeMyJava.InnerHtml = "\nfunction disableButton(button) {";
    includeMyJava.InnerHtml += "\nPage_ClientValidate();";
    includeMyJava.InnerHtml += "\nif(Page_IsValid)";
    includeMyJava.InnerHtml += "\n{";
    includeMyJava.InnerHtml += "\nbutton.disabled = true;";
    includeMyJava.InnerHtml += "}";
    includeMyJava.InnerHtml += "\n}";
    this.Page.Header.Controls.Add(includeMyJava);

Next, make sure to set your aspx button's parameters like this:

<asp:Button ID="submit" runat="server" UseSubmitBehavior="false" OnClientClick="disableButton(this);" Text="Submit" OnClick="submit_Click" />

Keep in mind that "onClientClick" is used to disable the button, while "UseSubmitBehavior" prevents the default submission behavior and lets asp.net handle the submission through user script.

Best of luck!

-Waqas Aslam

Recently learned about the "DisableOnSubmit" feature of an <asp:Button>, which can be implemented like this:

<asp:Button ID="submit" runat="server" Text="Save"
    OnClick="yourClickEvent" DisableOnSubmit="true" />

Upon rendering, the button's onclick attribute is set as follows:

onclick="this.disabled=true; setTimeout('enableBack()', 3000);
  WebForm_DoPostBackWithOptions(new
  WebForm_PostBackOptions('yourControlsName', '', true, '', '', false, true))

The "enableBack()' function in javascript is responsible for re-enabling the button:

function enableBack()
{
    document.getElementById('yourControlsName').disabled=false;
}

By clicking the button, it will be disabled for 3 seconds. If the form submits successfully, the button will not be re-enabled. However, if any validators fail, the button will become enabled again after 3 seconds.

All of this functionality is achieved simply by setting an attribute on the button without the need to manually write javascript code.

Just relying on disabling the button with javascript may not work across all browsers. For example, Chrome may not submit the form if you simply use

OnClientClick="this.disabled=true;"

. To ensure cross-browser compatibility, here's a solution that I have successfully tested in Firefox 9, Internet Explorer 9, and Chrome 16:

<script type="text/javascript">
var buttonToDisable;
function disableButton(sender)
{
    buttonToDisable=sender;
    setTimeout('if(Page_IsValid==true)buttonToDisable.disabled=true;', 10);
}
</script>

You can then attach the 'disableButton' function to the click event of your form submission button, like this:

<asp:Button runat="server" ID="btnSubmit" Text="Submit" OnClientClick="disableButton(this);" />

This method not only resolves the issue of the button staying disabled if client side validation fails, but it also eliminates the need for any server side processing.

Expanding on the previous answer from @rp., I have made adjustments to incorporate a custom function that will either submit and disable upon success or stop on error:

public static void DisableButtonOnClick(Button ButtonControl, string ClientFunction)
{
    StringBuilder scriptBuilder = new StringBuilder(128);

    if (!String.IsNullOrEmpty(ClientFunction))
    {
        scriptBuilder.AppendFormat("if (typeof({0}) == 'function') {{ if ({0}()) {{ {1}; this.disabled=true; return true; }} else {{ return false; }} }};", ClientFunction, ButtonControl.Page.ClientScript.GetPostBackEventReference(ButtonControl, null));
    }
    else
    {
        scriptBuilder.Append("return true;");
    }

    ButtonControl.Attributes.Add("onclick", scriptBuilder.ToString());
}

While exploring the code written by rp in one of our older applications, we encountered some unexpected behavior.

After some investigation, we discovered that when using DisableButtonOnClick() on an ASP button within an UpdatePanel, the POST request was being sent twice - once by the doPostBack method added by DisableButtonOnClick(), and once by the UpdatePanel. Interestingly, this issue only occurred with certain browsers (such as older versions of Edge and IE11, but not with Chrome or FireFox). It seems that Chrome and newer versions of Edge handle this situation differently, possibly resolving the problem internally. In Internet Explorer, using F12 developer tools, we observed that the two POST requests occurred so rapidly that the first one was immediately aborted. However, under certain conditions like network latency or high user machine load, the request did manage to reach the server before being aborted by the browser. This led to unexpected double-posting from button clicks throughout the system, making it difficult to identify the root cause. The solution we found was to add a "return false;" statement after the doPostBack function to prevent the UpdatePanel from interfering when older browsers are used.

In summary, be cautious when using this code on buttons within UpdatePanels, as it may cause unexpected behavior, particularly in older browser versions.

Additional note: I wanted to comment on rp's post, but I lack the reputation to do so. I hope this information is helpful for future users encountering similar issues.