Métodos de submissão de múltiplos botões no ASP.NET MVC

Às vezes, podemos encontrar essa situação: em um formulário, precisamos de vários botões para completar diferentes funções, por exemplo, uma função de aprovação simples.

　

Se usar webform, não há necessidade de discutir, mas no ASP.NET MVC, um formulário pode submeter-se apenas a um Action de processamento, o que é um pouco complicado.　

Método um:Uso de script do cliente　

Por exemplo, assim escrevemos no View:

<input type="submit" value="Aprovado" onclick='this.form.action="<%=Url.Action("Action1)%>"/>}}
<input type="submit" value="Não Aprovado" onclick='this.form.action="<%=Url.Action("Action2)%>" />}}
<input type="submit" value="Voltar" onclick='this.form.action="<%=Url.Action("Action3)%>" />}}

Ao clicar no botão de envio, alterar primeiro o atributo action do Form, para que o formulário seja submetido ao processamento action correspondente do botão.　

Mas às vezes, pode ser que Action1e2A lógica é muito semelhante, talvez apenas configurar o valor de algum campo para1Ou 0, então dividir em duas actions parece um pouco redundante.　

Método dois:Fazer a verificação no Action sobre qual botão foi submetido　

No View, não usamos nenhum script do cliente para processar, e atribuímos o nome correto a cada botão de envio:　

<input type="submit" value="Aprovado" name="action" />}}
<input type="submit" value="Não Aprovado" name="action"/>}}
<input type="submit" value="Voltar" name="action"/>}}

Então, no controlador, é necessário fazer a verificação:

[HttpPost]
 public ActionResult Index(string action /* Outros parâmetros*/)
 {
  if (action=="Aprovado")
  {
   //
  }
  else if (action=="Não Aprovado")
  {
//
  }
  else
  {
   //
  }
 }

Há alguns anos, quando escrevia código ASP, costumava usar esse método...　

O View se tornou simples, enquanto o Controller se tornou complexo.

　Demasiada dependência do View, pode haver alguns problemas. Se um dia o cliente disser que o texto do botão deve ser alterado para “Aprovado” ou criar uma versão multilíngue, isso pode ser complicado.　

　Método três:Uso de ActionSelector　

A princípio do ActionSelector pode ser vista neste POST para controlar a escolha de Action com ActionSelector.　

Usando este método, podemos escrever o controlador assim:}

[HttpPost]
[MultiButton("ação"1)];
public ActionResult Ação1(),
{
 //
 return Visualizar();
}
[HttpPost]
[MultiButton("ação"2)];
public ActionResult Ação2(),
{
 //
 return Visualizar();
}

No View:　

<input type="submit" value="aprovado revisão" name="ação"1" />}}
<input type="submit" value="rejeitar revisão" name="ação"2"/>}}
<input type="submit" value="voltar" name="ação"3"/>}}

Neste momento, o Controlador já não depende do valor do botão.　

Definição 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 quatro:Melhoria

Controlador:　

[HttpPost] 
[MultiButton(Name = "delete", Argument = "id")] 
public ActionResult Delete(string id) 
{ 
var response = System.Web.HttpContext.Current.Response; 
response.Write("Ação de exclusão foi invocada com ", + id); 
return Visualizar(); 
} 

Visualizar:

<input type="submit" value="não importante" name="delete" />}}
<input type="submit" value="não importante" name="delete:id" />}}

Definição 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); 
} 
} 
//Se estiver no MVC 2No .0, mude o método UpdateValueProviderIn para:
private void UpdateValueProviderIn(ControllerContext controllerContext, string value)
{
 if (string.IsNullOrEmpty(Argument))
 return;
 controllerContext.RouteData.Values[this.Argument] = value;
} 

Isso é tudo o que há no artigo. Esperamos que isso ajude no seu aprendizado e que você apoie o tutorial Yell.

Declaração: O conteúdo deste artigo é extraído da Internet, pertence ao respectivo proprietário. O conteúdo é contribuído e carregado voluntariamente pelos usuários da Internet. Este site não possui direitos de propriedade, não foi editado manualmente e não assume responsabilidades legais relacionadas. Se você encontrar conteúdo suspeito de violação de direitos autorais, por favor, envie um e-mail para: notice#oldtoolbag.com (ao enviar e-mail, substitua # por @ para denunciar e forneça provas relevantes. Apenas após a verificação, o site deletará o conteúdo suspeito de violação de direitos autorais.)