What's the difference between ViewData and ViewBag?

I saw the ViewBag in MVC 3. How's that different than ViewData in MVC 2?

It uses the C# 4.0 dynamic feature. It achieves the same goal as viewdata and should be avoided in favor of using strongly typed view models (the same way as viewdata should be avoided).

So basically it replaces magic strings:

ViewData["Foo"]

with magic properties:

ViewBag.Foo

for which you have no compile time safety.

I continue to blame Microsoft for ever introducing this concept in MVC.

The name of the properties are case sensitive.

Internally ViewBag properties are stored as name/value pairs in the ViewData dictionary.

Note: in most pre-release versions of MVC 3, the ViewBag property was named the ViewModel as noted in this snippet from MVC 3 release notes:

(edited 10-8-12) It was suggested I post the source of this info I posted, here is the source: http://www.asp.net/whitepapers/mvc3-release-notes#_Toc2_4

> MVC 2 controllers support a ViewData > property that enables you to pass data > to a view template using a late-bound > dictionary API. In MVC 3, you can also > use somewhat simpler syntax with the > ViewBag property to accomplish the > same purpose. For example, instead of > writing ViewData["Message"]="text", > you can write ViewBag.Message="text". > You do not need to define any > strongly-typed classes to use the > ViewBag property. Because it is a > dynamic property, you can instead just > get or set properties and it will > resolve them dynamically at run time. > Internally, ViewBag properties are > stored as name/value pairs in the > ViewData dictionary. (Note: in most > pre-release versions of MVC 3, the > ViewBag property was named the > ViewModel property.)

ViewBag vs ViewData in MVC

http://royalarun.blogspot.in/2013/08/viewbag-viewdata-tempdata-and-view.html

Similarities between ViewBag & ViewData :

> Helps to maintain data when you move from controller to view. Used to > pass data from controller to corresponding view. Short life means > value becomes null when redirection occurs. This is because their goal > is to provide a way to communicate between controllers and views. It’s > a communication mechanism within the server call.

Difference between ViewBag & ViewData:

> ViewData is a dictionary of objects that is derived from > ViewDataDictionary class and accessible using strings as keys. ViewBag > is a dynamic property that takes advantage of the new dynamic features > in C# 4.0. ViewData requires typecasting for complex data type and > check for null values to avoid error. ViewBag doesn’t require > typecasting for complex data type.

ViewBag & ViewData Example:

public ActionResult Index()
{   
    ViewBag.Name = "Arun Prakash";   
    return View();
}

public ActionResult Index()
{  
    ViewData["Name"] = "Arun Prakash";  
    return View();
}   

Calling in View

@ViewBag.Name    
@ViewData["Name"]

ViewData: It requires type casting for complex data types and checks for null values to avoid errors.

ViewBag: It doesn’t require type casting for complex data types.

Consider the following example:

public class HomeController : Controller
{
    public ActionResult Index()
    {
        var emp = new Employee
        {
            EmpID=101,
            Name = "Deepak",
            Salary = 35000,
            Address = "Delhi"
        };

        ViewData["emp"] = emp;
        ViewBag.Employee = emp;
 
        return View(); 
    }
}

And the code for View is as follows:

@model MyProject.Models.EmpModel;
@{ 
 Layout = "~/Views/Shared/_Layout.cshtml"; 
 ViewBag.Title = "Welcome to Home Page";
 var viewDataEmployee = ViewData["emp"] as Employee; //need type casting
}

<h2>Welcome to Home Page</h2>
This Year Best Employee is!
<h4>@ViewBag.Employee.Name</h4>
<h3>@viewDataEmployee.Name</h3>

All answers suggest that ViewBag and/or ViewData is to pass data from Controller to Views which is misinformation. both are very useful to pass data from Views to Layout or Partial to Views (or ViewComponents, etc) It's not controller exclusive.

as the default asp.net sample have this in the layout page:

<title>@ViewData["Title"] - MyApp</title>

and in any view

ViewData["Title"] = "Details";

So then, to asking the question: "what's the difference between ViewBag and ViewData?"

The most notable difference is ViewData is a Strongly Typed Dictionary while ViewBag is a dynamic type.

Note that the data inside IS THE SAME

ViewData["Title"] = "MyTitle";
ViewBag.Title; // returns "MyTitle";

When to use one or another?

• ViewBag doesn't support not valid C# names. you can't access ViewData["Key With Space"] with ViewBag
• ViewBag.Something is dynamic and you may have problems when calling methods (like extension methods) that needs to know the exact parameter at compile time.
• ViewBag can check for nulls syntactical cleaner: ViewBag.Person?.Name
• ViewData have all the properties of a Dictionary like ContainsKey, Add, etc. so you can use ViewData.Add("somekey", "somevalue") keep in mind it might throw exceptions.
• Using ViewData on views needs TypeCasting while ViewBag don't.

Knowing the subtle differences, using one or another is much more a taste preference.

Normally you can think of ViewBag.AnyKey to an alias of ViewData["AnyKey"]

Can I recommend to you to not use either?

If you want to "send" data to your screen, send a strongly typed object (A.K.A. ViewModel) because it's easier to test.

If you bind to some sort of "Model" and have random "viewbag" or "viewdata" items then it makes automated testing very difficult.

If you are using these consider how you might be able to restructure and just use ViewModels.

There are some subtle differences that mean you can use ViewData and ViewBag in slightly different ways from the view. One advantage is outlined in this post http://weblogs.asp.net/hajan/archive/2010/12/11/viewbag-dynamic-in-asp-net-mvc-3-rc-2.aspx and shows that casting can be avoided in the example by using the ViewBag instead of ViewData.

viewdata: is a dictionary used to store data between View and controller , u need to cast the view data object to its corresponding model in the view to be able to retrieve data from it ...

ViewBag: is a dynamic property similar in its working to the view data, However it is better cuz it doesn't need to be casted to its corressponding model before using it in the view ...

Below is the point to point difference about ViewData, ViewBag, TempData & Session. Credit/copied askforprogram.in , Follow the link for code example that i haven't mentioned here.

1. ViewData in MVC

• ViewData is property of ControllerBase class.
• ViewData is a type of dictionary object.
• ViewData is key-value dictionary collection.
• ViewData was introduced in MVC 1.0 version.
• ViewData works with .Net framework 3.5 and above.
• Need to do type conversion of code while enumerating.
• ViewData object keeps data only for current request.

2. ViewBag in MVC

• ViewBag is property of ControllerBase class.
• ViewBag is a type of dynamic object.
• ViewBag is a type of object.
• ViewBag was introduced in MVC 3.0 version.
• ViewBag works with .Net framework 4.0 and above.
• ViewBag uses property and handles it, so no need to do type conversion while enumerating.
• ViewBag object keeps data only for current request.

3. TempData in MVC

• TempData is property of ControllerBase class.
• TempData is a type of dictionary object.
• TempData is key-value dictionary collection.
• TempData was introduced in MVC 1.0 version.
• TempData works with .Net framework 3.5 and above.
• Need to do type conversion of code while enumerating.
• TempData object is used to data between current request and subsequent request.

4. Session in MVC

• Session is property of Controller(Abstract Class).
• Session is a type of HttpSessionStateBase.
• Session is key-value dictionary collection.
• Session was introduced in MVC 1.0 version.
• TempData works with .Net framework 1.0 and above.
• Need to do type conversion of code while enumerating.
• Session object keeps data for all requests. Valid for all requests, never expires.

Although you might not have a technical advantage to choosing one format over the other, you should be aware of some important differences between the two syntaxes. One obvious difference is that ViewBag works only when the key you’re accessing is a valid C# identifi er. For example, if you place a value in ViewData["Key With Spaces"], you can’t access that value using ViewBag because the code won’t compile. Another key issue to consider is that you cannot pass in dynamic values as parameters to extension methods. The C# compiler must know the real type of every parameter at compile time in order to choose the correct extension method. If any parameter is dynamic, compilation will fail. For example, this code will always fail: @Html.TextBox("name", ViewBag.Name). To work around this, either use ViewData["Name"] or cast the va

public ActionResult Index()
{
    ViewBag.Name = "Monjurul Habib";
    return View();
}

public ActionResult Index()
{
    ViewData["Name"] = "Monjurul Habib";
    return View();
} 

In View:

@ViewBag.Name 
@ViewData["Name"] 

In this way we can make it use the values to the pass the information between the controller to other page with TEMP DATA

One main difference I noticed between ViewData and ViewBag is:

ViewData : it will return object does not matter what you have assigned into this and need to typecast again back to the original type.

ViewBag : it is enough smart to return exact type what you have assigned to it it does not matter weather you have assigned simple type (i.e. int, string etc.) or complex type.

Ex: Controller code.

 namespace WebApplication1.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            Products p1 = new Products();
            p1.productId = 101;
            p1.productName = "Phone";
            Products p2 = new Products();
            p2.productId = 102;
            p2.productName = "laptop";

            List<Products> products = new List<Products>();
            products.Add(p1);
            products.Add(p2);
            ViewBag.Countries = products;
            return View();
        }
    }
    public class Products
    {
        public int productId { get; set; }
        public string productName { get; set; }
    }
}

View Code.

<ul>
            @foreach (WebApplication1.Controllers.Products item in ViewBag.Countries)
            {
            <li>@item.productId &nbsp;&nbsp;&nbsp;@item.productName</li>
            }
        </ul>

OutPut Screen.

ViewData

1. ViewData is used to pass data from controller to view
2. It is derived from ViewDataDictionary class
3. It is available for the current request only
4. Requires typecasting for complex data type and checks for null values to avoid error
5. If redirection occurs, then its value becomes null

ViewBag

1. ViewBag is also used to pass data from the controller to the respective view
2. ViewBag is a dynamic property that takes advantage of the new dynamic features in C# 4.0
3. It is also available for the current request only
4. If redirection occurs, then its value becomes null
5. Doesn’t require typecasting for complex data type

Here ViewData and ViewBag both are used pass data from Controller to View.

1. ViewData

-- ViewData is dictionary object that is derived from ViewDataDictonary class.

-- Data only allow for one request, ViewData values get cleared when page redirecting occurs.

-- ViewData value must be typed cate before use.

Example: In Controller

public ActionResult PassingDatatoViewWithViewData()
{
      ViewData["Message"] = "This message shown in view with the ViewData";
      return View();
}

In View

@ViewData["Message"];

-- With ViewData is a pair like Key and Value, Message is Key and in inverted comma value is Value.

-- Data is simple so we can not use typecasting here if data is complex then using type casting.

public ActionResult PassingDatatoViewWithViewData()
{
      var type= new List<string>
    {
        "MVC",
        "MVP",
        "MVVC"
    };
    ViewData["types"] = type;
    return View();
}

-- In View data can be extracted as

<ul>
        @foreach (var items in (List<string>)ViewData["types"])
        {
         <li>@items</li>
        }
  </ul>

2. ViewBag

--ViewBag uses the dynamic feature.ViewBag wrapper around the ViewData.

-- In ViewBag type casting is required.

-- Same as ViewData, if redirection occurs value becomes null.

Example:

public ActionResult PassingDatatoViewWithViewBag()
{
          ViewData.Message = "This message shown in view with the ViewBag";
          return View();
}

In View

@ViewBag.vbMessage

--For Complex type use ViewBag

public ActionResult PassingDatatoViewWithViewBag()
{
          var type= new List<string>
        {
            "MVC",
            "MVP",
            "MVVC"
        };
        ViewBag.types = type;
        return View();
 }

-- In View data can be extracted as

<ul>
       @foreach (var items in ViewBag.types)
       {
         <li>@items</li>
       }
</ul>

-- the main difference is that ViewBag not required typecasting but ViewData is required typecasting.

ViewBag

1. It returns Type Object.
2. It is a dynamic property of ControllerBase class.
3. ViewBag only works with .NET Framework 4.0 and above.
4. It does not require TypeCasting before use since ViewBag property is dynamic in nature.
5. ViewBag returns Dynamic Type Object and its properties are also dynamic.
6. It is bit faster than ViewData.

ViewData

1. It returns Key-Value Dictionary pair collection.
2. ViewData is a dictionary object and it is property of ControllerBase class.
3. ViewData is faster than ViewBag.
4. Type Conversion code is required while enumerating since its a Dictionary Pair Collections.
5. ViewData returns the object (type of key-value pair and value is type object, so you need to cast before use)

---

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

public ActionResult Index()
{  
    ViewData["Name"] = "Arun Prakash";  
    return View();
}

Calling in View

@ViewBag.Name    
@ViewData["Name"]

ViewBag and ViewData are two means which are used to pass information from controller to view in ASP.Net MVC. The goal of using both mechanism is to provide the communicaton between controller and View. Both have short life that is the value of both becomes null once the redirection has occured ie, once the page has redirected from the source page (where we set the value of ViewBag or ViewData) to the target page , both ViewBag as well as ViewData becomes null.

Despite having these similarities both (ViewBag and ViewData) are two different things if we talk about the implementation of both. The differences are as follows :

1.) If we analyse both implementation wise then we will find that ViewData is a dictionary data structure - Dictionary of Objects derived from ViewDataDictionary and accessible using strings as Keys to these values while ViewBag makes use of the dynamic features introduced in C#4.0 and is a dynamic property.

2.) While accessing the values form ViewData , we need to typecast the values (datatypes) as they are stored as Objects in the ViewData dictionary but there is no such need if we are accessing th value in case of ViewBag.

3.) In ViewBag we can set the value like this :

      ViewBag.Name = "Value"; 

and can access as follows:

          @ViewBag.Name

While in case of ViewData the values can be set and accessed as follows: Setting ViewData as follows :

ViewData["Name"] = "Value";

and accessing value like this

 @ViewData["Name"] 

For more details click here: