MVC, deren Senden-Taste gedrückt wurde

Ich habe zwei Schaltflächen in meinem MVC-Formular:

<input name="submit" type="submit" id="submit" value="Save" />
<input name="process" type="submit" id="process" value="Process" />

Woher weiß ich aus meiner Controller-Aktion, welche gedrückt wurden?

Benennen Sie beide Senden-Schaltflächen gleich

<input name="submit" type="submit" id="submit" value="Save" />
<input name="submit" type="submit" id="process" value="Process" />

Dann erhalten Sie in Ihrem Controller den Wert von submit. Nur die angeklickte Schaltfläche übergibt ihren Wert.

public ActionResult Index(string submit)
{
    Response.Write(submit);
    return View();
}

Sie können diesen Wert natürlich bewerten, um verschiedene Operationen mit einem Schalterblock auszuführen.

public ActionResult Index(string submit)
{
    switch (submit)
    {
        case "Save":
            // Do something
            break;
        case "Process":
            // Do something
            break;
        default:
            throw new Exception();
            break;
    }

    return View();
}

<input name="submit" type="submit" id="submit" value="Save" />
<input name="process" type="submit" id="process" value="Process" />

Und in Ihrer Controller-Aktion:

public ActionResult SomeAction(string submit)
{
    if (!string.IsNullOrEmpty(submit))
    {
        // Save was pressed
    }
    else
    {
        // Process was pressed
    }
}

Dies ist eine bessere Antwort, sodass wir sowohl Text als auch Wert für eine Schaltfläche haben können:

http://weblogs.asp.net/dfindley/archive/2009/05/31/asp-net-mvc-multiple-buttons-in-the-same-form.aspx

</p>
<button name="button" value="register">Register</button>
<button name="button" value="cancel">Cancel</button>
</p>

und der Controller:

public ActionResult Register(string button, string userName, string email, string password, string confirmPassword)
{
if (button == "cancel")
    return RedirectToAction("Index", "Home");
...

Kurz gesagt, es ist eine SUBMIT-Schaltfläche, aber Sie wählen den Namen mithilfe des Namensattributs. Dies ist sogar noch leistungsfähiger, da Sie nicht an den Namen Submit oder die Schaltfläche in den Parametern der Controller-Methode gebunden sind. Sie können ihn nach Belieben aufrufen.

Sie können Ihre Schaltfläche anhand des Namensschilds wie unten identifizieren. Sie müssen dies in Ihrem Controller überprüfen

if (Request.Form["submit"] != null)
{
//Write your code here
}
else if (Request.Form["process"] != null)
{
//Write your code here
}

Hier ist eine wirklich schöne und einfache Möglichkeit, dies mit wirklich einfach zu befolgenden Anweisungen unter Verwendung eines benutzerdefinierten MultiButtonAttribute zu tun:

http://blog.maartenballiauw.be/post/2009/11/26/Supporting-multiple-submit-buttons-on-an-ASPNET-MVC-view.aspx

Um es zusammenzufassen, machen Sie Ihre Senden-Schaltflächen wie folgt:

<input type="submit" value="Cancel" name="action" />
<input type="submit" value="Create" name="action" /> 

Ihre Aktionen wie folgt:

[HttpPost]
[MultiButton(MatchFormKey="action", MatchFormValue="Cancel")]
public ActionResult Cancel()
{
    return Content("Cancel clicked");
}

[HttpPost]
[MultiButton(MatchFormKey = "action", MatchFormValue = "Create")]
public ActionResult Create(Person person)
{
    return Content("Create clicked");
} 

Und erstelle diese Klasse:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public class MultiButtonAttribute : ActionNameSelectorAttribute
{
    public string MatchFormKey { get; set; }
    public string MatchFormValue { get; set; }

    public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo)
    {
        return controllerContext.HttpContext.Request[MatchFormKey] != null &&
            controllerContext.HttpContext.Request[MatchFormKey] == MatchFormValue;
    }
}

// Buttons
<input name="submit" type="submit" id="submit" value="Save" />
<input name="process" type="submit" id="process" value="Process" />

// Controller
[HttpPost]
public ActionResult index(FormCollection collection)
{
    string submitType = "unknown";

    if(collection["submit"] != null)
    {
        submitType = "submit";
    }
    else if (collection["process"] != null)
    {
        submitType = "process";
    }

} // End of the index method

Um es einfacher zu machen, werde ich sagen, dass Sie Ihre Schaltflächen wie folgt ändern können:

<input name="btnSubmit" type="submit" value="Save" />
<input name="btnProcess" type="submit" value="Process" />

Ihr Controller:

public ActionResult Create(string btnSubmit, string btnProcess)
{
    if(btnSubmit != null)
       // do something for the Button btnSubmit
    else 
       // do something for the Button btnProcess
}

Dieser Beitrag wird Coppermill nicht beantworten, da er vor langer Zeit beantwortet wurde. Mein Beitrag ist hilfreich für diejenigen, die nach einer solchen Lösung suchen. Zunächst muss ich sagen, dass "WDuffys Lösung völlig korrekt ist" und gut funktioniert, aber meine Lösung (nicht meine) wird in anderen Elementen verwendet und macht die Präsentationsschicht unabhängiger vom Controller (da Ihr Controller davon abhängt "Wert", der zum Anzeigen der Beschriftung der Schaltfläche verwendet wird. Diese Funktion ist für andere Sprachen wichtig.).

Hier ist meine Lösung, gib ihnen verschiedene Namen:

<input type="submit" name="buttonSave" value="Save"/>
<input type="submit" name="buttonProcess" value="Process"/>
<input type="submit" name="buttonCancel" value="Cancel"/>

Und Sie müssen die Namen der Schaltflächen als Argumente in der folgenden Aktion angeben:

public ActionResult Register(string buttonSave, string buttonProcess, string buttonCancel)
{
    if (buttonSave!= null)
    {
        //save is pressed
    }
    if (buttonProcess!= null)
    {
        //Process is pressed
    }
    if (buttonCancel!= null)
    {
        //Cancel is pressed
    }
}

Wenn der Benutzer die Seite mit einer der Schaltflächen sendet, hat nur eines der Argumente einen Wert. Ich denke, das wird für andere hilfreich sein.

Aktualisieren

Diese Antwort ist ziemlich alt und ich überdenke meine Meinung tatsächlich. Vielleicht ist die obige Lösung gut für Situationen, in denen Parameter an die Eigenschaften des Modells übergeben werden. Machen Sie sich keine Sorgen und finden Sie die beste Lösung für Ihr Projekt.

Können Sie es mit Request.Form Collection nicht herausfinden? Wenn auf Prozess geklickt wird, ist das Anfrageformular ["Prozess"] nicht leer

Geben Sie beiden Schaltflächen den Namen und überprüfen Sie den Wert aus dem Formular.

<div>
   <input name="submitButton" type="submit" value="Register" />
</div>

<div>
   <input name="cancelButton" type="submit" value="Cancel" />
</div>

Auf der Controllerseite:

public ActionResult Save(FormCollection form)
{
 if (this.httpContext.Request.Form["cancelButton"] !=null)
 {
   // return to the action;
 }

else if(this.httpContext.Request.Form["submitButton"] !=null)
 {
   // save the oprtation and retrun to the action;
 }
}

In Core 2.2 Razor-Seiten funktioniert diese Syntax:

    <button type="submit" name="Submit">Save</button>
    <button type="submit" name="Cancel">Cancel</button>
public async Task<IActionResult> OnPostAsync()
{
    if (!ModelState.IsValid)
        return Page();
    var sub = Request.Form["Submit"];
    var can = Request.Form["Cancel"];
    if (sub.Count > 0)
       {
       .......