HttpRequest.MapPath Méthode

Définition

Fait correspondre le chemin d'accès virtuel de l'URL demandée à un chemin physique sur le serveur pour la demande en cours.Maps the virtual path in the requested URL to a physical path on the server for the current request.

Surcharges

MapPath(String)

Mappe le chemin d'accès virtuel spécifié avec un chemin d'accès physique.Maps the specified virtual path to a physical path.

MapPath(String, String, Boolean)

Mappe le chemin d'accès virtuel spécifié avec un chemin d'accès physique.Maps the specified virtual path to a physical path.

MapPath(String)

Mappe le chemin d'accès virtuel spécifié avec un chemin d'accès physique.Maps the specified virtual path to a physical path.

public:
 System::String ^ MapPath(System::String ^ virtualPath);
public string MapPath (string virtualPath);
member this.MapPath : string -> string
Public Function MapPath (virtualPath As String) As String

Paramètres

virtualPath
String

Chemin d'accès virtuel (absolu ou relatif) de la demande en cours.The virtual path (absolute or relative) for the current request.

Retours

Chemin d'accès physique sur le serveur spécifié par virtualPath.The physical path on the server specified by virtualPath.

Exceptions

Aucun objet HttpContext n'est défini pour la demande.No HttpContext object is defined for the request.

Exemples

L’exemple de code suivant utilise MapPath la méthode pour convertir un chemin d’accès virtuel en un chemin d’accès physique complet sur le serveur.The following code example uses the MapPath method to convert a virtual path to a fully qualified physical path on the server. Cet exemple se compose de deux parties :This example has two parts:

  • Une page. aspx mappe le chemin d’accès, lit le fichier et affiche les résultats de l’opération de lecture.An .aspx page maps the path, reads the file, and displays results of the read operation.

  • Classe, UpperCaseFilterStream, qui modifie tous les caractères passés en majuscules.A class, UpperCaseFilterStream, that changes all characters passed through it to uppercase.

La première partie de l’exemple montre comment convertir un chemin d’accès virtuel en un chemin d’accès physique complet MapPath à l’aide de la méthode.The first part of the example shows how to convert a virtual path to a fully qualified physical path using the MapPath method. Ce chemin d’accès physique est ensuite passé StreamReader à un objet, qui obtient le contenu du fichier.This physical path is then passed to a StreamReader object, which obtains the contents of the file. La Write méthode est ensuite appelée pour afficher le contenu du fichier sur la page.The Write method is then called to display the content of the file on the page. La Filter propriété est utilisée pour attacher un filtre au flux de réponse qui met tout le texte affiché sur la page en majuscules.The Filter property is used to attach a filter to the response stream that makes the text displayed to the page all uppercase.

<%@ Page Language="C#" %>
<%@ Import Namespace="System.IO" %>
<%@ import Namespace="Samples.AspNet.CS.Controls"  %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">

    private void Page_Load(object sender, EventArgs e)
    {

      // Filter the text to be rendered as all uppercase.
      Response.Filter = new UpperCaseFilterStream(Response.Filter);

      // Convert a virtual path to a fully qualified physical path.
      string fullpath = Request.MapPath("~\\TestFile.txt");

      try
      {
        // Read the contents of the file using a StreamReader.
        using (StreamReader sr = new StreamReader(fullpath))
        while (sr.Peek() >= 0)
        {
          Response.Write((char)sr.Read());
        }
        Message.Text = "Reading the file was successful.";
        
      }
      catch (Exception ex)
      {
        Message.Text = "The process failed.";
      }    
     }

</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
  <head>
    <title>HttpResponse.MapPath Example</title>
  </head>
  <body>
    <form id="form1" runat="server">

      <asp:Label id="Message" 
                 runat="server"/>

    </form>
  </body>
</html>
<%@ Page Language="VB" Debug="true"%>
<%@ Import Namespace="System.IO" %>
<%@ Import Namespace="Samples.AspNet.VB.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">
     
  Private Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
      
    ' Filter the text to be rendered as all uppercase.
    Response.Filter = New UpperCaseFilterStream(Response.Filter)
    
    ' Convert a virtual path to a fully qualified physical path.
    Dim fullpath As String = Request.MapPath("~\\TestFile.txt")
    
    Try
      
      Dim sr As StreamReader = New StreamReader(fullpath)
      
      Do While sr.Peek() >= 0
        Response.Write(Convert.ToChar(sr.Read()))
      Loop
      sr.Close()
      Message.Text = "Reading the file was successful."
      
    Catch ex As Exception
      
      Message.Text = "The process failed."

    End Try

    
  End Sub

</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
  <head>
    <title>HttpResponse.MapPath Example</title>
  </head>
  <body>
    <form id="Form1" runat="server">

      <asp:Label id="Message" 
                 runat="server"/>

    </form>
  </body>
</html>

La deuxième partie de l’exemple montre une classe qui hérite de Stream et convertit tous les caractères d’un flux en majuscules.The second part of the example shows a class that inherits from Stream and converts all characters in a stream to uppercase. Placez ce code dans le App_Code dossier de votre application.Put this code in the App_Code folder for your application.


using System;
using System.IO;
using System.Text;

namespace Samples.AspNet.CS.Controls
{

   public class UpperCaseFilterStream : Stream
   // This filter changes all characters passed through it to uppercase.
   {
      private Stream strSink;
      private long lngPosition;

      public UpperCaseFilterStream(Stream sink)
      {
          strSink = sink;
      }

      // The following members of Stream must be overriden.
      public override bool CanRead
      {
         get { return true; }
      }

      public override bool CanSeek
      {
         get { return true; }
      }

      public override bool CanWrite
      {
         get { return true; }
      }

      public override long Length
      {
         get { return 0; }
      }

      public override long Position
      {
         get { return lngPosition; }
         set { lngPosition = value; }
      }

      public override long Seek(long offset, System.IO.SeekOrigin direction)
      {
         return strSink.Seek(offset, direction);
      }

      public override void SetLength(long length)
      {
         strSink.SetLength(length);
      }

      public override void Close()
      {
         strSink.Close();
      }

      public override void Flush()
      {
         strSink.Flush();
      }

      public override int Read(byte[] buffer, int offset, int count)
      {
         return strSink.Read(buffer, offset, count);
      }

      // The Write method actually does the filtering.
      public override void Write(byte[] buffer, int offset, int count)
      {
         byte[] data = new byte[count];
         Buffer.BlockCopy(buffer, offset, data, 0, count);
         string inputstring = Encoding.ASCII.GetString(data).ToUpper();
         data = Encoding.ASCII.GetBytes(inputstring);
         strSink.Write(data, 0, count);
       
      }
   }
}
Imports System.IO
Imports System.Text


Namespace Samples.AspNet.VB.Controls

    Public Class UpperCaseFilterStream
        Inherits Stream

        ' This filter changes all characters passed through it to uppercase.
        Private strSink As Stream
        Private lngPosition As Long


        Public Sub New(ByVal sink As Stream)
            strSink = sink
        End Sub

        ' The following members of Stream must be overriden.  
        Public Overrides ReadOnly Property CanRead() As Boolean
            Get
                Return True
            End Get
        End Property

        Public Overrides ReadOnly Property CanSeek() As Boolean
            Get
                Return True
            End Get
        End Property

        Public Overrides ReadOnly Property CanWrite() As Boolean
            Get
                Return True
            End Get
        End Property

        Public Overrides ReadOnly Property Length() As Long
            Get
                Return 0
            End Get
        End Property

        Public Overrides Property Position() As Long
            Get
                Return lngPosition
            End Get
            Set(ByVal value As Long)
                lngPosition = Value
            End Set
        End Property

        Public Overrides Function Seek( _
        ByVal offset As Long, ByVal direction As System.IO.SeekOrigin) As Long
            Return strSink.Seek(offset, direction)
        End Function 'Seek


        Public Overrides Sub SetLength(ByVal length As Long)
            strSink.SetLength(length)
        End Sub


        Public Overrides Sub Close()
            strSink.Close()
        End Sub


        Public Overrides Sub Flush()
            strSink.Flush()
        End Sub


        Public Overrides Function Read( _
        ByVal buffer() As Byte, ByVal offset As Integer, ByVal count As Integer) As Integer
            Return strSink.Read(buffer, offset, count)
        End Function 'Read


        ' The Write method actually does the filtering.
        Public Overrides Sub Write( _
        ByVal buffer() As Byte, ByVal offset As Integer, ByVal count As Integer)

            Dim data(count) As Byte
            System.Buffer.BlockCopy(buffer, offset, data, 0, count)
            Dim inputstring As String = Encoding.ASCII.GetString(data).ToUpper()
            data = Encoding.ASCII.GetBytes(InputString)
            strSink.Write(data, 0, count)

        End Sub

    End Class

End Namespace

Remarques

Attention

La MapPath propriété contient potentiellement des informations sensibles sur l’environnement d’hébergement.The MapPath property potentially contains sensitive information about the hosting environment. La valeur de retour ne doit pas être affichée aux utilisateurs.The return value should not be displayed to users.

MapPath(String, String, Boolean)

Mappe le chemin d'accès virtuel spécifié avec un chemin d'accès physique.Maps the specified virtual path to a physical path.

public:
 System::String ^ MapPath(System::String ^ virtualPath, System::String ^ baseVirtualDir, bool allowCrossAppMapping);
public string MapPath (string virtualPath, string baseVirtualDir, bool allowCrossAppMapping);
member this.MapPath : string * string * bool -> string
Public Function MapPath (virtualPath As String, baseVirtualDir As String, allowCrossAppMapping As Boolean) As String

Paramètres

virtualPath
String

Chemin d'accès virtuel (absolu ou relatif) de la demande en cours.The virtual path (absolute or relative) for the current request.

baseVirtualDir
String

Chemin d'accès du répertoire de base virtuel utilisé pour la résolution relative.The virtual base directory path used for relative resolution.

allowCrossAppMapping
Boolean

true pour indiquer que virtualPath peut appartenir à une autre application ; sinon, false.true to indicate that virtualPath may belong to another application; otherwise, false.

Retours

Chemin d'accès physique sur le serveur.The physical path on the server.

Exceptions

allowCrossMapping a la valeur false et virtualPath appartient à une autre application.allowCrossMapping is false and virtualPath belongs to another application.

- ou --or- Aucun objet HttpContext n'est défini pour la demande.No HttpContext object is defined for the request.

Remarques

Attention

La MapPath propriété contient potentiellement des informations sensibles sur l’environnement d’hébergement.The MapPath property potentially contains sensitive information about the hosting environment. La valeur de retour ne doit pas être affichée aux utilisateurs.The return value should not be displayed to users.

S’applique à