दिलचस्प पोस्ट
होस्ट 'xxx.xx.xxx.xxx' को इस MySQL सर्वर से कनेक्ट करने की अनुमति नहीं है आप SQL सर्वर तालिका की प्राथमिक कुंजी कैसे सूचीबद्ध करते हैं? 'करीइंग' क्या है? एंड्रॉइड में मैं एक बिंदीदार / धराशायी रेखा कैसे बना सकता हूं? ओरेकल डाटाबेस लिंक – MySQL समतुल्य? एचटीएमएल: वैकल्पिक समापन टैग को शामिल करना, या बहिष्कृत करना? डीपीआई-एवेयर एप्लिकेशन बनाना PHP का उपयोग करते हुए दो तिथियों के बीच अंतर की गणना कैसे करें? मैं सी में const / literal तार को कैसे जोड़ूं? शैली कैसे करें <option> केवल सीएसएस के साथ? PHP कर्ल के साथ दूरस्थ साइट पर लॉग इन करें अवैध JSON वेब टोकन AngularJS में सशर्त रूप से लागू गुणों का सबसे अच्छा तरीका क्या है? एंड्रॉइड में कस्टम रेडियो बटन जोड़ना डायरेक्टिव से नियंत्रक तक एक AngularJS स्कोप चर को पारित करने का सबसे आसान तरीका?

आप asp.net MVC फ्रेमवर्क में एकाधिक सबमिट बटन कैसे संभाल सकते हैं?

क्या एक ही रूप से एकाधिक सबमिट बटन को संभालने का कोई आसान तरीका है? उदाहरण:

<% Html.BeginForm("MyAction", "MyController", FormMethod.Post); %> <input type="submit" value="Send" /> <input type="submit" value="Cancel" /> <% Html.EndForm(); %> 

एएसपी.नेट फ्रेमवर्क बीटा में यह कैसे करना है? उन सभी उदाहरणों के लिए जिनके लिए मैंने गॉगल किया है उनमें एकल बटन हैं।

वेब के समाधान से एकत्रित समाधान "आप asp.net MVC फ्रेमवर्क में एकाधिक सबमिट बटन कैसे संभाल सकते हैं?"

यहां पर एक बहुसंख्यक सबमिट बटन मुद्दे के आधार पर अत्यधिक स्वच्छ गुण-आधारित समाधान है, जो पोस्ट के आधार पर बहुत अधिक है और मार्टिन बल्लियाव से टिप्पणियां

 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)] public class MultipleButtonAttribute : ActionNameSelectorAttribute { public string Name { get; set; } public string Argument { get; set; } public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo) { var isValidName = false; var keyValue = string.Format("{0}:{1}", Name, Argument); var value = controllerContext.Controller.ValueProvider.GetValue(keyValue); if (value != null) { controllerContext.Controller.ControllerContext.RouteData.Values[Name] = Argument; isValidName = true; } return isValidName; } } 

उस्तरा:

 <form action="" method="post"> <input type="submit" value="Save" name="action:Save" /> <input type="submit" value="Cancel" name="action:Cancel" /> </form> 

और नियंत्रक:

 [HttpPost] [MultipleButton(Name = "action", Argument = "Save")] public ActionResult Save(MessageModel mm) { ... } [HttpPost] [MultipleButton(Name = "action", Argument = "Cancel")] public ActionResult Cancel(MessageModel mm) { ... } 

अपडेट: बॉक्स के बाहर रेज़र पेज ही कार्यक्षमता प्रदान करने लगते हैं। नए विकास के लिए, यह बेहतर होगा

अपने सबमिट बटन को एक नाम दें, और फिर अपने नियंत्रक पद्धति में सबमिट किए गए मान का निरीक्षण करें:

 <% Html.BeginForm("MyAction", "MyController", FormMethod.Post); %> <input type="submit" name="submitButton" value="Send" /> <input type="submit" name="submitButton" value="Cancel" /> <% Html.EndForm(); %> 

पोस्ट करने के लिए

 public class MyController : Controller { public ActionResult MyAction(string submitButton) { switch(submitButton) { case "Send": // delegate sending to another controller action return(Send()); case "Cancel": // call another action to perform the cancellation return(Cancel()); default: // If they've submitted the form without a submitButton, // just return the view again. return(View()); } } private ActionResult Cancel() { // process the cancellation request here. return(View("Cancelled")); } private ActionResult Send() { // perform the actual send operation here. return(View("SendConfirmed")); } } 

संपादित करें:

स्थानीयकृत साइट्स के साथ काम करने के लिए इस दृष्टिकोण का विस्तार करने के लिए, अपने संदेशों को कहीं और अलग करें (जैसे किसी संसाधन फ़ाइल को एक दृढ़ता से टाइप किए गए संसाधन वर्ग में संकलित करना)

फिर कोड को संशोधित करें ताकि यह काम करता हो:

 <% Html.BeginForm("MyAction", "MyController", FormMethod.Post); %> <input type="submit" name="submitButton" value="<%= Html.Encode(Resources.Messages.Send)%>" /> <input type="submit" name="submitButton" value="<%=Html.Encode(Resources.Messages.Cancel)%>" /> <% Html.EndForm(); %> 

और आपका नियंत्रक इस तरह दिखना चाहिए:

 // Note that the localized resources aren't constants, so // we can't use a switch statement. if (submitButton == Resources.Messages.Send) { // delegate sending to another controller action return(Send()); } else if (submitButton == Resources.Messages.Cancel) { // call another action to perform the cancellation return(Cancel()); } 

जैसा कि उल्लेख किया गया है, आप कार्रवाई में नाम की जांच कर सकते हैं, लेकिन आप यह सोच सकते हैं कि यह अच्छा डिजाइन है या नहीं। यह एक अच्छा विचार है कि कार्रवाई की ज़िम्मेदारी पर विचार करें और कुछ नहीं, इस डिजाइन को बटन नामों जैसे यूआई पहलुओं के लिए बहुत अधिक है। तो 2 रूपों और 2 क्रियाओं का उपयोग करने पर विचार करें:

 <% Html.BeginForm("Send", "MyController", FormMethod.Post); %> <input type="submit" name="button" value="Send" /> <% Html.EndForm(); %> <% Html.BeginForm("Cancel", "MyController", FormMethod.Post); %> <input type="submit" name="button" value="Cancel" /> <% Html.EndForm(); %> 

साथ ही, "रद्द करें" के मामले में, आप आमतौर पर केवल प्रसंस्करण नहीं कर रहे हैं और एक नए URL पर जा रहे हैं। इस मामले में आपको फॉर्म को बिल्कुल भी सबमिट करने की आवश्यकता नहीं है और सिर्फ एक लिंक की आवश्यकता है:

 <%=Html.ActionLink("Cancel", "List", "MyController") %> 

एलॉन सुझाव देता है कि आप ऐसा कर सकते हैं:

यदि आपके पास एक से अधिक बटन हैं तो आप प्रत्येक बटन को एक नाम देकर उनमें अंतर कर सकते हैं:

 <input type="submit" name="SaveButton" value="Save data" /> <input type="submit" name="CancelButton" value="Cancel and go back to main page" /> 

आपके नियंत्रक क्रिया विधि में आप HTML इनपुट टैग नामों के नाम पर पैरामीटर जोड़ सकते हैं:

 public ActionResult DoSomeStuff(string saveButton, string cancelButton, ... other parameters ...) { ... } 

यदि कोई मान उन मानकों में से किसी पर पोस्ट हो जाता है, तो इसका मतलब है कि बटन क्लिक किया गया था। वेब ब्राउज़र केवल एक क्लिक के लिए एक मान पोस्ट करेगा। अन्य सभी मान शून्य हो जाएंगे।

 if (saveButton != null) { /* do save logic */ } if (cancelButton != null) { /* do cancel logic */ } 

मुझे यह तरीका पसंद है क्योंकि यह सबमिट बटनों की मान की संपत्ति पर भरोसा नहीं करता है जो असाइन किए गए नामों की तुलना में अधिक होने की संभावना है और जावास्क्रिप्ट सक्षम होने की आवश्यकता नहीं है

देखें: http://forums.asp.net/p/1369617/2865166.aspx#2865166

बस इसके बारे में एक पोस्ट लिखा है: एकाधिक asp.net MVC के साथ सबमिट बटन :

असल में, ActionMethodSelectorAttribute का उपयोग करने के बजाय, मैं ActionMethodSelectorAttribute का उपयोग कर रहा हूँ, जो मुझे ActionMethodSelectorAttribute कि कार्रवाई का नाम है जो मैं चाहता हूं कि वह होना चाहिए। सौभाग्य से, ActionNameSelectorAttribute सिर्फ मुझे कार्रवाई नाम निर्दिष्ट नहीं करता है, इसके बजाय मैं चुन सकता हूँ कि वर्तमान क्रिया अनुरोधों से मेल खाता है या नहीं

तो मेरी कक्षा है (बीटीडब्ल्यू मैं नाम का बहुत शौक नहीं हूं):

 public class HttpParamActionAttribute : ActionNameSelectorAttribute { public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo) { if (actionName.Equals(methodInfo.Name, StringComparison.InvariantCultureIgnoreCase)) return true; if (!actionName.Equals("Action", StringComparison.InvariantCultureIgnoreCase)) return false; var request = controllerContext.RequestContext.HttpContext.Request; return request[methodInfo.Name] != null; } } 

बस इस तरह से एक फार्म को परिभाषित करने के लिए उपयोग करें:

 <% using (Html.BeginForm("Action", "Post")) { %> <!— …form fields… --> <input type="submit" name="saveDraft" value="Save Draft" /> <input type="submit" name="publish" value="Publish" /> <% } %> 

और दो विधियों के साथ नियंत्रक

 public class PostController : Controller { [HttpParamAction] [AcceptVerbs(HttpVerbs.Post)] public ActionResult SaveDraft(…) { //… } [HttpParamAction] [AcceptVerbs(HttpVerbs.Post)] public ActionResult Publish(…) { //… } } 

जैसा कि आप देख रहे हैं, इस विशेषता के लिए आपको कुछ भी निर्दिष्ट करने की आवश्यकता नहीं है। इसके अलावा, बटन का नाम सीधे विधि नामों में अनुवाद किया जाता है इसके अतिरिक्त (मैंने ऐसा करने की कोशिश नहीं की है) इन्हें सामान्य कार्यों के रूप में भी काम करना चाहिए, ताकि आप इनमें से किसी भी पर सीधे पोस्ट कर सकें

मैं सुझाव देता हूं कि इच्छुक पार्टियों ने मार्टन बल्लियाव के समाधान पर एक नज़र डाला है । मुझे लगता है कि यह बहुत खूबसूरत है

यदि लिंक को गायब हो जाता है, तो यह MultiButton एट्रिब्यूट का इस्तेमाल नियंत्रक कार्रवाई के लिए लागू किया गया है, यह इंगित करने के लिए कि कौन से बटन क्लिक करें जो उस क्रिया से संबंधित होना चाहिए।

यह छोटा और सूट है:

इसे जेरोनी डॉप ने उत्तर दिया

 <input type="submit" name="submitbutton1" value="submit1" /> <input type="submit" name="submitbutton2" value="submit2" /> 

और इस तरह से कोड के पीछे की तरह

  if( Request.Form["submitbutton1"] != null) { // Code for function 1 } else if(Request.Form["submitButton2"] != null ) { // code for function 2 } 

सौभाग्य।

आपको बटनों को नाम देने में सक्षम होना चाहिए और उन्हें एक मूल्य देना चाहिए; फिर कार्रवाई के लिए एक तर्क के रूप में इस नाम को मैप करें वैकल्पिक रूप से, 2 अलग एक्शन-लिंक या 2 फॉर्म का उपयोग करें।

आप लिख सकते हैं:

 <% Html.BeginForm("MyAction", "MyController", FormMethod.Post); %> <input type="submit" name="button" value="Send" /> <input type="submit" name="button" value="Cancel" /> <% Html.EndForm(); %> 

और फिर पृष्ठ में जांचें कि नाम == "भेजें" या नाम == "रद्द करें" …

ActionSelectName के बारे में मुझे कुछ पसंद नहीं है कि IsValidName को नियंत्रक में प्रत्येक एक्शन विधि के लिए कहा जाता है; मुझे नहीं पता कि यह इस तरह से काम क्यों करता है मुझे ऐसे समाधान की तरह है जहां हर बटन के आधार पर अलग-अलग नाम होता है, लेकिन मुझे इस तथ्य को पसंद नहीं है कि आपको कार्रवाई विधि में कई मापदंडों के रूप में बटन के रूप में रखना होगा। मैंने सभी बटन प्रकारों के लिए एक एन्यूम बनाया है:

 public enum ButtonType { Submit, Cancel, Delete } 

ActionSelectName के बजाय, मैं एक ActionFilter का उपयोग करता हूं:

 public class MultipleButtonsEnumAttribute : ActionFilterAttribute { public Type EnumType { get; set; } public MultipleButtonsEnumAttribute(Type enumType) { EnumType = enumType; } public override void OnActionExecuting(ActionExecutingContext filterContext) { foreach (var key in filterContext.HttpContext.Request.Form.AllKeys) { if (Enum.IsDefined(EnumType, key)) { var pDesc = filterContext.ActionDescriptor.GetParameters() .FirstOrDefault(x => x.ParameterType == EnumType); filterContext.ActionParameters[pDesc.ParameterName] = Enum.Parse(EnumType, key); break; } } } } 

फिल्टर फॉर्म डेटा में बटन का नाम मिलेगा और यदि बटन नाम किसी भी प्रकार के बटन से मेल खाता है, तो यह एट्यूमेन्ट पैरामीटर के बीच ButtonType पैरामीटर को मिलेगा:

 [MultipleButtonsEnumAttribute(typeof(ButtonType))] public ActionResult Manage(ButtonType buttonPressed, ManageViewModel model) { if (button == ButtonType.Cancel) { return RedirectToAction("Index", "Home"); } //and so on return View(model) } 

और फिर विचारों में, मैं इसका उपयोग कर सकता हूं:

 <input type="submit" value="Button Cancel" name="@ButtonType.Cancel" /> <input type="submit" value="Button Submit" name="@ButtonType.Submit" /> 

यह मेरे लिए सबसे अच्छा काम करता है:

 <input type="submit" value="Delete" name="onDelete" /> <input type="submit" value="Save" name="onSave" /> public ActionResult Practice(MyModel model, string onSave, string onDelete) { if (onDelete != null) { // Delete the object ... return EmptyResult(); } // Save the object ... return EmptyResult(); } 

मैं इस 'समस्या' के रूप में अच्छी तरह से आया हूं, लेकिन name विशेषता को जोड़कर एक बहुत ही तार्किक समाधान पाया। मैं अन्य भाषाओं में इस समस्या को याद नहीं कर सका।

http://www.w3.org/TR/html401/interact/forms.html#h-17.13.2

  • यदि कोई फ़ॉर्म में एक से अधिक सबमिट बटन होता है, तो केवल सक्रिय सबमिट बटन ही सफल होता है

जिसका मतलब है कि निम्नलिखित कोड value विशेषताओं को बदला जा सकता है, स्थानीयकृत, अंतरराष्ट्रीयकृत बिना अतिरिक्त कोड की आवश्यकता के बिना दृढ़ता से टाइप किए गए संसाधन फ़ाइलें या स्थिरांक।

 <% Html.BeginForm("MyAction", "MyController", FormMethod.Post); %> <input type="submit" name="send" value="Send" /> <input type="submit" name="cancel" value="Cancel" /> <input type="submit" name="draft" value="Save as draft" /> <% Html.EndForm(); %>` 

प्राप्त करने के अंत में आपको केवल यह जांचना होगा कि क्या आपके ज्ञात सबमिट प्रकारों में से कोई भी null नहीं है

 public ActionResult YourAction(YourModel model) { if(Request["send"] != null) { // we got a send }else if(Request["cancel"]) { // we got a cancel, but would you really want to post data for this? }else if(Request["draft"]) { // we got a draft } } 

डेविड Findley अपने एएसपी.नेट वेबलॉग पर ऐसा करने के लिए आपके बारे में 3 अलग-अलग विकल्प लिखते हैं।

अपने समाधान देखने और प्रत्येक के फायदे और नुकसान देखने के लिए उसी प्रकार के आलेख के कई बटन पढ़ें। आईएमएचओ वह एक बहुत ही खूबसूरत समाधान प्रदान करता है जो आपके गुणों का उपयोग करता है जो कि आप अपनी कार्रवाई को सजते हैं।

यह वह तकनीक है जिसका उपयोग मैं करूंगा और मैं इसे यहां तक ​​नहीं देखता हूं। लिंक (साजिद इस्माइल द्वारा पोस्ट किया गया) जो इस समाधान को प्रेरित करता है http://weblogs.asp.net/dfindley/archive/2009/05/31/asp-net-mvc-multiple-buttons-in-the-same-form .aspx ) यह किसी भी समस्याओं के बिना स्थानीयकरण करने के लिए डायलन बेट्टी के उत्तर का अनुकूलन करता है।

दृश्य में:

 <% Html.BeginForm("MyAction", "MyController", FormMethod.Post); %> <button name="button" value="send"><%: Resources.Messages.Send %></button> <button name="button" value="cancel"><%: Resources.Messages.Cancel %></button> <% Html.EndForm(); %> 

नियंत्रक में:

 public class MyController : Controller { public ActionResult MyAction(string button) { switch(button) { case "send": this.DoSend(); break; case "cancel": this.DoCancel(); break; } } } 

यदि आपके पास एचटीएमएल 5 के उपयोग पर प्रतिबंध नहीं है, तो आप <button> टैग के साथ formaction विशेषता का उपयोग कर सकते हैं:

 <form action="demo_form.asp" method="get"> First name: <input type="text" name="fname" /><br /> Last name: <input type="text" name="lname" /><br /> <button type="submit">Submit</button><br /> <button type="submit" formaction="demo_admin.asp">Submit as admin</button> </form> 

संदर्भ: http://www.w3schools.com/html5/att_button_formaction.asp

यह स्क्रिप्ट डेटा-फॉर्म-एक्शन एट्रिब्यूट को निर्दिष्ट करने की अनुमति देता है जो सभी ब्राउज़रों में एक HTML5 फार्मानमेंट एट्रिब्यूट के रूप में काम करेगा (एक विवादास्पद तरीके से):

 $(document).on('click', '[type="submit"][data-form-action]', function(event) { var $this = $(this), var formAction = $this.attr('data-form-action'), $form = $($this.closest('form')); $form.attr('action', formAction); }); 

बटन वाले फ़ॉर्म को डेटा-फॉर्म-एक्शन विशेषता में निर्दिष्ट यूआरएल पर पोस्ट किया जाएगा:

 <button type="submit" data-form-action="different/url">Submit</button> 

इसकी आवश्यकता है jQuery 1.7 पिछले संस्करणों के लिए आपको live() बजाय live() उपयोग करना चाहिए

ऐसे तीन तरीके हैं जिनसे आप ऊपर दिए गए मुद्दे को हल कर सकते हैं

  1. HTML मार्ग
  2. Jquery मार्ग
  3. "एक्शनएनैमसैक्टेक्टरअटिबेट" रास्ता

नीचे एक वीडियो है जो एक निष्पक्ष तरीके से सभी तीन तरीकों का सारांश देता है।

https://www.facebook.com/shivprasad.koirala/videos/vb.100002224977742/809335512483940

HTML तरीके: –

एचटीएमएल रूप में हमें दो रूपों को बनाने और प्रत्येक फॉर्म के अंदर "जमा करें" बटन को जगह देने की आवश्यकता है। और हर प्रपत्र की कार्रवाई विभिन्न / संबंधित कार्यों को इंगित करेगी आप निम्न कोड देख सकते हैं पहला फ़ॉर्म "एक्शन 1" पर पोस्ट कर रहा है और दूसरा फॉर्म "एक्शन 2" पर पोस्ट करेगा, जिस पर "सबमिट करें" बटन क्लिक किया जाता है।

 <form action="Action1" method=post> <input type=”submit” name=”Submit1”/> </form> <form action="Action2" method=post> <input type=”submit” name=”Submit2”> </form> 

अजाक्स रास्ता: –

यदि आप एक अजाक्स प्रेमी हैं तो इस दूसरे विकल्प से आपको अधिक उत्साहित किया जाएगा। अजाक्स रास्ते में हम दो अलग-अलग फ़ंक्शन "फन 1" और "फन 1" बना सकते हैं, नीचे कोड देखें। ये फ़ंक्शन JQUERY या किसी अन्य रूपरेखा का उपयोग करके अजाक्स कॉल कर देगा। इनमें से प्रत्येक फ़ंक्शन "सबमिट करें" बटन के "ऑनक्लिक" ईवेंट के साथ बाध्य है इनमें से प्रत्येक फ़ंक्शन, संबंधित कार्रवाई नामों पर कॉल करता है।

 <Script language="javascript"> function Fun1() { $.post(“/Action1”,null,CallBack1); } function Fun2() { $.post(“/Action2”,null,CallBack2); } </Script> <form action="/Action1" method=post> <input type=submit name=sub1 onclick=”Fun2()”/> </form> <form action="/Action2" method=post> <input type=submit name=sub2 onclick=”Fun1()”/> </form> 

"ActionNameSelectorAttribute" का उपयोग करना: –

यह एक महान और साफ विकल्प है "एक्शन नाइमचैक्टर एट्रिब्यूट" एक साधारण विशेषता वर्ग है, जहां हम निर्णय लेने तर्क लिख सकते हैं जो कि कौन से कार्रवाई निष्पादित की जा सकती है।

तो पहली बात HTML में है, हमें उन्हें सर्वर पर पहचानने के लिए सबमिट बटन पर उचित नाम देना होगा।

आप देख सकते हैं कि हमने बटन नामों को "सहेजें" और "हटाएं" डाल दिया है। इसके अलावा आप हमारे द्वारा अभी तक नियंत्रक का नाम "ग्राहक" रखा है और किसी विशेष कार्रवाई के नाम से नहीं देख सकते हैं। हम उम्मीद करते हैं कि कार्रवाई का नाम "ActionNameSelectorAttribute" द्वारा तय किया जाएगा

 <form action=”Customer” method=post> <input type=submit value="Save" name="Save" /> <br /> <input type=submit value="Delete" name="Delete"/> </form> 

इसलिए जब सबमिट बटन क्लिक किया जाता है, यह पहली बार "एक्शनएनमेसचूकर" विशेषता को हिट करता है और फिर यह निर्भर करता है कि कौन सा सबमिट किया जाता है, यह उपयुक्त कार्रवाई को आमंत्रित करता है

यहां छवि विवरण दर्ज करें

तो पहला कदम एक वर्ग बनाना है जो "ActionNameSelectorAttribute" वर्ग से प्राप्त होता है। इस वर्ग में हमने एक सरल संपत्ति "नाम" बनाया है

हमें "IsValidName" फ़ंक्शन को ओवरराइड करना होगा जो सही या फ्लेक्स देता है। यह फ़ंक्शन है जहां हम तर्क लिखते हैं कि क्या किसी क्रिया को निष्पादित किया जाना है या नहीं। इसलिए यदि यह फ़ंक्शन सही होता है तो कार्रवाई निष्पादित होती है या फिर ये नहीं है।

 public class SubmitButtonSelector : ActionNameSelectorAttribute { public string Name { get; set; } public override bool IsValidName(ControllerContext controllerContext, string actionName, System.Reflection.MethodInfo methodInfo) { // Try to find out if the name exists in the data sent from form var value = controllerContext.Controller.ValueProvider.GetValue(Name); if (value != null) { return true; } return false; } } 

उपर्युक्त कार्य का मुख्य हृदय निम्न कोड में है। "मूल्य प्रदाता" संग्रह में सभी आंकड़े हैं जो फ़ॉर्म से पोस्ट किए गए हैं। तो यह पहले "नाम" मान को देखता है और यदि उसे HTTP अनुरोध में पाया जाता है तो यह सत्य रिटर्न करता है या फिर वह गलत देता है।

 var value = controllerContext.Controller.ValueProvider.GetValue(Name); if (value != null) { return true; } return false; 

इस विशेषता वर्ग को तब संबंधित कार्रवाई पर सजाया जा सकता है और संबंधित "नाम" मान प्रदान किया जा सकता है। इसलिए यदि सबमिट इस कार्रवाई को मार रहा है और अगर HTML के नाम से मेल खाने का नाम मैच आता है तो वह आगे की कार्रवाई करता है या फिर यह नहीं करता है।

 public class CustomerController : Controller { [SubmitButtonSelector(Name="Save")] public ActionResult Save() { return Content("Save Called"); } [SubmitButtonSelector(Name = "Delete")] public ActionResult Delete() { return Content("Delete Called"); } } 

यहां एक एक्सटेंशन विधि है जिसे मैंने कई छवि और / या टेक्स्ट बटनों को संभालने के लिए लिखा था।

छवि बटन के लिए यहां HTML है:

 <input id="btnJoin" name="Join" src="/content/images/buttons/btnJoin.png" type="image"> 

या एक पाठ सबमिट बटन के लिए:

 <input type="submit" class="ui-button green" name="Submit_Join" value="Add to cart" /> <input type="submit" class="ui-button red" name="Submit_Skip" value="Not today" /> 

यहां एक्सटेंशन विधि है जिसे आप form.GetSubmitButtonName() साथ नियंत्रक से कॉल करते हैं। form.GetSubmitButtonName() छवि बटन के लिए यह .x साथ प्रपत्र पैरामीटर की तलाश करता है (जो इंगित करता है कि कोई छवि बटन क्लिक किया गया था) और नाम निकाला गया है। नियमित input बटनों के लिए यह Submit_ साथ शुरू होने वाले नाम की Submit_ और इसके बाद से कमांड निकालता है क्योंकि मैं 'कमांड' को निर्धारित करने के तर्क को समाप्त करना चाहता हूं क्योंकि आप छवि के बीच स्विच कर सकते हैं + क्लाइंट पर पाठ बॉक्स को सर्वर साइड कोड बदल दिए बिना।

 public static class FormCollectionExtensions { public static string GetSubmitButtonName(this FormCollection formCollection) { return GetSubmitButtonName(formCollection, true); } public static string GetSubmitButtonName(this FormCollection formCollection, bool throwOnError) { var imageButton = formCollection.Keys.OfType<string>().Where(x => x.EndsWith(".x")).SingleOrDefault(); var textButton = formCollection.Keys.OfType<string>().Where(x => x.StartsWith("Submit_")).SingleOrDefault(); if (textButton != null) { return textButton.Substring("Submit_".Length); } // we got something like AddToCart.x if (imageButton != null) { return imageButton.Substring(0, imageButton.Length - 2); } if (throwOnError) { throw new ApplicationException("No button found"); } else { return null; } } } 

नोट: पाठ बटन के लिए आपको Submit_ नाम के साथ नाम का उपसर्ग देना Submit_ । मैं इस तरह से पसंद करता हूं क्योंकि इसका मतलब है कि आप कोड को बदलने के बिना पाठ (डिस्प्ले) मान बदल सकते हैं। SELECT तत्वों के विपरीत, एक INPUT बटन में केवल 'मान' और कोई अलग 'टेक्स्ट' विशेषता नहीं है। मेरे बटन अलग अलग संदर्भों के तहत अलग बातें कहते हैं – लेकिन एक ही 'आदेश' के लिए मानचित्र मैं बहुत अधिक नाम == "Add to cart" के लिए कोड करने के लिए इस तरह से निकालने पसंद करता है

मेरे पास सही जगह पर टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है, लेकिन मैं इस पर पूरे दिन बिताया ताकि मैं हिस्सा लेना चाहता हूं।

" ValueProvider.GetValue(keyValue) " समाधान ValueProvider.GetValue(keyValue) को कार्यान्वित करने का प्रयास करते समय। ValueProvider.GetValue(keyValue) गलत तरीके से वापस null आएगा।

यह पता चला कि मैं System.Web.MVC संस्करण 3.0 को संदर्भित कर रहा था जब यह 4.0 होना चाहिए (अन्य असेंबलीएं 4.0 हैं)। मुझे नहीं पता कि मेरा प्रोजेक्ट सही तरीके से अपग्रेड नहीं कर रहा था और मेरे पास कोई अन्य स्पष्ट समस्या नहीं थी।

इसलिए यदि आपके ActionNameSelectorAttribute कार्य नहीं कर रहा है … तो जांचें

मैंने सभी समाधानों का संश्लेषण करने का प्रयास किया है और एक [[ButtenHandler] विशेषता का निर्माण किया है जो किसी प्रपत्र पर एकाधिक बटन को संभालना आसान बनाता है।

मैंने इसे CodeProject पर वर्णित किया है एकाधिक asp.net MVC में parameterized (localizable) फार्म बटन

इस बटन का सरल मामला संभालने के लिए:

 <button type="submit" name="AddDepartment">Add Department</button> 

आपके पास निम्न क्रिया विधि की तरह कुछ है:

 [ButtonHandler()] public ActionResult AddDepartment(Company model) { model.Departments.Add(new Department()); return View(model); } 

ध्यान दें कि बटन का नाम कार्रवाई विधि के नाम से मेल खाता है। लेख में यह भी बताया गया है कि इंडेक्स के साथ मान और बटन वाले बटन कैसे हैं।

HttpParamActionAttribute विधि का संशोधित संस्करण, लेकिन एक बग ठीक होने के कारण समाप्त होने वाली / अमान्य सत्र पोस्टबैक पर कोई त्रुटि नहीं हुई है। यह देखने के लिए कि क्या यह आपकी वर्तमान साइट के साथ एक समस्या है, अपना प्रपत्र एक विंडो में खोलें और Save या Publish Save पर क्लिक करने से पहले, एक डुप्लिकेट विंडो खोलें और लॉग आउट करें। अब अपनी पहली विंडो पर वापस जाएं और अपना फ़ॉर्म किसी भी बटन का उपयोग करके सबमिट करें। मेरे लिए मुझे एक त्रुटि मिली है, इसलिए यह परिवर्तन मेरे लिए यह समस्या हल करता है मैं संक्षेप की खातिर सामान का एक गुच्छा छोड़ देता हूं, लेकिन आपको यह विचार प्राप्त करना चाहिए। मुख्य भाग विशेषता पर ActionName को शामिल करने और यह सुनिश्चित करने के लिए है कि नाम से पारित किया गया नाम उस दृश्य का नाम होता है जो फॉर्म दिखाता है

एट्रिब्यूट क्लास

 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)] public class HttpParamActionAttribute : ActionNameSelectorAttribute { private readonly string actionName; public HttpParamActionAttribute(string actionName) { this.actionName = actionName; } public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo) { if (actionName.Equals(methodInfo.Name, StringComparison.InvariantCultureIgnoreCase)) return true; if (!actionName.Equals(this.actionName, StringComparison.InvariantCultureIgnoreCase)) return false; var request = controllerContext.RequestContext.HttpContext.Request; return request[methodInfo.Name] != null; } } 

नियंत्रक

 [Authorize(Roles="CanAddContent")] public ActionResult CreateContent(Guid contentOwnerId) { var viewModel = new ContentViewModel { ContentOwnerId = contentOwnerId //populate rest of view model } return View("CreateContent", viewModel); } [Authorize(Roles="CanAddContent"), HttpPost, HttpParamAction("CreateContent"), ValidateAntiForgeryToken] public ActionResult SaveDraft(ContentFormModel model) { //Save as draft return RedirectToAction("CreateContent"); } [Authorize(Roles="CanAddContent"), HttpPost, HttpParamAction("CreateContent"), ValidateAntiForgeryToken] public ActionResult Publish(ContentFormModel model) { //publish content return RedirectToAction("CreateContent"); } 

राय

 @using (Ajax.BeginForm("CreateContent", "MyController", new { contentOwnerId = Model.ContentOwnerId })) { @Html.AntiForgeryToken() @Html.HiddenFor(x => x.ContentOwnerId) <!-- Rest of your form controls --> <input name="SaveDraft" type="submit" value="SaveDraft" /> <input name="Publish" type="submit" value="Publish" /> } 

this is the best way that i have found:

http://iwayneo.blogspot.co.uk/2013/10/aspnet-mvc-action-selector-with-list.html

यहां कोड है:

  /// <summary> /// ActionMethodSelector to enable submit buttons to execute specific action methods. /// </summary> public class AcceptParameterAttribute : ActionMethodSelectorAttribute { /// <summary> /// Gets or sets the value to use to inject the index into /// </summary> public string TargetArgument { get; set; } /// <summary> /// Gets or sets the value to use in submit button to identify which method to select. This must be unique in each controller. /// </summary> public string Action { get; set; } /// <summary> /// Gets or sets the regular expression to match the action. /// </summary> public string ActionRegex { get; set; } /// <summary> /// Determines whether the action method selection is valid for the specified controller context. /// </summary> /// <param name="controllerContext">The controller context.</param> /// <param name="methodInfo">Information about the action method.</param> /// <returns>true if the action method selection is valid for the specified controller context; otherwise, false.</returns> public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } Func<NameValueCollection> formGetter; Func<NameValueCollection> queryStringGetter; ValidationUtility.GetUnvalidatedCollections(HttpContext.Current, out formGetter, out queryStringGetter); var form = formGetter(); var queryString = queryStringGetter(); var req = form.AllKeys.Any() ? form : queryString; if (!string.IsNullOrEmpty(this.ActionRegex)) { foreach (var key in req.AllKeys.Where(k => k.StartsWith(Action, true, System.Threading.Thread.CurrentThread.CurrentCulture))) { if (key.Contains(":")) { if (key.Split(':').Count() == this.ActionRegex.Split(':').Count()) { bool match = false; for (int i = 0; i < key.Split(':').Count(); i++) { if (Regex.IsMatch(key.Split(':')[0], this.ActionRegex.Split(':')[0])) { match = true; } else { match = false; break; } } if (match) { return !string.IsNullOrEmpty(req[key]); } } } else { if (Regex.IsMatch(key, this.Action + this.ActionRegex)) { return !string.IsNullOrEmpty(req[key]); } } } return false; } else { return req.AllKeys.Contains(this.Action); } } } 

Enjoy a code-smell-less multi submit button future.

धन्यवाद

If your browser supports the attribute formaction for input buttons (IE 10+, not sure about other browsers) then the following should work:

 @using (Html.BeginForm()){ //put form inputs here <input id="sendBtn" value="Send" type="submit" formaction="@Url.Action("Name Of Send Action")" /> <input id="cancelBtn" value="Cancel" type="submit" formaction="@Url.Action("Name of Cancel Action") /> } 

I'm pretty late to the party, but here goes… My implementation borrows from @mkozicki but requires less hardcoded strings to get wrong. Framework 4.5+ required . Essentially, the controller method name should be the key to the routing.

Markup . The button name must be keyed with "action:[controllerMethodName]"

(notice the use of the C#6 nameof API, providing type-specific reference to the name of the controller method you wish to invoke.

 <form> ... form fields .... <button name="action:@nameof(MyApp.Controllers.MyController.FundDeathStar)" type="submit" formmethod="post">Fund Death Star</button> <button name="action:@nameof(MyApp.Controllers.MyController.HireBoba)" type="submit" formmethod="post">Hire Boba Fett</button> </form> 

Controller :

 namespace MyApp.Controllers { class MyController { [SubmitActionToThisMethod] public async Task<ActionResult> FundDeathStar(ImperialModel model) { await TrainStormTroopers(); return View(); } [SubmitActionToThisMethod] public async Task<ActionResult> HireBoba(ImperialModel model) { await RepairSlave1(); return View(); } } } 

Attribute Magic . Notice the use of CallerMemberName goodness.

 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)] public class SubmitActionToThisMethodAttribute : ActionNameSelectorAttribute { public SubmitActionToThisMethodAttribute([CallerMemberName]string ControllerMethodName = "") { controllerMethod = ControllerMethodName; actionFormat = string.Concat(actionConstant, ":", controllerMethod); } const string actionConstant = "action"; readonly string actionFormat; readonly string controllerMethod; public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo) { var isValidName = false; var value = controllerContext.Controller.ValueProvider.GetValue(actionFormat); if (value != null) { controllerContext.Controller.ControllerContext.RouteData.Values[actionConstant] = controllerMethod; isValidName = true; } return isValidName; } } 
 //model public class input_element { public string Btn { get; set; } } //views--submit btn can be input type also... @using (Html.BeginForm()) { <button type="submit" name="btn" value="verify"> Verify data</button> <button type="submit" name="btn" value="save"> Save data</button> <button type="submit" name="btn" value="redirect"> Redirect</button> } //controller public ActionResult About() { ViewBag.Message = "Your app description page."; return View(); } [HttpPost] public ActionResult About(input_element model) { if (model.Btn == "verify") { // the Verify button was clicked } else if (model.Btn == "save") { // the Save button was clicked } else if (model.Btn == "redirect") { // the Redirect button was clicked } return View(); } 

My JQuery approach using an extension method:

 public static MvcHtmlString SubmitButtonFor<TController>(this HtmlHelper helper, Expression<Action<TController>> action, string value) where TController : Controller { RouteValueDictionary routingValues = Microsoft.Web.Mvc.Internal.ExpressionHelper.GetRouteValuesFromExpression(action); var onclick = string.Format("$('form').first().attr('action', '/{0}')", string.Join("/", routingValues.Values.ToArray().Where(x => x != null).Select(x => x.ToString()).ToArray())); var html = "<input type=\"submit\" value=\"" + value + "\" onclick=\"" + onclick + "\" />"; return MvcHtmlString.Create(html); } 

आप इसे इस तरह से उपयोग कर सकते हैं:

 @(Html.SubmitButtonFor<FooController>(c => c.Save(null), "Save")) 

And it renders like this:

 <input type="submit" value="Save" onclick="$('form').first().attr('action', '/Foo/Save')" > 

For each submit button just add:

 $('#btnSelector').click(function () { $('form').attr('action', "/Your/Action/); $('form').submit(); }); 

Based on mkozicki answer I come up with a bit different solution. I still use ActionNameSelectorAttribute But I needed to handle two buttons 'Save' and 'Sync'. They do almost the same so I didn't want to have two actions.

attribute :

 public class MultipleButtonActionAttribute : ActionNameSelectorAttribute { private readonly List<string> AcceptedButtonNames; public MultipleButtonActionAttribute(params string[] acceptedButtonNames) { AcceptedButtonNames = acceptedButtonNames.ToList(); } public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo) { foreach (var acceptedButtonName in AcceptedButtonNames) { var button = controllerContext.Controller.ValueProvider.GetValue(acceptedButtonName); if (button == null) { continue; } controllerContext.Controller.ControllerContext.RouteData.Values.Add("ButtonName", acceptedButtonName); return true; } return false; } } 

view

 <input type="submit" value="Save" name="Save" /> <input type="submit" value="Save and Sync" name="Sync" /> 

controller

  [MultipleButtonAction("Save", "Sync")] public ActionResult Sync(OrgSynchronizationEditModel model) { var btn = this.RouteData.Values["ButtonName"]; 

I also want to point out that if actions do different things I would probably follow mkozicki post.

When using ajax forms, we can use ActionLinks with POST HttpMethod and serialize the form in the AjaxOptions.OnBegin event.

Let's say you have two actions, InsertAction and UpdateAction:

 <form> @Html.Hidden("SomeField", "SomeValue") @Ajax.ActionLink( "Insert", "InsertAction", null, new AjaxOptions { OnBegin = "OnBegin", UpdateTargetId = "yourDiv", HttpMethod = "POST" }) @Ajax.ActionLink( "Update", "UpdateAction", null, new AjaxOptions { OnBegin = "OnBegin", UpdateTargetId = "yourDiv", HttpMethod = "POST" }) </form> 

Javascript

 function OnBegin(xhr, settings) { settings.data = $("form").serialize(); } 

I've created an ActionButton method for the HtmlHelper . It will generate normal input button with a bit of javascript in the OnClick event that will submit the form to the specified Controller/Action.

You use the helper like that

 @Html.ActionButton("MyControllerName", "MyActionName", "button text") 

this will generate the following HTML

 <input type="button" value="button text" onclick="this.form.action = '/MyWebsiteFolder/MyControllerName/MyActionName'; this.form.submit();"> 

Here is the extension method code:

VB.Net

 <System.Runtime.CompilerServices.Extension()> Function ActionButton(pHtml As HtmlHelper, pAction As String, pController As String, pRouteValues As Object, pBtnValue As String, pBtnName As String, pBtnID As String) As MvcHtmlString Dim urlHelperForActionLink As UrlHelper Dim btnTagBuilder As TagBuilder Dim actionLink As String Dim onClickEventJavascript As String urlHelperForActionLink = New UrlHelper(pHtml.ViewContext.RequestContext) If pController <> "" Then actionLink = urlHelperForActionLink.Action(pAction, pController, pRouteValues) Else actionLink = urlHelperForActionLink.Action(pAction, pRouteValues) End If onClickEventJavascript = "this.form.action = '" & actionLink & "'; this.form.submit();" btnTagBuilder = New TagBuilder("input") btnTagBuilder.MergeAttribute("type", "button") btnTagBuilder.MergeAttribute("onClick", onClickEventJavascript) If pBtnValue <> "" Then btnTagBuilder.MergeAttribute("value", pBtnValue) If pBtnName <> "" Then btnTagBuilder.MergeAttribute("name", pBtnName) If pBtnID <> "" Then btnTagBuilder.MergeAttribute("id", pBtnID) Return MvcHtmlString.Create(btnTagBuilder.ToString(TagRenderMode.Normal)) End Function 

C# (the C# code is just decompiled from the VB DLL, so it can get some beautification… but time is so short :-))

 public static MvcHtmlString ActionButton(this HtmlHelper pHtml, string pAction, string pController, object pRouteValues, string pBtnValue, string pBtnName, string pBtnID) { UrlHelper urlHelperForActionLink = new UrlHelper(pHtml.ViewContext.RequestContext); bool flag = Operators.CompareString(pController, "", true) != 0; string actionLink; if (flag) { actionLink = urlHelperForActionLink.Action(pAction, pController, System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(pRouteValues)); } else { actionLink = urlHelperForActionLink.Action(pAction, System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(pRouteValues)); } string onClickEventJavascript = "this.form.action = '" + actionLink + "'; this.form.submit();"; TagBuilder btnTagBuilder = new TagBuilder("input"); btnTagBuilder.MergeAttribute("type", "button"); btnTagBuilder.MergeAttribute("onClick", onClickEventJavascript); flag = (Operators.CompareString(pBtnValue, "", true) != 0); if (flag) { btnTagBuilder.MergeAttribute("value", pBtnValue); } flag = (Operators.CompareString(pBtnName, "", true) != 0); if (flag) { btnTagBuilder.MergeAttribute("name", pBtnName); } flag = (Operators.CompareString(pBtnID, "", true) != 0); if (flag) { btnTagBuilder.MergeAttribute("id", pBtnID); } return MvcHtmlString.Create(btnTagBuilder.ToString(TagRenderMode.Normal)); } 

These methods have various parameters, but for the ease of use you can create some overload that take just the parameters you need.