War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

FtpWebRequest-Klasse

Implementiert einen FTP (File Transfer Protocol)-Client.

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

public sealed class FtpWebRequest : WebRequest

Der FtpWebRequest-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche EigenschaftAuthenticationLevelRuft Werte ab, die die für diese Anforderung verwendete Ebene von Authentifizierung und Identitätswechsel angeben, oder legt diese fest. (Von WebRequest geerbt.)
Öffentliche EigenschaftCachePolicyRuft die Cacherichtlinie für diese Anforderung ab oder legt diese fest. (Von WebRequest geerbt.)
Öffentliche EigenschaftClientCertificatesRuft die Zertifikate ab, die für das Herstellen einer verschlüsselten Verbindung mit dem FTP-Server verwendet werden, oder legt sie fest.
Öffentliche EigenschaftConnectionGroupNameRuft den Namen der Verbindungsgruppe ab, die den zum Senden der aktuellen Anforderung verwendeten Dienstpunkt enthält, oder legt diesen fest. (Überschreibt WebRequest.ConnectionGroupName.)
Öffentliche EigenschaftContentLengthInfrastruktur. Ruft einen Wert ab, der von der FtpWebRequest-Klasse ignoriert wird, oder legt diesen fest. (Überschreibt WebRequest.ContentLength.)
Öffentliche EigenschaftContentOffsetRuft einen Byteoffset für die durch diese Anforderung heruntergeladene Datei ab oder legt diesen fest.
Öffentliche EigenschaftContentTypeInfrastruktur. Löst immer eine NotSupportedException aus. (Überschreibt WebRequest.ContentType.)
Öffentliche EigenschaftCreatorInstance Veraltet. Ruft beim Überschreiben in einer Nachfolgerklasse das von der IWebRequestCreate-Klasse abgeleitete Factoryobjekt ab. Mit dieser Klasse wird die WebRequest erstellt, die instanziiert wird, um die Anforderung an den angegebenen URI zu stellen. (Von WebRequest geerbt.)
Öffentliche EigenschaftCredentialsRuft die für die Kommunikation mit dem FTP-Server verwendeten Anmeldeinformationen ab oder legt diese fest. (Überschreibt WebRequest.Credentials.)
Öffentliche EigenschaftStatischer MemberDefaultCachePolicyDefiniert die Standardcacherichtlinie für alle FTP-Anforderungen.
Öffentliche EigenschaftEnableSslRuft einen Wert vom Typ Boolean ab, der angibt, dass eine SSL-Verbindung verwendet werden soll, oder legt diesen fest.
Öffentliche EigenschaftHeadersInfrastruktur. Ruft ein leeres WebHeaderCollection-Objekt ab. (Überschreibt WebRequest.Headers.)
Öffentliche EigenschaftImpersonationLevelRuft die Ebene des Identitätswechsels für die aktuelle Anforderung ab oder legt diese fest. (Von WebRequest geerbt.)
Öffentliche EigenschaftKeepAliveRuft einen Boolean-Wert ab, der angibt, ob die Steuerungsverbindung mit dem FTP-Server nach Abschluss der Anforderung geschlossen wird, oder legt diesen fest.
Öffentliche EigenschaftMethodRuft den an den FTP-Server zu sendenden Befehl ab oder legt diesen fest. (Überschreibt WebRequest.Method.)
Öffentliche EigenschaftPreAuthenticateInfrastruktur. Löst immer eine NotSupportedException aus. (Überschreibt WebRequest.PreAuthenticate.)
Öffentliche EigenschaftProxyRuft den für die Kommunikation mit dem FTP-Server verwendeten Proxy ab oder legt diesen fest. (Überschreibt WebRequest.Proxy.)
Öffentliche EigenschaftReadWriteTimeoutRuft ein Timeout für das Lesen aus einem Stream oder das Schreiben in einen Stream ab oder legt dieses fest.
Öffentliche EigenschaftRenameToRuft den neuen Namen einer umbenannten Datei ab oder legt diesen fest.
Öffentliche EigenschaftRequestUriRuft den von dieser Instanz angeforderten URI ab. (Überschreibt WebRequest.RequestUri.)
Öffentliche EigenschaftServicePointRuft das ServicePoint-Objekt ab, das zum Herstellen der Verbindung mit dem FTP-Server verwendet wird.
Öffentliche EigenschaftTimeoutRuft die Wartezeit in Millisekunden für eine Anforderung ab oder legt diese fest. (Überschreibt WebRequest.Timeout.)
Öffentliche EigenschaftUseBinaryRuft einen Boolean-Wert ab, der den Datentyp für Dateiübertragungen angibt, oder legt diesen fest.
Öffentliche EigenschaftUseDefaultCredentialsInfrastruktur. Löst immer eine NotSupportedException aus. (Überschreibt WebRequest.UseDefaultCredentials.)
Öffentliche EigenschaftUsePassiveRuft das Verhalten der Datenübertragung einer Clientanwendung ab oder legt dieses fest.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeAbortBeendet einen asynchrone FTP-Vorgang. (Überschreibt WebRequest.Abort().)
Öffentliche MethodeBeginGetRequestStreamBeginnt das asynchrone Öffnen des Inhaltsstreams einer Anforderung zum Schreiben. (Überschreibt WebRequest.BeginGetRequestStream(AsyncCallback, Object).)
Öffentliche MethodeBeginGetResponseBeginnt mit dem asynchronen Senden einer Anforderung und Empfangen einer Antwort von einem FTP-Server. (Überschreibt WebRequest.BeginGetResponse(AsyncCallback, Object).)
Öffentliche MethodeCreateObjRefErstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeEndGetRequestStreamBeendet einen ausstehenden Vorgang, der mit BeginGetRequestStream gestartet wurde. (Überschreibt WebRequest.EndGetRequestStream(IAsyncResult).)
Öffentliche MethodeEndGetResponseBeendet einen ausstehenden Vorgang, der mit BeginGetResponse gestartet wurde. (Überschreibt WebRequest.EndGetResponse(IAsyncResult).)
Öffentliche MethodeEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Öffentliche MethodeGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeGetLifetimeServiceRuft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeGetRequestStreamRuft den Stream ab, der zum Hochladen von Daten auf einen FTP-Server verwendet wird. (Überschreibt WebRequest.GetRequestStream().)
Öffentliche MethodeGetRequestStreamAsyncGibt nach dem Überschreiben in einer abgeleiteten Klasse einen Stream zurück, womit Daten in einem asynchronen Vorgang in die Internetressource geschrieben werden können. (Von WebRequest geerbt.)
Öffentliche MethodeGetResponseGibt die FTP-Serverantwort zurück. (Überschreibt WebRequest.GetResponse().)
Öffentliche MethodeGetResponseAsync Wenn diese Methode in einer abgeleiteten Klasse überschrieben wird, gibt Sie eine Antwort auf einen Request als asynchronen Vorgang zurück. (Von WebRequest geerbt.)
Öffentliche MethodeGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeInitializeLifetimeServiceRuft ein Lebensdauerdienstobjekt ab, mit dem die Lebensdauerrichtlinien für diese Instanz gesteuert werden können. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeISerializable.GetObjectDataInfrastruktur. Füllt beim Überschreiben in einer Nachfolgerklasse eine SerializationInfo-Instanz mit den Daten auf, die zum Serialisieren der WebRequest erforderlich sind. (Von WebRequest geerbt.)
Zum Seitenanfang

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 hochzuladen oder von einem FTP-Server herunterzuladen. 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.

WarnhinweisVorsicht

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 Hochladen 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 heruntergeladene 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 Herunterladen 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 heruntergeladener 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 Herunterladen 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 Hochladen 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();
            }
        }
    }
}


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

  • WebPermission 

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

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

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

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

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft