Question

Just wondering what the actual difference between the ViewData that is bound to the MVC view and the ViewData that is bound to the @Html helper object?

I have written a page and they don’t seem to refer to the same thing. Is ViewData used anywhere else in the application as another dictionary hidden under the same name?

Answer 1

SHORT ANSWER:
The HtmlHelper‘s ViewData is based on the view’s data. So it has same values upon entering view code (for example, Razor or ASPX page). But you can change these ViewDatas separately.

It is used same way in AjaxHelper.

RepeaterItem has it’s own ViewData, which is based on the item.

I have not found any use of different ViewData anywhere.

UPDATE:
ViewData and @Html.ViewData are different only when you use a strongly typed view. If you use a not strongly typed view, both they are equal as reference. So I think this was done to wrap the ViewData into strongly typed ViewDataDictionary<>.

---

SOME INVESTIGATIONS:

I have taken a look at the decompiled sources and here is what I found.

Let’s see, what is @Html.ViewData:

namespace System.Web.Mvc
{
  public class HtmlHelper<TModel> : HtmlHelper
  {
    private ViewDataDictionary<TModel> _viewData;

    public ViewDataDictionary<TModel> ViewData
    {
      get
      {
        return this._viewData;
      }
    }

    public HtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
      : this(viewContext, viewDataContainer, RouteTable.Routes)
    {
    }

    public HtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer, RouteCollection routeCollection)
      : base(viewContext, viewDataContainer, routeCollection)
    {
      this._viewData = new ViewDataDictionary<TModel>(viewDataContainer.ViewData);
    }
  }
}

As we see, the ViewData is instantiated from some viewDataContainer in HtmlHelper constructor.

Let’s try to see, how is this connected with the page:

namespace System.Web.Mvc { 

    public abstract class WebViewPage<TModel> : WebViewPage {

        // some code

        public override void InitHelpers() {
            base.InitHelpers(); 

            // ...

            Html = new HtmlHelper<TModel>(ViewContext, this);
        } 

       // some more code
    }
}

So the current page is the viewDataContainer.

So, we see, that a new instance of a ViewData dictionary is instantiated for HtmlHelper based on the dictionary, which is stored in View. The only option, which could make the two be kinda same, if they used same Disctionary internally. Let’s check that.

Here is ViewData constructor:

    public ViewDataDictionary(ViewDataDictionary dictionary) 
    {
        if (dictionary == null) { 
            throw new ArgumentNullException("dictionary");
        } 

        foreach (var entry in dictionary) {
            _innerDictionary.Add(entry.Key, entry.Value); 
        }
        foreach (var entry in dictionary.ModelState) {
            ModelState.Add(entry.Key, entry.Value);
        } 

        Model = dictionary.Model; 
        TemplateInfo = dictionary.TemplateInfo; 

        // PERF: Don't unnecessarily instantiate the model metadata 
        _modelMetadata = dictionary._modelMetadata;
    }

As we can see, entries a just copied, but a different underlying _innerDictionary is used.