FtpWebRequest Klasse

Definition

Implementiert einen FTP (File Transfer Protocol)-Client.Implements a File Transfer Protocol (FTP) client.

public ref class FtpWebRequest sealed : System::Net::WebRequest
public sealed class FtpWebRequest : System.Net.WebRequest
type FtpWebRequest = class
    inherit WebRequest
Public NotInheritable Class FtpWebRequest
Inherits WebRequest
Vererbung

Beispiele

Im folgenden Codebeispiel wird das Löschen einer Datei von einem FTP-Server veranschaulicht.The following code example demonstrates deleting a file from an FTP server.

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 = dynamic_cast<FtpWebRequest^>(WebRequest::Create( serverUri ));
   request->Method = WebRequestMethods::Ftp::DeleteFile;
   FtpWebResponse^ response = dynamic_cast<FtpWebResponse^>(request->GetResponse());
   Console::WriteLine( "Delete status: {0}", response->StatusDescription );
   response->Close();
   return true;
}
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 WebClient mithilfe der-Klasse veranschaulicht.The following code example demonstrates downloading a file from an FTP server by using the WebClient class.

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 = gcnew WebClient;

   // This example assumes the FTP site uses anonymous logon.
   request->Credentials = gcnew NetworkCredential( "anonymous","janeDoe@contoso.com" );
   try
   {
      array<Byte>^newFileData = request->DownloadData( serverUri->ToString() );
      String^ fileString = System::Text::Encoding::UTF8->GetString( newFileData );
      Console::WriteLine( fileString );
   }
   catch ( WebException^ e ) 
   {
      Console::WriteLine( e );
   }

   return true;
}
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 veranschaulicht, wie asynchrone Vorgänge verwendet werden, um eine Datei auf einen FTP-Server hochzuladen.The following code example demonstrates using asynchronous operations to upload a file to an FTP server.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Threading;
using namespace System::IO;

public ref class FtpState
{
private:
   ManualResetEvent^ wait;
   FtpWebRequest^ request;
   String^ fileName;
   Exception^ operationException;
   String^ status;

public:
   FtpState()
   {
      wait = gcnew ManualResetEvent( false );
   }

   property ManualResetEvent^ OperationComplete 
   {
      ManualResetEvent^ get()
      {
         return wait;
      }

   }

   property FtpWebRequest^ Request 
   {
      FtpWebRequest^ get()
      {
         return request;
      }

      void set( FtpWebRequest^ value )
      {
         request = value;
      }

   }

   property String^ FileName 
   {
      String^ get()
      {
         return fileName;
      }

      void set( String^ value )
      {
         fileName = value;
      }

   }

   property Exception^ OperationException 
   {
      Exception^ get()
      {
         return operationException;
      }

      void set( Exception^ value )
      {
         operationException = value;
      }

   }

   property String^ StatusDescription 
   {
      String^ get()
      {
         return status;
      }

      void set( String^ value )
      {
         status = value;
      }

   }
};

public ref class AsynchronousFtpUpLoader
{
public:

   // 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.
   //
   static void Main()
   {
      array<String^>^args = Environment::GetCommandLineArgs();

      // 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 = gcnew Uri( args[ 1 ] );
      String^ fileName = args[ 2 ];
      FtpState^ state = gcnew FtpState;
      FtpWebRequest ^ request = dynamic_cast<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 = gcnew 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( gcnew 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 != nullptr )
      {
         throw state->OperationException;
      }
      else
      {
         Console::WriteLine( "The operation completed - {0}", state->StatusDescription );
      }
   }

private:
   static void EndGetStreamCallback( IAsyncResult^ ar )
   {
      FtpState^ state = dynamic_cast<FtpState^>(ar->AsyncState);
      Stream^ requestStream = nullptr;

      // 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;
         array<Byte>^buffer = gcnew array<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, bufferLength );
            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( gcnew 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.
   static void EndGetResponseCallback( IAsyncResult^ ar )
   {
      FtpState^ state = dynamic_cast<FtpState^>(ar->AsyncState);
      FtpWebResponse ^ response = nullptr;
      try
      {
         response = dynamic_cast<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();
      }
   }
};

int main()
{
   AsynchronousFtpUpLoader::Main();
}
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();
            }
        }
    }
}

Hinweise

Wichtig

Es wird nicht empfohlen, die- FtpWebRequest Klasse für die neue Entwicklung zu verwenden.We don't recommend that you use the FtpWebRequest class for new development. Weitere Informationen und Alternativen zu finden FtpWebRequestSie unter WebRequest sollte nicht auf GitHub verwendet werden.For more information and alternatives to FtpWebRequest, see WebRequest shouldn't be used on GitHub.

Verwenden Sie die Create -Methode FtpWebRequest, um eine Instanz von zu erhalten.To obtain an instance of FtpWebRequest, use the Create method. Sie können auch die WebClient -Klasse verwenden, um Informationen von einem FTP-Server hochzuladen und herunterzuladen.You can also use the WebClient class to upload and download information from an FTP server. Wenn Sie eine dieser Vorgehensweisen angeben und eine Netzwerkressource angeben, die das FTP-Schema verwendet (z "ftp://contoso.com". b FtpWebRequest .), bietet die-Klasse die Möglichkeit, Programm gesteuert mit FTP-Servern zu interagieren.Using either of these approaches, when you specify a network resource that uses the FTP scheme (for example, "ftp://contoso.com") the FtpWebRequest class provides the ability to programmatically interact with FTP servers.

Der URI kann relativ oder absolut sein.The URI may be relative or absolute. Wenn der URI das "ftp://contoso.com/%2fpath" Format hat (% 2F ist eine Escapezeichen "/"), ist der URI absolut, und das aktuelle Verzeichnis ist. /pathIf the URI is of the form "ftp://contoso.com/%2fpath" (%2f is an escaped '/'), then the URI is absolute, and the current directory is /path. Wenn der URI jedoch das "ftp://contoso.com/path"Format hat, meldet sich der .NET Framework zuerst beim FTP-Server an (mit dem Benutzernamen und dem Kennwort, die von der Credentials -Eigenschaft festgelegt werden), dann <UserLoginDirectory>/pathwird das aktuelle Verzeichnis auf festgelegt.If, however, the URI is of the form "ftp://contoso.com/path", first the .NET Framework logs into the FTP server (using the user name and password set by the Credentials property), then the current directory is set to <UserLoginDirectory>/path.

Sie müssen über einen gültigen Benutzernamen und ein Kennwort für den Server verfügen, oder der Server muss die anonyme Anmeldung zulassen.You must have a valid user name and password for the server or the server must allow anonymous logon. Sie können die Anmelde Informationen zum Herstellen einer Verbindung mit dem Server angeben, Credentials indem Sie die-Eigenschaft festlegen, oder UserInfo Sie können Sie in den Teil des Create URIs einschließen, der an die-Methode übermittelt wird.You can specify the credentials used to connect to the server by setting the Credentials property or you can include them in the UserInfo portion of the URI passed to the Create method. Wenn Sie Informationen UserInfo in den URI einschließen, wird Credentials die Eigenschaft auf neue Netzwerk Anmelde Informationen mit dem angegebenen Benutzernamen und Kenn Wort Informationen festgelegt.If you include UserInfo information in the URI, the Credentials property is set to a new network credential with the specified user name and password information.

Achtung

Sofern die EnableSsl -Eigenschaft truenicht ist, werden alle Daten und Befehle, einschließlich des Benutzernamens und der Kenn Wort Informationen, als Klartext an den Server gesendet.Unless the EnableSsl property is true, all data and commands, including your user name and password information, are sent to the server in clear text. Personen, die den Netzwerk Datenverkehr überwachen, können Ihre Anmelde Informationen anzeigen und zum Herstellen der Verbindung mit dem Server verwendenAnyone monitoring network traffic can view your credentials and use them to connect to the server. Wenn Sie eine Verbindung mit einem FTP-Server herstellen, für den Anmelde Informationen erforderlich sind, und Secure Sockets Layer ( EnableSsl SSL true) unterstützt, sollten Sie auf festlegen.If you are connecting to an FTP server that requires credentials and supports Secure Sockets Layer (SSL), you should set EnableSsl to true.

Sie müssen WebPermission auf die FTP-Ressource zugreifen müssen. andernfalls wird SecurityException eine-Ausnahme ausgelöst.You must have WebPermission to access the FTP resource; otherwise, a SecurityException exception is thrown.

Geben Sie den an den Server zu sendenden FTP-Befehl Method an, indem Sie die-Eigenschaft WebRequestMethods.Ftp auf einen in der-Struktur definierten Wert festlegen.Specify the FTP command to send to the server by setting the Method property to a value defined in the WebRequestMethods.Ftp structure. Um Textdaten zu übertragen, UseBinary ändern Sie die-Eigenschaft vontrueIhrem Standard falseWert () in.To transmit text data, change the UseBinary property from its default value (true) to false. Weitere Informationen und Einschränkungen finden MethodSie unter.For details and restrictions, see Method.

Wenn Sie ein FtpWebRequest -Objekt verwenden, um eine Datei auf einen Server hochzuladen, müssen Sie den Dateiinhalt in den Anforderungs Datenstrom GetRequestStream schreiben, der durch Aufrufen der-Methode oder BeginGetRequestStream seiner EndGetRequestStream asynchronen Entsprechungen abgerufen wurde, die-und-Methoden.When using an FtpWebRequest object to upload a file to a server, you must write the file content to the request stream obtained by calling the GetRequestStream method or its asynchronous counterparts, the BeginGetRequestStream and EndGetRequestStream methods. Sie müssen in den Stream schreiben und den Stream schließen, bevor Sie die Anforderung senden.You must write to the stream and close the stream before sending the request.

Anforderungen werden durch Aufrufen der GetResponse -Methode oder der asynchronen Entsprechungen, der BeginGetResponse -Methode und EndGetResponse der-Methode an den Server gesendet.Requests are sent to the server by calling the GetResponse method or its asynchronous counterparts, the BeginGetResponse and EndGetResponse methods. Wenn der angeforderte Vorgang abgeschlossen ist FtpWebResponse , wird ein Objekt zurückgegeben.When the requested operation completes, an FtpWebResponse object is returned. Das FtpWebResponse -Objekt stellt den Status des Vorgangs und alle Daten bereit, die vom Server heruntergeladen werden.The FtpWebResponse object provides the status of the operation and any data downloaded from the server.

Mithilfe der ReadWriteTimeout -Eigenschaft können Sie einen Timeout Wert für das Lesen oder schreiben auf den Server festlegen.You can set a time-out value for reading or writing to the server by using the ReadWriteTimeout property. Wenn der Timeout Zeitraum überschritten wird, löst die Aufruf Methode eine WebException aus, bei WebExceptionStatus der Timeoutauf festgelegt ist.If the time-out period is exceeded, the calling method throws a WebException with WebExceptionStatus set to Timeout.

Beim Herunterladen einer Datei von einem FTP-Server ist der Inhalt der angeforderten Datei im Stream des Antwort Objekts verfügbar, wenn der Befehl erfolgreich ausgeführt wurde.When downloading a file from an FTP server, if the command was successful, the contents of the requested file are available in the response object's stream. Sie können auf diesen Stream zugreifen, indem GetResponseStream Sie die-Methode aufrufen.You can access this stream by calling the GetResponseStream method. Weitere Informationen finden Sie unter FtpWebResponse.For more information, see FtpWebResponse.

Wenn die Proxy Eigenschaft entweder direkt oder in einer Konfigurationsdatei festgelegt wird, erfolgt die Kommunikation mit dem FTP-Server über den angegebenen Proxy.If the Proxy property is set, either directly or in a configuration file, communications with the FTP server are made through the specified proxy. Wenn der angegebene Proxy ein HTTP-Proxy ist, werden DownloadFilenur ListDirectorydie Befehle ListDirectoryDetails , und unterstützt.If the specified proxy is an HTTP proxy, only the DownloadFile, ListDirectory, and ListDirectoryDetails commands are supported.

Nur heruntergeladener binärer Inhalt wird zwischengespeichert. Das heißt, dass Inhalt mithilfe des DownloadFile -Befehls empfangen UseBinary wird und die true-Eigenschaft auf festgelegt ist.Only downloaded binary content is cached; that is, content received using the DownloadFile command with the UseBinary property set to true.

Mehrere FtpWebRequests wieder verwenden vorhandene Verbindungen, wenn möglich.Multiple FtpWebRequests reuse existing connections, if possible.

Weitere Informationen zum FTP-Protokoll finden Sie unter RFC 959: Dateiübertragungsprotokoll.For more information about the FTP protocol, see RFC 959: File Transfer Protocol.

Eigenschaften

AuthenticationLevel

Ruft Werte ab, die die für diese Anforderung verwendete Ebene von Authentifizierung und Identitätswechsel angeben, oder legt diese fest.Gets or sets values indicating the level of authentication and impersonation used for this request.

(Geerbt von WebRequest)
CachePolicy

Ruft die Cacherichtlinie für diese Anforderung ab oder legt diese fest.Gets or sets the cache policy for this request.

(Geerbt von WebRequest)
ClientCertificates

Ruft die Zertifikate ab, die für das Herstellen einer verschlüsselten Verbindung mit dem FTP-Server verwendet werden, oder legt sie fest.Gets or sets the certificates used for establishing an encrypted connection to the FTP server.

ConnectionGroupName

Ruft den Namen der Verbindungsgruppe ab, die den zum Senden der aktuellen Anforderung verwendeten Dienstpunkt enthält, oder legt diesen fest.Gets or sets the name of the connection group that contains the service point used to send the current request.

ContentLength

Ruft einen Wert ab, der von der FtpWebRequest-Klasse ignoriert wird, oder legt diesen fest.Gets or sets a value that is ignored by the FtpWebRequest class.

ContentOffset

Ruft einen Byteoffset für die durch diese Anforderung heruntergeladene Datei ab oder legt diesen fest.Gets or sets a byte offset into the file being downloaded by this request.

ContentType

Löst immer eine NotSupportedException aus.Always throws a NotSupportedException.

CreatorInstance

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.When overridden in a descendant class, gets the factory object derived from the IWebRequestCreate class used to create the WebRequest instantiated for making the request to the specified URI.

(Geerbt von WebRequest)
Credentials

Ruft die für die Kommunikation mit dem FTP-Server verwendeten Anmeldeinformationen ab oder legt diese fest.Gets or sets the credentials used to communicate with the FTP server.

DefaultCachePolicy

Definiert die Standardcacherichtlinie für alle FTP-Anforderungen.Defines the default cache policy for all FTP requests.

EnableSsl

Ruft einen Wert vom Typ Boolean ab, der angibt, dass eine SSL-Verbindung verwendet werden soll, oder legt diesen fest.Gets or sets a Boolean that specifies that an SSL connection should be used.

Headers

Ruft ein leeres WebHeaderCollection-Objekt ab.Gets an empty WebHeaderCollection object.

ImpersonationLevel

Ruft die Ebene des Identitätswechsels für die aktuelle Anforderung ab oder legt diese fest.Gets or sets the impersonation level for the current request.

(Geerbt von WebRequest)
KeepAlive

Ruft einen Boolean-Wert ab, der angibt, ob die Steuerungsverbindung mit dem FTP-Server nach Abschluss der Anforderung geschlossen wird, oder legt diesen fest.Gets or sets a Boolean value that specifies whether the control connection to the FTP server is closed after the request completes.

Method

Ruft den an den FTP-Server zu sendenden Befehl ab oder legt diesen fest.Gets or sets the command to send to the FTP server.

PreAuthenticate

Löst immer eine NotSupportedException aus.Always throws a NotSupportedException.

Proxy

Ruft den für die Kommunikation mit dem FTP-Server verwendeten Proxy ab oder legt diesen fest.Gets or sets the proxy used to communicate with the FTP server.

ReadWriteTimeout

Ruft ein Timeout für das Lesen aus einem Stream oder das Schreiben in einen Stream ab oder legt dieses fest.Gets or sets a time-out when reading from or writing to a stream.

RenameTo

Ruft den neuen Namen einer umbenannten Datei ab oder legt diesen fest.Gets or sets the new name of a file being renamed.

RequestUri

Ruft den von dieser Instanz angeforderten URI ab.Gets the URI requested by this instance.

ServicePoint

Ruft das ServicePoint-Objekt ab, das zum Herstellen der Verbindung mit dem FTP-Server verwendet wird.Gets the ServicePoint object used to connect to the FTP server.

Timeout

Ruft die Wartezeit in Millisekunden für eine Anforderung ab oder legt diese fest.Gets or sets the number of milliseconds to wait for a request.

UseBinary

Ruft einen Boolean-Wert ab, der den Datentyp für Dateiübertragungen angibt, oder legt diesen fest.Gets or sets a Boolean value that specifies the data type for file transfers.

UseDefaultCredentials

Löst immer eine NotSupportedException aus.Always throws a NotSupportedException.

UsePassive

Ruft das Verhalten der Datenübertragung einer Clientanwendung ab oder legt dieses fest.Gets or sets the behavior of a client application's data transfer process.

Methoden

Abort()

Beendet einen asynchronen FTP-Vorgang.Terminates an asynchronous FTP operation.

BeginGetRequestStream(AsyncCallback, Object)

Beginnt das asynchrone Öffnen des Inhaltsstreams einer Anforderung zum Schreiben.Begins asynchronously opening a request's content stream for writing.

BeginGetResponse(AsyncCallback, Object)

Beginnt mit dem asynchronen Senden einer Anforderung und Empfangen einer Antwort von einem FTP-Server.Begins sending a request and receiving a response from an FTP server asynchronously.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
EndGetRequestStream(IAsyncResult)

Beendet einen ausstehenden Vorgang, der mit BeginGetRequestStream(AsyncCallback, Object) gestartet wurde.Ends a pending asynchronous operation started with BeginGetRequestStream(AsyncCallback, Object).

EndGetResponse(IAsyncResult)

Beendet einen ausstehenden Vorgang, der mit BeginGetResponse(AsyncCallback, Object) gestartet wurde.Ends a pending asynchronous operation started with BeginGetResponse(AsyncCallback, Object).

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)

Füllt eine SerializationInfo mit den Daten auf, die zum Serialisieren des Zielobjekts erforderlich sind.Populates a SerializationInfo with the data needed to serialize the target object.

(Geerbt von WebRequest)
GetRequestStream()

Ruft den Stream ab, der zum Hochladen von Daten auf einen FTP-Server verwendet wird.Retrieves the stream used to upload data to an FTP server.

GetRequestStreamAsync()

Gibt nach dem Überschreiben in einer abgeleiteten Klasse einen Stream zurück, womit Daten in einem asynchronen Vorgang in die Internetressource geschrieben werden können.When overridden in a descendant class, returns a Stream for writing data to the Internet resource as an asynchronous operation.

(Geerbt von WebRequest)
GetResponse()

Gibt die FTP-Serverantwort zurück.Returns the FTP server response.

GetResponseAsync()

Gibt beim Überschreiben in einer Nachfolgerklasse in einem asynchronen Vorgang eine Antwort auf eine Internetanforderung zurück.When overridden in a descendant class, returns a response to an Internet request as an asynchronous operation.

(Geerbt von WebRequest)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Geerbt von MarshalByRefObject)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt beim Überschreiben in einer Nachfolgerklasse eine SerializationInfo-Instanz mit den Daten auf, die zum Serialisieren der WebRequest erforderlich sind.When overridden in a descendant class, populates a SerializationInfo instance with the data needed to serialize the WebRequest.

(Geerbt von WebRequest)

Sicherheit

WebPermission
für den Zugriff auf die Ressource, auf die diese Anforderung verweist.for accessing the resource referenced by this request. Zugeordnete Enumeration: ConnectAssociated enumeration: Connect.

Gilt für:

Siehe auch