What's the difference between ViewData and ViewBag?

2023-02-04 19:41 问答作者：

I saw the ViewBag in MVC 3. How's t开发者_高级运维hat 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.

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.
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.
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.
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.