What's the difference between ViewData and Vie

问题:

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

回答1:

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.

回答2:

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

回答3:

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\"]

回答4:

ViewData: It’s required type casting for complex data type and check for null values to avoid error.

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

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>

回答5:

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\"]

回答6:

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.

回答7:

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.

回答8:

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

回答9:

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

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

In View:

@ViewBag.Name 
@ViewData[\"Name\"] 

回答10:

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

回答11:

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

回答12:

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.

回答13:

View Data

1. ViewData is used to pass data from controller to view
2. ViewData is derived from the ViewDataDictionary class and is basically a Dictionary object i.e.Keys and Values where Keys are String while Values will be objects.
3. Data typcasting is required while retrieving the data from ViewData because of its Object type of data and also null vvalue check befor type casting otherwise it will break the application. If redirection occurs, then its value becomes null Read full difference between TempData ViewData and View Bag

http://www.gurujipoint.com/2017/09/view-data-viewbag-and-tempdata.html

回答14:

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

回答15:

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.

回答16:

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: