Ottieni il controller e il nome dell'azione dal controller?

Per la nostra applicazione web ho bisogno di salvare l'ordine degli elementi recuperati e visualizzati a seconda della vista - o per essere precisi - il controller e l'azione che hanno generato la vista (e l'id utente ovviamente, ma non è questo il punto qui).

Invece di fornire semplicemente un identificatore in ogni azione del controller (al fine di usarlo per un ordinamento delle uscite DB dipendente dalla vista), ho pensato che sarebbe stato più sicuro e più semplice creare questo identificatore automaticamente dal controller e dal metodo di azione che ottiene chiamato da.

Come posso ottenere il nome del controller e l'azione dal metodo action in un controller? O ho bisogno di riflessione per quello? Immagino sia abbastanza facile, grazie in anticipo!

string actionName = this.ControllerContext.RouteData.Values["action"].ToString();
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();

Ecco alcuni metodi di estensione per ottenere tali informazioni (include anche l'ID):

public static class HtmlRequestHelper
{
    public static string Id(this HtmlHelper htmlHelper)
    {
        var routeValues = HttpContext.Current.Request.RequestContext.RouteData.Values;

        if (routeValues.ContainsKey("id"))
            return (string)routeValues["id"];
        else if (HttpContext.Current.Request.QueryString.AllKeys.Contains("id"))
            return HttpContext.Current.Request.QueryString["id"];

        return string.Empty;
    }

    public static string Controller(this HtmlHelper htmlHelper)
    {
        var routeValues = HttpContext.Current.Request.RequestContext.RouteData.Values;

        if (routeValues.ContainsKey("controller"))
            return (string)routeValues["controller"];

        return string.Empty;
    }

    public static string Action(this HtmlHelper htmlHelper)
    {
        var routeValues = HttpContext.Current.Request.RequestContext.RouteData.Values;

        if (routeValues.ContainsKey("action"))
            return (string)routeValues["action"];

        return string.Empty;
    }
}

Uso:

@Html.Controller();
@Html.Action();
@Html.Id();

Potrebbe essere utile. Avevo bisogno dell'azione nel costruttore del controller, e appare a questo punto del ciclo di vita di MVC, thisnon è stato inizializzato e ControllerContext = null. Invece di approfondire il ciclo di vita di MVC e trovare il nome della funzione appropriata da sovrascrivere, ho appena trovato l'azione nelRequestContext.RouteData .

Ma per fare ciò, come per qualsiasi HttpContextuso correlato nel costruttore, è necessario specificare lo spazio dei nomi completo, perché this.HttpContextanche questo non è stato inizializzato. Fortunatamente, sembra System.Web.HttpContext.Currentstatico.

// controller constructor
public MyController() {
    // grab action from RequestContext
    string action = System.Web.HttpContext.Current.Request.RequestContext.RouteData.GetRequiredString("action");

    // grab session (another example of using System.Web.HttpContext static reference)
    string sessionTest = System.Web.HttpContext.Current.Session["test"] as string
}

NOTA: probabilmente non è il modo più supportato per accedere a tutte le proprietà in HttpContext, ma per RequestContext e Session sembra funzionare bene nella mia applicazione.

var routeValues = HttpContext.Current.Request.RequestContext.RouteData.Values;
if (routeValues != null) 
{
    if (routeValues.ContainsKey("action"))
    {
        var actionName = routeValues["action"].ToString();
                }
    if (routeValues.ContainsKey("controller"))
    {
        var controllerName = routeValues["controller"].ToString();
    }
}

 @this.ViewContext.RouteData.Values["controller"].ToString();

Questo è quello che ho finora:

var actionName = filterContext.ActionDescriptor.ActionName;
var controllerName = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName;

Ecco la risposta più semplice e pratica per ottenere un nome:

var actionName = RouteData.Values["action"];
var controllerName = RouteData.Values["controller"];

O

string actionName = RouteData.Values["action"].ToString();
string controllerName = RouteData.Values["controller"].ToString();

Codice sopra test con asp.net mvc 5.

Aggiungi questo al controller di base nel metodo GetDefaults ()

    protected override void OnActionExecuting(ActionExecutingContext filterContext)
    {
         GetDefaults();
         base.OnActionExecuting(filterContext);
    }

    private void GetDefaults()
    {
    var actionName = filterContext.ActionDescriptor.ActionName;
    var controllerName = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName;
    }

Implementa i tuoi controller su Basecontroller

Aggiungi una vista parziale _Breadcrumb.cshtml e aggiungila in tutte le pagine richieste con @ Html.Partial ("_ Breadcrumb")

_Breadcrumb.cshtml

<span>
    <a href="../@ViewData["controllerName"]">
        @ViewData["controllerName"]
    </a> > @ViewData["actionName"]
</span>

È possibile ottenere il nome del controller o il nome dell'azione dall'azione come qualsiasi variabile. Sono solo speciali (controller e azione) e sono già definiti, quindi non è necessario fare nulla di speciale per ottenerli se non per dirti che ne hai bisogno.

public string Index(string controller,string action)
   {
     var names=string.Format("Controller : {0}, Action: {1}",controller,action);
     return names;
   }

Oppure puoi includere controller, azione nei tuoi modelli per ottenerne due e i tuoi dati personalizzati.

public class DtoModel
    {
        public string Action { get; set; }
        public string Controller { get; set; }
        public string Name { get; set; }
    }

public string Index(DtoModel baseModel)
    {
        var names=string.Format("Controller : {0}, Action: {1}",baseModel.Controller,baseModel.Action);
        return names;
    }

Questo sembra funzionare bene per me (finora), funziona anche se si utilizza il routing degli attributi.

public class BaseController : Controller
{
    protected string CurrentAction { get; private set; }
    protected string CurrentController { get; private set; }

    protected override void Initialize(RequestContext requestContext)
    {
        this.PopulateControllerActionInfo(requestContext);
    }

    private void PopulateControllerActionInfo(RequestContext requestContext)
    {
        RouteData routedata = requestContext.RouteData;

        object routes;

        if (routedata.Values.TryGetValue("MS_DirectRouteMatches", out routes))
        {
            routedata = (routes as List<RouteData>)?.FirstOrDefault();
        }

        if (routedata == null)
            return;

        Func<string, string> getValue = (s) =>
        {
            object o;
            return routedata.Values.TryGetValue(s, out o) ? o.ToString() : String.Empty;
        };

        this.CurrentAction = getValue("action");
        this.CurrentController = getValue("controller");
    }
}

Per rimuovere la necessità di ToString()utilizzare la chiamata

string actionName = ControllerContext.RouteData.GetRequiredString("action");
string controllerName = ControllerContext.RouteData.GetRequiredString("controller");

Utilizzare le righe fornite in OnActionExecuting per azione e nome del controller.

string actionName = this.ControllerContext.RouteData.Values ​​["action"]. ToString ();

string controllerName = this.ControllerContext.RouteData.Values ​​["controller"]. ToString ();

Perché non avere qualcosa di più semplice?

Basta chiamare Request.Path, restituirà una stringa separata dal "/"

e quindi è possibile utilizzare .Split('/')[1]per ottenere il nome del controller.