原文地址：http://www.15seconds.com/issue/010522.htm
Summary
This article examines an example of multiple binary file upload for Web applications using Extensible Markup Language (XML) technology, without the typical limitation of traditional file upload processing. It describes how to use Microsoft XML Parser 3.0 (MSXML) and ActiveX Data Objects (ADO) Stream objects for a new upload strategy with several benefits. For example, no custom ASP components are required.
Introduction
To obtain a file upload with a traditional HTML page, on the client side we can use a form structured in the following way:
<FORM NAME="myForm"
ACTION="TargetURL.asp"
ENCTYPE="multipart/form-data"
METHOD="post">
<INPUT TYPE="file" NAME="myFile">
<INPUT TYPE="submit" VALUE="Upload File">
</FORM>
This solution presents several limitations both on the client and server side. We must use the POST method (because the GET can't manage this type of data), and we have no solutions to trigger a POST processing without using an HTML form. When we send data to the TargetURL, the browser loads this page as the new current page and we have an undesirable "context switch."
The ENCTYPE property defines the Multipurpose Internet Mail Extensions (MIME) encoding for the form and must be set to "multipart/form-data" for file upload forms. When we set this property to "multipart/form-data" we obtain a different structure of the POST buffer (which is also more complex) and the Request ASP object can't access the form contents. Therefore, we can read the POST buffer using the Request.binaryRead method, but we can't use scripting languages to do this. The Request.binaryRead method returns a VTarray (which is a variant array of unsigned one byte characters) while scripting languages can manage only variant variables. We can resolve this problem only by using a specific, custom ASP component or ISAPI extension, such as CPSHOST.DLL. This behavior is by design.
A New Upload Strategy
The idea underlying this article is the use of the following step: On the client-side:
create a XML document using the MSXML 3.0 object;
create a XML node with binary content;
populate this node with the content of the uploading file using the ADO Stream object;
send the document to the Web server using the XMLHTTP object.
On the server-side:
read the XML document from the Request ASP object;
read the content of the binary node and store it into a file on the server. Optionally, we can store it into a BLOB field of a database tables.
Before explaining the source code sample, we can make a few considerations about the solution used in this article.
XML Consideration
XML support many data types, such as numeric, float, character, etc. Many authors define XML as the ASCII of the future, but we can't forget that this technology can also describe binary information using the "bin.base64" data type. This feature is fully available with MS XML 3.0 Parser and to date requires a custom setup. This object provides some properties that enable a complete management of binary contents:
obj_node.dataType - This read/write property specifies the data type of the selected node. The XML parser supports more dataType values (see the MSDN reference for a complete list -- http://msdn.microsoft.com/library/psdk/xmlsdk/xmls3z1v.htm).
For binary contents we can use the "bin.base64" data type;
obj_node.nodeTypedValue - This read/write property contains the selected node's value expressed in its defined data type.
We can create an XML document with more "bin.base64"-type nodes that contain the files we want to upload. This consideration allows the processing of multiple uploading files with a single POST.
We can use the XMLHttpRequest object to send an XML document to a Web server using the POST method. This object provides client-side protocol support for communication with HTTP servers and allows us to send and receive MS XML Document Object Model (DOM) objects from a Web server. XMLHttpRequest is a built-in COM object with Internet Explorer 5 (not requiring a custom setup) and does not generate a context switch after posting data.
The ADO Stream Object
The previous considerations allow the creation (on the client-side) of an XML document with one or more binary nodes. Now we need to populate this node with the contents of the uploading files. Unfortunately, scripting languages can't access the local file system, and the Scripting.FileSystemObject (which is a built-in COM object of the recent Win32 platform) to date can't manage binary files. This behavior is by design. We need an other COM object that provides the access to the local binary files.
The ADO Stream object (which is a COM object included in the MDAC 2.5 components) provides the means to read, write, and manage a stream of bytes. This byte stream may be text or binary and hasn't particular size limitations. In ADO 2.5, Microsoft has introduced the Stream object without any dependency in the ADO object model hierarchy; therefore, we can use the Stream object without binding it to the other ADO objects.
In this article, we use the Stream object to access file content and store it into XML node, and vice versa.
Client-Side Code
The following code sample provides a client-side file upload using Stream and MSXML objects:
<HTML>
<HEAD><TITLE>File Send</TITLE></HEAD>
<BODY>
<INPUT id=btn_send name="btn_send" type=button value="FILE SEND">
<DIV id=div_message>Ready</DIV>
</BODY>
</HTML>
<SCRIPT LANGUAGE=JavaScript>
// files upload function
function btn_send.onclick()
{
// create ADO-stream Object
var ado_stream = new ActiveXObject("ADODB.Stream");
// create XML document with default header and primary node
var xml_dom = new ActiveXObject("MSXML2.DOMDocument");
xml_dom.loadXML('<?xml version="1.0" ?> <root/>');
// specify namespaces datatypes
xml_dom.documentElement.setAttribute("xmlns:dt", "urn:schemas-microsoft-com:datatypes");
// create a new node and set binary content
var l_node1 = xml_dom.createElement("file1");
l_node1.dataType = "bin.base64";
// open stream object and read source file
ado_stream.Type = 1; // 1=adTypeBinary
ado_stream.Open();
ado_stream.LoadFromFile("c:\\tmp\\myfile.doc");
// store file content into XML node
l_node1.nodeTypedValue = ado_stream.Read(-1); // -1=adReadAll
ado_stream.Close();
xml_dom.documentElement.appendChild(l_node1);
// we can create more XML nodes for multiple file upload
// send XML documento to Web server
var xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
xmlhttp.open("POST","./file_recieve.asp",false);
xmlhttp.send(xml_dom);
// show server message in message-area
div_message.innerHTML = xmlhttp.ResponseText;
}
</SCRIPT>
Server-Side Code
The following code sample provides a server-side file upload using the same objects:
<%@ LANGUAGE=VBScript%>
<% Option Explicit
Response.Expires = 0
' define variables and COM objects
dim ado_stream
dim xml_dom
dim xml_file1
' create Stream Object
set ado_stream = Server.CreateObject("ADODB.Stream")
' create XMLDOM object and load it from request ASP object
set xml_dom = Server.CreateObject("MSXML2.DOMDocument")
xml_dom.load(request)
' retrieve XML node with binary content
set xml_file1 = xml_dom.selectSingleNode("root/file1")
' open stream object and store XML node content into it
ado_stream.Type = 1 ' 1=adTypeBinary
ado_stream.open
ado_stream.Write xml_file1.nodeTypedValue
' save uploaded file
ado_stream.SaveToFile "c:\tmp\upload1.doc",2 ' 2=adSaveCreateOverWrite
ado_stream.close
' destroy COM object
set ado_stream = Nothing
set xml_dom = Nothing
' write message to browser
Response.Write "Upload successful!"
%>
We can also use the ADO Stream to store the uploading file into a BLOB field of a database table. (See the related link for more information.)
Benefits
This strategy allows a file upload processing with several benefits:
It does not trigger a context switch on the client.
No custom ASP components are required.
We can use this strategy for multiple binary file upload in a single POST process.
This process is totally implemented into a SCRIPT code. We can easily insert this code into a script library since no HTML objects are required. We can also implement this algorithm (on the client-side) using any other language that supports the COM interface, such as Visual Basic (VB), Delphi, PowerBuilder, etc.
Security and System Consideration
We can use this solution only for an intranet application because it requires an IE5 security setting with low protection. We must:
enable script and activeX controls. This parameter allows the execution of the "myobj = new activexobject(...)" JScript statement;
enable access to data source through domain. This parameter allows the use of the Stream object on the client side. We must also install MS XML DOM 3.0 and MDAC 2.5 both on the client and server side.
References
Read Tiago Halm's article about traditional file-upload processing at http://www.15seconds.com/Issue/001003.htm
For a description of the data types supported by MS XML parser, see http://msdn.microsoft.com/library/psdk/xmlsdk/xmls1cbp.htm and http://msdn.microsoft.com/library/psdk/xmlsdk/xmls3z1v.htm
A sample of creating an XML document with binary data in VB is available at http://support.microsoft.com/support/kb/articles/Q254/3/88.ASP
For a Microsoft reference on the ADO Stream object, see http://msdn.microsoft.com/library/psdk/dasdk/mdao1ajx.htm .
Another sample for managing BLOB and binary files can be found at http://support.microsoft.com/support/kb/articles/Q258/0/38.ASP.
About the Author
Marco Nanni is an Italian Web developer with experience in (D)HTML and XML technology used for implementing enterprise solutions. Marco can be contacted at: mnanni@lycos.it.