Come impostare le proprietà ViewBag per tutte le viste senza utilizzare una classe base per i controller?

In passato ho bloccato proprietà comuni, come l'utente corrente, su ViewData / ViewBag in modo globale facendo in modo che tutti i controller ereditino da un controller di base comune.

Ciò mi ha permesso di utilizzare IoC sul controller di base e non solo di raggiungere la condivisione globale per tali dati.

Mi chiedo se esiste un modo alternativo per inserire questo tipo di codice nella pipeline MVC?

Non provato da me, ma potresti prendere in considerazione la registrazione delle tue visualizzazioni e quindi l'impostazione dei dati di visualizzazione durante il processo di attivazione.

Poiché le viste vengono registrate al volo, la sintassi della registrazione non ti aiuta a connetterti Activatedall'evento, quindi dovresti configurarla in un Module:

class SetViewBagItemsModule : Module
{
    protected override void AttachToComponentRegistration(
        IComponentRegistration registration,
        IComponentRegistry registry)
    {
        if (typeof(WebViewPage).IsAssignableFrom(registration.Activator.LimitType))
        {
            registration.Activated += (s, e) => {
                ((WebViewPage)e.Instance).ViewBag.Global = "global";
            };
        }
    }
}

Questo potrebbe essere uno di quei suggerimenti del tipo "l'unico strumento è un martello" da me; ci possono essere modi più semplici abilitati per MVC per arrivarci.

Modifica: approccio alternativo, meno codice: basta collegarlo al controller

public class SetViewBagItemsModule: Module
{
    protected override void AttachToComponentRegistration(IComponentRegistry cr,
                                                      IComponentRegistration reg)
    {
        Type limitType = reg.Activator.LimitType;
        if (typeof(Controller).IsAssignableFrom(limitType))
        {
            registration.Activated += (s, e) =>
            {
                dynamic viewBag = ((Controller)e.Instance).ViewBag;
                viewBag.Config = e.Context.Resolve<Config>();
                viewBag.Identity = e.Context.Resolve<IIdentity>();
            };
        }
    }
}

Modifica 2: un altro approccio che funziona direttamente dal codice di registrazione del controller:

builder.RegisterControllers(asm)
    .OnActivated(e => {
        dynamic viewBag = ((Controller)e.Instance).ViewBag;
        viewBag.Config = e.Context.Resolve<Config>();
        viewBag.Identity = e.Context.Resolve<IIdentity>();
    });

Il modo migliore è usare ActionFilterAttribute e registrare la tua classe personalizzata nel tuo file global. asax (Application_Start)

public class UserProfilePictureActionFilter : ActionFilterAttribute
{

    public override void OnResultExecuting(ResultExecutingContext filterContext)
    {
        filterContext.Controller.ViewBag.IsAuthenticated = MembershipService.IsAuthenticated;
        filterContext.Controller.ViewBag.IsAdmin = MembershipService.IsAdmin;

        var userProfile = MembershipService.GetCurrentUserProfile();
        if (userProfile != null)
        {
            filterContext.Controller.ViewBag.Avatar = userProfile.Picture;
        }
    }

}

registra la tua classe personalizzata nel tuo global. asax (Application_Start)

protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        GlobalFilters.Filters.Add(new UserProfilePictureActionFilter(), 0);

    }

Quindi puoi usarlo in tutte le visualizzazioni

@ViewBag.IsAdmin
@ViewBag.IsAuthenticated
@ViewBag.Avatar

Inoltre c'è un altro modo

Creazione di un metodo di estensione su HtmlHelper

[Extension()]
public string MyTest(System.Web.Mvc.HtmlHelper htmlHelper)
{
    return "This is a test";
}

Quindi puoi usarlo in tutte le visualizzazioni

@Html.MyTest()

Poiché le proprietà di ViewBag sono, per definizione, legate alla presentazione della vista e a qualsiasi logica di visualizzazione leggera che potrebbe essere necessaria, creerei una WebViewPage di base e imposterò le proprietà sull'inizializzazione della pagina. È molto simile al concetto di controller di base per logica ripetuta e funzionalità comuni, ma per le tue visualizzazioni:

    public abstract class ApplicationViewPage<T> : WebViewPage<T>
    {
        protected override void InitializePage()
        {
            SetViewBagDefaultProperties();
            base.InitializePage();
        }

        private void SetViewBagDefaultProperties()
        {
            ViewBag.GlobalProperty = "MyValue";
        }
    }

E poi in \Views\Web.config, imposta la pageBaseTypeproprietà:

<system.web.webPages.razor>
    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
    <pages pageBaseType="MyNamespace.ApplicationViewPage">
      <namespaces>
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Routing" />
      </namespaces>
    </pages>
  </system.web.webPages.razor>

Il post di Brandon è giusto sui soldi. È un dato di fatto, vorrei fare un ulteriore passo avanti e dire che dovresti semplicemente aggiungere i tuoi oggetti comuni come proprietà della WebViewPage di base in modo da non dover eseguire il cast di elementi dal ViewBag in ogni singola vista. Faccio la mia configurazione CurrentUser in questo modo.

Puoi usare un ActionResult personalizzato:

public class  GlobalView : ActionResult 
{
    public override void ExecuteResult(ControllerContext context)
    {
        context.Controller.ViewData["Global"] = "global";
    }
}

O anche un ActionFilter:

public class  GlobalView : ActionFilterAttribute 
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        filterContext.Result = new ViewResult() {ViewData = new ViewDataDictionary()};

        base.OnActionExecuting(filterContext);
    }
}

Aveva un progetto MVC 2 aperto ma entrambe le tecniche si applicano ancora con piccole modifiche.

Non devi fare confusione con le azioni o cambiare il modello, usa semplicemente un controller di base ed esegui il cast del controller esistente dal layout viewcontext.

Creare un controller di base con i dati comuni desiderati (titolo / pagina / posizione, ecc.) E inizializzazione dell'azione ...

public abstract class _BaseController:Controller {
    public Int32 MyCommonValue { get; private set; }

    protected override void OnActionExecuting(ActionExecutingContext filterContext) {

        MyCommonValue = 12345;

        base.OnActionExecuting(filterContext);
    }
}

Assicurati che ogni controller utilizzi il controller di base ...

public class UserController:_BaseController {...

Trasmetti il ​​controller di base esistente dal contesto della vista nella tua _Layout.cshmlpagina ...

@{
    var myController = (_BaseController)ViewContext.Controller;
}

Ora puoi fare riferimento ai valori nel controller di base dalla pagina del layout.

@myController.MyCommonValue

Se vuoi controllare il tempo di compilazione e intellisense per le proprietà nelle tue viste, ViewBag non è la strada da percorrere.

Considera una classe BaseViewModel e fai in modo che gli altri tuoi modelli di visualizzazione ereditino da questa classe, ad esempio:

Base ViewModel

public class BaseViewModel
{
    public bool IsAdmin { get; set; }

    public BaseViewModel(IUserService userService)
    {
        IsAdmin = userService.IsAdmin;
    }
}

Visualizza ViewModel specifico

public class WidgetViewModel : BaseViewModel
{
    public string WidgetName { get; set;}
}

Ora il codice di visualizzazione può accedere alla proprietà direttamente nella visualizzazione

<p>Is Admin: @Model.IsAdmin</p>

Ho trovato che il seguente approccio è il più efficiente e offre un controllo eccellente utilizzando il file _ViewStart.chtml e le istruzioni condizionali quando necessario:

_ ViewStart :

@{
 Layout = "~/Views/Shared/_Layout.cshtml";

 var CurrentView = ViewContext.Controller.ValueProvider.GetValue("controller").RawValue.ToString();

 if (CurrentView == "ViewA" || CurrentView == "ViewB" || CurrentView == "ViewC")
    {
      PageData["Profile"] = db.GetUserAccessProfile();
    }
}

VistaA :

@{
   var UserProfile= PageData["Profile"] as List<string>;
 }

Nota :

PageData funzionerà perfettamente in Views; tuttavia, nel caso di PartialView, dovrà essere passato dalla View al Partial figlio.