FtpWebRequest Klasse

Referenz

Definition

Namespace:: System.Net

Assembly:: System.Net.Requests.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Quelle:: FtpWebRequest.cs

Quelle:: FtpWebRequest.cs

Quelle:: FtpWebRequest.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Implementiert einen FTP (File Transfer Protocol)-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: Object

MarshalByRefObject

WebRequest
FtpWebRequest

Beispiele

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

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 mithilfe der WebClient -Klasse veranschaulicht.

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;
}

Das folgende Codebeispiel veranschaulicht die Verwendung asynchroner Vorgänge zum Hochladen einer Datei auf einen 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 Neuentwicklung zu verwenden. Weitere Informationen und Alternativen zu FtpWebRequestfinden Sie unter WebRequest sollte nicht auf GitHub verwendet werden.

Verwenden Sie die Create -Methode, um eine Instanz von FtpWebRequestabzurufen. Sie können die WebClient -Klasse auch verwenden, um Informationen von einem FTP-Server hoch- und herunterzuladen. Wenn Sie mithilfe eines dieser Ansätze eine Netzwerkressource angeben, die das FTP-Schema verwendet (z. B. ), bietet die FtpWebRequest -Klasse die Möglichkeit, "ftp://contoso.com"programmgesteuert mit FTP-Servern zu interagieren.

Der URI kann relativ oder absolut sein. Wenn der URI das Format "ftp://contoso.com/%2fpath" hat (%2f ist ein Escapezeichen '/'), ist der URI absolut, und das aktuelle Verzeichnis ist /path. Wenn der URI jedoch das Format "ftp://contoso.com/path"hat, meldet sich zuerst .NET Framework beim FTP-Server an (unter Verwendung des benutzernamens und kennworts, die von der Credentials -Eigenschaft festgelegt werden), dann wird das aktuelle Verzeichnis auf <UserLoginDirectory>/pathfestgelegt.

Sie benötigen einen gültigen Benutzernamen und ein gültiges Kennwort für den Server, oder der Server muss die anonyme Anmeldung zulassen. Sie können die Anmeldeinformationen angeben, die zum Herstellen einer Verbindung mit dem Server verwendet werden, indem Sie die Credentials -Eigenschaft festlegen, oder Sie können sie in den UserInfo Teil des URI einschließen, der an die Create -Methode übergeben wird. Wenn Sie Informationen in den URI einschließen UserInfo , wird die Credentials -Eigenschaft auf neue Netzwerkanmeldeinformationen mit dem angegebenen Benutzernamen und den angegebenen Kennwortinformationen festgelegt.

Achtung

Sofern die EnableSsl Eigenschaft nicht lautet true, werden alle Daten und Befehle, einschließlich Ihres Benutzernamens und Ihrer Kennwortinformationen, in Klartext an den Server gesendet. Jede Person, die den Netzwerkdatenverkehr überwacht, kann Ihre Anmeldeinformationen sehen 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, sollten Sie auf truefestlegenEnableSsl.

Sie müssen WebPermission auf die FTP-Ressource zugreifen. Andernfalls wird eine SecurityException Ausnahme ausgelöst.

Geben Sie den FTP-Befehl an, der an den Server gesendet werden soll, indem Sie die Method -Eigenschaft auf einen in der -Struktur definierten WebRequestMethods.Ftp Wert festlegen. Um Textdaten zu übertragen, ändern Sie die UseBinary Eigenschaft von ihrem Standardwert (true) in false. Ausführliche Informationen und Einschränkungen finden Sie unter Method.

Wenn Sie ein FtpWebRequest -Objekt zum Hochladen einer Datei auf einen Server verwenden, müssen Sie den Dateiinhalt in den Anforderungsdatenstrom schreiben, der durch Aufrufen der -Methode oder ihrer GetRequestStream asynchronen Entsprechungen, der -Methode und EndGetRequestStream der BeginGetRequestStream -Methode abgerufen wurde. Sie müssen in den Stream schreiben und den Stream schließen, bevor Sie die Anforderung senden.

Anforderungen werden an den Server gesendet, indem die -Methode oder ihre GetResponse asynchronen Entsprechungen, die BeginGetResponse Methoden und EndGetResponse aufgerufen werden. Wenn der angeforderte Vorgang abgeschlossen ist, wird ein FtpWebResponse -Objekt zurückgegeben. Das FtpWebResponse -Objekt stellt den Status des Vorgangs und alle vom Server heruntergeladenen Daten bereit.

Sie können einen Timeoutwert für lese- oder schreibvorgänge auf dem Server festlegen, indem Sie die ReadWriteTimeout -Eigenschaft verwenden. Wenn der Timeoutzeitraum überschritten wird, löst die aufrufende Methode eine WebException mit WebExceptionStatus auf Timeoutfestgelegt aus.

Wenn der Befehl erfolgreich war, stehen beim Herunterladen einer Datei von einem FTP-Server die Inhalte der angeforderten Datei im Datenstrom des Antwortobjekts zur Verfügung. Sie können auf diesen Stream zugreifen, indem Sie die GetResponseStream -Methode aufrufen. Weitere Informationen finden Sie unter FtpWebResponse.

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

Nur heruntergeladene binäre Inhalte werden zwischengespeichert. d. h. Inhalte, die mit dem DownloadFile Befehl empfangen werden, wobei die UseBinary -Eigenschaft auf truefestgelegt ist.

Mehrere FtpWebRequests können vorhandene Verbindungen nach Möglichkeit wiederverwenden.

Weitere Informationen zum FTP-Protokoll finden Sie unter 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. (Geerbt von WebRequest)
CachePolicy	Ruft die Cacherichtlinie für diese Anforderung ab oder legt diese fest. (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.
ConnectionGroupName	Ruft den Namen der Verbindungsgruppe ab, die den zum Senden der aktuellen Anforderung verwendeten Dienstpunkt enthält, oder legt diesen fest.
ContentLength	Ruft einen Wert ab, der von der FtpWebRequest-Klasse ignoriert wird, oder legt diesen fest.
ContentOffset	Ruft einen Byteoffset für die durch diese Anforderung heruntergeladene Datei ab oder legt diesen fest.
ContentType	Löst immer eine NotSupportedException aus.
CreatorInstance	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. (Geerbt von WebRequest)
Credentials	Ruft die für die Kommunikation mit dem FTP-Server verwendeten Anmeldeinformationen ab oder legt diese fest.
DefaultCachePolicy	Definiert die Standardcacherichtlinie für alle FTP-Anforderungen.
EnableSsl	Ruft einen Wert vom Typ Boolean ab, der angibt, dass eine SSL-Verbindung verwendet werden soll, oder legt diesen fest.
Headers	Ruft ein leeres WebHeaderCollection-Objekt ab.
ImpersonationLevel	Ruft die Ebene des Identitätswechsels für die aktuelle Anforderung ab oder legt diese fest. (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.
Method	Ruft den an den FTP-Server zu sendenden Befehl ab oder legt diesen fest.
PreAuthenticate	Löst immer eine NotSupportedException aus.
Proxy	Ruft den für die Kommunikation mit dem FTP-Server verwendeten Proxy ab oder legt diesen fest.
ReadWriteTimeout	Ruft ein Timeout für das Lesen aus einem Stream oder das Schreiben in einen Stream ab oder legt dieses fest.
RenameTo	Ruft den neuen Namen einer umbenannten Datei ab oder legt diesen fest.
RequestUri	Ruft den von dieser Instanz angeforderten URI ab.
ServicePoint	Ruft das ServicePoint-Objekt ab, das zum Herstellen der Verbindung mit dem FTP-Server verwendet wird.
Timeout	Ruft die Wartezeit in Millisekunden für eine Anforderung ab oder legt diese fest.
UseBinary	Ruft einen Boolean-Wert ab, der den Datentyp für Dateiübertragungen angibt, oder legt diesen fest.
UseDefaultCredentials	Löst immer eine NotSupportedException aus.
UsePassive	Ruft das Verhalten der Datenübertragung einer Clientanwendung ab oder legt dieses fest.

Methoden

Abort()	Beendet einen asynchronen FTP-Vorgang.
BeginGetRequestStream(AsyncCallback, Object)	Beginnt das asynchrone Öffnen des Inhaltsstreams einer Anforderung zum Schreiben.
BeginGetResponse(AsyncCallback, Object)	Beginnt mit dem asynchronen Senden einer Anforderung und Empfangen einer Antwort von einem FTP-Server.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
EndGetRequestStream(IAsyncResult)	Beendet einen ausstehenden Vorgang, der mit BeginGetRequestStream(AsyncCallback, Object) gestartet wurde.
EndGetResponse(IAsyncResult)	Beendet einen ausstehenden Vorgang, der mit BeginGetResponse(AsyncCallback, Object) gestartet wurde.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)	Veraltet. Füllt eine SerializationInfo mit den Daten auf, die zum Serialisieren des Zielobjekts erforderlich sind. (Geerbt von WebRequest)
GetRequestStream()	Ruft den Stream ab, der zum Hochladen von Daten auf einen FTP-Server verwendet wird.
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. (Geerbt von WebRequest)
GetResponse()	Gibt die FTP-Serverantwort zurück.
GetResponseAsync()	Gibt beim Überschreiben in einer Nachfolgerklasse in einem asynchronen Vorgang eine Antwort auf eine Internetanforderung zurück. (Geerbt von WebRequest)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Veraltet.

Füllt beim Überschreiben in einer Nachfolgerklasse eine SerializationInfo-Instanz mit den Daten auf, die zum Serialisieren der WebRequest erforderlich sind.

(Geerbt von WebRequest)

Gilt für:

Freigeben über