(0) exportieren Drucken
Alle erweitern

FtpWebRequest-Klasse

Hinweis: Diese Klasse ist neu in .NET Framework, Version 2.0.

Implementiert einen FTP (File Transfer Protocol)-Client.

Namespace: System.Net
Assembly: System (in system.dll)

public sealed class FtpWebRequest : WebRequest
public final class FtpWebRequest extends WebRequest
public final class FtpWebRequest extends WebRequest

Um eine Instanz von FtpWebRequest abzurufen, verwenden Sie die Create-Methode. Sie können auch die WebClient-Klasse verwenden, um Informationen auf einen FTP-Server zu uploaden oder von einem FTP-Server zu downloaden. Wenn Sie eine dieser Vorgehensweisen verwenden und eine Netzwerkressource angeben, die das FTP-Schema (z. B. "ftp://contoso.com") verwendet, ermöglicht die FtpWebRequest-Klasse das programmgesteuerte Interagieren mit FTP-Servern.

Der URI kann relativ oder absolut sein. Wenn der URI in der Form "ftp://contoso.com/%2fpath" (%2f ist das Escapezeichen für "/") vorliegt, ist der URI absolut, und das aktuelle Verzeichnis ist /path. Wenn der URI hingegen in der Form "ftp://contoso.com/path" vorliegt, meldet sich .NET Framework zunächst auf dem FTP-Server (mit dem durch die Credentials-Eigenschaft festgelegten Benutzernamen und Kennwort) an und legt dann das aktuelle Verzeichnis auf <UserLoginDirectory>/path fest.

Sie müssen über einen gültigen Benutzernamen und ein gültiges Kennwort für den Server verfügen, oder der Server muss die anonyme Anmeldung zulassen. Sie können die Anmeldeinformationen zum Herstellen der Verbindung mit dem Server durch Festlegen der Credentials-Eigenschaft angeben oder die Anmeldeinformationen in den UserInfo-Abschnitt des an die Create-Methode übergebenen URIs einfügen. Wenn Sie UserInfo-Informationen in den URI einfügen, wird die Credentials-Eigenschaft auf neue Netzwerkanmeldeinformationen mit dem angegebenen Benutzernamen und Kennwort festgelegt.

VorsichtVorsicht

Sofern die EnableSsl-Eigenschaft nicht true ist, werden alle Daten und Befehle, einschließlich des Benutzernamens und Kennworts, als Klartext an den Server gesendet. Jede den Netzwerkverkehr überwachende Person kann die Anmeldeinformationen anzeigen und zum Herstellen einer Verbindung mit dem Server verwenden. Wenn Sie eine Verbindung mit einem FTP-Server herstellen, der Anmeldeinformationen erfordert und SSL (Secure Sockets Layer) unterstützt, legen Sie EnableSsl auf true fest.

Sie müssen über WebPermission verfügen, um auf die FTP-Ressource zuzugreifen. Andernfalls wird eine SecurityException-Ausnahme ausgelöst.

Geben Sie den an den Server zu sendenden FTP-Befehl an, indem Sie die Method-Eigenschaft auf einen in der WebRequestMethods.Ftp-Struktur definierten Wert festlegen. Für die Übertragung von Textdaten ändern Sie den Standardwert der UseBinary-Eigenschaft (true) in false. Details und Informationen über Einschränkungen finden Sie unter Method.

Bei Verwendung eines FtpWebRequest-Objekts zum Uploaden einer Datei auf einen Server müssen Sie den Dateiinhalt in den Anforderungsstream schreiben, der durch Aufruf der GetRequestStream-Methode oder ihrer asynchronen Entsprechungen, der BeginGetRequestStream-Methode und der EndGetRequestStream-Methode abgerufen wurde. Vor dem Senden der Anforderung müssen Sie in den Stream schreiben und den Stream schließen.

Anforderungen werden durch Aufruf der GetResponse-Methode oder ihrer asynchronen Entsprechungen, der BeginGetResponse-Methode und der EndGetResponse-Methode an den Server gesendet. Wenn der angeforderte Vorgang abgeschlossen wurde, wird ein FtpWebResponse-Objekt zurückgegeben. Das FtpWebResponse-Objekt stellt den Status des Vorgangs und ggf. vom Server gedownloadete Daten bereit.

Mithilfe der ReadWriteTimeout-Eigenschaft können Sie einen Timeoutwert zum Lesen vom oder Schreiben auf den Server festlegen. Wenn der Timeout überschritten wurde, wird durch den Aufruf der Methode eine WebException ausgelöst, wobei WebExceptionStatus auf Timeout festgelegt ist.

Beim Downloaden einer Datei von einem FTP-Server ist der Inhalt der angeforderten Datei im Stream des Antwortobjekts verfügbar, sofern der Befehl erfolgreich ausgeführt wurde. Sie können auf diesen Stream zugreifen, indem Sie die GetResponseStream-Methode aufrufen. Weitere Informationen finden Sie unter FtpWebResponse.

Wenn die Proxy-Eigenschaft direkt oder in einer Konfigurationsdatei festgelegt wurde, erfolgt die Kommunikation mit dem FTP-Server über den angegebenen Proxy. Wenn der angegebene Proxy ein HTTP-Proxy ist, werden nur der DownloadFile-Befehl, der ListDirectory-Befehl und der ListDirectoryDetails-Befehl unterstützt.

Nur gedownloadeter binärer Inhalt wird zwischengespeichert, also Inhalt, der mithilfe des DownloadFile-Befehls empfangen wurde, wenn die UseBinary-Eigenschaft auf true festgelegt ist.

Mehrere FtpWebRequest verwenden vorhandene Verbindungen erneut, sofern möglich.

Weitere Informationen über das FTP-Protokoll finden Sie in RFC 959 "File Transfer Protocol", verfügbar unter http://www.rfc-editor.org/.

Im folgenden Codebeispiel wird das Löschen einer Datei von einem FTP-Server veranschaulicht.

public static bool DeleteFileOnServer(Uri serverUri)
{
    // The serverUri parameter should use the ftp:// scheme.
    // It contains the name of the server file that is to be deleted.
    // Example: ftp://contoso.com/someFile.txt.
    // 
    
    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUri);
    request.Method = WebRequestMethods.Ftp.DeleteFile;
 
    FtpWebResponse response = (FtpWebResponse) request.GetResponse();
    Console.WriteLine("Delete status: {0}",response.StatusDescription);  
    response.Close();
    return true;
}

Im folgenden Codebeispiel wird das Downloaden einer Datei von einem FTP-Server mithilfe der WebClient-Klasse veranschaulicht.

public static bool DisplayFileFromServer(Uri serverUri)
{
    // The serverUri parameter should start with the ftp:// scheme.
    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    WebClient request = new WebClient();
    
    // This example assumes the FTP site uses anonymous logon.
    request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");
    try 
    {
        byte [] newFileData = request.DownloadData (serverUri.ToString());
        string fileString = System.Text.Encoding.UTF8.GetString(newFileData);
        Console.WriteLine(fileString);
    }
    catch (WebException e)
    {
        Console.WriteLine(e.ToString());
    }
    return true;
}

Im folgenden Codebeispiel wird die Verwendung asynchroner Vorgänge zum Uploaden einer Datei auf einen FTP-Server veranschaulicht.

using System;
using System.Net;
using System.Threading;

using System.IO;
namespace Examples.System.Net
{
    public class FtpState
    {
        private ManualResetEvent wait;
        private FtpWebRequest request;
        private string fileName;
        private Exception operationException = null;
        string status;
        
        public FtpState()
        {
            wait = new ManualResetEvent(false);
        }
        
        public ManualResetEvent OperationComplete
        {
            get {return wait;}
        }
        
        public FtpWebRequest Request
        {
            get {return request;}
            set {request = value;}
        }
        
        public string FileName
        {
            get {return fileName;}
            set {fileName = value;}
        }
        public Exception OperationException
        {
            get {return operationException;}
            set {operationException = value;}
        }
        public string StatusDescription
        {
            get {return status;}
            set {status = value;}
        }
    }
    public class AsynchronousFtpUpLoader
    {  
        // Command line arguments are two strings:
        // 1. The url that is the name of the file being uploaded to the server.
        // 2. The name of the file on the local machine.
        //
        public static void Main(string[] args)
        {
            // Create a Uri instance with the specified URI string.
            // If the URI is not correctly formed, the Uri constructor
            // will throw an exception.
            ManualResetEvent waitObject;
            
            Uri target = new Uri (args[0]);
            string fileName = args[1];
            FtpState state = new FtpState();
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(target);
            request.Method = WebRequestMethods.Ftp.UploadFile;
            
            // This example uses anonymous logon.
            // The request is anonymous by default; the credential does not have to be specified. 
            // The example specifies the credential only to
            // control how actions are logged on the server.
            
            request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");
            
            // Store the request in the object that we pass into the
            // asynchronous operations.
            state.Request = request;
            state.FileName = fileName;
            
            // Get the event to wait on.
            waitObject = state.OperationComplete;
            
            // Asynchronously get the stream for the file contents.
            request.BeginGetRequestStream(
                new AsyncCallback (EndGetStreamCallback), 
                state
            );
            
            // Block the current thread until all operations are complete.
            waitObject.WaitOne();
            
            // The operations either completed or threw an exception.
            if (state.OperationException != null)
            {
                throw state.OperationException;
            }
            else
            {
                Console.WriteLine("The operation completed - {0}", state.StatusDescription);
            }
        }
        private static void EndGetStreamCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;
            
            Stream requestStream = null;
            // End the asynchronous call to get the request stream.
            try
            {
                requestStream = state.Request.EndGetRequestStream(ar);
                // Copy the file contents to the request stream.
                const int bufferLength = 2048;
                byte[] buffer = new byte[bufferLength];
                int count = 0;
                int readBytes = 0;
                FileStream stream = File.OpenRead(state.FileName);
                do
                {
                    readBytes = stream.Read(buffer, 0, bufferLength);
                    requestStream.Write(buffer, 0, readBytes);
                    count += readBytes;
                }
                while (readBytes != 0);
                Console.WriteLine ("Writing {0} bytes to the stream.", count);
                // IMPORTANT: Close the request stream before sending the request.
                requestStream.Close();
                // Asynchronously get the response to the upload request.
                state.Request.BeginGetResponse(
                    new AsyncCallback (EndGetResponseCallback), 
                    state
                );
            } 
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine("Could not get the request stream.");
                state.OperationException = e;
                state.OperationComplete.Set();
                return;
            }
           
        }
        
        // The EndGetResponseCallback method  
        // completes a call to BeginGetResponse.
        private static void EndGetResponseCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;
            FtpWebResponse response = null;
            try 
            {
                response = (FtpWebResponse) state.Request.EndGetResponse(ar);
                response.Close();
                state.StatusDescription = response.StatusDescription;
                // Signal the main application thread that 
                // the operation is complete.
                state.OperationComplete.Set();
            }
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine ("Error getting response.");
                state.OperationException = e;
                state.OperationComplete.Set();
            }
        }
    }
}

  • WebPermission  für den Zugriff auf die Ressource, auf die durch diese Anforderung verwiesen wird. Zugeordnete Enumeration: Connect

System.Object
   System.MarshalByRefObject
     System.Net.WebRequest
      System.Net.FtpWebRequest

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

.NET Framework

Unterstützt in: 2.0
Anzeigen:
© 2014 Microsoft