AcceptTypes |
stringArray = Request.AcceptTypes |
Returns a String array containing the Multipurpose Internet Mail Extension (MIME) types accepted by the client. You can use this property to determine whether a client can accept certain response types, including application types such as Word or Excel, which are supported only by Internet Explorer.The following table lists some common MIME types:

MIME type | Description
text/html | HTML text content
text/xml | XML text content
image/gif | GIF-encoded image data
image/jpg | JPEG-encoded image data
application/msword | Binary data for Microsoft Word

Parameters

- stringArray
  A String array that receives the array of accept types from the property.

Example
The code example declares a string array and an integer counter variable and assigns the AcceptTypes property value to the array variable. It then iterates the array members using the counter variable, writing each value to the browser by using the Message label control:
    Sub Page_Load(  )
       'Display Accept Types
       Dim MyArray(  ) As String
       Dim I As Integer
       MyArray = Request.AcceptTypes
       For I = 0 To MyArray.GetUpperBound(0)
          Message.Text &= "Type " & CStr(I) & ": " & CStr(MyArray(I)) & _
                  "<br/>"
       Next I
    End Sub
The output of the code would look something like this: Type 0: image/gif Type 1: image/x-xbitmap Type 2: image/jpeg Type 3: image/pjpeg Type 4: application/vnd.ms-powerpoint
Type 5: application/vnd.ms-excel
Type 6: application/msword
Type 7: */*
Notes
This property can prevent the server from wasting time sending responses to the client that the client cannot handle. For example, a request that would normally be fulfilled by returning an Excel spreadsheet could be fulfilled with an alternate response type for clients that do not support the Excel MIME type, application/vnd.ms-excel.

ApplicationPath |
stringvar = Request.ApplicationPath |
Returns a String containing the path to the virtual root of the current application.
Parameters

- stringvar
  A string variable to receive the value of the ApplicationPath property.

Example
The code example retrieves the ApplicationPath and writes it to the client using the Message label control:
    Sub Page_Load(  )
       Message.Text = Request.ApplicationPath
    End Sub
The output of the code should be the name of the virtual root of the application to which the request was sent.

Browser |
bc = Request.Browser |
Returns an instance of the HttpBrowserCapabilities class that describes the capabilities of the client browser. You can then use the class instance to determine what capabilities the client browser supports. The HttpBrowserCapabilities class exposes the capabilities of the client browser as a set of Boolean and String properties. Properties of the HttpBrowserCapabilities class include:

- ActiveXControls
  A Boolean indicating whether the browser supports ActiveX controls.
- AOL
  A Boolean indicating whether the browser is an AOL browser.
- BackgroundSounds
  A Boolean indicating whether the browser supports background sounds.
- Beta
  A Boolean indicating whether the browser is beta software.
- Browser
  A String containing the User-Agent header value.
- CDF
  A Boolean indicating whether the browser supports the Channel Definition Format for pushing content.
- ClrVersion
  Returns a System.Version object containing version information about the CLR (if any) installed on the client machine (from the User-Agent header). If ClrVersion is not Nothing, you can retrieve version information from four of its Integer properties: Major, Minor, Revision, and Build.
- Cookies
  A Boolean indicating whether the browser supports cookies.
- Crawler
  A Boolean indicating whether the browser is a search engine web crawler.
- EcmaScriptVersion
  Returns an instance of the Version class containing information about the version of ECMAScript supported by the client browser. If EcmaScriptVersion is not Nothing, you can retrieve version information from four of its Integer properties: Major, Minor, Revision, and Build.
- Frames
  A Boolean indicating whether the browser supports frames.
- Item
  A Dictionary interface to values (i.e., Request.Browser.Item(keyname)).
- JavaApplets
  A Boolean indicating whether the browser supports Java applets.
- JavaScript
  A Boolean indicating whether the browser supports JavaScript.
- MajorVersion
  An Integer representing the browser major version number (for example, for IE 3.01, the MajorVersion property would return 3).
- MinorVersion
  A Double representing the browser minor version number (for example, for IE 3.01, the MinorVersion property would return .01).
- MSDomVersion
  Returns an instance of the Version class containing information about the version of the Microsoft XML Document Object Model (DOM) supported by the client browser. If MSDomVersion is not Nothing, you can retrieve version information from four of its Integer properties: Major, Minor, Revision, and Build.
- Platform
  A String containing the platform name (if any) included in the User-Agent header.
- Tables
  A Boolean indicating whether the browser supports HTML tables.
- Type
  A String containing the name and major version of the client browser.
- VBScript
  A Boolean indicating whether the browser supports VBScript.
- Version
  A String containing both the major and minor version numbers of the client browser.
- W3CDomVersion
  Returns an instance of the Version class containing information about the version of the World Wide Web Consortium (W3C) XML DOM supported by the client browser. If W3CDomVersion is not Nothing, you can retrieve version information from four of its Integer properties: Major, Minor, Revision, and Build.
- Win16
  A Boolean indicating whether the client is a Win16 machine.
- Win32
  A Boolean indicating whether the client is a Win32 machine.

Parameters

- bc
  An Object variable of type HttpBrowserCapabilities.

Example
    Sub Page_Load(  )
       Dim bc As HttpBrowserCapabilities
       bc = Request.Browser
       If bc.Cookies Then
          Message.Text = "Cookies are available with this browser"
       Else
          Message.Text = "Cookies are not available with this browser"
       End If
    End Sub
Notes
You will probably use this property a lot if you plan to support multiple browsers and must provide the highest level of functionality on uplevel browsers such as Internet Explorer 5 or 6 or Netscape 6. For some properties, such as Cookies and JavaScript, the returned Boolean indicates only whether the browser version sending the request supports these features, not whether they are currently enabled in the current user's browser. This property is especially important when developing custom server controls, since it allows you to have your custom controls automatically tailor their output to a specific browser (or class of browsers). See Chapter 6 for more information on custom control development.

ClientCertificate |
cs = Request.ClientCertificate |
Returns an instance of the HttpClientCertificate class, which exposes information about the client security certificate settings. These properties include issuer information, key size, and certificate validity dates.
Parameters

- cs
  An Object variable of type HttpClientCertificate.

Example
    Sub Page_Load(  )
       Dim cs As HttpClientCertificate
       cs = Request.ClientCertificate
       Message.Text = "Certificate Issuer is: " & cs.Issuer & "."
    End Sub
Notes
You will probably use this property in intranet settings, where you have provided a limited set of clients with certificates (issued from your own Certificate Server) for accessing your application, rather than requiring them to authenticate by using a set of credentials entered via the browser. In this case, client certificates are mapped to NT user accounts to provide secure access. Client certificates can also be issued by trusted third parties, but this method is rarely used. If no client certificate is installed on the requesting client, this property returns an HttpClientCertificate instance with no valid property values.

ContentEncoding |
ce = Request.ContentEncoding |
Returns an instance of the Encoding class (located in the System.Text namespace), which represents the character encoding of the body of the current request.
Parameters

- ce
  An Object variable of type Encoding.

Example
The example demonstrates how to display the current ContentEncoding to the user:
    Sub Page_Load(  )
       Dim ce As System.Text.Encoding
       ce = Request.ContentEncoding
       Message.Text = "Current encoding is: " & ce.EncodingName & "."
    End Sub
For a request using UTF-8 content encoding, the output of this example would be: Current encoding is: Unicode (UTF-8).

ContentLength |
intvar = Request.ContentLength |
Returns an integer containing the length, in bytes, of the request sent from the client. This property includes only the content sent in the body of the HTTP request and does not include the length of the HTTP headers or of any data sent as part of an HTTP GET request (which would appear in the headers). If the HTTP request contains no body, its value is 0.
Parameters

- intvar
  An Integer variable to receive the length, in bytes, of the content.

Example
This example demonstrates how to display the length of the current request in the browser:
    Sub Page_Load(  )
       Dim length As Integer
       length = Request.ContentLength
       Message.Text = "Length of request was: " & length & " bytes."
    End Sub
The following code can be used to post to the example page:
    <html>
       <head>
          <title>Submit a named parameter via POST</title>
       </head>
    <body>
       <form id="form1" action="ContentLength.aspx" method="POST">
          <h3>Name:</h3>
          <input type="text" name="name">
          <input type="submit">
       </form>
    </body>
    </html>
Notes
You can use this property to test the length of content posted via a POST request before acting on that content. For example, if your page receives files from a file input field, you could check the ContentLength property before saving or processing the uploaded file to prevent users from uploading files greater than a specific size. Note that in cases when you receive multiple form fields, you can get more specific data on the size of an uploaded file by referring to the PostedFile.ContentLength property of an HtmlInputFile control used for submitting files.

ContentType |
stringvar = Request.ContentType |
Returns a String containing the MIME type of the current client request. On GET requests, this property may return an empty string.
Parameters

- stringvar
  A String variable to receive the content type.

Example
The example shows how you can take different actions in your page, depending on the ContentType of the request:
    Sub Page_Load(  )
       Dim ct As String
       ct = Request.ContentType
       If ct = "application/x-www-form-urlencoded" Then
          'Process form input
          Message.Text = "Form data was submitted."
       Else
          Message.Text = "Content Type of request is: " & ct
       End If
    End Sub
The following code can be used to post to the example page:
    <html>
       <head>
          <title>Submit a named parameter via POST</title>
       </head>
    <body>
       <form id="form1" action="ContentType.aspx" method="POST">
          <h3>Name:</h3>
          <input type="text" name="name">
          <input type="submit">
       </form>
    </body>
    </html>
Notes
One potential use for this property is to ensure that the content type of the request is what you expect it to be. This can help avoid wasting processor time with invalid requests and prevent malicious users from attempting to forge requests to your application that send unexpected content.

FilePath |
stringvar = Request.FilePath |
Returns a String containing the virtual path of the current client request. The virtual path includes the name of the application root folder, any subfolders in the request path, and the requested filename.
Parameters

- stringvar
  A String variable to receive the file path.

Example
The example displays the FilePath property to the user.
    Sub Page_Load(  )
       Dim fp As String
       fp = Request.FilePath
       Message.Text = "The virtual path of the current request is: _
       & "<strong>" & fp & "</strong>"
    End Sub
Notes
This property is identical to the Path property listed later in this chapter.

HttpMethod |
stringvar = Request.HttpMethod |
Returns a String containing the method (i.e., GET, POST, or HEAD) of the current request.
Parameters

- stringvar
  A String variable to receive the HTTP method of the current request.

Example
The example uses the HttpMethod property to determine what action to take for a given request:
    Sub Page_Load(  )
       Select Case Request.HttpMethod
          Case "POST"
             Response.Write("POST requests not allowed!<br/>")
             Response.End
          Case "HEAD"
             Response.Write("HEAD requests not allowed!<br/>")
             Response.End
          Case "GET"
             'Process request
             Message.Text = "GET requests are allowed!<br/>"
          Case Else
             Response.Write("Unknown request: not allowed!<br/>")
             Response.End
       End Select
    End Sub
Note that we use Response.Write to send the message before calling Response.End. Calling Response.End will immediately terminate processing of the page, which will also prevent rendering of any server control output. The code for a page that makes a POST request to the example page is shown here:
    <html>
    	<head>
    		<title>Submit a named parameter via POST</title>
    	</head>
    <body>
    	<form id="form1" action="HttpMethod.aspx" method="POST">
    		<h3>Name:</h3>
    		<input type="text" name="name">
    		<input type="submit">
    	</form>
    </body>
    </html>
Notes
In classic ASP, the request method was typically retrieved using the REQUEST_METHOD key of the ServerVariables collection. Often, this key was used to create self-submitting form pages by displaying a set of form fields when the GET method was detected and processing the input received from the form fields when the POST method was detected. ASP.NET Web Forms provide built-in plumbing for self-submitting forms. By adding a form with the runat="server" attribute and adding one or more input type server controls to the form, the developer only needs to check the page's IsPostBack property to determine whether a POST or GET request has been received, and execute the desired code based on that property.

InputStream |
inputstream = Request.InputStream |
Returns a Stream object containing the body of the incoming HTTP request.
Parameters

- inputstream
  An Object variable of type Stream.

Example
The example uses a byte array to search for a specified character and then copies that character and the remaining contents of the stream to a string. The @Import directive shown in the example should be placed at the top of the page:
    <% @ Import Namespace="System.IO" %>

    Sub Page_Load( )
    	Dim InStream As Stream
    	Dim iCounter, StreamLength, iRead As Integer
    	Dim OutString As String
    	Dim Found As Boolean

    	InStream = Request.InputStream
    	StreamLength = CInt(InStream.Length)
    	Dim ByteArray(StreamLength) As Byte
    	iRead = InStream.Read(ByteArray, 0, StreamLength)
    	InStream.Close( )

    	For iCounter = 0 to StreamLength - 1
    		If Found = True Then
    			OutString &= Chr(ByteArray(iCounter))
    		End If
    		If Chr(ByteArray(iCounter)) = "A" Then
    			Found = True OutString &= Chr(ByteArray(iCounter))
    		End If
    	Next iCounter

    	Message.Text = "Output:" & OutString
    End Sub
The following code can be used to post to the example page:
    <html>
    	<head>
    	</head>
    <body>
    	<form id="form1" action="InputStream.aspx" method="POST">
    		<h3>Name:</h3>
    		<input type="text" name="name">
    		<input type="submit">
    	</form>
    </body>
    </html>
The code returns as output the first capital A appearing in the request body. Any characters after it are returned to the end of the stream.
Notes
This property is useful if you wish to perform byte-level filtering of the request body. It works only with POST requests, since these requests are the only commonly used HTTP requests that provide a request body.

IsAuthenticated |
boolvar = Request.IsAuthenticated |
Returns a Boolean indicating whether the current request is coming from a user who is authenticated. This property refers to authentication against the NTLM account database.
Parameters

- boolvar
  A Boolean variable to receive the authentication status of the user.

Example
The example checks to see if the current user is authenticated and it outputs one of two messages, depending on the authentication status of the user. Note that the message delivered to authenticated users utilizes the User property of the page to output the current user's name and domain.
    Sub Page_Load( )
    	Dim boolAuth As Boolean

    	boolAuth = Request.IsAuthenticated

    	If boolAuth Then
    		Message.Text = "User" & Page.User.Identity.Name & "is authenticated."
    	Else
    		Message.Text = "Current user is not authenticated."
    	End If
    End Sub
Notes
In addition to the IsAuthenticated property that the HttpRequest class exposes, the FormsIdentity, WindowsIdentity, and PassportIdentity classes expose an IsAuthenticated property for much the same purpose as the HttpRequest class. Note that the IsAuthenticated property of the HttpRequest class returns the authentication status of the user regardless of the authentication method used.

IsSecureConnection |
boolvar = Request.IsSecureConnection |
Returns a Boolean indicating whether the current connection uses secure sockets (SSL) for communication.
Parameters

- boolvar
  A Boolean variable to receive the SSL status of the current request.

Example
The example shows how you can take different actions depending on whether or not the current request was made via SSL:
    Sub Page_Load( )
    	Dim boolvar As Boolean
    	boolvar = Request.IsSecureConnection
    	If boolvar = True Then
    		Message.Text = "Connection is HTTPS."
    	Else
    		Message.Text = "Connection is HTTP."
    	End If
    End Sub
Notes
You would typically use this property to determine whether or not to fulfill a request that requires an SSL connection in order to encrypt sensitive data (such as credit card numbers) that might be submitted via the requested page. Additionally, you could use this property on a page that may or may not use SSL to determine how to render output to the page depending on the SSL status. Since encrypting and decrypting content for SSL communication exacts a performance penalty, reducing the number and/or size of graphics used on SSL-enabled pages is generally considered good practice. With this property, you could render more and/or higher-resolution graphics when SSL is not enabled for the request, and render fewer and/or lower-resolution graphics for SSL requests.

Path |
stringvar = Request.Path |
Returns a String containing the virtual path of the current client request. The virtual path includes the name of the application root folder, subfolders in the request path, and the requested filename.
Parameters

- stringvar
  A String variable to receive the file path.

Example
The example displays the Path property to the user:
    Sub Page_Load( )
    	Dim path As String
    	path = Request.FilePath
    	Message.Text = "The virtual path of the current request is:" & path
    End Sub
Notes
This property is identical to the FilePath property listed earlier in this chapter.

PathInfo |
stringvar = Request.PathInfo |
Returns a String containing any additional path information (including path information appended to a URL after the filename of the requested resource) passed with the current request.
Parameters

- stringvar
  A String variable to receive the additional path information.

Example
The example writes both the Path and PathInfo properties to the client browser:
    Sub Page_Load( )
    	Message.Text = "Path = " & Request.Path & "<br/>"
    	Message.Text &= "Additional Path Info = " & Request.PathInfo & "<br/>"
    End Sub
Notes
PathInfo does not return information such as query string values. PathInfo returns any characters following a forward-slash (/) after the resource (file) name, including the forward-slash itself.

PhysicalApplicationPath |
stringvar = Request.PhysicalApplicationPath |
Returns a String containing the physical path to the root of the current application.
Parameters

- stringvar
  A String variable to receive the application path.

Example
The example writes the PhysicalApplicationPath property to the browser:
    Sub Page_Load( )
    	Dim physAppPath As String
    	physAppPath = Request.PhysicalApplicationPath
    	Message.Text = "Physical Application Path = " & physAppPath
    End Sub
Notes
This property is useful when you need to create or write to a file within your web application. Rather than hardcoding a filesystem path in your page, you can use this property in combination with a filename to create or edit a file in the same folder as the page containing the code, regardless of the page's location.

PhysicalPath |
stringvar = Request.PhysicalPath |
Returns a String containing the physical path to the requested file.
Parameters

- stringvar
  A String variable to receive the physical path.

Example
The example writes the PhysicalPath property to the browser:
    Sub Page_Load( )
    	Dim physicalPath As String
    	physicalPath = Request.PhysicalPath
    	Message.Text = "Physical Path = " & physicalPath
    End Sub
Notes
Unlike the PhysicalApplicationPath, which returns only the path to the root of the application, the PhysicalPath property returns the full physical path of the requested resource, including any intervening folders and the resource's filename. This property may be useful in combination with ASP.NET's Trace functionality in troubleshooting situations when files you are attempting to write to or read from are not found, or when created files aren't located where you expect them to be. Adding Trace.Write statements to your page to write the Path, PhysicalApplicationPath, and PhysicalPath properties to the trace log (which you can enable by adding the Trace="true" attribute to the @ Page directive) may help you track down such bugs.

RawUrl |
stringvar = Request.RawUrl |
Returns a String containing the raw URL of the current request. The raw URL consists of the portion of the URL following the domain information. Thus, for the URL http://search.support.microsoft.com/kb/c.asp, the raw URL is /kb/c.asp. The raw URL includes the query string, if one is present.
Parameters

- stringvar
  A String variable to receive the raw URL.

Example
The example writes the RawUrl property to the browser:
    Sub Page_Load( )
    	Dim stringvar As String
    	stringvar = Request.RawUrl
    	Message.Text = "The raw URL is:" & stringvar
    End Sub

RequestType |
stringvar = Request.RequestType |
The RequestType property returns a String containing the request type (i.e., GET or POST) of the current request.
Parameters

- stringvar
  A String variable to receive the request type.

Example
The example writes the RequestType property to the browser:
    Sub Page_Load( )
    	Dim stringvar As String
    	stringvar = Request.RequestType
    	Message.Text = "The request type is:" & stringvar
    End Sub
Notes
This property is listed as read/write; however, there really aren't any situations where it would be useful to change its value. From the read standpoint, this property returns the same information as the read-only HttpMethod property listed earlier in this chapter. If you attempt to change its value, no corresponding change occurs in the value of HttpMethod.

TotalBytes |
intvar = Request.TotalBytes |
Returns an Integer representing the size of the HTTP request body. The TotalBytes property does not include the size of the HTTP request headers, or the size of query string values passed with a GET request.
Parameters

- intvar
  An Integer variable to receive the size, in bytes, of the current request body.

Example
The example writes the TotalBytes property to the browser:
    Sub Page_Load( )
    	Dim intvar As Integer
    	intvar = Request.TotalBytes
    	Message.Text = "The size of the current request body is: <br/>"
    	Message.Text &= intvar & "bytes."
    End Sub
The following code can be used to post to the example page:
    <html>
    	<head>
    		<title>Submit a named parameter via POST</title>
    	</head>
    <body>
    	<form id="form1" action="TotalBytes.aspx" method="POST">
    		<h3>Name:</h3>
    		<input type="text" name="name">
    		<input type="submit">
    	</form>
    </body>
    </html>
Notes
This property's behavior is identical to that of the ContentLength property described earlier in this chapter.

Url |
uriObj = Request.Url |
Returns an instance of the Uri class containing properties that describe the current URL requested by the user. Properties exposed by the Uri class include Scheme (protocol), Port, and Host.
Parameters

- uriObj
  An Object variable of type Uri.

Example
The example uses the Uri object that the Url property returns to write information about the URL for the current request to the browser:
    Sub Page_Load( )
    	Dim myUri As Uri
    	myUri = Request.Url

    	Message.Text = "Current request URL info - <br/><br/>"
    	Message.Text &= "Protocol:" & myUri.Scheme & "<br/>"
    	Message.Text &= "Port:" & myUri.Port & "<br/>"
    	Message.Text &= "Host Name:" & myUri.Host & "<br/>"
    End Sub
Notes
While the Uri class this property returns has methods as well as properties, you're more likely to use these methods (particularly the CheckHostName and CheckSchemeName methods) when creating your own Uri resource from scratch, rather than when receiving the Uri instance from the Url property. A note on URIs: Uniform Resource Identifier (URI) (compare to Uniform Resource Locator, or URL) is a more general version of URLs and URNs. In most cases today, URI and URL are identical, although this may change as URNs are used more frequently. For the purposes of the Url property, the terms carry the same meaning.

UrlReferrer |
uriObj = Request.UrlReferrer |
Returns an instance of the Uri class containing properties that describe the URL for the resource from which the user navigated to the current requested resource. If the user did not navigate to the current resource (i.e., if the current resource is accessed directly), the UrlReferrer property returns Nothing.
Parameters

- uriObj
  An Object variable of type Uri.

Example
The example uses the Uri object that the UrlReferrer property returned in order to write information about the URL for the referring resource to the browser:
    Sub Page_Load( )
    	Dim myUri As Uri
    	myUri = Request.UrlReferrer

    	If Not (myUri Is Nothing) Then
    		Message.Text = "Referral URL info - <br/><br/>"
    		Message.Text &= "Protocol:" & myUri.Scheme & "<br/>"
    		Message.Text &= "Port:" & myUri.Port & "<br/>"
    		Message.Text &= "Host Name:" & myUri.Host & "<br/>"
    		Message.Text &= "App Path:" & myUri.AbsolutePath & "<br/>"
    	Else
    		Message.Text = "No referral URL info available."
    	End If
    End Sub
The following code can link to the example page
    <html>
    	<head>
    		<title>Link to UrlReferrer</title>
    	</head>
    <body>
    	<a href="UrlReferrer.aspx">Go to UrlReferrer.aspx</a>
    </body>
    </html>
Notes
The example code makes sure that the UrlReferrer property returns a valid instance of the Uri class. The UrlReferrer property returns Nothing if the page is accessed directly, rather than from a link on another page.

UserAgent |
stringvar = Request.UserAgent |
Returns a String containing the User-Agent header. The User-Agent string identifies the browser (or other HTTP-capable client software, such as that used on mobile phones, etc.) the client uses to make the request. Depending on the browser and platform, this string may also identify the operating system the client uses, as well as the version of the installed .NET Framework (IE only).
Parameters

- stringvar
  A String variable to receive the User-Agent string.

Example
The example writes the UserAgent property to the browser:
    Sub Page_Load( )
    	Dim stringvar As String
    	stringvar = Request.UserAgent
    	Message.Text = "User Agent:" & stringvar
    End Sub
Notes
When you attempt to discern the capabilities of the client browser, using the properties of the HttpBrowserCapabilities object returned by the Request.Browser property is generally easier. However, there may be cases in which the User-Agent for a given client returns information that is not checked for by the HttpBrowserCapabilities class. In this case, you could add the desired information to the <browserCaps> configuration section handler in machine.config (see Chapter 8 and Chapter 20 for more information on ASP.NET configuration) and then create your own version of the HttpBrowserCapabilities class by inheriting from the built-in class and adding your own property or properties for the User-Agent attribute you're looking for. Or, if you don't want to make that effort, you could simply parse the User-Agent string for the desired attribute by using the UserAgent property.

UserHostAddress |
stringvar = Request.UserHostAddress |
Returns the IP address of the client making the request.
Parameters

- stringvar
  A String variable to receive the client IP address.

Example
The example writes the UserHostAddress, UserHostName, and UserLanguages properties to the browser:
    Sub Page_Load( )
    	Dim HostAddress, HostName, Languages( ) As String
    	Dim iCounter As Integer

    	HostAddress = Request.UserHostAddress
    	HostName = Request.UserHostName
    	Languages = Request.UserLanguages

    	Message.Text = "Client IP Address:" & HostAddress & "<br/>"
    	Message.Text &= "Client Machine Name:" & HostName & "<br/>"
    	For iCounter = 0 To Languages.GetUpperBound(0)
    		Message.Text &= "Client Language" & iCounter & ": " &_
    				CStr(Languages(iCounter)) & "<br/>"
    	Next iCounter
    End Sub

UserHostName |
stringvar= Request.UserHostName |
Returns a string that contains the DNS hostname of the client making the request.
Parameters

- stringvar
  A String variable to receive the hostname.

Example
See the example for the UserHostAddress property.
Notes
If no DNS server is available that can resolve the client IP address to a DNS name, the UserHostName property returns the IP address of the client (just like the UserHostAddress property).

UserLanguages |
stringArray = Request.UserLanguages |
Returns a sorted String array containing the list of languages supported by the client.
Parameters

- stringArray
  A String array variable to receive the list of client-supported languages.

Example
See the example for the UserHostAddress property.
Notes
To test this property, you can set support for additional languages in your browser. Now if you browse a page containing the code in the UserHostAddress example, all languages you select will be listed in the order you chose.

- In Internet Explorer 6, select Internet Options... from the Tools menu. On the General tab of the Internet Options dialog, click the Languages... button. Use the Language Preference dialog to add, remove, or move languages up or down on the list of preferred languages.
- In Netscape Navigator 6, select Preferences... from the Edit menu and then select the Languages node in the lefthand tree view. Use the options on the right to add, remove, or move languages up or down on the list.

Now if you browse a page containing the code in the UserHostAddress example, all languages you select will be listed in the order you chose.

Cookies |
HttpCookieCollection = Request.Cookies |
The Cookies collection returns an instance of the HttpCookieCollection class containing all cookies sent as a part of the current request. The HttpCookieCollection class contains an instance of the HttpCookie class for each cookie passed as part of the client request. The properties of these HttpCookie instances can be used to access information about the cookie(s).

As in classic ASP, the Cookies collection is still implemented as a collection (in fact, the HttpCookieCollection inherits from the .NET NameObjectCollectionBase class), but rather than a collection of string keys and string values, the ASP.NET implementation is a collection of string keys and objects (instances of the HttpCookie class). Individual cookies are retrieved into variables of type HttpCookie, providing access to the cookies' values through class properties.

Dictionary-style cookies (cookies with more than one value) are accessible through the Values property of the HttpCookie class, which returns a NameValueCollection containing the cookie subkeys and values. You can also retrieve individual values by their key with the following syntax:

HttpCookie.Values(" keyname ")
Parameters

- HttpCookieCollection
  An Object variable of type HttpCookieCollection.

Example
The example retrieves the collection of cookies from the Cookies property and writes out the key and value of each, along with any subkeys of dictionary cookies:
    Sub Page_Load( )
    	Dim Counter1, Counter2 As Integer
    	Dim Keys(), SubKeys( ) As String
    	Dim CookieColl As HttpCookieCollection
    	Dim Cookie As HttpCookie

    	' Get Cookie collection
    	CookieColl = Request.Cookies

    	' Get Cookie keys
    	Keys = CookieColl.AllKeys

    	' Get cookies by index
    	For Counter1 = 0 To Keys.GetUpperBound(0)
    		Cookie = CookieColl(Keys(Counter1))
    		Message.Text = "Cookie:" & Cookie.Name & "<br/>"
    		Message.Text &= "Expires: " & Cookie.Expires &"<br/>"

    		' Get keys for dictionary cookie into an array
    		SubKeys = Cookie.Values.AllKeys
    		' Write dictionary cookie values to the browser
    		For Counter2 = 0 To SubKeys.GetUpperBound(0)
    			Message.Text &= "Key " & CStr(Counter2) + ": " &_
    				SubKeys(Counter2) & "<br/>"
    			Message.Text &= "Value " & CStr(Counter2) + ": " &_
    				Cookie.Values(Counter2) & "<br/>"
    		Next Counter2
    		Message.Text &= "<br/>"
    	Next Counter1
    End Sub
Notes
The ASP implementation of the Cookies collection and the HttpCookieCollection class returned by the Cookies property expose a common set of properties; these properties are described in Section 16.3. While it is still possible in ASP.NET to retrieve an individual cookie by its text key as well as its numerical index, the differences in the operation make wholesale migration of ASP cookie-handling code to ASP.NET impractical without significant changes. For example, the following code will raise exceptions:
    For Each strKey In Request.Cookies
    	Response.Write	strKey & " = " &Request.Cookies(strKey) &_
    					"<br/>"
    	If Request.Cookies(strKey).HasKeys Then
    		For Each strSubKey In Request.Cookies(strKey)
    			Response.Write "->"& strKey & "(" & strSubKey &_
    				") = " &Request.Cookies(strKey)(strSubKey) & "<br/>"
    		Next
    	End If
    Next
Apart from the fact that this code does not explicitly declare its variables or their types (both of which are required by default in ASP.NET), the previous code fails because the Request.Cookies(key) property returns an instance of HttpCookie, rather than a string, and the HttpCookie instance cannot be implicitly converted to a string for the Response.Write statement, which expects a string. Additionally, the call to Request.Cookies(key) does not get the subkeys for a dictionary cookie. Fortunately, the modifications necessary to make the previous code work are fairly simple and are shown here:
    For Each strKey In Request.Cookies
    	Message.Text = strKey & " = " &_
    		Request.Cookies(strKey).ToString( ) & "<br/>"
    	If Request.Cookies(strKey).HasKeys Then
    		For Each strSubKey In Request.Cookies(strKey).Values
    			Message.Text = "->"& strKey & "(" & strSubKey & _
    				") = " & Request.Cookies(strKey)(strSubKey).ToString()_
    				& "<br/>"
    		Next
    	End If
    Next
To solve the first issue, we use the HttpCookie's Value method to get the value of the cookie as a string. The solution to the second issue is to call the Values property of the HttpCookie instance, which allows us to retrieve the subkeys of a dictionary cookie.
Another quirk of the change from the mostly text-based manipulation of cookie keys and values in ASP to class-based manipulation in ASP.NET is that the Expires property of the HttpCookie class is available whether you read or write to a cookie. In ASP, however, attempting to read the Expires property of a cookie would result in an error. Unfortunately, at the time of this writing, the Expires property of HttpCookie does not actually return the expiration of the cookie. Instead, it returns the value 12:00:00 AM, which suggests that despite its readability, the property is not designed to be read from.
Finally, unlike classic ASP, the collections in ASP.NET are zero-based, so the first element in any collection or array is 0, not 1. This is especially important to remember when retrieving values by their index.

Files |
HttpFileCollection = Request.Files |
The Files collection, which is new to ASP.NET, returns a collection of type HttpFileCollection that contains any files uploaded by the user's current request. This collection is especially useful in combination with the HtmlInputFile Server Control, which provides the basic plumbing necessary to upload files via an HTTP POST request. When a user submits one or more files (one per HtmlInputFile control on the submitting page), you can retrieve the files by using the Files collection.
Parameters

- HttpFileCollection
  An Object variable of type HttpFileCollection.

Example
The example uses two HtmlInputFile server controls and a server-side <script> block to upload files and process them. The example shows both the <form> section of the page and its controls and the <script> block containing the UploadBtn_OnClick method called by the onServerClick event of the HtmlInputButton control:
    <!--Place between the <head> and </head> tags -->
    <script runat="server">
    		Sub UploadBtn_Click(Sender as Object, e as EventArgs)
    			UploadForm.Visible = False
    			If InStr(Request.ContentType, "multipart/form-data") Then
    				Dim Counter1 As Integer
    				Dim Keys( ) As String
    				Dim Files As HttpFileCollection

    				' Load File
    				Files = Request.Files
    				' Get names of all files into an array
    				Keys = Files.AllKeys
    				For Counter1 = 0 To Keys.GetUpperBound(0)
    					Message.Text &= "File ID: " & Keys(Counter1) & "<br/>"_
    					Message.Text &= "File Name/Path: " &_
    						Files(Counter1).FileName & "<br/>"
    				Next Counter1
    			Else
    				Message.Text = "Wrong content type!"
    			End If
    		End Sub
    </script>

    <!-- This section resides between the <body> and </body> tags -->
    <form id="UploadForm" enctype="multipart/form-data" runat="server">
    	Select File To Upload to Server:
    	<br/>
    	<%-- MyFile and MyFile2 are HtmlInputFile controls --%>
    	<%-- note the runat attribute --%>
    	<input id="MyFile" type="file" runat="server">
    	<br/>
    	<input id="MyFile2" type="file" runat="server">
    	<br/>
    	<input id="Submit1" type="submit" value="Upload!"
    		onserverclick="UploadBtn_Click" runat="server" >
    </form>
    <asp:label id="Message" runat="server"/>
Notes
In classic ASP, file uploading was a painful process that usually involved finding and purchasing a third-party upload control to use on the receiving ASP page to parse and save uploaded files. Thanks to the Files collection, you no longer need to locate and learn how to use third-party controls to upload files. This is bad for the control developers (although we suspect they'll more than make up for the loss by writing new Server Controls), but great for ASP.NET developers. Two important points to remember about the Files collection to successfully upload files:

- If using a client-side HTML form (no runat="server" attribute), set the method attribute of the form to POST.
- Set the enctype attribute of the form to multipart/form-data .

The upload will succeed only if you take both steps. Note that the code example checks to see if the incoming request is multipart/form-data before attempting to retrieve the files.
It is not necessary to use the HtmlInputFile control to upload files that can be retrieved via the Files collection. As long as the submitting page uses the POST method and the multipart/form-data enctype attribute, you can use the standard HTML file input tags:
    <input type="file" id="myFile" name="myFile">
Note the use of the name attribute, without which the files collection will not contain the uploaded file for the control.

Form |
NameValueCollection = Request.Form |
The Form collection returns an instance of the NameValueCollection class containing all form fields passed along with an HTTP POST request. This collection will contain data only when the Content-Type of the HTTP request is either application/x-www-form-urlencoded or multipart/form-data.

The Form collection is one of two ways to retrieve data, depending on the HTTP method used to submit the data. The Form collection retrieves data submitted by an HTML form whose method attribute is set to POST , while the QueryString collection (covered later in this section) retrieves values submitted by HTML forms whose method attribute is set to GET.

Parameters

- NameValueCollection
  An Object variable of type NameValueCollection.

Example
The example demonstrates how ASP.NET allows a single page to be used to submit values via HTTP POST and retrieve and display the values to the user. The example uses the IsPostBack property of the Page class to determine whether the request is a result of the form being submitted. If the request is not a postback, the form fields are displayed to allow the user to enter values. If the request is a postback, the page retrieves the Form collection and displays the name and value of each field in the browser.
    Sub Page_Load( )
    	If IsPostBack Then
    		Form1.Visible = False
    		If Request.HttpMethod= "POST" Then
    			Dim Counter1 As Integer
    			Dim Keys( ) As String
    			Dim FormElements As NameValueCollection

    			' Get Form keys/elements
    			FormElements=Request.Form ' Get names of form fields into array
    			Keys = FormElements.AllKeys
    			For Counter1 = 0 To Keys.GetUpperBound(0)
    				Message.Text &= "Form " & Counter1 & " name: " &_
    					Keys(Counter1) & " <br/>"
    				Message.Text &= "Form " & Counter1 & " value: " &_
    					FormElements(Counter1) & "<br/>"
    			Next Counter1
    		End If
    	Else
    		Form1.Visible = True
    	End If
    End Sub

    <!-- This section resides between the <body> and </body> tags -->
    <form id="Form1" runat="server">
    	First Name:
    	<br/>
    	<asp:Textbox id="txtFName" runat="server"/>
    	<br/>
    	Last Name:
    	<br/>
    	<asp:Textbox id="txtLName" runat="server"/>
    	<br/>
    	<asp:Button id="Submit" Text="Submit" runat="server"/>
    </form>
    <asp:label id="Message" runat="server"/>
Notes
The Form collection exposes the same properties and methods described in Section 16.3 and adds the following methods:

- Get ( Index | Key )
Returns the contents of the specified item in the NameValueCollection as a comma-delimited String.
- GetValues ( Index | Key ) Returns the contents of the specified item in the NameValueCollection as a String array.

Headers |
NameValueCollection = Request.Headers |
The Headers collection returns an instance of the NameValueCollection class containing all HTTP headers sent with the current request. This collection provides the same information that is returned by calling the Request.ServerVariables collection with the ALL_HTTP key.
Parameters

- NameValueCollection
  An Object variable of type NameValueCollection.

Example
The example writes the HTTP headers passed with the request to the browser, first by using the ServerVariables("ALL_HTTP") method and then by using the Headers collection:
    Sub Page_Load( )
    	Dim AllHttp As String
    	' Get a String with all the HTTP headers
    	AllHttp = Request.ServerVariables("ALL_HTTP")
    	' Use Replace to format the String
    	AllHttp = Replace(AllHttp, "HTTP", " <br/>HTTP"
    	Message.Text &= AllHttp & "<br/><br/>"
    	Dim Counter1, Counter2 As Integer
    	Dim Keys(), subKeys( ) As String
    	Dim HeaderColl As NameValueCollection

    	' Load Headers into NameValueCollection
    	HeaderColl=Request.Headers
    	' Get keys into an array
    	Keys = HeaderColl.AllKeys
    	For Counter1 = 0 To Keys.GetUpperBound(0)
    		Message.Text &= "Key: " & Keys(Counter1) & "<br/>"
    		' Get all values under this key
    		subKeys = HeaderColl.GetValues(Counter1)
    		For Counter2 = 0 To subKeys.GetUpperBound(0)
    			Message.Text &= "Value " & CStr(Counter2) & ": " &_
    				subKeys(Counter2) & "<br/>"
    		Next Counter2
    	Next Counter1
    End Sub
Notes
The Headers collection returns only the HTTP headers that were sent as a part of the current request, as opposed to the ServerVariables collection (described later in this section), which contains keys for every HTTP header, regardless of whether a value was passed. If all you need to do is write the HTTP headers to a file or display them in the browser, it may be simpler to use the ServerVariables collection. In cases when you need to access a specific HTTP header by name or loop through the collection, the Headers collection is the way to go.

Params |
NameValueCollection = Request.Params |
The Params collection returns an instance of the NameValueCollection class containing key/value pairs for the QueryString, Form, ServerVariables, and Cookies collections. You can use the Params collection to dump all of these collections to a file or to the browser and to troubleshoot an application or track the form values your application receives, regardless of whether they come via GET (QueryString collection) or POST (Form collection).
Parameters

- NameValueCollection
  An Object variable of type NameValueCollection.

Example
The example writes the keys and values contained in the Params collection to the browser:
    Sub Page_Load( )
    	Dim Counter1, Counter2 As Integer
    	Dim Keys(), subKeys( ) As String
    	Dim ParamColl As NameValueCollection

    	' Load Params into NameValueCollection
    	ParamColl=Request.Params ' Get keys into an array
    	Keys = ParamColl.AllKeys
    	For Counter1 = 0 To Keys.GetUpperBound(0)
    		Message.Text &= "Key: " & Keys(Counter1) & "<br/>"
    		' Get all values under this key subKeys = ParamColl.GetValues(Counter1)
    		For Counter2 = 0 To subKeys.GetUpperBound(0)
    			Message.Text &= "Value " & CStr(Counter2) & ": " &_
    				subKeys(Counter2) & "<br/>"
    		Next Counter2
    		Message.Text &= "<br/>"
    	Next Counter1
    End Sub
The following code can be used to post to the example page:
    <html>
    	<head>
    	<title>Submit a named parameter via POST</title>
    	</head>
    <body>
    	<form id="form1" action="Params.aspx" method="POST">
    		<h3>Name:</h3>
    		<input type="text" name="name">
    		<input type="submit">
    	</form>
    </body>
    </html>
Notes
The collections are listed in the following order:

- QueryString
- Form
- Cookies
- ServerVariables

While it is possible to have both the Form and QueryString collections populated (for example, if a query string name/value pair is added to the URL for the action attribute of a form by us.

QueryString |
NameValueCollection = Request.QueryStrings |
The QueryString collection returns an instance of the NameValueCollection class containing all the keys and values passed as a part of the query string (typically by submitting an HTML form that uses the GET method instead of POST).
Parameters

- NameValueCollection
  An Object variable of type NameValueCollection.

Example
The example writes the contents of the QueryString collection to the browser:
    Sub Page_Load(  )
       Dim Counter1, Counter2 As Integer
       Dim Keys(), subKeys(  ) As String
       Dim QSColl As NameValueCollection

       ' Load QS into NameValueCollection
       QSColl=Request.QueryString
       ' Get keys into an array
       Keys = QSColl.AllKeys
       For Counter1 = 0 To Keys.GetUpperBound(0)
         Message.Text &= "Key: " & Keys(Counter1) & "<br/>"
         subKeys = QSCol1.GetValues(Counter1) 'Get all values under this key
         For Counter2 = 0 To subKeys.GetUpperBound(0)
            Message.Text &= "Value " & CStr(Counter2) & ": " & _
               subKeys(Counter2) & "<br/>"
         Next Counter2
         Message.Text &= "<br/>"
       Next Counter1
    End Sub
The following code can be used to post to the example page (note that the form method attribute has been set to GET, which is required for the form value to be sent as part of the query string):
    <html>
       <head>
          <title>Submit a named parameter via POST</title>
       </head>
    <body>
       <form id="form1" action="QueryString.aspx" method="GET">
          <h3>Name:</h3>
          <input type="text" name="name">"
          <input type="submit">
       </form>
    </body>
    </html>
Notes
One advantage that the QueryString collection has over the Form collection is that you do not always need to have the user submit a form to use it. Because the query string values are appended to the URL, it is relatively simple to statically add query strings to links within pages or dynamically create anchor tags with query string values appended. In fact, many online stores use this method to drive their catalog pages (by passing a product ID appended onto a link to the page designed to display the product). That page can then retrieve the ID by using the QueryString collection.
Because query string values are passed as plain text appended to the URL, they are more vulnerable to tampering than values passed as a result of a POST operation. If you need to pass important data or data that, if tampered with, could create problems for your application, you should consider encrypting values before adding them to the query string or using another method to pass the values
Certain characters used in query string processing, including &, ?, %, and +, must be encoded to avoid confusion between their use in your key/value pair and their role as special characters in a query string. The following table lists the encoding for each of these special characters:

Character | Encoding
& | %26
? | %3f
% | %25
+ | %2b
Space | %20

Rather than memorizing these values, you could make your life easier by simply using the UrlEncode method provided by the HttpServerUtility class (covered in Chapter 18), which automatically substitutes the appropriate encoding for any special characters in a string passed to it.

ServerVariables |
NameValueCollection = Request.ServerVariables |
Parameters

- NameValueCollection
  An Object variable of type NameValueCollection.

Example
The example, as in the previous collection-related examples, writes the contents of the ServerVariables collection to the browser:
    Sub Page_Load(  )
       Dim Counter1, Counter2 As Integer
       Dim Keys(), subKeys(  ) As String
       Dim SVarsColl As NameValueCollection

       ' Load ServerVariables into NameValueCollection
       SVarsColl=Request.ServerVariables
       ' Get keys into an array
       Keys = SVarsColl.AllKeys
       For Counter1 = 0 To Keys.GetUpperBound(0)
          Message.Text &= "Key: " & Keys(Counter1) & "<br/>"
          subKeys = SVarsColl.GetValues(Counter1)
          ' Get all values under this key
          For Counter2 = 0 To subKeys.GetUpperBound(0)
             Message.Text &= "Value " & CStr(Counter2) & ": " & _
                subKeys(Counter2) & "<br/>"
          Next Counter2
          Message.Text &= "<br/>"
       Next Counter1
    End Sub
Notes
In addition to retrieving all the values by looping through the Keys, you can access individual values if you know their key. The following list shows the available keys for the ServerVariable collection:

- ALL_HTTP
  Returns a string containing all HTTP headers with each header name taking the form HTTP_headername, for which headername is the name of an HTTP header in all capital letters.
- ALL_RAW
  Provides the same information as ALL_HTTP, but header names are not all capital letters and are not prefixed with HTTP_.
- APPL_MD_PATH
  Returns the path of the application in the IIS metabase.
- APPL_PHYSICAL_PATH
  Returns the physical path that corresponds to APPL_MD_PATH.
- AUTH_TYPE
  Returns the authentication method used to validate access to protected content.
- AUTH_USER
  Returns the username of the authenticated user in raw form.
- AUTH_PASSWORD
  Returns the password entered in the browser's authentication dialog, assuming Basic authentication was used.
- LOGON_USER
  Returns the name of the Windows account the current user is logged in to. 1
- REMOTE_USER
  Returns the username string sent by the browser before any authentication filtering has taken place.
- CERT_COOKIE
  Returns a unique string identifier for the client certificate.
- CERT_FLAGS
  Returns bit flags that represent whether a certificate is present (bit0) and whether the certificate authority for the client certificate is in the list of recognized certificate authorities on the server (bit1).
- CERT_ISSUER
  Returns the issuer of the client certificate.
- CERT_KEYSIZE
  Returns the number of bits for the SSL key (e.g., 40 or 128).
- CERT_SECRETKEYSIZE
  Returns the number of bits in the server's private key.
- CERT_SERIALNUMBER
  Returns the serial number of the client certificate.
- CERT_SERVER_ISSUER
  Returns the issuer of the server certificate
- CERT_SERVER_SUBJECT
  Returns the subject field of the server certificate.
- CERT_SUBJECT
  Returns the subject field of the client certificate.
- CONTENT_LENGTH
  Returns the length of the content in the body of the HTTP request.
- CONTENT_TYPE
  Returns the MIME type of the content in the HTTP request.
- GATEWAY_INTERFACE
  Returns the revision number of the CGI specification used by the server.
- HTTPS
  Returns either on or off, depending on whether the request came through a secure socket (HTTPS) connection.
- HTTPS_KEYSIZE
  Returns the size, in bits, of the SSL key.
- HTTPS_SECRETKEYSIZE
  Returns the number of bits in the server's private key.
- HTTPS_SERVER_ISSUER
  Returns the issuer of the server certificate.
- HTTPS_SERVER_SUBJECT
  Returns the subject field of the server certificate.
- INSTANCE_ID
  Returns the ID for the IIS instance associated with the request. Unless more than one instance of IIS is running, this value is always 1.
- INSTANCE_META_PATH
  Returns the metabase path to the instance of IIS that responds to the current request.
- LOCAL_ADDR
  Returns the server address on which the request was received. Useful for servers with multiple NICs and IP addresses to determine which address received the request.
- PATH_INFO
  Returns any extra path information passed with the request. See the.PathInfo property earlier in the chapter for more information.
- PATH_TRANSLATED
  Returns the physical path corresponding to the virtual path for the request.
- QUERY_STRING
  Returns the raw query string (if any) passed with the request.
- REMOTE_ADDR
  Returns the IP address of the machine making the request.
- REMOTE_HOST
  Returns the DNS name of the machine making the request, if available.Otherwise, returns the IP address.
- REQUEST_METHOD
  Returns the HTTP request method (GET, POST, etc.) used in the request.
- SCRIPT_NAME
  Returns a virtual path to the page being executed.
- SERVER_NAME
  Returns the server name, DNS name, or IP address of the server.
- SERVER_PORT
  Returns the port number on which the request was received.
- SERVER_PORT_SECURE
  Returns a string containing either 0 or 1, depending on whether the request was received on a secure port (1) or not (0).
- SERVER_PROTOCOL
  Returns the name and version of the protocol used to handle the client request. For IE 5.5 and IIS 5, this name and version would be "HTTP/1.1".
- SERVER_SOFTWARE
  Returns the name and version of the web server software.
- URL
  Returns the base URL of the request (i.e., everything after the domain name).
- HTTP_CONNECTION
  Returns the type of connection established.
- HTTP_ACCEPT
  Returns the value of the HTTP Accept header.
- HTTP_ACCEPT_ENCODING
  Returns the value of the HTTP Accept-Encoding header.
- HTTP_ACCEPT_LANGUAGE
  Returns the value of the HTTP Accept-Language header.
- HTTP_HOST
  Returns the value of the HTTP Host header.
- HTTP_USER_AGENT
  Returns the value of the HTTP User-Agent header.

BinaryRead |
byteArray = Request.BinaryRead(byteCount) |
Returns a byte array containing the number of bytes specified by the byteCount argument.
Parameters

- byteArray
  An Array variable of type Byte to receive the specified number of bytes from the method.
- byteCount
  An integer specifying the number of bytes to return.

Notes
This method provides backward compatibility with classic ASP applications. For new development, using other means (such as the Files collection, etc.) is preferable to achieve the results that this method was used for.

MapPath |
    stringvar = Request.MapPath(virtualPath)
    stringvar = Request.MapPath(virtualPath, _
                 baseVirtualDirectory, allowCrossMapping)
The MapPath method, which the Server object exposed in classic ASP, allows you to retrieve a physical path on the server for a provided virtual path. In ASP.NET, this method is overloaded, meaning that it can be called with two different sets of arguments, as shown in the previous code. The first style, which is the same as in classic ASP, simply passes in a String containing the virtual path to be mapped. The second adds the baseVirtualDirectory argument, which specifies a base from which to resolve relative paths, and the allowCrossMapping argument, which allows you to map virtual paths that belong to other applications.
Parameters

- stringvar
  A String variable to receive the mapped physical path.
- virtualPath
  A String argument containing the virtual path to map.
- baseVirtualDirectory
  A String argument containing a base path to be used for resolving relative paths.
- allowCrossMapping
  A Boolean argument specifying whether paths can be mapped across applications.

Example
The example maps the path of the .NET Framework SDK samples' /QuickStart directory and writes the result to the browser:
    Sub Page_Load(  )
       Dim VirPath, PhysPath, BasePath As String
       Dim BoolCross As Boolean = True

       VirPath = "/QuickStart"
       BasePath = ""

       Message.Text = Request.MapPath(VirPath, BasePath, BoolCross)
    End Sub
Notes
In the previous example, if we had set the BoolCross variable to False and called the example code from outside the QuickStart application, an HttpException would be thrown, since this argument must be set to True to map paths across applications.

SaveAs |
Request.SaveAs(filename, includeHeaders) |
Saves the current HTTP request to disk, using the filename argument as the path and filename under which to save the request
Parameters

- filename
  A String argument containing the path and filename under which the request should be saved.
- includeHeaders
  A Boolean argument indicating whether to save the HTTP header information as part of the request. Note that unless this is a POST request (or other request type with a request body), no information is saved if this argument is set to False.

Example
The example writes the HTTP request headers to the browser (for comparison purposes) and then saves the current request both with and without header information:
    Sub Page_Load(  )
       Message.Text = Request.Headers

       ' Save HTTP Request and Headers to a file
       Request.SaveAs((Request.PhysicalApplicationPath & _
          "HTTPRequest.txt"), True)
       ' Save HTTP Request to a file
       Request.SaveAs((Request.PhysicalApplicationPath & _
          "HTTPRequest_NoHeaders.txt"), False)
    End Sub
Notes
This method can be very useful when debugging because it allows you to look at all the information sent in a given request (which is particularly useful in POST requests).