CODEWITHSUNDEEP
asp.net-mvcsession-variables
MrM
MrM

Reputation: 21989

What is the right time for ViewData, ViewBag, Session, TempData

I was editing a project and I saw a Session[""] in one controller method and TempData[""] in another. Is there a difference between the 4 or is it just 4 ways to do the same thing?

Upvotes: 48

Views: 50635

Answers (3)

marvelTracker
marvelTracker

Reputation: 4969

ASP.net MVC introduced ViewData, ViewBag, TempData, Session to pass data between controller to view.

ViewData

ViewData is implemented by using ViewDataDictionary class which stored in CurrentRequestContext. So, ViewData life-cycle will end when the current request ends.

ViewBag is also like ViewData, and only difference is it enable dynamically sharing the data using dynamics objects.

TempData is a very short-lived instance, and you should only use it during the current and the subsequent requests only. This will be handy if you want to use Redirections (RedirectToAction, RedirectToRoute, Redirect) in ASP.net MVC and pass some data among redirects. TempData stores data in Session but framework disposes the data when current and subsequent requests ends.

Session is long-lived (never expires) data that belongs to user session. You need to be mindful when you use session variables which can easily cause issues.

protected void Session_Start(Object sender, EventArgs e) 
{
   int userType = 1;
   HttpContext.Current.Session.Add("_SessionUserType",userType );
}

Upvotes: 6

Elnaz
Elnaz

Reputation: 2890

ViewData:

  • Is a special dictionary inherited from ViewDataDictionary.
  • Used to send data from controller to view.
  • It's life span is the current request.
  • It will be destroyed if you have Redirect.
  • For security reasons, it's better to check it for null before usage.
  • The casting should be done for the operation.

ViewBag:

  • Is a dynamic type (this type is presented in c#4).

  • Like ViewData is used to send data from the controller to the view.

  • The duration of the validity of its values ​​in the current request.
  • In redirection between pages, its value will be null.
  • For security reasons before use, check it for null.
  • The casting is not necessary, so it's more faster than ViewData.

TempData:

  • A special kind of dictionary derived from TempDataDictionary.
  • It has Short life time, and used to send information between pages (Redirect).
  • After rendering the View completely, its value will be null.
  • For security reasons before use, check it for null.
  • The casting should be done for the operation.

Session:

  • used To send information between different requests.
  • Its value is not null not null values; Unless after a certain time (session expire).
  • For security reasons before use, check it for null.
  • The casting should be done for the operation.

This article explains the difference between ViewData, ViewBag and TempData. I hope you can refer this article for your need.

Upvotes: 5

Darin Dimitrov
Darin Dimitrov

Reputation: 1038710

  • ViewData/ViewBag - valid only for the duration of the current request.
    You set it in a controller action and use it in the view, then it disappears.
    The difference is that the first is a dictionary whereas the second is just a dynamic wrapper around this dictionary.
    Both point to the same data though.
    ViewBag was introduced in ASP.NET MVC 3.

Example:

public ActionResult Index()
{
    ViewData["foo"] = "bar";
    return View();
}

and inside the view you could use this value:

<div>@ViewData["foo"]</div>

Same with ViewBag but it is dynamic:

public ActionResult Index()
{
    ViewBag.foo = "bar";
    return View();
}

and inside the view you could use this value:

<div>@ViewBag.foo</div>

So as you can see ViewData/ViewBag are just an alternative way to pass information to a view from a controller action compared to the classic and recommended way which is using a view model:

public class MyViewModel
{
    public string Foo { get; set; }
}

and then:

public ActionResult Index()
{
    var model = new MyViewModel { Foo = "bar" };
    return View(model);
}

and inside your strongly typed view:

@model MyViewModel
<div>@Html.DisplayFor(x => x.Foo)</div>

As you can see using view models provide a strongly typed approach in passing information to a view from a controller action.

  • TempData - it allows for persisting information for the duration of a single subsequent request. You store something inside TempData and then redirect. In the target controller action to which you redirected you could retrieve the value that was stored inside TempData.

Example:

public ActionResult Foo()
{
    TempData["foo"] = "bar";
    return RedirectToAction("bar");
}

public ActionResult Bar()
{
    var value = TempData["foo"] as string;
    // use the value here. If you need to pass it to the view you could
    // use ViewData/ViewBag (I can't believe I said that but I will leave it for the moment)
    return View();
}

ASP.NET MVC will automatically expire the value that was stored in TempData once you read it. Under the covers ASP.NET MVC persists the information into the Session.

  • Session - same as TempData except that it never expires - it will be valid for all requests, not a single redirect.

Upvotes: 89

Related Questions