View difference between Paste ID: Y1ES6gg7 and EL1vcV58

 namespace Nansen {
   public static class DisplayExtensions {
     public const string DEFAULT_PREFIX_VIEW_FORMAT = "{0}.{1}";
     public const string DIRECTORY_PREFIX_VIEW_FORMAT = "{0}/{1}";
 
-    /// <summary>
+    /// <summary>
-    /// &lt;see cref="System.Web.Mvc.Html.DisplayExtensions.DisplayFor{TModel,TValue}(System.Web.Mvc.HtmlHelper{TModel},System.Linq.Expressions.Expression{System.Func{TModel,TValue}})"/&gt;
+    /// <see cref="System.Web.Mvc.Html.DisplayExtensions.DisplayFor{TModel,TValue}(System.Web.Mvc.HtmlHelper{TModel},System.Linq.Expressions.Expression{System.Func{TModel,TValue}})"/>
     /// overload using a template prefix. Used to display for the value type using a custom prefix so one object type can have different templates. Will fall back to base types.
-    /// &lt;/summary&gt;
+    /// </summary>
-    /// &lt;remarks&gt;
+    /// <remarks>
-    /// Works similar to regular &lt;see cref="System.Web.Mvc.Html.DisplayExtensions.DisplayFor{TModel,TValue}(System.Web.Mvc.HtmlHelper{TModel},System.Linq.Expressions.Expression{System.Func{TModel,TValue}})"/&gt;
+    /// Works similar to regular <see cref="System.Web.Mvc.Html.DisplayExtensions.DisplayFor{TModel,TValue}(System.Web.Mvc.HtmlHelper{TModel},System.Linq.Expressions.Expression{System.Func{TModel,TValue}})"/>
-    /// where the template type is searched recursively using &lt;see cref="Type.BaseType"/&gt;. If no template can be found, it will fallback to the default System.Web.Mvc.Html.DisplayExtensions.DisplayFor method
+    /// where the template type is searched recursively using <see cref="Type.BaseType"/>. If no template can be found, it will fallback to the default System.Web.Mvc.Html.DisplayExtensions.DisplayFor method
     /// using no template at all.
-    /// &lt;/remarks&gt;
+    /// </remarks>
-    /// &lt;typeparam name="TModel"&gt;The model type&lt;/typeparam&gt;
+    /// <typeparam name="TModel">The model type</typeparam>
-    /// &lt;typeparam name="TValue"&gt;The value type&lt;/typeparam&gt;
+    /// <typeparam name="TValue">The value type</typeparam>
-    /// &lt;param name="html"&gt;The html helper&lt;/param&gt;
+    /// <param name="html">The html helper</param>
-    /// &lt;param name="expression"&gt;The value expression&lt;/param&gt;
+    /// <param name="expression">The value expression</param>
-    /// &lt;param name="templatePrefix"&gt;The template prefix, ex using "MyStringList" for &lt;typeparamref name="TValue"/&gt; string would, using default &lt;paramref name="viewFormat" /&gt;, look for the display template named MyStringList.string.cshtml&lt;/param&gt;
+    /// <param name="templatePrefix">The template prefix, ex using "MyStringList" for <typeparamref name="TValue"/> string would, using default <paramref name="viewFormat" />, look for the display template named MyStringList.string.cshtml</param>
-    /// &lt;param name="viewFormat"&gt;How to format the view template name, format arguments: {0} - &lt;paramref name="templatePrefix"/&gt;, {1} - model type name. / can also be used to make the prefix be a directory&lt;/param&gt;
+    /// <param name="viewFormat">How to format the view template name, format arguments: {0} - <paramref name="templatePrefix"/>, {1} - model type name. / can also be used to make the prefix be a directory</param>
-    /// &lt;param name="fallbackTemplate"&gt;If set, will be used if no display template can be found, otherwise DisplayFor without template will be called as fallback&lt;/param&gt;
+    /// <param name="fallbackTemplate">If set, will be used if no display template can be found, otherwise DisplayFor without template will be called as fallback</param>
-    /// &lt;param name="preferInterfaceBeforeBaseClass"&gt;If true, the display template search prefers interfaces before base classes, otherwise all base classes will be checked before any interface. Also, only interfaces defined directly on the current type being searched is considered each &lt;see cref="Type.BaseType"/&gt; iteration&lt;/param&gt;
+    /// <param name="preferInterfaceBeforeBaseClass">If true, the display template search prefers interfaces before base classes, otherwise all base classes will be checked before any interface. Also, only interfaces defined directly on the current type being searched is considered each <see cref="Type.BaseType"/> iteration</param>
-    /// &lt;returns&gt;The rendered html&lt;/returns&gt;
+    /// <returns>The rendered html</returns>
-    public static MvcHtmlString DisplayForWithPrefix&lt;TModel, TValue&gt;(this HtmlHelper&lt;TModel&gt; html, Expression&lt;Func&lt;TModel, TValue&gt;&gt; expression, string templatePrefix,
+    public static MvcHtmlString DisplayForWithPrefix<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templatePrefix,
       string viewFormat = DEFAULT_PREFIX_VIEW_FORMAT, string fallbackTemplate = null, bool preferInterfaceBeforeBaseClass = false)
     {
       var metaData = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
       var modelType = metaData.Model.GetType(); // this is the most derived type of the model
 
-      Func&lt;string, MvcHtmlString&gt; renderer = templateName =&gt; System.Web.Mvc.Html.DisplayExtensions.DisplayFor(html, expression, templateName);
+      Func<string, MvcHtmlString> renderer = templateName => System.Web.Mvc.Html.DisplayExtensions.DisplayFor(html, expression, templateName);
 
       // first, check all concrete implementations
       while(modelType != null) {
         var viewName = string.Format(viewFormat, templatePrefix, modelType.Name);
 
         if(DisplayTemplateExist(html.ViewContext, viewName)) {
           return renderer(viewName);
         }
 
         if(preferInterfaceBeforeBaseClass) {
           // check interfaces defined on the model type directly
-          var exceptions = modelType.BaseType != null ? modelType.BaseType.GetInterfaces() : Enumerable.Empty&lt;Type&gt;();
+          var exceptions = modelType.BaseType != null ? modelType.BaseType.GetInterfaces() : Enumerable.Empty<Type>();
           foreach(var @interface in metaData.Model.GetType().GetInterfaces().Except(exceptions)) {
             viewName = string.Format(viewFormat, templatePrefix, @interface.Name);
             if(DisplayTemplateExist(html.ViewContext, viewName)) {
               return renderer(viewName);
             }
           }
         }
 
         modelType = modelType.BaseType;
       }
 
       // check all interfaces, if not already checked per implementation
       if(!preferInterfaceBeforeBaseClass) {
         foreach(var @interface in metaData.Model.GetType().GetInterfaces()) {
           var viewName = string.Format(viewFormat, templatePrefix, @interface.Name);
           if(DisplayTemplateExist(html.ViewContext, viewName)) {
             return renderer(viewName);
           }
         }
       }
 
       // fallback
       return renderer(fallbackTemplate);
     }
 
     private static bool DisplayTemplateExist(ViewContext context, params string[] templateNames)
     {
       foreach(var templateName in templateNames) {
         // the FindPartialView will not automatically search the displaytemplates folder, but the DisplayFor method will
         var viewResult = ViewEngines.Engines.FindPartialView(context, "DisplayTemplates/" + templateName);
         return viewResult.View != null;
       }
       return false;
     }
   }
 }