TempData Wrapper

Question

Ponieważ wciąż używam tych samych klawiszy do TempData, chciałbym ułatwić śledzenie tych kluczy. Byłoby wspaniale, gdyby w końcu mogę napisać coś takiego:

MyTempData.Message = "my message"; 

zamiast

TempData["Message"] = "my message"; 

Answer 1

Brzmi jak chcesz silnie typami TempData. Jednym ze sposobów, aby przejść o tym pisze metodę rozszerzenia na kontrolerze, aby to zrobić:

public static class ControllerExtensions 
{ 
    public string GetMessage(this Controller instance) 
    { 
    string result = instance.TempData["Message"] as string; 
    if (result == null) 
    { 
     result = "some default value or throw null argument exception"; 
    } 
    return result; 
    } 

    public void SetMessage(this Controller instance, string value) 
    { 
    instance.TempData["Message"] = value; 
    } 
} 

Answer 2

Trudno powiedzieć, na jakim poziomie chcesz dane tymczasowe, aby utrzymywać. Moja interpretacja brzmi tak, jakbyś chciał mieć wspólny zestaw właściwości dostępny dla wszystkich modeli ViewModels.

Aby to osiągnąć, dziedziczmy ze wspólnej klasy ViewModel.

public class BaseViewModel 
{ 
    public string Message{get;set;} 
} 

public class MyModel : BaseViewModel 
{ 
    public string MyUniquePropety{get;set;} 
} 

Jeśli okaże się, że chcesz się utrzymywać w danych sesji, a następnie wdrożenie Singleton, i pamiętaj, aby dodać oświadczenie @using do widzenia do niego odwoływać.

Answer 3

Można naśladować to, co robi ViewBag.

Najpierw używa wewnętrznej zamkniętej klasy o nazwie DynamicViewDataDictionary. Zasadniczo zamierzam zrobić wersję tego dla TempData. Następnie, możemy użyć metody rozszerzenie, aby była dostępna w Controller, WebViewPage itp

public sealed class DynamicTempDataDictionary : DynamicObject 
{ 
    private readonly Func<TempDataDictionary> _tempDataThunk; 

    public DynamicTempDataDictionary(Func<TempDataDictionary> viewDataThunk) 
    { 
     _tempDataThunk = viewDataThunk; 
    } 

    private TempDataDictionary ViewData 
    { 
     get { return _tempDataThunk(); } 
    } 

    public override IEnumerable<string> GetDynamicMemberNames() 
    { 
     return ViewData.Keys; 
    } 

    public override bool TryGetMember(GetMemberBinder binder, out object result) 
    { 
     result = ViewData[binder.Name]; 
     return true; 
    } 

    public override bool TrySetMember(SetMemberBinder binder, object value) 
    { 
     ViewData[binder.Name] = value; 
     return true; 
    } 
} 

public static class TempBagExtensions 
{ 
    private const string TempBagKey = "__CurrentTempBagDictionary"; 

    public static dynamic TempBag(this ControllerBase controller) 
    { 
     return GetCurrentDictionary(controller.ControllerContext); 
    } 

    public static dynamic TempBag(this WebViewPage viewPage) 
    { 
     return GetCurrentDictionary(viewPage.ViewContext.Controller.ControllerContext); 
    } 


    private static DynamicTempDataDictionary GetCurrentDictionary(ControllerContext context) 
    { 
     var dictionary = context.HttpContext.Items[TempBagKey] as DynamicTempDataDictionary; 

     if (dictionary == null) 
     { 
      dictionary = new DynamicTempDataDictionary(() => context.Controller.TempData); 
      context.HttpContext.Items[TempBagKey] = dictionary; 
     } 

     return dictionary; 
    } 
} 

W kontrolerze:

this.TempBag().SomeValue = "Test"; 

w widoku z ostrzami:

@this.TempBag().SomeValue 

Jeśli nie myśl, że metoda rozszerzenia jest wystarczająco czysta, możesz stworzyć własną klasę bazową kontrolera, a także własne klasy bazowe dla widoków maszynki, które używają ładnych, zwięzłych właściwości ala ViewBag.

Answer 4

Dość opcja low-tech, ale jeśli po prostu chcesz śledzić klucze których używasz, można po prostu stworzyć pewne stałe:

public static class TempDataKeys 
{ 
    public const string Message = "Message"; 
    public const string Warning = "Warning"; 
    public const string Error = "Error"; 
    // etc 
} 

następnie:

TempData[TempDataKeys.Message] = "Some message";