Métodos para implementar múltiples métodos de envío de botones en ASP.NET MVC

A veces nos encontramos con esta situación: en un formulario se necesitan varios botones para completar diferentes funciones, como una función de aprobación simple.

　

Si se usa webform, no es necesario discutirlo, pero en asp.net mvc, un formulario solo puede enviarse a un tratamiento de Action, lo que es un poco más complicado.　

Método uno:Uso de script del cliente　

Por ejemplo, si escribimos así en View:

<input type="submit" value="Aprobado" onclick='this.form.action="<%=Url.Action("Action1)%>"/>}}
<input type="submit" value="No aprobado" onclick='this.form.action="<%=Url.Action("Action2)%>" />}}
<input type="submit" value="Volver" onclick='this.form.action="<%=Url.Action("Action3)%>" />}}

Al hacer clic en el botón de envío, primero cambia el atributo action del Form, para que el formulario se envíe al tratamiento de action correspondiente del botón.　

Pero a veces, puede que Action1Y2La lógica es muy similar, tal vez solo se establece el valor de algún campo1O 0, entonces parece un poco innecesario dividirlo en dos actions.　

Método dos:En Action, se determina a través de qué botón se realiza el envío　

En View, no utilizamos ningún script del cliente para procesar, y le damos un atributo name a cada botón de envío:　

<input type="submit" value="Aprobado" name="action" />}}
<input type="submit" value="No aprobado" name="action"/>}}
<input type="submit" value="Volver" name="action"/>}}

Luego, en el controlador, se realiza la siguiente evaluación:

[HttpPost]
 public ActionResult Index(string action /* Otros parámetros*/)
 {
  if (action=="Aprobado")
  {
   //
  }
  else if (action=="No aprobado")
  {
//
  }
  else
  {
   //
  }
 }

Hace unos años, cuando escribía código ASP, a menudo usaba este método...　

View se vuelve simple, mientras que Controller se complica.

　Demasiada dependencia de View, puede haber algunos problemas. Si algún día el cliente dice que el texto del botón debe cambiarse a "Aprobado" o hacer una versión multilingüe, eso sería un problema.　

　Método tres:Uso de ActionSelector　

El principio básico de ActionSelector se puede ver en este POST que utiliza ActionSelector para controlar la selección de Action.　

Con este método, podemos escribir el controlador de la siguiente manera:}

[HttpPost]
[MultiButton("acción"1)
public ActionResult Acción1(),
{
 //
 return Ver();
}
[HttpPost]
[MultiButton("acción"2)
public ActionResult Acción2(),
{
 //
 return Ver();
}

En la View:　

<input type="submit" value="aceptar revisión" name="acción"1" />}}
<input type="submit" value="rechazar revisión" name="acción"2"/>}}
<input type="submit" value="volver" name="acción"3"/>}}

En este momento, el Controlador ya no depende del valor de Value del botón.　

Definición de MultiButtonAttribute:

public class MultiButtonAttribute : ActionNameSelectorAttribute
{
 public string Name { get; set; }
 public MultiButtonAttribute(string name)
 {
  this.Name = name;
 }
 public override bool IsValidName(ControllerContext controllerContext,
  string actionName, System.Reflection.MethodInfo methodInfo)
 {
  if (string.IsNullOrEmpty(this.Name))
  {
   return false;
  }
  return controllerContext.HttpContext.Request.Form.AllKeys.Contains(this.Name);
 }
}

Método cuatro：Mejora

Controlador：　

[HttpPost] 
[MultiButton(Name = "delete", Argument = "id")] 
public ActionResult Eliminar(string id) 
{ 
var response = System.Web.HttpContext.Current.Response; 
response.Write("Acción de eliminación invocada con ", + id); 
return Ver(); 
} 

Ver:

<input type="submit" value="no importante" name="delete" />}}
<input type="submit" value="no importante" name="delete:id" />}}

Definición de MultiButtonAttribute:　

código

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)] 
public class MultiButtonAttribute : ActionNameSelectorAttribute 
{ 
public string Name { get; set; } 
public string Argument { get; set; } 
public override bool IsValidName(ControllerContext controllerContext, string 
actionName, MethodInfo methodInfo) 
{ 
var key = ButtonKeyFrom(controllerContext); 
var keyIsValid = IsValid(key); 
if (keyIsValid) 
{ 
UpdateValueProviderIn(controllerContext, ValueFrom(key)); 
} 
return keyIsValid; 
} 
private string ButtonKeyFrom(ControllerContext controllerContext) 
{ 
var keys = controllerContext.HttpContext.Request.Params.AllKeys; 
return keys.FirstOrDefault(KeyStartsWithButtonName); 
} 
private static bool IsValid(string key) 
{ 
return key != null; 
} 
private static string ValueFrom(string key) 
{ 
var parts = key.Split(":".ToCharArray()); 
return parts.Length < 2 ? null : parts[1]; 
} 
private void UpdateValueProviderIn(ControllerContext controllerContext, 
string value) 
{ 
if (string.IsNullOrEmpty(Argument)) return; 
controllerContext.Controller.ValueProvider[Argument] = new ValueProviderResult
 (value, value, null); 
} 
private bool KeyStartsWithButtonName(string key) 
{ 
return key.StartsWith(Name, StringComparison.InvariantCultureIgnoreCase); 
} 
} 
//Si es en MVC 2En .0, cambie el método UpdateValueProviderIn a:
private void UpdateValueProviderIn(ControllerContext controllerContext, string value)
{
 if (string.IsNullOrEmpty(Argument))
 return;
 controllerContext.RouteData.Values[this.Argument] = value;
} 

Esto es todo el contenido de este artículo, espero que ayude a su aprendizaje y que todos lo apoyen en el tutorial de grito.

Declaración: el contenido de este artículo se obtiene de la red, es propiedad del autor original, el contenido se contribuye y carga espontáneamente por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha procesado editorialmente y no asume responsabilidades legales relacionadas. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, por favor reemplace # con @) para denunciar y proporcionar evidencia relevante. Una vez verificada, este sitio eliminará inmediatamente el contenido sospechoso de infracción.