Заставьте ASP.NET MVC 3 Razor View Engine игнорировать файлы .vbhtml.

Question

Как я могу удалить VB Razor Engine или настроить RazorViewEngine, чтобы он не использовал и не искал файлы .vbhtml на диске?Для новых проектов ASP.NET MVC 3 Razor я всегда удаляю WebFormViewEngine в Application_Start, потому что я никогда не буду его использовать и поэтому он мне не нужен для поиска файлов .aspx, .ascx или .master на диске.По этой же причине я хотел бы избежать поиска файлов .vbhtml.

Answer 1

Это код для вашего пользовательского механизма просмотра:

public class CSRazorViewEngine : RazorViewEngine {

    public CSRazorViewEngine() {

        base.AreaViewLocationFormats = new string[] { 
            "~/Areas/{2}/Views/{1}/{0}.cshtml",
            "~/Areas/{2}/Views/Shared/{0}.cshtml"
        };

        base.AreaMasterLocationFormats = new string[] { 
            "~/Areas/{2}/Views/{1}/{0}.cshtml",
            "~/Areas/{2}/Views/Shared/{0}.cshtml"
        };

        base.AreaPartialViewLocationFormats = new string[] { 
            "~/Areas/{2}/Views/{1}/{0}.cshtml",
            "~/Areas/{2}/Views/Shared/{0}.cshtml"
        };

        base.ViewLocationFormats = new string[] {
            "~/Views/{1}/{0}.cshtml",
            "~/Views/Shared/{0}.cshtml"
        };

        base.PartialViewLocationFormats = new string[] {
            "~/Views/{1}/{0}.cshtml",
            "~/Views/Shared/{0}.cshtml"
        };

        base.MasterLocationFormats = new string[] {
            "~/Views/{1}/{0}.cshtml",
            "~/Views/Shared/{0}.cshtml"
        };

        base.FileExtensions = new string[] { "cshtml" };
    }
}

Зарегистрируйте это в методе Application_Start следующим образом:

ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new CSRazorViewEngine());

Answer 2

Почему нет смысла удалять поиск в .vbhtml, если я никогда не буду его использовать?

Вот как я это делаю (но я до сих пор не знаю, стоит ли удалять vbhtml):

protected void Application_Start()
{
    ViewEngines.Engines.Clear();
    ViewEngines.Engines.Add(new RazorViewEngine().DisableVbhtml());

    ...
}

Код метода расширения:

public static RazorViewEngine DisableVbhtml(this RazorViewEngine engine)
{
    engine.AreaViewLocationFormats = FilterOutVbhtml(engine.AreaViewLocationFormats);
    engine.AreaMasterLocationFormats = FilterOutVbhtml(engine.AreaMasterLocationFormats);
    engine.AreaPartialViewLocationFormats = FilterOutVbhtml(engine.AreaPartialViewLocationFormats);
    engine.ViewLocationFormats = FilterOutVbhtml(engine.ViewLocationFormats);
    engine.MasterLocationFormats = FilterOutVbhtml(engine.MasterLocationFormats);
    engine.PartialViewLocationFormats = FilterOutVbhtml(engine.PartialViewLocationFormats);
    engine.FileExtensions = FilterOutVbhtml(engine.FileExtensions);

    return engine;
}

private static string[] FilterOutVbhtml(string[] source)
{
    return source.Where(s => !s.Contains("vbhtml")).ToArray();
}

Answer 3

Нет никакого смысла в этом.

Однако, если вы действительно хотите, вы можете очистить ViewEngines, а затем зарегистрировать свой собственный RazorViewEngine с FileExtensions, установленным на ".cshtml".

Answer 4

Я решил объединить примеры из @tugberk и @Dimps:

public class CSHtmlRazorViewEngine : RazorViewEngine {
    public CSHtmlRazorViewEngine()
        : base() {
        this.AreaMasterLocationFormats = Filter(base.AreaMasterLocationFormats);
        this.AreaPartialViewLocationFormats = Filter(base.AreaPartialViewLocationFormats);
        this.AreaViewLocationFormats = Filter(base.AreaViewLocationFormats);
        this.FileExtensions = Filter(base.FileExtensions);
        this.MasterLocationFormats = Filter(base.MasterLocationFormats);
        this.PartialViewLocationFormats = Filter(base.PartialViewLocationFormats);
        this.ViewLocationFormats = Filter(base.ViewLocationFormats);
    }

    private static string[] Filter(
        string[] source) {
        return source.Where(
            s =>
                s.Contains("cshtml")).ToArray();
    }
}

Answer 5

Сводка сверху с одним классом.

Используйте это так:

ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new FilteredRazorViewEngine("cshtml"));

Класс:

public class FilteredRazorViewEngine : RazorViewEngine
{
    private string _extension;

    public FilteredRazorViewEngine(string viewTypeExtension)
        : base()
    {
        _extension = viewTypeExtension;

        AreaMasterLocationFormats = Filter(base.AreaMasterLocationFormats);
        AreaPartialViewLocationFormats = Filter(base.AreaPartialViewLocationFormats);
        AreaViewLocationFormats = Filter(base.AreaViewLocationFormats);
        FileExtensions = Filter(base.FileExtensions);
        MasterLocationFormats = Filter(base.MasterLocationFormats);
        PartialViewLocationFormats = Filter(base.PartialViewLocationFormats);
        ViewLocationFormats = Filter(base.ViewLocationFormats);
    }

    private string[] Filter(string[] source)
    {
        return source.Where(
            s =>
                s.Contains(_extension)).ToArray();
    }
}

Answer 6

Этот сохраняет оригинальный RazorViewEngine и очищает расширения VB.

//Remove the legacy ASPX view engine
ViewEngines.Engines.Remove(ViewEngines.Engines.OfType<WebFormViewEngine>().Single());

//Remove VB from the remaining view engine
var target = ViewEngines.Engines.OfType<RazorViewEngine>().Single();
(new Expression<Func<RazorViewEngine,string[]>>[] {
    y => y.FileExtensions,
    y => y.ViewLocationFormats,
    y => y.PartialViewLocationFormats,
    y => y.MasterLocationFormats,
    y => y.AreaMasterLocationFormats,
    y => y.AreaPartialViewLocationFormats,
    y => y.AreaViewLocationFormats
}
).Select(y => (PropertyInfo)((MemberExpression)y.Body).Member).ToList()
    .ForEach(y => y.SetValue(target,((string[])y.GetValue(target))
    .Where(x => x.EndsWith("cshtml")).ToArray(),null));

Answer 7

Как и @ Алекс , объединяя и расширяя предыдущие решения.

На всякий случай, если вы хотите указать расширения для других ViewEngines, наследовать от «оригинала» и либо строить, либо фильтровать (ваше предпочтение, я просто подумал, что фильтрация кажется более эффективной, чем запуск нового списка).

Использование:

// custom extension(s)
ViewEngines.Engines.UseOnly(new ExtensionSpecificRazorViewEngine("cshtml"));
ViewEngines.Engines.UseOnly(new ExtensionSpecificRazorViewEngine("myhtml", "xhtml"));

// filtered from original extensions
ViewEngines.Engines.UseOnly(new ExtensionSpecificRazorViewEngine(false, "cshtml", "vbhtml"));

Двигатель-конкретно:

/// <summary>
/// Razor View Engine only expecting the specified extensions
/// </summary>
public class ExtensionSpecificRazorViewEngine : RazorViewEngine
{
    public ExtensionSpecificRazorViewEngine(params string[] extensions) : this(true, extensions) { }

    public ExtensionSpecificRazorViewEngine(bool isBuildOrFilter, params string[] extensions) : this(null, isBuildOrFilter, extensions) {}

    /// <summary>
    /// Create a new ViewEngine only expecting the provided extension
    /// </summary>
    /// <param name="viewPageActivator"></param>
    /// <param name="isBuildOrFilter"></param>
    /// <param name="extensions"></param>
    public ExtensionSpecificRazorViewEngine(IViewPageActivator viewPageActivator, bool isBuildOrFilter, params string[] extensions)
        : base(viewPageActivator)
    {
        if (isBuildOrFilter) this.BuildSpecifically(extensions);
        else this.FilterSpecifically(extensions);

        this.FileExtensions = extensions;
    }
}//---  class   ExtensionSpecificRazorViewEngine

Который использует:

/// <summary>
/// Because classes can't inherit from multiple classes, we put the build/filter logic in a helper
/// that's used by the ViewEngine implementation which inherits from RazorViewEngine or WebFormViewEngine, etc
/// </summary>
public static class ExtensionSpecificViewEngineExtensions
{
    /// <summary>
    /// <para>Given a collection of ViewEngines, clear them and add the indicated engine</para>
    /// <example>ex) <code>ViewEngines.Engines.UseOnly(new RazorViewEngine());</code></example>
    /// </summary>
    /// <param name="engines">list of available engines</param>
    /// <param name="engine">the only engine to use</param>
    public static void UseOnly(this ViewEngineCollection engines, IViewEngine engine)
    {
        engines.Clear();
        engines.Add(engine);
    }

    /// <summary>
    /// Build the lookup paths specifically for the indicated extension(s)
    /// </summary>
    /// <param name="engine"></param>
    /// <param name="extensions"></param>
    public static void BuildSpecifically(this BuildManagerViewEngine engine, string[] extensions)
    {
        engine.AreaMasterLocationFormats =      Build(extensions, "~/Areas/{2}");
        engine.AreaPartialViewLocationFormats = Build(extensions, "~/Areas/{2}");
        engine.AreaViewLocationFormats =        Build(extensions, "~/Areas/{2}");
        engine.FileExtensions =                 Build(extensions);
        engine.MasterLocationFormats =          Build(extensions);
        engine.PartialViewLocationFormats =     Build(extensions);
        engine.ViewLocationFormats =            Build(extensions);
    }
    /// <summary>
    /// Filter the existing, default extensions from the view engine's lookup paths for the indicated extensions
    /// </summary>
    /// <param name="engine"></param>
    /// <param name="extensions"></param>
    public static void FilterSpecifically(this BuildManagerViewEngine engine, string[] extensions)
    {
        engine.AreaMasterLocationFormats =      Filter(extensions, engine/*base*/.AreaMasterLocationFormats);
        engine.AreaPartialViewLocationFormats = Filter(extensions, engine/*base*/.AreaPartialViewLocationFormats);
        engine.AreaViewLocationFormats =        Filter(extensions, engine/*base*/.AreaViewLocationFormats);
        engine.FileExtensions =                 Filter(extensions, engine/*base*/.FileExtensions);
        engine.MasterLocationFormats =          Filter(extensions, engine/*base*/.MasterLocationFormats);
        engine.PartialViewLocationFormats =     Filter(extensions, engine/*base*/.PartialViewLocationFormats);
        engine.ViewLocationFormats =            Filter(extensions, engine/*base*/.ViewLocationFormats);
    }

    private static string[] Build(string[] extensions, string prefix = "~")
    {
        return extensions.SelectMany(x => new[] {
                prefix + "/Views/{1}/{0}." + x,
                prefix + "/Views/Shared/{0}." + x
            }).ToArray();
    }

    private static string[] Filter(string[] extensions, params string[] source)
    {
        return source.Where(s => extensions.Any(s.EndsWith)).ToArray();
    }
}//---  class   ExtensionSpecificViewEngineExtensions