VirtualPathProvider Classe

Definizione

Fornisce un insieme di metodi che consentono a un'applicazione Web di recuperare risorse da un file system virtuale.Provides a set of methods that enable a Web application to retrieve resources from a virtual file system.

public ref class VirtualPathProvider abstract : MarshalByRefObject
public abstract class VirtualPathProvider : MarshalByRefObject
type VirtualPathProvider = class
    inherit MarshalByRefObject
Public MustInherit Class VirtualPathProvider
Inherits MarshalByRefObject
Ereditarietà
VirtualPathProvider

Esempi

L'esempio di codice seguente è VirtualPathProvider un'implementazione della classe che crea una file system virtuale usando le informazioni DataSet archiviate in un oggetto.The following code example is a VirtualPathProvider class implementation that creates a virtual file system using information stored in a DataSet object. L'esempio di codice funziona con gli esempi di codice VirtualFile per VirtualDirectory le classi e per fornire risorse virtuali da un archivio dati caricato in un DataSet oggetto.The code example works with the code examples for the VirtualFile and VirtualDirectory classes to provide virtual resources from a data store that is loaded into a DataSet object.

Questo esempio è costituito da quattro VirtualPathProvider parti: l'implementazione della classe, un file di dati DataSet XML usato per AppStart popolare l'oggetto, AppInitialize un oggetto che contiene un VirtualPathProvider metodo usato per registrare la classe con la compilazione System e una pagina ASP.NET che fornisce collegamenti ai file virtuali.This example has four parts: the VirtualPathProvider class implementation, an XML data file used to populate the DataSet object, an AppStart object that contains an AppInitialize method used to register the VirtualPathProvider class with the compilation system, and an ASP.NET page that provides links to the virtual files.

Per usare questo codice di esempio in un'applicazione, seguire questa procedura.To use this sample code in an application, follow these steps.

  1. Creare un'applicazione di esempio nel server Web.Create a sample application on your Web server.

  2. Copiare il codice sorgente per l'oggetto VirtualPathProvider personalizzato (vedere di seguito) in un file nella App_Code directory dell'applicazione.Copy the source code for the custom VirtualPathProvider object (see below) into a file in the application's App_Code directory.

  3. Copiare il codice sorgente per l'oggetto VirtualDirectory personalizzato (vedere la sezione esempio VirtualDirectory nell'argomento Panoramica della classe) in un App_Code file nella directory dell'applicazione.Copy the source code for the custom VirtualDirectory object (see the Example section in the VirtualDirectory class overview topic) into a file in the application's App_Code directory.

  4. Copiare il codice sorgente per l'oggetto VirtualFile personalizzato (vedere la sezione esempio VirtualFile nell'argomento Panoramica della classe) in un App_Code file nella directory dell'applicazione.Copy the source code for the custom VirtualFile object (see the Example section in the VirtualFile class overview topic) into a file in the application's App_Code directory.

  5. Copiare il codice sorgente per l' AppStart oggetto (vedere di seguito) in un file nella App_Code directory dell'applicazione.Copy the source code for the AppStart object (see below) into a file in the application's App_Code directory.

  6. Copiare i dati XML (vedere di seguito) in un file XMLData.xml denominato in un file nella App_Data directory dell'applicazione.Copy the XML data (see below) into a file named XMLData.xml into a file in the application's App_Data directory.

  7. Copiare il default.aspx file (vedere di seguito) nella directory radice dell'applicazione di esempio.Copy the default.aspx file (see below) into the root directory of the sample application. Usare un Web browser per aprire il default.aspx file e quindi fare clic sui collegamenti nella pagina per visualizzare il contenuto dei file virtuali.Use a Web browser to open the default.aspx file, and then click the links on the page to see the contents of the virtual files.

Il primo esempio è una classe VirtualPathProvider personalizzata.The first example is a custom VirtualPathProvider class. I DirectoryExists metodi FileExists e vengono sottoposti a override per indicare se una directory richiesta è presente nel file system virtuale.The DirectoryExists and FileExists methods are overridden to indicate whether a requested directory is present in the virtual file system. I GetDirectory metodi GetFile e vengono sottoposti a override per VirtualDirectory restituire VirtualFile istanze personalizzate e contenenti informazioni provenienti dal file system virtuale.The GetDirectory and GetFile methods are overridden to return custom VirtualDirectory and VirtualFile instances containing information from the virtual file system.

La classe fornisce anche un GetVirtualData metodo usato VirtualDirectory dalle classi e VirtualFile per accedere all' DataSet oggetto che contiene i dati di file system virtuale.The class also provides a GetVirtualData method used by the VirtualDirectory and VirtualFile classes to access the DataSet object containing the virtual file system data. In un'implementazione di produzione, questo metodo viene in genere implementato in un oggetto business responsabile dell'interazione con l'archivio dati.In a production implementation, this method would typically be implemented in a business object responsible for interacting with the data store.

using System;
using System.Data;
using System.Security.Permissions;
using System.Web;
using System.Web.Caching;
using System.Web.Hosting;

namespace Samples.AspNet.CS
{
  [AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Medium)]
  [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.High)]
  public class SamplePathProvider : VirtualPathProvider
  {
    private string dataFile;

    public SamplePathProvider()
      : base()
    {
    }

    protected override void Initialize()
    {
      // Set the datafile path relative to the application's path.
      dataFile = HostingEnvironment.ApplicationPhysicalPath + "App_Data\\XMLData.xml";
    }

    /// <summary>
    ///   Data set provider for the SampleVirtualDirectory and
    ///   SampleVirtualFile classes. In a production application
    ///   this method would be on a provider class that accesses
    ///   the virtual resource data source.
    /// </summary>
    /// <returns>
    ///   The System.Data.DataSet containing the virtual resources 
    ///   provided by the SamplePathProvider.
    /// </returns>
    public DataSet GetVirtualData()
    {
      // Get the data from the cache.
      DataSet ds = (DataSet)HostingEnvironment.Cache.Get("VPPData");
      if (ds == null)
      {
        // Data not in cache. Read XML file.
        ds = new DataSet();
        ds.ReadXml(dataFile);

        // Make DataSet dependent on XML file.
        CacheDependency cd = new CacheDependency(dataFile);

        // Put DataSet into cache for maximum of 20 minutes.
        HostingEnvironment.Cache.Add("VPPData", ds, cd,
          Cache.NoAbsoluteExpiration,
          new TimeSpan(0, 20, 0),
          CacheItemPriority.Default, null);

        // Set data timestamp.
        DateTime dataTimeStamp = DateTime.Now;
        // Cache it so we can get the timestamp in later calls.
        HostingEnvironment.Cache.Insert("dataTimeStamp", dataTimeStamp, null,
          Cache.NoAbsoluteExpiration,
          new TimeSpan(0, 20, 0),
          CacheItemPriority.Default, null);
      }
      return ds;
    }

    /// <summary>
    ///   Determines whether a specified virtual path is within
    ///   the virtual file system.
    /// </summary>
    /// <param name="virtualPath">An absolute virtual path.</param>
    /// <returns>
    ///   true if the virtual path is within the 
    ///   virtual file sytem; otherwise, false.
    /// </returns>
    private bool IsPathVirtual(string virtualPath)
    {
      String checkPath = VirtualPathUtility.ToAppRelative(virtualPath);
      return checkPath.StartsWith("~/vrdir", StringComparison.InvariantCultureIgnoreCase);
    }

    public override bool FileExists(string virtualPath)
    {
      if (IsPathVirtual(virtualPath))
      {
        SampleVirtualFile file = (SampleVirtualFile)GetFile(virtualPath);
        return file.Exists;
      }
      else
        return Previous.FileExists(virtualPath);
    }

    public override bool DirectoryExists(string virtualDir)
    {
      if (IsPathVirtual(virtualDir))
      {
        SampleVirtualDirectory dir = (SampleVirtualDirectory)GetDirectory(virtualDir);
        return dir.Exists;
      }
      else
        return Previous.DirectoryExists(virtualDir);
    }

    public override VirtualFile GetFile(string virtualPath)
    {
      if (IsPathVirtual(virtualPath))
        return new SampleVirtualFile(virtualPath, this);
      else
        return Previous.GetFile(virtualPath);
    }

    public override VirtualDirectory GetDirectory(string virtualDir)
    {
      if (IsPathVirtual(virtualDir))
        return new SampleVirtualDirectory(virtualDir, this);
      else
        return Previous.GetDirectory(virtualDir);
    }

    public override CacheDependency GetCacheDependency(
      string virtualPath, 
      System.Collections.IEnumerable virtualPathDependencies, 
      DateTime utcStart)
    {
      if (IsPathVirtual(virtualPath))
      {
        System.Collections.Specialized.StringCollection fullPathDependencies = null;

        // Get the full path to all dependencies.
        foreach (string virtualDependency in virtualPathDependencies)
        {
          if (fullPathDependencies == null)
            fullPathDependencies = new System.Collections.Specialized.StringCollection();

          fullPathDependencies.Add(virtualDependency);
        }
        if (fullPathDependencies == null)
          return null;

        // Copy the list of full-path dependencies into an array.
        string[] fullPathDependenciesArray = new string[fullPathDependencies.Count];
        fullPathDependencies.CopyTo(fullPathDependenciesArray, 0);
        // Copy the virtual path into an array.
        string[] virtualPathArray = new string[1];
        virtualPathArray[0] = virtualPath;

        return new CacheDependency(virtualPathArray, fullPathDependenciesArray, utcStart);
      }
      else
        return Previous.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
    }
  }
  
}

Imports System.Data
Imports System.Security.Permissions
Imports System.Web
Imports System.Web.Caching
Imports System.Web.Hosting


Namespace Samples.AspNet.VB
  <AspNetHostingPermission(SecurityAction.Demand, Level:=AspNetHostingPermissionLevel.Medium), _
   AspNetHostingPermission(SecurityAction.InheritanceDemand, level:=AspNetHostingPermissionLevel.High)> _
  Public Class SamplePathProvider
    Inherits VirtualPathProvider

    Private dataFile As String

    Public Sub New()
      MyBase.New()
    End Sub

    Protected Overrides Sub Initialize()
      ' Set the datafile path relative to the application's path.
      dataFile = HostingEnvironment.ApplicationPhysicalPath & _
        "App_Data\XMLData.xml"
    End Sub

    '   Data set provider for the SampleVirtualFile and
    '   SampleVirtualDirectory classes. In a production application
    '   this method would be on a provider class that accesses
    '   the virtual resource data source.
    '   The System.Data.DataSet containing the virtual resources
    '   provided by the SamplePathProvider.
    Public Function GetVirtualData() As DataSet
      ' Get the data from the cache.
      Dim ds As DataSet
      ds = CType(HostingEnvironment.Cache.Get("VPPData"), DataSet)

      If ds Is Nothing Then
        ' Data set not in cache. Read XML file.
        ds = New DataSet
        ds.ReadXml(dataFile)

        ' Make DataSet dependent on XML file.
        Dim cd As CacheDependency
        cd = New CacheDependency(dataFile)

        ' Put DataSet into cache for maximum of 20 minutes.
        HostingEnvironment.Cache.Add("VPPData", ds, cd, _
         Cache.NoAbsoluteExpiration, _
         New TimeSpan(0, 20, 0), _
         CacheItemPriority.Default, Nothing)

        ' Set data timestamp.
        Dim dataTimeStamp As DateTime
        dataTimeStamp = DateTime.Now
        ' Cache it so we can get the timestamp in later calls.
        HostingEnvironment.Cache.Add("dataTimeStamp", dataTimeStamp, Nothing, _
          Cache.NoAbsoluteExpiration, _
          New TimeSpan(0, 20, 0), _
          CacheItemPriority.Default, Nothing)
      End If
      Return ds
    End Function

    Private Function IsPathVirtual(ByVal virtualPath As String) As Boolean
      Dim checkPath As String
      checkPath = VirtualPathUtility.ToAppRelative(virtualPath)
      Return checkPath.StartsWith("~/vrdir", StringComparison.InvariantCultureIgnoreCase)
    End Function

    Public Overrides Function FileExists(ByVal virtualPath As String) As Boolean
      If (IsPathVirtual(virtualPath)) Then
        Dim file As SampleVirtualFile
        file = CType(GetFile(virtualPath), SampleVirtualFile)
        Return file.Exists
      Else
        Return Previous.FileExists(virtualPath)
      End If
    End Function

    Public Overrides Function DirectoryExists(ByVal virtualDir As String) As Boolean
      If (IsPathVirtual(virtualDir)) Then
        Dim dir As SampleVirtualDirectory
        dir = CType(GetDirectory(virtualDir), SampleVirtualDirectory)
        Return dir.exists
      Else
        Return Previous.DirectoryExists(virtualDir)
      End If
    End Function

    Public Overrides Function GetFile(ByVal virtualPath As String) As VirtualFile
      If (IsPathVirtual(virtualPath)) Then
        Return New SampleVirtualFile(virtualPath, Me)
      Else
        Return Previous.GetFile(virtualPath)
      End If
    End Function

    Public Overrides Function GetDirectory(ByVal virtualDir As String) As VirtualDirectory
      If (IsPathVirtual(virtualDir)) Then
        Return New SampleVirtualDirectory(virtualDir, Me)
      Else
        Return Previous.GetDirectory(virtualDir)
      End If
    End Function

    Public Overrides Function GetCacheDependency(ByVal virtualPath As String, ByVal virtualPathDependencies As IEnumerable, ByVal utcStart As Date) As CacheDependency
      If (IsPathVirtual(virtualPath)) Then

        Dim fullPathDependencies As System.Collections.Specialized.StringCollection
        fullPathDependencies = Nothing

        ' Get the full path to all dependencies.
        For Each virtualDependency As String In virtualPathDependencies
          If fullPathDependencies Is Nothing Then
            fullPathDependencies = New System.Collections.Specialized.StringCollection
          End If

          fullPathDependencies.Add(virtualDependency)
        Next

        If fullPathDependencies Is Nothing Then
          Return Nothing
        End If

        Dim fullPathDependenciesArray As String()
        fullPathDependencies.CopyTo(fullPathDependenciesArray, 0)

        Return New CacheDependency(fullPathDependenciesArray, utcStart)
      Else
        Return Previous.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart)
      End If
    End Function
  End Class
End Namespace

Il secondo esempio è il file di dati XML utilizzato per popolare DataSet l'oggetto restituito dall'oggetto VirtualPathProvider personalizzato.The second example is the XML data file used to populate the DataSet object returned by the custom VirtualPathProvider object. Questi dati XML vengono utilizzati per illustrare l' VirtualPathProviderutilizzo VirtualDirectorydegli oggetti VirtualFile , e per recuperare dati da dati esterni e non sono destinati a rappresentare un archivio dati di qualità di produzione.This XML data is used to demonstrate using the VirtualPathProvider, VirtualDirectory, and VirtualFile objects to retrieve data from external data and is not intended to represent a production-quality data store.

<?xml version="1.0" encoding="utf-8" ?>  
  <resource type="dir"   
    path="/vrDir"   
    parentPath=""   
    content="">  
    <resource type="file"   
      path="/vrDir/Level1FileA.vrf"  
      parentPath="/vrDir"   
      content="This is the content of file Level1FileA.">  
    </resource>  
    <resource type="file"   
      path="/vrDir/Level1FileB.vrf"  
      parentPath="/vrDir"   
      content="This is the content of file Level1FileB.">  
    </resource>  
    <resource type="dir"   
      path="/vrDir/Level2DirA"   
      parentPath="/vrDir"   
      content="">  
    <resource type="file"   
      path="/vrDir/Level2DirA/Level2FileA.vrf"   
      parentPath="/vrDir/Level2DirA"   
      content="This is the content of file Level2FileA.">  
    </resource>  
    <resource type="file"   
      path="/vrDir/Level2DirA/Level2FileB.vrf"  
      parentPath="/vrDir/Level2DirA"   
      content="This is the content of file Level2FileB.">  
    </resource>  
  </resource>  
  <resource type="dir"   
    path="/vrDir/Level2DirB"   
    parentPath="/vrDir"   
    content="">  
    <resource type="file"   
      path="/vrDir/Level2DirB/Level2FileA.vrf"   
      parentPath="/vrDir/Level2DirB"   
      content="This is the content of file Level2FileA.">  
    </resource>  
    <resource type="file"   
      path="/vrDir/Level2DirB/Level2FileB.vrf"  
      parentPath="/vrDir/Level2DirB"   
      content="This is the content of file Level2FileB.">  
    </resource>  
  </resource>  
</resource>  

Nel terzo esempio viene fornito AppStart un oggetto che contiene AppInitialize un metodo.The third example provides an AppStart object that contains an AppInitialize method. Questo metodo viene chiamato durante l'inizializzazione di un'applicazione ASP.NET per eseguire qualsiasi inizializzazione personalizzata necessaria.This method is called during the initialization of an ASP.NET application to perform any custom initialization required. In questo caso, registra l'oggetto personalizzato VirtualPathProvider con il sistema di compilazione ASP.NET.In this case, it registers the custom VirtualPathProvider object with the ASP.NET build system.

using System.Web.Hosting;

namespace Samples.AspNet.CS
{
  /// <summary>
  ///   Contains the application initialization method
  ///   for the sample application.
  /// </summary>
  public static class AppStart
  {
    public static void AppInitialize()
    {
      SamplePathProvider sampleProvider = new SamplePathProvider();
      HostingEnvironment.RegisterVirtualPathProvider(sampleProvider);
    } 
  }
}

Imports System.Web.Hosting

Namespace Samples.AspNet.VB

  Public Class AppStart

    Public Shared Sub AppInitialize()
      Dim sampleProvider As SamplePathProvider = New SamplePathProvider()
      HostingEnvironment.RegisterVirtualPathProvider(sampleProvider)
    End Sub

  End Class
End Namespace

L'ultimo esempio è una pagina ASP.NET che contiene collegamenti ai file virtuali contenuti nel file system virtuale.The last example is an ASP.NET page that contains links to the virtual files contained in the virtual file system.


<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">

</script>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
  <meta http-equiv="Content-Type" content="text/html" />
  <title>Virtual Path Provider Example</title>
</head>
<body>
  <form id="form1" runat="server">
    <asp:HyperLink ID="hyperLink1" runat="server" NavigateUrl="vrDir/Level1FileA.vrf" Text="Level 1, File A" /><br />
    <asp:HyperLink ID="hyperLink2" runat="server" NavigateUrl="vrDir/Level1FileB.vrf" Text="Level 1, File B" /><br />
    <asp:HyperLink ID="hyperLink3" runat="server" NavigateUrl="vrDir/Level2DirA/Level2FileA.vrf" Text="Level 2a, File A" /><br />
    <asp:HyperLink ID="hyperLink4" runat="server" NavigateUrl="vrDir/Level2DirA/Level2FileB.vrf" Text="Level 2a, File B" /><br />
    <asp:HyperLink ID="hyperLink5" runat="server" NavigateUrl="vrDir/Level2DirB/Level2FileA.vrf" Text="Level 2b, File A" /><br />
    <asp:HyperLink ID="hyperLink6" runat="server" NavigateUrl="vrDir/Level2DirB/Level2FileB.vrf" Text="Level 2b, File B" /><br />
  </form>
</body>
</html>
<%@ Page Language="VB" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
  <meta http-equiv="Content-Type" content="text/html" />
  <title>Virtual Path Provider Example</title>
</head>
<body>
  <form id="form1" runat="server">
    <asp:HyperLink ID="hyperLink1" runat="server" NavigateUrl="vrDir/Level1FileA.vrf" Text="Level 1, File A" /><br />
    <asp:HyperLink ID="hyperLink2" runat="server" NavigateUrl="vrDir/Level1FileB.vrf" Text="Level 1, File B" /><br />
    <asp:HyperLink ID="hyperLink3" runat="server" NavigateUrl="vrDir/Level2DirA/Level2FileA.vrf" Text="Level 2a, File A" /><br />
    <asp:HyperLink ID="hyperLink4" runat="server" NavigateUrl="vrDir/Level2DirA/Level2FileB.vrf" Text="Level 2a, File B" /><br />
    <asp:HyperLink ID="hyperLink5" runat="server" NavigateUrl="vrDir/Level2DirB/Level2FileA.vrf" Text="Level 2b, File A" /><br />
    <asp:HyperLink ID="hyperLink6" runat="server" NavigateUrl="vrDir/Level2DirB/Level2FileB.vrf" Text="Level 2b, File B" /><br />
  </form>
</body>
</html>

Commenti

La VirtualPathProvider classe fornisce un set di metodi per l'implementazione di un file system virtuale per un'applicazione Web.The VirtualPathProvider class provides a set of methods for implementing a virtual file system for a Web application. In una file system virtuale, i file e le directory vengono gestiti da un archivio dati diverso da quello file system fornito dal sistema operativo del server.In a virtual file system, the files and directories are managed by a data store other than the file system provided by the server's operating system. È ad esempio possibile utilizzare un file system virtuale per archiviare il contenuto in un database SQL Server.For example, you can use a virtual file system to store content in a SQL Server database.

È possibile archiviare qualsiasi file elaborato su richiesta in un file system virtuale.You can store any file that is processed on request in a virtual file system. vale a dire:This includes:

  • Pagine ASP.NET, pagine master, controlli utente e altri oggetti.ASP.NET pages, master pages, user controls, and other objects.

  • Pagine Web standard con estensioni quali. htm e. jpg.Standard Web pages with extensions such as .htm and .jpg.

  • Qualsiasi estensione personalizzata mappata a BuildProvider un'istanza di.Any custom extension mapped to a BuildProvider instance.

  • Qualsiasi tema denominato nella App_Theme cartella.Any named theme in the App_Theme folder.

Non è possibile archiviare i file o le cartelle dell'applicazione ASP.NET che generano assembly a livello di applicazione in un file system virtuale.You cannot store ASP.NET application folders or files that generate application-level assemblies in a virtual file system. vale a dire:This includes:

  • Il file Global. asax.The Global.asax file.

  • File Web. config.Web.config files.

  • File di dati della mappa del XmlSiteMapProvidersito usati da.Site map data files used by the XmlSiteMapProvider.

  • Directory contenenti assembly di applicazioni o che generano assembly di Binapplicazioni App_Code: App_GlobalResources,, App_LocalResources, any.Directories that contain application assemblies or that generate application assemblies: Bin, App_Code, App_GlobalResources, any App_LocalResources.

  • Cartella Application Data App_Data.The application data folder, App_Data.

Nota

Se un sito Web viene precompilato per la distribuzione, il contenuto fornito da VirtualPathProvider un'istanza non viene compilato e nessuna VirtualPathProvider istanza viene utilizzata dal sito precompilato.If a Web site is precompiled for deployment, content provided by a VirtualPathProvider instance is not compiled, and no VirtualPathProvider instances are used by the precompiled site.

Registrazione di un VirtualPathProviderRegistering a VirtualPathProvider

Un'istanza VirtualPathProvider personalizzata deve essere registrata con il sistema di compilazione ASP.NET utilizzando il HostingEnvironment.RegisterVirtualPathProvider metodo prima che l'applicazione Web effettui l'analisi o la compilazione di pagine.A custom VirtualPathProvider instance should be registered with the ASP.NET compilation system by using the HostingEnvironment.RegisterVirtualPathProvider method before any page parsing or compilation is performed by the Web application.

In genere, VirtualPathProvider un'istanza di viene registrata AppInitialize in un metodo definito App_Code nella Global.asax directory o durante l' Application_Start evento nel file.Typically, a VirtualPathProvider instance is registered in an AppInitialize method defined in the App_Code directory, or during the Application_Start event in the Global.asax file. Per un esempio di registrazione di un' VirtualPathProvider istanza in un AppInitialize metodo, vedere la sezione relativa agli esempi.For an example of registering a VirtualPathProvider instance in an AppInitialize method, see the Example section.

È possibile registrare un' VirtualPathProvider istanza di durante altri eventi, ma le pagine compilate VirtualPathProvider e memorizzate nella cache prima che l'istanza venga registrata non verranno invalidate, anche se la nuova VirtualPathProvider istanza fornirà ora l'origine per la prima pagina compilata.You can register a VirtualPathProvider instance during other events, but pages compiled and cached before the VirtualPathProvider instance is registered will not be invalidated, even if the new VirtualPathProvider instance would now provide the source for the previously compiled page.

Note per gli eredi

Quando si eredita da VirtualPathProvider, è necessario eseguire l'override dei membri seguenti:When you inherit from VirtualPathProvider, you must override the following members:

Se la classe VirtualPathProvider personalizzata supporta le directory nella file system virtuale, è necessario eseguire l'override dei membri seguenti.If your custom VirtualPathProvider class supports directories in the virtual file system, you must override the following members.

  • DirectoryExists(String)

  • GetDirectory(String)


    Se il file system virtuale conterrà temi per il sito Web (creando una directory App_Themes virtuale), la classe personalizzata VirtualPathProvider deve supportare le directory.If your virtual file system will contain themes for the Web site (by creating a virtual App_Themes directory), your custom VirtualPathProvider class must support directories.

    Una classe VirtualPathProvider personalizzata funziona con le classi derivate VirtualDirectory VirtualFile dalle classi e.A custom VirtualPathProvider class works with classes derived from the VirtualFile and VirtualDirectory classes. È consigliabile implementare classi derivate da questi tipi per fornire informazioni su file e directory dal file system virtuale.You should implement derived classes from these types to provide file and directory information from your virtual file system. Per un esempio di implementazione personalizzata VirtualFile , vedere la sezione esempio VirtualFile dell'argomento Panoramica della classe.For an example of a custom VirtualFile implementation, see the Example section of the VirtualFile class overview topic. Per un esempio di implementazione personalizzata VirtualDirectory , vedere la sezione esempio VirtualDirectory dell'argomento Panoramica della classe.For an example of a custom VirtualDirectory implementation, see the Example section of the VirtualDirectory class overview topic.

Costruttori

VirtualPathProvider()

Inizializza la classe per l'uso da parte di un'istanza di una classe ereditata.Initializes the class for use by an inherited class instance. Questo costruttore può essere chiamato solo da una classe ereditata.This constructor can be called only by an inherited class.

Proprietà

Previous

Ottiene un riferimento a un oggetto VirtualPathProvider registrato in precedenza nel sistema di compilazione.Gets a reference to a previously registered VirtualPathProvider object in the compilation system.

Metodi

CombineVirtualPaths(String, String)

Combina un percorso di base con un percorso relativo per restituire un percorso completo a una risorsa virtuale.Combines a base path with a relative path to return a complete path to a virtual resource.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Ereditato da MarshalByRefObject)
DirectoryExists(String)

Ottiene un valore che indica se una directory esiste nel file system virtuale.Gets a value that indicates whether a directory exists in the virtual file system.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
FileExists(String)

Ottiene un valore che indica se un file esiste nel file system virtuale.Gets a value that indicates whether a file exists in the virtual file system.

GetCacheDependency(String, IEnumerable, DateTime)

Crea una dipendenza della cache basata sui percorsi virtuali specificati.Creates a cache dependency based on the specified virtual paths.

GetCacheKey(String)

Restituisce una chiave di cache da utilizzare per il percorso virtuale specificato.Returns a cache key to use for the specified virtual path.

GetDirectory(String)

Ottiene una directory virtuale dal file system virtuale.Gets a virtual directory from the virtual file system.

GetFile(String)

Ottiene un file virtuale dal file system virtuale.Gets a virtual file from the virtual file system.

GetFileHash(String, IEnumerable)

Restituisce un hash dei percorsi virtuali specificati.Returns a hash of the specified virtual paths.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
Initialize()

Inizializza l'istanza di VirtualPathProvider.Initializes the VirtualPathProvider instance.

InitializeLifetimeService()

Fornisce all'oggetto VirtualPathProvider una durata infinita impedendo la creazione di lease.Gives the VirtualPathProvider object an infinite lifetime by preventing a lease from being created.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
OpenFile(String)

Restituisce un flusso da un file virtuale.Returns a stream from a virtual file.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a