(0) exportieren Drucken
Alle erweitern
Erweitern Minimieren

Upload von Dateien mit ASP.NET 2.0

Veröffentlicht: 31. Mrz 2006
Von Bill Evjen

ASP.NET 2.0 enthält ein neues FileUpload-Steuerelement für das Hochladen von Dateien vom Webbrowser aus. Dieser Artikel erklärt neben der sinnvollen Verwendung des Steuerelements auch, wie Sie zulässige Dateitypen festlegen können. Außerdem erfahren Sie, wie Sie beliebig große und beliebig viele Dateien für das Hochladen zulassen können.

Auf dieser Seite

Einführung Einführung
Beispiel eines FileUpload-Serversteuerelements Beispiel eines FileUpload-Serversteuerelements
Umgehen von Dateigrößenbeschränkungen Umgehen von Dateigrößenbeschränkungen
Clientseitige Überprüfung der für den Upload zulässigen Dateitypen Clientseitige Überprüfung der für den Upload zulässigen Dateitypen
Hinzufügen einer serverseitigen Überprüfung des Dateityps Hinzufügen einer serverseitigen Überprüfung des Dateityps
Gleichzeitiges Hochladen mehrerer Dateien Gleichzeitiges Hochladen mehrerer Dateien
Schlussbemerkung Schlussbemerkung
Der Autor Der Autor

Einführung

Seit Microsoft ASP.NET mit der Version 1.0 eingeführt wurde, standen integrierte Möglichkeiten zum Erstellen von Webanwendungen zur Verfügung, mit denen Dateien auf den Hostserver hochgeladen werden konnten. Hierzu war die Verwendung des Serversteuerelements File Field erforderlich. Dieser Artikel bietet eine erneute Einführung in den Dateiupload-Prozess. Sie werden erfahren, wie dabei anstelle des File Field-Serversteuerelements das neue in ASP.NET 2.0 enthaltene FileUpload-Serversteuerelement effektiv eingesetzt werden kann.

Dabei ist zu beachten, dass neben dem in diesem Artikel beschriebenen neuen FileUpload-Serversteuerelement durchaus weiterhin das in verschiedenen Anwendungen enthaltene File Field-Steuerelement verwendet werden kann.

Beispiel eines FileUpload-Serversteuerelements

Bei der Verwendung des File Field-Steuerelements in ASP.NET 1.x waren vor dem endgültigen Einsatz einige zusätzliche Schritte erforderlich. So musste beispielsweise dem <form>-Element der Seite zunächst manuell enctype="multipart/form-data" hinzugefügt werden. Das neue, in ASP.NET 2.0 enthaltene FileUpload-Serversteuerelement gestaltet den Prozess des Dateiuploads auf den Hostserver so einfach wie nur möglich.

Letztendlich soll der Zugriff auf das HTML-Tag <input type="file"> ermöglicht werden. Mithilfe dieses Tags können Sie innerhalb eines HTML-Formulars mit Dateien arbeiten. In der Vergangenheit haben viele Programmierer bei der Verwendung einer klassischen ASP-Version (ASP 3.0 oder früher) Dateien mithilfe von Komponenten von Drittanbietern vom Client auf den Server hochgeladen. Wenn Sie .NET mit diesem neuen Steuerelement verwenden, wird der Upload für Sie ausgeführt. Im Codebeispiel 1 wird die Verwendung des FileUpload-Steuerelements beim Dateiupload auf den Server dargestellt.

Hinweis   Der Beispielcode steht sowohl in Microsoft Visual Basic als auch in C# zur Verfügung.

Codebeispiel 1: Hochladen von Dateien auf den Server mithilfe des "FileUpload"-Steuerelements

Visual Basic
<%@ Page Language="VB" %>

<script runat="server">
    Protected Sub Button1_Click(ByVal sender As Object, _
      ByVal e As System.EventArgs)
        If FileUpload1.HasFile Then
            Try
                FileUpload1.SaveAs("C:\Uploads\" & _
                   FileUpload1.FileName)
                Label1.Text = "File name: " & _
                   FileUpload1.PostedFile.FileName & "<br>" & _
                   "File Size: " & _
                   FileUpload1.PostedFile.ContentLength & " kb<br>" & _
                   "Content type: " & _
                   FileUpload1.PostedFile.ContentType
            Catch ex As Exception
                Label1.Text = "ERROR: " & ex.Message.ToString()
            End Try
        Else
            Label1.Text = "You have not specified a file."
        End If
    End Sub
</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Upload Files</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:FileUpload ID="FileUpload1" runat="server" /><br />
        <br />
        <asp:Button ID="Button1" runat="server" OnClick="Button1_Click" 
         Text="Upload File" />&nbsp;<br />
        <br />
        <asp:Label ID="Label1" runat="server"></asp:Label></div>
    </form>
</body>
</html>
C#
<%@ Page Language="C#" %>

<script runat="server">
    protected void Button1_Click(object sender, EventArgs e)
    {
        if (FileUpload1.HasFile)
            try
            {
                FileUpload1.SaveAs("C:\\Uploads\\" + 
                     FileUpload1.FileName);
                Label1.Text = "File name: " +
                     FileUpload1.PostedFile.FileName + "<br>" +
                     FileUpload1.PostedFile.ContentLength + " kb<br>" +
                     "Content type: " +
                     FileUpload1.PostedFile.ContentType;
            }
            catch (Exception ex)
            {
                Label1.Text = "ERROR: " + ex.Message.ToString();
            }
        else
        {
            Label1.Text = "You have not specified a file.";
        }
    }
</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Upload Files</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:FileUpload ID="FileUpload1" runat="server" /><br />
        <br />
        <asp:Button ID="Button1" runat="server" OnClick="Button1_Click" 
         Text="Upload File" />&nbsp;<br />
        <br />
        <asp:Label ID="Label1" runat="server"></asp:Label></div>
    </form>
</body>
</html>

Wenn Sie diese Seite ausführen, werden Ihnen beim Betrachten des für die Seite generierten Quellcodes einige Punkte auffallen. Dieser Quellcode wird im Codebeispiel 2 dargestellt.

Codebeispiel 2: Der aus dem "FileUpload"-Steuerelement generierte Quellcode

<html xmlns="http://www.w3.org/1999/xhtml" >
<head><title>
   Upload Files
</title></head>
<body>
    <form name="form1" method="post" action="MyFileUpload.aspx" 
     id="form1" enctype="multipart/form-data">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUJNDcxNTg5NDg3D2QWAgIEDxYCHgdlbmN0eXBlBRNtdWx0aXBhcnQvZm9yb
       S1kYXRhZGQUQEUFMY1+/fp1mnrkbqmVNQIzFA==" />
</div>

    <div>
        <input type="file" name="FileUpload1" id="FileUpload1" /><br />
        <br />
        <input type="submit" name="Button1" value="Upload File" 
         id="Button1" />&nbsp;<br />
        <br />
        <span id="Label1"></span>
    </div>
    
<div>

   <input type="hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" 
    value="/wEWAgLB+7jIAwKM54rGBv2Iz6LxVY7jWec0gZMxnuaK2ufq" />
</div></form>
</body>
</html>

Zunächst fällt auf, dass ASP.NET 2.0 das <form>-Element der Seite durch Hinzufügen des entsprechenden Attributs enctype geändert hat, da das FileUpload-Steuerelement in der Seite enthalten ist. Sie werden außerdem feststellen, dass das FileUpload-Steuerelement in ein HTML-<input type="file">-Element konvertiert wurde.

Wenn die im Codebeispiel 1 dargestellte Seite ausgeführt wird, können Sie eine Datei auswählen und diese auf den Server hochladen, indem Sie auf der Seite auf die Schaltfläche Upload File (Datei hochladen) anklicken. Zum besseren Verständnis aller zur reibungslosen Ausführung erforderlichen Elemente werden einige wichtige Punkte dieses Beispiels im Folgenden dargestellt.

Damit der im Codebeispiel 1 dargestellte Code ausgeführt werden kann, muss auf dem Server der Schreibschutz des Zielordners für das von ASP.NET verwendete Konto aufgehoben werden, damit die Datei im angegebenen Ordner gespeichert werden kann. Wenn Sie vermuten, dass Ihr ASP.NET-Konto zum Schreiben in den gewünschten Ordner nicht berechtigt ist, öffnen Sie einfach den Microsoft Windows-Explorer und wechseln Sie zu dem Ordner, dem Sie diese Berechtigung hinzufügen möchten. Klicken Sie mit der rechten Maustaste auf den Ordner (in diesem Fall auf den Ordner Uploads), und wählen Sie die Option Eigenschaften aus. Klicken Sie im Dialogfeld Eigenschaften auf die Registerkarte Sicherheit, und stellen Sie dabei sicher, dass das ASP.NET-Computerkonto in der Liste enthalten ist und über die erforderlichen Schreibberechtigungen verfügt (siehe Abbildung 1).

Die Registerkarte Security (Sicherheit) des Ordners Uploads
Abbildung 1: Die Registerkarte Security (Sicherheit) des Ordners Uploads

Wenn das ASP.NET-Computerkonto auf der Registerkarte Sicherheit nicht angezeigt wird, können Sie das Konto hinzufügen, indem sie auf die Schaltfläche Hinzufügen klicken und in den Textbereich ASPNET eingeben (ohne Punkt), wie in Abbildung 2 dargestellt.

Hinzufügen des ASP.NET-Computerkontos zu den Sicherheitsdefinitionen des Ordners
Abbildung 2: Hinzufügen des ASP.NET-Computerkontos zu den Sicherheitsdefinitionen des Ordners

Klicken Sie auf OK, um das ASP.NET-Computerkonto der Liste hinzuzufügen. Stellen Sie sicher, dass Sie dem Konto die erforderlichen Berechtigungen zuweisen, und klicken Sie dann einfach auf OK.

Durch Klicken auf die Schaltfläche Submit (Senden) auf der Seite wird das Ereignis Button1_Click ausgelöst. Durch dieses Ereignis wird die Datei hochgeladen. Wenn der Upload erfolgreich ausgeführt wurde, wird eine Meldung angezeigt, die Informationen zur hochgeladenen Datei enthält. Wenn der Upload nicht erfolgreich ausgeführt werden konnte, wird auf der Seite eine Fehlermeldung angezeigt, in der die Ursachen für den Fehler aufgeführt werden.

Wenn Sie das FileUpload-Steuerelement verwenden (das sich selbst in ein <input type="file">-Tag konvertiert), wird vom Browser automatisch die Schaltfläche Durchsuchen auf der ASP.NET-Seite angezeigt. Ansonsten sind hier keine weiteren Programmierungen erforderlich. Wenn der Endbenutzer auf die Schaltfläche Durchsuchen klickt, kann er im lokalen Dateisystem nach der Datei suchen, die auf den Server hochgeladen werden soll. Dieser Vorgang wird in Abbildung 3 dargestellt. Durch Klicken auf Öffnen werden im Textfeld der Dateiname und der Dateipfad dargestellt.

Auswählen einer Datei
Abbildung 3: Auswählen einer Datei

Umgehen von Dateigrößenbeschränkungen

Dateien, die mithilfe dieser Technik hochgeladen werden, dürfen eine bestimmte Größe nicht überschreiten. In der Standardeinstellung darf die unter Verwendung des FileUpload-Steuerelements auf den Server hochzuladende Datei eine Größe von ungefähr 4 MB nicht überschreiten. Dateien, deren Größe über diesem Höchstwert liegt, können nicht hochgeladen werden.

Einer der Vorteile von .NET besteht jedoch darin, dass Beschränkungen in der Regel umgangen werden können. Normalerweise können die vorhandenen Standardeinstellungen geändert werden. Bearbeiten Sie die Größenbeschränkung, indem Sie in der im Konfigurationsordner von ASP.NET 2.0 unter C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\CONFIG gespeicherten Datei web.config.comments oder in der Datei web.config der Anwendung einige Änderungen vornehmen.

Suchen Sie in der Datei web.config.comments den Knoten <httpRuntime>, der folgendermaßen aussieht:

<httpRuntime 
 executionTimeout="110" 
 maxRequestLength="4096" 
 requestLengthDiskThreshold="80" 
 useFullyQualifiedRedirectUrl="false" 
 minFreeThreads="8" 
 minLocalRequestFreeThreads="4" 
 appRequestQueueLimit="5000" 
 enableKernelOutputCache="true" 
 enableVersionHeader="true" 
 requireRootedSaveAsPath="true" 
 enable="true" 
 shutdownTimeout="90" 
 delayNotificationTimeout="5" 
 waitChangeNotification="0" 
 maxWaitChangeNotification="0" 
 enableHeaderChecking="true" 
 sendCacheControlHeader="true" 
 apartmentThreading="false" />

Dieser einzelne Knoten bildet die Grundlage für mehrere Vorgänge, die Größe der hochzuladenen Dateien wird jedoch durch die Einstellung des Attributs maxRequestLength bestimmt. In der Standardeinstellung liegt die Größe bei 4096 KB. Ändern Sie einfach diesen Wert, um die zulässige Größe für Dateien zu erhöhen, die auf den Server hochgeladen werden können. Wenn die zulässige Größe der auf den Server hochzuladenden Dateien 10 MB betragen soll, legen Sie den Wert für maxRequestLength auf 11264 fest. Dadurch lässt die Anwendung den Upload von Dateien mit einer Größe von bis zu 11.000 KB auf den Server zu.

Wenn diese Änderung in der Datei web.config.comments vorgenommen wird, wirkt sich die Einstellung auf alle auf dem Server vorhandenen Anwendungen aus. Wenn diese Einstellung sich nur auf die von Ihnen bearbeitete Anwendung beziehen soll, verwenden Sie diesen Knoten in der Datei web.config Ihrer Anwendung. Dadurch werden alle in der Datei web.config.comments vorhandenen Einstellungen überschrieben. Stellen Sie dabei sicher, dass der Knoten sich in der Konfigurationsdatei zwischen den <system.web>-Knoten befindet.

Größenbeschränkungen für hochzuladene Dateien werden außerdem durch den Wert des Attributs executionTimeout im Knoten <httpRuntime> bestimmt: Der Wert des Attributs executionTimeout entspricht der Anzahl von Sekunden, die für den Upload beansprucht werden dürfen, bevor ASP.NET den Vorgang beendet. Wenn der Upload großer Dateien auf den Server ermöglicht werden soll, muss dementsprechend neben dem Wert für maxRequestLength auch dieser Wert erhöht werden.

Ein Argument gegen die Erhöhung der für den Upload zulässigen Dateigröße liegt allerdings darin, dass Hacker oftmals versuchen, Server durch mehrfache Anforderungen sehr großer Dateien anzugreifen. Davor können Sie sich schützen, indem Sie die zulässige Dateigröße für Uploads verringern, damit der Server nicht von hunderten oder gar tausenden von Anforderungen für Dateien einer Größe von 10 MB überfordert wird.

Clientseitige Überprüfung der für den Upload zulässigen Dateitypen

Zur Steuerung der Dateitypen, die auf den Server hochgeladen werden können, bestehen mehrere Möglichkeiten. Leider steht keine hundertprozentig sichere Methode zum Schutz gegen den Dateiupload durch Personen mit möglicherweise böswilligen Absichten zur Verfügung. Sie können jedoch einige Maßnahmen ergreifen, um den Prozess des Uploads von Dateien durch Endbenutzer besser zu kontrollieren.

Eine geeignete Methode hierfür ist die Verwendung der im Programmumfang enthaltenen ASP.NET-Steuerelemente zur Gültigkeitsprüfung. Mithilfe dieser Steuerelemente kann für die hochzuladende Datei eine Überprüfung mit regulären Ausdrücken durchgeführt werden, um so sicherzustellen, dass die Dateierweiterung den für den Upload zulässigen Erweiterungen entspricht.

Diese Möglichkeit bietet sich bei Browsern an, die eine clientseitige Verwendung der Steuerelemente zur Gültigkeitsprüfung zulassen, da in diesem Fall die Überprüfung durch den Client erzwungen und die Datei nicht auf den Server hochgeladen wird, wenn die Signatur nicht den von Ihnen zugelassenen Signaturen entspricht. Im Codebeispiel 3 wird ein Beispiel für die Verwendung von Steuerelementen zur Gültigkeitsprüfung dargestellt.

Hinweis   Die Verwendung von Steuerelementen zur Gültigkeitsprüfung wird an dieser Stelle nicht erläutert. Unter Überprüfen von ASP.NET-Serversteuerelementen finden Sie eine vollständige Erläuterung der Steuerelemente zur Gültigkeitsprüfung sowie zu deren Verwendung in ASP.NET-Seiten.

Codebeispiel 3: Verwenden von Steuerelementen zur Gültigkeitsprüfung zur Beschränkung der für den Upload zulässigen Dateitypen

<asp:FileUpload ID="FileUpload1" runat="server" /><br />
<br />
<asp:Button ID="Button1" runat="server" OnClick="Button1_Click" 
 Text="Upload File" />&nbsp;<br />
<br />
<asp:Label ID="Label1" runat="server"></asp:Label>
<asp:RegularExpressionValidator 
 id="RegularExpressionValidator1" runat="server" 
 ErrorMessage="Only mp3, m3u or mpeg files are allowed!" 
 ValidationExpression="^(([a-zA-Z]:)|(\\{2}\w+)\$?)(\\(\w[\w].*))
    +(.mp3|.MP3|.mpeg|.MPEG|.m3u|.M3U)$" 
 ControlToValidate="FileUpload1"></asp:RegularExpressionValidator>
<br />
<asp:RequiredFieldValidator 
 id="RequiredFieldValidator1" runat="server" 
 ErrorMessage="This is a required field!" 
 ControlToValidate="FileUpload1"></asp:RequiredFieldValidator>

Diese einfache ASP.NET-Seite verwendet Steuerelemente zur Gültigkeitsprüfung, damit der Endbenutzer nur Dateien mit den Erweiterungen MP3, MPEG oder M3U auf den Server hochladen kann. Wenn der Dateityp nicht einer dieser drei Optionen entspricht, wird vom Steuerelement Validation eine Ausnahme ausgelöst und die entsprechende Meldung angezeigt. Dies wird in Abbildung 4 dargestellt.

Überprüfen des Dateityps mithilfe von Steuerelementen zur Gültigkeitsprüfung
Abbildung 4: Überprüfen des Dateityps mithilfe von Steuerelementen zur Gültigkeitsprüfung

Der Einsatz von Validation-Steuerelementen stellt keine absolut sichere Methode zur Überprüfung von Dateien dar, die auf den Server hochgeladen werden. Dieses einfache Sicherheitsmodell kann relativ leicht umgangen werden, indem die Dateierweiterung einer Datei so geändert wird, dass diese akzeptiert und auf den Server hochgeladen wird.

Hinzufügen einer serverseitigen Überprüfung des Dateityps

Anhand der gerade beschriebenen einfachen Methode können Sie einer ASP.NET-Seite einige ASP.NET-Serversteuerelemente hinzufügen, um die clientseitige Überprüfung der Dateierweiterung (lediglich auf Textbasis) durchzuführen. Werfen wir nun einen Blick auf die serverseitige Durchführung eines ähnlichen Vorgangs. Dieses Verfahren wird im Codebeispiel 4 dargestellt.

Codebeispiel 4: Überprüfen des Dateityps auf dem Server

Visual Basic
    Protected Sub Button1_Click(ByVal sender As Object, _
      ByVal e As System.EventArgs)
        If FileUpload1.HasFile Then
            Dim fileExt As String
            fileExt = System.IO.Path.GetExtension(FileUpload1.FileName)
            
            If (fileExt = ".mp3") Then
                Try
                    FileUpload1.SaveAs("C:\Uploads\" & _
                       FileUpload1.FileName)
                    Label1.Text = "File name: " & _
                      FileUpload1.PostedFile.FileName & "<br>" & _
                      "File Size: " & _
                      FileUpload1.PostedFile.ContentLength & " kb<br>" & _
                      "Content type: " & _
                      FileUpload1.PostedFile.ContentType
                Catch ex As Exception
                    Label1.Text = "ERROR: " & ex.Message.ToString()
                End Try
            Else
                Label1.Text = "Only .mp3 files allowed!"
            End If
        Else
            Label1.Text = "You have not specified a file."
        End If
    End Sub
C#
    protected void Button1_Click(object sender, EventArgs e)
    {

        if (FileUpload1.HasFile)
        {
            string fileExt = 
               System.IO.Path.GetExtension(FileUpload1.FileName);

            if (fileExt == ".mp3")
            {
                try
                {
                    FileUpload1.SaveAs("C:\\Uploads\\" + 
                       FileUpload1.FileName);
                    Label1.Text = "File name: " +
                        FileUpload1.PostedFile.FileName + "<br>" +
                        FileUpload1.PostedFile.ContentLength + " kb<br>" +
                        "Content type: " +
                        FileUpload1.PostedFile.ContentType;
                }
                catch (Exception ex)
                {
                    Label1.Text = "ERROR: " + ex.Message.ToString();
                }
            }
            else
            {
                Label1.Text = "Only .mp3 files allowed!";
            }
        }
        else
        {
            Label1.Text = "You have not specified a file.";
        }
    }

Mithilfe der GetExtension-Methode aus dem System.IO.Path-Namespace können Sie im Grunde denselben Vorgang ausführen. Dabei sollte jedoch beachtet werden, dass auch bei diesem Verfahren die Möglichkeit bestehen bleibt, einfach die Dateierweiterung anzupassen, damit sie akzeptiert und die geänderte Datei auf den Hostserver hochgeladen wird.

Gleichzeitiges Hochladen mehrerer Dateien

Bisher wurden einige nützliche Beispiele zum problemlosen Hochladen einer Datei auf den Server erläutert. Wenden wir uns nun dem Hochladen mehrerer Dateien auf den Server durch eine einzelne Seite zu.

Keine der im Microsoft .NET Framework integrierten Funktionen ermöglichen den Upload mehrerer Dateien über eine einzelne ASP.NET-Seite. Diese Aufgabe kann jedoch mit geringem zusätzlichem Aufwand durchgeführt werden. Das Verfahren ähnelt dabei der in .NET 1.x verwendeten Methode.

Der Trick besteht darin, die System.IO-Klasse in die ASP.NET-Seite zu importieren und dann mithilfe der HttpFileCollection-Klasse alle Dateien zu erfassen, die mit dem Request-Objekt übermittelt wurden. Mit diesem Ansatz können sie beliebig viele Dateien von einer einzelnen Seite aus hochladen.

Bei Bedarf könnten Sie jedes FileUpload-Steuerelement auf der Seite einzeln bearbeiten, wie im Codebeispiel 5 dargestellt.

Codebeispiel 5: Individuelles Bearbeiten einzelner "FileUpload"-Steuerelemente

Visual Basic
If FileUpload1.HasFile Then
   ' Handle file
End If

If FileUpload2.HasFile Then
   ' Handle file
End If
C#
if (FileUpload1.HasFile) {
   // Handle file
}

if (FileUpload2.HasFile) {
   // Handle file
}

Dieses Verfahren funktioniert. In einigen Fällen möchten Sie die Dateien jedoch möglicherweise mithilfe der HttpFileCollection-Klasse bearbeiten – insbesondere dann, wenn Sie mit einer dynamisch generierten Liste von Serversteuerelementen arbeiten.

Sie können beispielsweise eine ASP.NET-Seite erstellen, die über drei FileUpload-Steuerelemente und eine Schaltfläche Submit (Senden) verfügt (dazu verwenden Sie das Button-Steuerelement). Nachdem der Benutzer auf die Submit-Schaltfläche geklickt hat und die Dateien zum Server übertragen wurden, übernimmt der Codebehind die Dateien und speichert diese an einem bestimmten Speicherort auf dem Server. Nachdem die Dateien gespeichert wurden, werden die bereitgestellten Dateiinformationen auf der ASP.NET-Seite angezeigt (siehe Codebeispiel 6).

Codebeispiel 6: Hochladen mehrerer Dateien auf den Server

Visual Basic
Protected Sub Button1_Click(ByVal sender As Object, _
   ByVal e As System.EventArgs)

   Dim filepath As String = "C:\Uploads"
   Dim uploadedFiles As HttpFileCollection = Request.Files
   Dim i As Integer = 0

   Do Until i = uploadedFiles.Count
     Dim userPostedFile As HttpPostedFile = uploadedFiles(i)

     Try
        If (userPostedFile.ContentLength > 0) Then
           Label1.Text += "<u>File #" & (i + 1) & "</u><br>"
           Label1.Text += "File Content Type: " & _
              userPostedFile.ContentType & "<br>"
           Label1.Text += "File Size: " & _
              userPostedFile.ContentLength & "kb<br>"
           Label1.Text += "File Name: " & _
              userPostedFile.FileName & "<br>"

           userPostedFile.SaveAs(filepath & "\" & _
              System.IO.Path.GetFileName(userPostedFile.FileName))

           Label1.Text += "Location where saved: " & _
              filepath & "\" & _
              System.IO.Path.GetFileName(userPostedFile.FileName) & _
              "<p>"
        End If
     Catch ex As Exception
        Label1.Text += "Error:<br>" & ex.Message
     End Try
     i += 1
   Loop
End Sub
C#
protected void Button1_Click(object sender, EventArgs e)
{
   string filepath = "C:\\Uploads";
   HttpFileCollection uploadedFiles = Request.Files;
    
   for (int i = 0; i < uploadedFiles.Count; i++)
   {    
      HttpPostedFile userPostedFile = uploadedFiles[i];
    
      try
      {    
         if (userPostedFile.ContentLength > 0 )
         {
            Label1.Text += "<u>File #" + (i+1) + 
               "</u><br>";
            Label1.Text += "File Content Type: " + 
               userPostedFile.ContentType + "<br>";
            Label1.Text += "File Size: " + 
               userPostedFile.ContentLength + "kb<br>";
            Label1.Text += "File Name: " + 
               userPostedFile.FileName + "<br>";
    
            userPostedFile.SaveAs(filepath + "\\" + 
               System.IO.Path.GetFileName(userPostedFile.FileName));
    
            Label1.Text += "Location where saved: " + 
               filepath + "\\" + 
               System.IO.Path.GetFileName(userPostedFile.FileName) + 
               "<p>";
         }    
      } 
      catch (Exception Ex)
      {    
         Label1.Text += "Error: <br>" + Ex.Message;    
      }    
   }    
}

Der Endbenutzer kann bis zu vier Dateien auswählen und anschließend durch Klicken auf die Schaltfläche Upload Files (Dateien hochladen) das Ereignis Button1_Click auslösen. Die Verwendung der HttpFileCollection-Klasse ermöglicht in Verbindung mit der Request.Files-Eigenschaft die Kontrolle über alle hochgeladenen Dateien. Unter diesen Voraussetzungen können Sie mit den Dateien beliebig verfahren. Im Beispielfall werden die Dateieigenschaften überprüft und auf dem Bildschirm angezeigt. Die Dateien werden dann im Ordner Uploads im physikalischen Stammverzeichnis des Servers gespeichert. Das Ergebnis dieser Aktion wird in Abbildung 5 dargestellt.

Gleichzeitiges Hochladen von vier Dateien über eine einzelne ASP.NET-Seite
Abbildung 5: Gleichzeitiges Hochladen von vier Dateien über eine einzelne ASP.NET-Seite

Schlussbemerkung

Das von ASP.NET bereitgestellte FileUpload-Serversteuerelement ist ein leistungsfähiges Steuerelement, das seinerzeit unter Active Server Pages 3.0 nur schwer erstellt werden konnte. Diese neue Funktion ermöglicht den Endbenutzern das Hochladen von einer oder mehreren Dateien auf den Server. Beachten Sie, dass Sie die Größe der hochgeladenen Dateien durch Einstellungen in den Dateien web.config.comments oder web.config steuern können.

Der Autor

Bill Evjen ist ein aktiver Befürworter von .NET-Technologien sowie von community-basierten Lerninitiativen für .NET. Er ist einer der Technical Directors bei Reuters, dem internationalen Nachrichten- und Finanzdienstleister in St. Louis, Missouri. Bill ist Gründer und Executive Director der International .NET Association (INETA), in der weltweit über 100.000 Mitglieder organisiert sind. Bill ist außerdem Autor und Referent und hat mehrere Bücher veröffentlicht, z. B. ASP.NET Professional Secrets, XML Web Services for ASP.NET, Web Services Enhancements und die Visual Basic .NET Bible (alle in englischer Sprache und veröffentlicht durch Wiley).


Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2014 Microsoft