VirtualPathProvider implementation

VirtualPathProvider.cs

// Type: System.Web.Hosting.VirtualPathProvider
// Assembly: System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
// Assembly location: C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.Web.dll

using System;
using System.Collections;
using System.IO;
using System.Web;
using System.Web.Caching;
using System.Web.Util;

namespace System.Web.Hosting
{
  public abstract class VirtualPathProvider : MarshalByRefObject
  {
    private VirtualPathProvider _previous;

    protected internal VirtualPathProvider Previous
    {
      get
      {
        return this._previous;
      }
    }

    public override object InitializeLifetimeService()
    {
      return (object) null;
    }

    internal virtual void Initialize(VirtualPathProvider previous)
    {
      this._previous = previous;
      this.Initialize();
    }

    protected virtual void Initialize()
    {
    }

    public virtual string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies)
    {
      if (this._previous == null)
        return (string) null;
      else
        return this._previous.GetFileHash(virtualPath, virtualPathDependencies);
    }

    internal string GetFileHash(VirtualPath virtualPath, IEnumerable virtualPathDependencies)
    {
      return this.GetFileHash(virtualPath.VirtualPathString, virtualPathDependencies);
    }

    public virtual CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
    {
      if (this._previous == null)
        return (CacheDependency) null;
      else
        return this._previous.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
    }

    internal CacheDependency GetCacheDependency(VirtualPath virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
    {
      return this.GetCacheDependency(virtualPath.VirtualPathString, virtualPathDependencies, utcStart);
    }

    public virtual bool FileExists(string virtualPath)
    {
      if (this._previous == null)
        return false;
      else
        return this._previous.FileExists(virtualPath);
    }

    internal bool FileExists(VirtualPath virtualPath)
    {
      return this.FileExists(virtualPath.VirtualPathString);
    }

    public virtual bool DirectoryExists(string virtualDir)
    {
      if (this._previous == null)
        return false;
      else
        return this._previous.DirectoryExists(virtualDir);
    }

    internal bool DirectoryExists(VirtualPath virtualDir)
    {
      return this.DirectoryExists(virtualDir.VirtualPathString);
    }

    public virtual VirtualFile GetFile(string virtualPath)
    {
      if (this._previous == null)
        return (VirtualFile) null;
      else
        return this._previous.GetFile(virtualPath);
    }

    internal VirtualFile GetFile(VirtualPath virtualPath)
    {
      return this.GetFileWithCheck(virtualPath.VirtualPathString);
    }

    internal VirtualFile GetFileWithCheck(string virtualPath)
    {
      VirtualFile file = this.GetFile(virtualPath);
      if (file == null)
        return (VirtualFile) null;
      if (StringUtil.EqualsIgnoreCase(virtualPath, file.VirtualPath))
        return file;
      throw new HttpException(System.Web.SR.GetString("Bad_VirtualPath_in_VirtualFileBase", (object) "VirtualFile", (object) file.VirtualPath, (object) virtualPath));
    }

    public virtual VirtualDirectory GetDirectory(string virtualDir)
    {
      if (this._previous == null)
        return (VirtualDirectory) null;
      else
        return this._previous.GetDirectory(virtualDir);
    }

    internal VirtualDirectory GetDirectory(VirtualPath virtualDir)
    {
      return this.GetDirectoryWithCheck(virtualDir.VirtualPathString);
    }

    internal VirtualDirectory GetDirectoryWithCheck(string virtualPath)
    {
      VirtualDirectory directory = this.GetDirectory(virtualPath);
      if (directory == null)
        return (VirtualDirectory) null;
      if (StringUtil.EqualsIgnoreCase(virtualPath, directory.VirtualPath))
        return directory;
      throw new HttpException(System.Web.SR.GetString("Bad_VirtualPath_in_VirtualFileBase", (object) "VirtualDirectory", (object) directory.VirtualPath, (object) virtualPath));
    }

    public virtual string GetCacheKey(string virtualPath)
    {
      return (string) null;
    }

    internal string GetCacheKey(VirtualPath virtualPath)
    {
      return this.GetCacheKey(virtualPath.VirtualPathString);
    }

    public virtual string CombineVirtualPaths(string basePath, string relativePath)
    {
      string basepath = (string) null;
      if (!string.IsNullOrEmpty(basePath))
        basepath = UrlPath.GetDirectory(basePath);
      return UrlPath.Combine(basepath, relativePath);
    }

    internal VirtualPath CombineVirtualPaths(VirtualPath basePath, VirtualPath relativePath)
    {
      return VirtualPath.Create(this.CombineVirtualPaths(basePath.VirtualPathString, relativePath.VirtualPathString));
    }

    public static Stream OpenFile(string virtualPath)
    {
      return HostingEnvironment.VirtualPathProvider.GetFileWithCheck(virtualPath).Open();
    }

    internal static Stream OpenFile(VirtualPath virtualPath)
    {
      return VirtualPathProvider.OpenFile(virtualPath.VirtualPathString);
    }

    internal static CacheDependency GetCacheDependency(VirtualPath virtualPath)
    {
      return HostingEnvironment.VirtualPathProvider.GetCacheDependency(virtualPath, (IEnumerable) new SingleObjectCollection((object) virtualPath.VirtualPathString), DateTime.MaxValue);
    }

    internal static VirtualPath CombineVirtualPathsInternal(VirtualPath basePath, VirtualPath relativePath)
    {
      VirtualPathProvider virtualPathProvider = HostingEnvironment.VirtualPathProvider;
      if (virtualPathProvider != null)
        return virtualPathProvider.CombineVirtualPaths(basePath, relativePath);
      else
        return basePath.Parent.Combine(relativePath);
    }

    internal static bool DirectoryExistsNoThrow(string virtualDir)
    {
      try
      {
        return HostingEnvironment.VirtualPathProvider.DirectoryExists(virtualDir);
      }
      catch
      {
        return false;
      }
    }

    internal static bool DirectoryExistsNoThrow(VirtualPath virtualDir)
    {
      return VirtualPathProvider.DirectoryExistsNoThrow(virtualDir.VirtualPathString);
    }
  }
}