3

As you know, we can create two types of Helper methods in ASP.NET MVC:

  • Inline helper methods
  • External helper methods

And now, let's say I am passsing data from the controller to the view by using the ViewBag object. Like that:

ViewBag.Fruits = new string[] {"Apple", "Orange", "Pear"};

And I have defined such inline helper method in the view:

@helper ListArrayItemsInline(string[] items)
{
    ...
}

And here is an external helper method which takes a string array as an input:

public static MvcHtmlString ListArrayItemsExternal(this HtmlHelper html, string[] list)
{
    ...
}

And the difference is that, I must cast ViewBag.Fruits to string[] if I want to use external one. Yes, everything is right here. But, this is not the case with the inline one. As I see, it evaluates types at runtime.

// external one, we must cast 
@Html.ListArrayItemsExternal((string[])ViewBag.Fruits) 

// internal one, works just fine
@ListArrayItemsInline(ViewBag.Fruits)

Could you please explain me, how and why inline helper methods evaluating types at runtime?

Farhad Jabiyev
  • 26,014
  • 8
  • 72
  • 98

2 Answers2

1

ViewBag property offers a flexible way to pass data to the view.The property of ViewBag is defined as dynamic type.

public dynamic ViewBag{get;}

When a .NET compiler encounters a dynamic type,it emits a special chunk of code instead of simply evaluating the expression.Such special chunk of code passes the expression to the Dynamic Language Runtime(DLR) for a run-time evaluation.

In other words any expression based on the dynamic type is compiled at run time.Any member set or read out of ViewBag is always accepted by the compiler but not actually evaluated until execution.

Rohit
  • 10,056
  • 7
  • 50
  • 82
  • 1
    But, why it is not the case with **external helper methods?** – Farhad Jabiyev Mar 08 '15 at 16:16
  • 1
    He did answer. Inline methods are parsed by the DLR, while external methods use static typing resolution to solve the parameters. – Marius Ungureanu Mar 08 '15 at 16:21
  • Thanks for the answer. I got it from your answer. But, I have understood what is the exact difference after reading other answer. Anyway, it was also really very helpful. Thanks again. – Farhad Jabiyev Mar 08 '15 at 18:26
  • 1
    @MariusUngureanu We can say this, but the reason of this difference is not if the method is internal or external. But, if the method is extension or not. Because, extension methods can't be dynamically dispatched. – Farhad Jabiyev Mar 08 '15 at 20:07
1

The difference is solely in the syntax you use to invoke the helper: ListArrayItemsInline is a normal method, but ListArrayItemsExternal is an extension method. If you attempt to invoke ListArrayItemsExternal as an extension method without casting the argument, then the compiler gives you this error message:

CS1973: 'System.Web.Mvc.HtmlHelper' has no applicable method named 'ListArrayItemsExternal' but appears to have an extension method by that name. Extension methods cannot be dynamically dispatched. Consider casting the dynamic arguments or calling the extension method without the extension method syntax.

The error message suggests two options for resolving the error:

Option 1. Cast the dynamic argument:

@Html.ListArrayItemsExternal((string[])ViewBag.Fruits)

Option 2. Call ListArrayItemsExternal using normal method syntax, in which case you don't have to cast the dynamic argument:

MyHelpers.ListArrayItemsExternal(Html, ViewBag.Fruits)

The second option demonstrates that types can be resolved at run time for external helper methods. You just have to use the right syntax.

As for why extension methods can't be dynamically dispatched, check out this answer by Eric Lippert.

Community
  • 1
  • 1
Michael Liu
  • 52,147
  • 13
  • 117
  • 150
  • Thanks for explanation. I got it. So, the reason of this difference is not if the method is internal or external. But, if the method is extension or not. Yes? Because, extension methods can't be dynamically dispatched. – Farhad Jabiyev Mar 08 '15 at 18:24