VirtualPathProvider Classe

Riferimento

Definizione

Spazio dei nomi:: System.Web.Hosting

Assembly:: System.Web.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce un insieme di metodi che consentono a un'applicazione Web di recuperare risorse da un file system virtuale.

public ref class VirtualPathProvider abstract : MarshalByRefObject

public abstract class VirtualPathProvider : MarshalByRefObject

type VirtualPathProvider = class
    inherit MarshalByRefObject

Public MustInherit Class VirtualPathProvider
Inherits MarshalByRefObject

Ereditarietà: Object

MarshalByRefObject
VirtualPathProvider

Esempio

L'esempio di codice seguente è un'implementazione di VirtualPathProvider classe che crea un file system virtuale usando le informazioni archiviate in un DataSet oggetto . L'esempio di codice funziona con gli esempi di codice per le VirtualFile classi e VirtualDirectory per fornire risorse virtuali da un archivio dati caricato in un DataSet oggetto .

In questo esempio sono presenti quattro parti: l'implementazione della VirtualPathProvider classe, un file di dati XML utilizzato per popolare l'oggetto DataSet , un AppStart oggetto che contiene un AppInitialize metodo utilizzato per registrare la VirtualPathProvider classe con il sistema di compilazione e una pagina di ASP.NET che fornisce collegamenti ai file virtuali.

Per usare questo codice di esempio in un'applicazione, seguire questa procedura.

Creare un'applicazione di esempio nel server Web.
Copiare il codice sorgente per l'oggetto personalizzato VirtualPathProvider (vedere di seguito) in un file nella directory dell'applicazione App_Code .
Copiare il codice sorgente per l'oggetto personalizzato VirtualDirectory (vedere la sezione Esempio nell'argomento panoramica della VirtualDirectory classe) in un file nella directory dell'applicazione App_Code .
Copiare il codice sorgente per l'oggetto personalizzato VirtualFile (vedere la sezione Esempio nell'argomento panoramica della VirtualFile classe) in un file nella directory dell'applicazione App_Code .
Copiare il codice sorgente per l'oggetto AppStart (vedere di seguito) in un file nella directory dell'applicazione App_Code .
Copiare i dati XML (vedere di seguito) in un file denominato XMLData.xml in un file nella directory dell'applicazione App_Data .
Copiare il default.aspx file (vedere di seguito) nella directory radice dell'applicazione di esempio. 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.

Il primo esempio è una classe personalizzata VirtualPathProvider . I DirectoryExists metodi e FileExists vengono sottoposti a override per indicare se una directory richiesta è presente nel file system virtuale. I GetDirectory metodi e GetFile vengono sottoposti a override per restituire istanze personalizzate VirtualDirectory e VirtualFile contenenti informazioni dal file system virtuale.

La classe fornisce anche un GetVirtualData metodo utilizzato dalle VirtualDirectory classi e VirtualFile per accedere all'oggetto DataSet contenente i dati del file system virtuale. In un'implementazione di produzione questo metodo viene in genere implementato in un oggetto business responsabile dell'interazione con l'archivio dati.

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 l'oggetto DataSet restituito dall'oggetto personalizzato VirtualPathProvider . Questi dati XML vengono usati per illustrare l'utilizzo degli VirtualPathProvideroggetti , VirtualDirectorye VirtualFile per recuperare dati da dati esterni e non rappresentano un archivio dati di qualità di produzione.

<?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>

Il terzo esempio fornisce un AppStart oggetto che contiene un AppInitialize metodo . Questo metodo viene chiamato durante l'inizializzazione di un'applicazione ASP.NET per eseguire qualsiasi inizializzazione personalizzata necessaria. In questo caso, registra l'oggetto personalizzato VirtualPathProvider con il sistema di compilazione ASP.NET.

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.


<%@ 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. In un file system virtuale, i file e le directory vengono gestiti da un archivio dati diverso dal file system fornito dal sistema operativo del server. Ad esempio, è possibile usare un file system virtuale per archiviare il contenuto in un database SQL Server.

È possibile archiviare qualsiasi file elaborato su richiesta in un file system virtuale. ad esempio:

ASP.NET pagine, pagine master, controlli utente e altri oggetti.
Pagine Web standard con estensioni quali .htm e .jpg.
Qualsiasi estensione personalizzata mappata a un'istanza BuildProvider di .
Qualsiasi tema denominato nella App_Theme cartella .

Non è possibile archiviare ASP.NET cartelle o file dell'applicazione che generano assembly a livello di applicazione in un file system virtuale. ad esempio:

File Global.asax.
Web.config file.
File di dati della mappa del XmlSiteMapProvidersito usati da .
Directory che contengono assembly dell'applicazione o che generano assembly dell'applicazione: Bin, App_Code, App_GlobalResources, qualsiasi App_LocalResources.
Cartella dei dati dell'applicazione, App_Data.

Nota

Se un sito Web è precompilato per la distribuzione, il contenuto fornito da un'istanza VirtualPathProvider non viene compilato e nessuna VirtualPathProvider istanza viene utilizzata dal sito precompilato.

Registrazione di un VirtualPathProvider

È necessario registrare un'istanza personalizzata VirtualPathProvider con il sistema di compilazione ASP.NET usando il HostingEnvironment.RegisterVirtualPathProvider metodo prima di eseguire l'analisi o la compilazione di pagine dall'applicazione Web.

In genere, un'istanza VirtualPathProvider viene registrata in un AppInitialize metodo definito nella App_Code directory o durante l'evento Application_Start nel Global.asax file. Per un esempio di registrazione di un'istanza VirtualPathProvider in un AppInitialize metodo, vedere la sezione Esempio.

È possibile registrare un'istanza VirtualPathProvider durante altri eventi, ma le pagine compilate e memorizzate nella cache prima della registrazione dell'istanza VirtualPathProvider non verranno invalidate, anche se la nuova VirtualPathProvider istanza fornisce ora l'origine per la pagina compilata in precedenza.

Note per gli implementatori

Quando si eredita da VirtualPathProvider, è necessario eseguire l'override dei membri seguenti:

Se la classe personalizzata VirtualPathProvider supporta le directory nel file system virtuale, è necessario eseguire l'override dei membri seguenti.

DirectoryExists(String)
GetDirectory(String)

Nota: se il file system virtuale conterrà temi per il sito Web (creando una directory virtuale App_Themes ), la classe personalizzata VirtualPathProvider deve supportare le directory.

Una classe personalizzata VirtualPathProvider funziona con le classi derivate dalle VirtualFile classi e VirtualDirectory . È necessario implementare classi derivate da questi tipi per fornire informazioni su file e directory dal file system virtuale. Per un esempio di implementazione personalizzata VirtualFile , vedere la sezione Esempio dell'argomento di panoramica della VirtualFile classe. Per un esempio di implementazione personalizzata VirtualDirectory , vedere la sezione Esempio dell'argomento di panoramica della VirtualDirectory classe.

Costruttori

VirtualPathProvider()

Inizializza la classe per l'uso da parte di un'istanza di una classe ereditata. Questo costruttore può essere chiamato solo da una classe ereditata.

Proprietà

Ottiene un riferimento a un oggetto VirtualPathProvider registrato in precedenza nel sistema di compilazione.

Metodi

CombineVirtualPaths(String, String)	Combina un percorso di base con un percorso relativo per restituire un percorso completo a una risorsa virtuale.
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. (Ereditato da MarshalByRefObject)
DirectoryExists(String)	Ottiene un valore che indica se una directory esiste nel file system virtuale.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
FileExists(String)	Ottiene un valore che indica se un file esiste nel file system virtuale.
GetCacheDependency(String, IEnumerable, DateTime)	Crea una dipendenza della cache basata sui percorsi virtuali specificati.
GetCacheKey(String)	Restituisce una chiave di cache da utilizzare per il percorso virtuale specificato.
GetDirectory(String)	Ottiene una directory virtuale dal file system virtuale.
GetFile(String)	Ottiene un file virtuale dal file system virtuale.
GetFileHash(String, IEnumerable)	Restituisce un hash dei percorsi virtuali specificati.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
Initialize()	Inizializza l'istanza di VirtualPathProvider.
InitializeLifetimeService()	Fornisce all'oggetto VirtualPathProvider una durata infinita impedendo la creazione di lease.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OpenFile(String)	Restituisce un flusso da un file virtuale.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Si applica a