asp.net - Was ist der beste Ansatz für die(clientseitige)Deaktivierung einer Submit-Schaltfläche?




javascript jquery webforms .net-1.1 (7)

Einzelheiten:

  • Nur deaktivieren, nachdem der Benutzer auf die Schaltfläche zum Senden geklickt hat, jedoch vor dem Zurückgeben auf den Server
  • ASP.NET-Webformulare (.NET 1.1)
  • Bevorzuge jQuery (falls überhaupt eine Bibliothek)
  • Muss aktiviert werden, wenn das Formular neu geladen wird (dh die Kreditkarte ist ausgefallen)

Das ist keine Notwendigkeit, dass ich das tue, aber wenn es einen einfachen Weg gibt, es zu tun, ohne zu viel ändern zu müssen, werde ich es tun. (dh wenn es keine einfache Lösung gibt, werde ich es wahrscheinlich nicht machen, also mach dir keine Sorgen, zu tief zu graben)


Answers

Es gibt drei Möglichkeiten, ein Formular einzureichen, das abgedeckt werden sollte. Benutze die Vorschläge von David McLaughlin und Jimmy. Einer wird das Formularelement für den Absenden-Button deaktivieren, während der andere das Absenden des einfachen HTML-Formulars deaktiviert.

Für das dritte wird Javascript nicht von einem form.submit () abschalten. Die OnSubmit="return false" -Methode gilt nur, wenn ein Benutzer auf die Schaltfläche OnSubmit="return false" klickt oder in einem Eingabeformularelement die Eingabetaste drückt. Client Side Scripting muss ebenfalls behandelt werden.


Für alle Submit-Schaltflächen über JQuery wäre es:

$('input[type=submit]').click(function() { this.disabled = true; });

Oder es ist sinnvoller, dies bei der Formularübergabe zu tun:

$('form').submit(function() {
    $('input[type=submit]', this).attr("disabled","disabled");
});

Aber ich denke, wir könnten Ihre Frage besser beantworten, wenn wir etwas mehr über den Zusammenhang wissen.

Wenn es sich um eine AJAX-Anforderung handelt, müssen Sie sicherstellen, dass Sie die Schaltflächen zum Senden erneut aktivieren, entweder bei Erfolg oder Misserfolg.

Wenn es sich um eine standardmäßige HTTP-Formularübermittlung handelt (abgesehen von der Deaktivierung der Schaltfläche mit Javascript) und Sie dies tun, um sich vor mehreren Einsendungen desselben Formulars zu schützen, sollten Sie eine gewisse Kontrolle über den Code haben, übermittelte Daten, da das Deaktivieren einer Schaltfläche mit Javascript möglicherweise mehrere Einreichungen nicht verhindert.


in JQuery:

$('#SubmitButtonID').click(function() { this.disabled = true; });

Ich vermute, dass Sie nicht mehr als einmal auf die Schaltfläche "Senden" klicken, während die Übergabe ausgeführt wird.

Mein Ansatz bestand darin, die Schaltfläche nur ganz zu verbergen und stattdessen eine Art Statusanzeige (animiertes GIF usw.) anzuzeigen.

Hier ist ein sehr gekünsteltes Beispiel (es ist technisch im Prototyp, aber ich denke, eine Jquery-Version wäre sehr ähnlich):

<html>
    <head>
        <script type="text/javascript" src="include/js/prototype.js"></script>

        <script type="text/javascript">
            function handleSubmit()
            {
                $('submit').hide();
                $('progressWheel').show();
                return true;
            }
        </script>
    </head>
    <body>
        <img src="include/images/progress-wheel_lg.gif" id="progressWheel" style="display:none;"/>
        <input type="submit" name="submit" id="submit" value="Submit" onclick="handleSubmit();"/>
    </body>
</html>

Wie wäre es mit

Code hinter :

btnContinue3.Attributes.Item ("onclick") = "disableSubmit ()"

Javascript :

function disableSubmit() {
    document.getElementById('btnContinue3').onclick = function() { 
        alert('Please only click once on the submit button!'); return false;
    };
}

Dies löst nicht das Problem, was passiert, wenn das Postback-Zeitlimit überschritten wird, aber abgesehen davon funktionierte es für mich.


Sie könnten so etwas tun:

$('form').submit(function() {
    $(this)
        .find(":submit,:image")             // get all the submit buttons
        .attr({ disabled : 'disabled' })    // disable them
        .end()                              // go back to this form
        .submit(function() {                // change the onsubmit to always reject.
            return false;
        })
    ;
});

Vorteile davon:

  • Es wird mit allen Formularen arbeiten, mit allen Methoden der Einreichung:
    • Klicken auf ein Sendeelement
    • Drücken Sie die Eingabetaste oder
    • Aufruf von form.submit() von einem anderen Code
  • Es werden alle Sendeelemente deaktiviert:
    • <input type="submit"/>
    • <button type="submit"></button>
    • <input type="image" />
  • Es ist wirklich kurz.

Diese Einstellungen können am besten anhand eines Beispiels erläutert werden. Nehmen wir an, wir möchten eine Hierarchie von Mitarbeitern in einem Unternehmen darstellen. Also machen wir eine einfache Klasse wie folgt:

class Employee
{
    public string Name { get; set; }
    public List<Employee> Subordinates { get; set; }
}

Dies ist eine kleine Firma mit nur drei Angestellten: Angela, Bob und Charles. Angela ist der Boss, Bob und Charles sind ihre Untergebenen. Lassen Sie uns die Daten zur Beschreibung dieser Beziehung einrichten:

Employee angela = new Employee { Name = "Angela Anderson" };
Employee bob = new Employee { Name = "Bob Brown" };
Employee charles = new Employee { Name = "Charles Cooper" };

angela.Subordinates = new List<Employee> { bob, charles };

List<Employee> employees = new List<Employee> { angela, bob, charles };

Wenn wir die Liste der Mitarbeiter zu JSON serialisieren ...

string json = JsonConvert.SerializeObject(employees, Formatting.Indented);
Console.WriteLine(json);

... wir bekommen diese Ausgabe:

[
  {
    "Name": "Angela Anderson",
    "Subordinates": [
      {
        "Name": "Bob Brown",
        "Subordinates": null
      },
      {
        "Name": "Charles Cooper",
        "Subordinates": null
      }
    ]
  },
  {
    "Name": "Bob Brown",
    "Subordinates": null
  },
  {
    "Name": "Charles Cooper",
    "Subordinates": null
  }
]

So weit, ist es gut. Sie werden jedoch feststellen, dass die Informationen für Bob und Charles im JSON wiederholt werden, da die Objekte, die sie repräsentieren, sowohl von der Hauptliste der Mitarbeiter als auch von Angelas Liste der Untergebenen referenziert werden. Vielleicht ist das für jetzt okay.

Nun nehmen wir an, wir möchten auch einen Weg haben, den Vorgesetzten jedes Mitarbeiters zusätzlich zu seinen Untergebenen im Auge zu behalten. Daher ändern wir unser Employee , um eine Supervisor Eigenschaft hinzuzufügen ...

class Employee
{
    public string Name { get; set; }
    public Employee Supervisor { get; set; }
    public List<Employee> Subordinates { get; set; }
}

... und fügen unserem Setup-Code noch ein paar Zeilen hinzu, um anzuzeigen, dass Charles und Bob Angela berichten:

Employee angela = new Employee { Name = "Angela Anderson" };
Employee bob = new Employee { Name = "Bob Brown" };
Employee charles = new Employee { Name = "Charles Cooper" };

angela.Subordinates = new List<Employee> { bob, charles };
bob.Supervisor = angela;       // added this line
charles.Supervisor = angela;   // added this line

List<Employee> employees = new List<Employee> { angela, bob, charles };

Aber jetzt haben wir ein kleines Problem. Da das Objektdiagramm Referenzschleifen enthält (z. B. angela references bob und bob references angela ), erhalten wir eine JsonSerializationException wenn wir versuchen, die Mitarbeiterliste zu serialisieren. Eine Möglichkeit, dieses Problem zu Ignore besteht darin, ReferenceLoopHandling wie folgt auf Ignore :

JsonSerializerSettings settings = new JsonSerializerSettings
{
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
    Formatting = Formatting.Indented
};

string json = JsonConvert.SerializeObject(employees, settings);

Mit dieser Einstellung erhalten wir folgendes JSON:

[
  {
    "Name": "Angela Anderson",
    "Supervisor": null,
    "Subordinates": [
      {
        "Name": "Bob Brown",
        "Subordinates": null
      },
      {
        "Name": "Charles Cooper",
        "Subordinates": null
      }
    ]
  },
  {
    "Name": "Bob Brown",
    "Supervisor": {
      "Name": "Angela Anderson",
      "Supervisor": null,
      "Subordinates": [
        {
          "Name": "Charles Cooper",
          "Subordinates": null
        }
      ]
    },
    "Subordinates": null
  },
  {
    "Name": "Charles Cooper",
    "Supervisor": {
      "Name": "Angela Anderson",
      "Supervisor": null,
      "Subordinates": [
        {
          "Name": "Bob Brown",
          "Subordinates": null
        }
      ]
    },
    "Subordinates": null
  }
]

Wenn Sie das JSON untersuchen, sollte klar sein, was diese Einstellung bewirkt: Jedes Mal, wenn der Serializer eine Referenz zurück zu einem Objekt findet, das er gerade serialisiert, überspringt er einfach dieses Mitglied. (Dies verhindert, dass der Serialisierer in eine Endlosschleife gerät.) Sie können sehen, dass in Angelas Liste der Untergebenen im oberen Teil des JSON weder Bob noch Charles einen Supervisor zeigen. Im unteren Teil des JSON zeigen Bob und Charles beide Angela als ihren Vorgesetzten, aber beachten Sie, dass die Liste ihrer Untergebenen zu diesem Zeitpunkt nicht Bob und Charles einschließt.

Es ist zwar möglich, mit diesem JSON zu arbeiten und vielleicht sogar die ursprüngliche Objekthierarchie mit etwas Arbeit zu rekonstruieren, aber es ist eindeutig nicht optimal. Wir können die wiederholten Informationen in JSON entfernen, während die Objektreferenzen PreserveReferencesHandling indem stattdessen die Einstellung PreserveReferencesHandling verwendet wird:

JsonSerializerSettings settings = new JsonSerializerSettings
{
    PreserveReferencesHandling = PreserveReferencesHandling.Objects,
    Formatting = Formatting.Indented
};

string json = JsonConvert.SerializeObject(employees, settings);

Jetzt bekommen wir folgendes JSON:

[
  {
    "$id": "1",
    "Name": "Angela Anderson",
    "Supervisor": null,
    "Subordinates": [
      {
        "$id": "2",
        "Name": "Bob Brown",
        "Supervisor": {
          "$ref": "1"
        },
        "Subordinates": null
      },
      {
        "$id": "3",
        "Name": "Charles Cooper",
        "Supervisor": {
          "$ref": "1"
        },
        "Subordinates": null
      }
    ]
  },
  {
    "$ref": "2"
  },
  {
    "$ref": "3"
  }
]

Beachten Sie, dass nun jedem Objekt im JSON ein sequenzieller $id Wert zugewiesen wurde. Wenn ein Objekt das erste Mal auftritt, wird es vollständig serialisiert, während nachfolgende Referenzen durch eine spezielle $ref Eigenschaft ersetzt werden, die auf das ursprüngliche Objekt mit der entsprechenden $id verweist. Mit dieser Einstellung ist das JSON viel prägnanter und kann ohne zusätzliche Arbeit in die ursprüngliche Objekthierarchie deserialisiert werden, vorausgesetzt, Sie verwenden eine Bibliothek, die die von Json.Net / Web erzeugte Schreibweise $id und $ref versteht API.

Warum also wählten Sie die eine oder die andere Einstellung? Es hängt natürlich von Ihren Bedürfnissen ab. Wenn der JSON von einem Client konsumiert wird, der das $id / $ref Format nicht versteht und unvollständige Daten an einigen Stellen tolerieren kann, würden Sie sich für ReferenceLoopHandling.Ignore . Wenn Sie nach einem kompakteren JSON suchen und die JSer.Net- oder Web-API (oder eine andere kompatible Bibliothek) zum Deserialisieren der Daten verwenden möchten, verwenden Sie PreserveReferencesHandling.Objects . Wenn Ihre Daten ein gerichteter azyklischer Graph ohne doppelte Referenzen sind, brauchen Sie keine Einstellung.





asp.net javascript jquery webforms .net-1.1