Since a lot of .NET classes are internal, I copied one and implemented missing methods.

FileVirtualPathProvider.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Web.Hosting;

namespace Helpers.Web
{
    public class FileVirtualPathProvider : VirtualPathProvider
    {
        private bool _ensureExists = true;

        public string ApplicationPath { get; set; }

        internal bool EnsureExists
        {
            get
            {
                return _ensureExists;
            }
            set
            {
                _ensureExists = value;
            }
        }

        public FileVirtualPathProvider(string applicationPath)
        {
            ApplicationPath = applicationPath;
        }

        public string MapPath(string virtualPath)
        {
            string oldValue = ApplicationPath.EndsWith("/", StringComparison.OrdinalIgnoreCase) ? "~/" : "~";
            return virtualPath.Replace(oldValue, ApplicationPath);
        }

        public override bool FileExists(string virtualPath)
        {
            if (EnsureExists)
                return File.Exists(MapPath(virtualPath));
            return true;
        }

        public override bool DirectoryExists(string virtualDir)
        {
            if (EnsureExists)
                return Directory.Exists(MapPath(virtualDir));
            return true;
        }

        public override VirtualFile GetFile(string virtualPath)
        {
            string str = MapPath(virtualPath);
            return new FileInfoVirtualFile(str, new FileInfo(str));
        }

        public override VirtualDirectory GetDirectory(string virtualDir)
        {
            string str = MapPath(virtualDir);
            return new DirectoryInfoVirtualDirectory(str, new DirectoryInfo(str));
        }

        internal class FileInfoVirtualFile : VirtualFile
        {
            public FileInfo File { get; set; }

            public FileInfoVirtualFile(string virtualPath, FileInfo file)
                : base(virtualPath)
            {
                File = file;
            }

            public override Stream Open()
            {
                return File.OpenRead();
            }
        }

        internal class DirectoryInfoVirtualDirectory : VirtualDirectory
        {
            public DirectoryInfo Directory { get; set; }

            public override IEnumerable Files
            {
                get
                {
                    List<VirtualFile> list = new List<VirtualFile>();
                    foreach (FileInfo file in Directory.GetFiles())
                        list.Add(new FileInfoVirtualFile(file.FullName, file));
                    return list;
                }
            }

            public override IEnumerable Children
            {
                get
                {
                    var list = new List<object>();
                    list.AddRange((List<VirtualFile>)Files);
                    list.AddRange((List<VirtualDirectory>)Directories);
                    return list;
                }
            }

            public override IEnumerable Directories
            {
                get
                {
                    List<VirtualDirectory> list = new List<VirtualDirectory>();
                    foreach (var dir in Directory.GetDirectories())
                        list.Add(new DirectoryInfoVirtualDirectory(dir.FullName, dir));
                    return list;
                }
            }

            public DirectoryInfoVirtualDirectory(string virtualPath, DirectoryInfo directory)
                : base(virtualPath)
            {
                Directory = directory;
            }
        }
    }
}