FtpWebRequest Třída

Definice

Implementuje klienta protokol FTP (File Transfer Protocol) (FTP).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
Dědičnost

Příklady

Následující příklad kódu ukazuje odstranění souboru ze serveru FTP.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;
}

Následující příklad kódu ukazuje, jak stáhnout soubor ze serveru FTP pomocí WebClient třídy.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;
}

Následující příklad kódu ukazuje použití asynchronních operací pro nahrání souboru na server FTP.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();
            }
        }
    }
}

Poznámky

Důležité

Nedoporučujeme používat FtpWebRequest pro nový vývoj třídu.We don't recommend that you use the FtpWebRequest class for new development. Další informace a alternativy k nástroji FtpWebRequest naleznete v tématu WebRequest by se na GitHubu použít neměl.For more information and alternatives to FtpWebRequest, see WebRequest shouldn't be used on GitHub.

Chcete-li získat instanci FtpWebRequest , použijte Create metodu.To obtain an instance of FtpWebRequest, use the Create method. Můžete také použít WebClient třídu k nahrání a stažení informací ze serveru FTP.You can also use the WebClient class to upload and download information from an FTP server. Při použití některého z těchto přístupů se při zadávání síťového prostředku, který používá schéma FTP (například "ftp://contoso.com" ), FtpWebRequest poskytuje schopnost programově pracovat se servery FTP.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.

Identifikátor URI může být relativní nebo absolutní.The URI may be relative or absolute. Pokud má identifikátor URI formu "ftp://contoso.com/%2fpath" (% 2F je řídicí znak "/"), pak je identifikátor URI absolutní a aktuální adresář je /path .If 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. Pokud je však identifikátor URI formuláře "ftp://contoso.com/path" , nejprve se .NET Framework přihlásí k serveru FTP (pomocí uživatelského jména a hesla nastaveného Credentials vlastností), přičemž aktuální adresář je nastaven na hodnotu <UserLoginDirectory>/path .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.

Musíte mít platné uživatelské jméno a heslo pro server nebo server musí umožňovat anonymní přihlášení.You must have a valid user name and password for the server or the server must allow anonymous logon. Můžete zadat pověření používaná k připojení k serveru nastavením Credentials vlastnosti nebo je můžete zahrnout do UserInfo části identifikátoru URI předaného Create metodě.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. Pokud UserInfo do identifikátoru URI zahrnete informace, Credentials nastaví se tato vlastnost na nové síťové přihlašovací údaje se zadaným uživatelským jménem a heslem.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.

Upozornění

Pokud EnableSsl se nejedná o vlastnost true , všechna data a příkazy, včetně vašeho uživatelského jména a hesla, se odešlou na server v prostém textu.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. Kdokoli, kdo sleduje síťový provoz, může zobrazit vaše přihlašovací údaje a použít je k připojení k serveru.Anyone monitoring network traffic can view your credentials and use them to connect to the server. Pokud se připojujete k serveru FTP, který vyžaduje přihlašovací údaje a podporuje SSL (Secure Sockets Layer) (SSL), měli byste nastavit EnableSsl na true .If you are connecting to an FTP server that requires credentials and supports Secure Sockets Layer (SSL), you should set EnableSsl to true.

Musíte mít WebPermission přístup k prostředku FTP; v opačném případě SecurityException je vyvolána výjimka.You must have WebPermission to access the FTP resource; otherwise, a SecurityException exception is thrown.

Určete příkaz FTP pro odeslání na server nastavením Method vlastnosti na hodnotu definovanou ve WebRequestMethods.Ftp struktuře.Specify the FTP command to send to the server by setting the Method property to a value defined in the WebRequestMethods.Ftp structure. Chcete-li přenést textová data, změňte UseBinary vlastnost z výchozí hodnoty ( true ) na false .To transmit text data, change the UseBinary property from its default value (true) to false. Podrobnosti a omezení najdete v tématu Method .For details and restrictions, see Method.

Při použití FtpWebRequest objektu k nahrání souboru na server, je nutné zapsat obsah souboru do datového proudu požadavků, který byl získán voláním GetRequestStream metody nebo jejích asynchronních protějšků, BeginGetRequestStream metod a EndGetRequestStream .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. Před odesláním žádosti musíte zapsat do datového proudu a zavřít datový proud.You must write to the stream and close the stream before sending the request.

Žádosti jsou odesílány na server voláním GetResponse metody nebo jejích asynchronních protějšků, BeginGetResponse metod a EndGetResponse .Requests are sent to the server by calling the GetResponse method or its asynchronous counterparts, the BeginGetResponse and EndGetResponse methods. Po dokončení požadované operace FtpWebResponse se vrátí objekt.When the requested operation completes, an FtpWebResponse object is returned. FtpWebResponseObjekt poskytuje stav operace a všechna data stažená ze serveru.The FtpWebResponse object provides the status of the operation and any data downloaded from the server.

Můžete nastavit hodnotu časového limitu pro čtení nebo zápis na server pomocí ReadWriteTimeout Vlastnosti.You can set a time-out value for reading or writing to the server by using the ReadWriteTimeout property. Pokud je překročen časový limit, volající metoda vyvolá výjimku WebException s WebExceptionStatus nastavenou na Timeout .If the time-out period is exceeded, the calling method throws a WebException with WebExceptionStatus set to Timeout.

Pokud při stahování souboru ze serveru FTP dojde k úspěšnému provedení příkazu, obsah požadovaného souboru je k dispozici v datovém proudu objektu odpovědi.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. K tomuto datovému proudu můžete přistupovat voláním GetResponseStream metody.You can access this stream by calling the GetResponseStream method. Další informace naleznete v tématu FtpWebResponse.For more information, see FtpWebResponse.

Pokud Proxy je tato vlastnost nastavená buď přímo, nebo v konfiguračním souboru, provedou se komunikace se serverem FTP přes zadaný proxy server.If the Proxy property is set, either directly or in a configuration file, communications with the FTP server are made through the specified proxy. Pokud je zadaný proxy proxy serverem HTTP, DownloadFile ListDirectory jsou podporovány pouze příkazy, a ListDirectoryDetails .If the specified proxy is an HTTP proxy, only the DownloadFile, ListDirectory, and ListDirectoryDetails commands are supported.

Pouze stažený binární obsah je uložen do mezipaměti. To znamená, že obsah přijatý pomocí DownloadFile příkazu s UseBinary vlastností nastavenou na true .Only downloaded binary content is cached; that is, content received using the DownloadFile command with the UseBinary property set to true.

FtpWebRequestPokud je to možné, vícenásobné opakované použití stávajících připojení:Multiple FtpWebRequests reuse existing connections, if possible.

Další informace o protokolu FTP najdete v dokumentu RFC 959: protokol FTP (File Transfer Protocol).For more information about the FTP protocol, see RFC 959: File Transfer Protocol.

Vlastnosti

AuthenticationLevel

Získá nebo nastaví hodnoty určující úroveň ověřování a zosobnění použitou pro tuto žádost.Gets or sets values indicating the level of authentication and impersonation used for this request.

(Zděděno od WebRequest)
CachePolicy

Získá nebo nastaví zásady mezipaměti pro tento požadavek.Gets or sets the cache policy for this request.

(Zděděno od WebRequest)
ClientCertificates

Získá nebo nastaví certifikáty používané k navázání šifrovaného připojení k serveru FTP.Gets or sets the certificates used for establishing an encrypted connection to the FTP server.

ConnectionGroupName

Získá nebo nastaví název skupiny připojení, která obsahuje bod služby, který slouží k odeslání aktuálního požadavku.Gets or sets the name of the connection group that contains the service point used to send the current request.

ContentLength

Získá nebo nastaví hodnotu, která je FtpWebRequest třídou ignorována.Gets or sets a value that is ignored by the FtpWebRequest class.

ContentOffset

Získá nebo nastaví posunutí bajtů do souboru, který je tímto požadavkem stahován.Gets or sets a byte offset into the file being downloaded by this request.

ContentType

Vždy vyvolá výjimku NotSupportedException .Always throws a NotSupportedException.

CreatorInstance
Zastaralé.

Při přepsání v odvozené třídě získá objekt factory odvozený z IWebRequestCreate třídy, která se používá k vytvoření WebRequest instance pro vytvoření instance pro zadání tohoto identifikátoru URI.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.

(Zděděno od WebRequest)
Credentials

Získá nebo nastaví pověření používaná ke komunikaci se serverem FTP.Gets or sets the credentials used to communicate with the FTP server.

DefaultCachePolicy

Definuje výchozí zásady mezipaměti pro všechny požadavky FTP.Defines the default cache policy for all FTP requests.

EnableSsl

Získá nebo nastaví, který Boolean Určuje, že by mělo být použito připojení SSL.Gets or sets a Boolean that specifies that an SSL connection should be used.

Headers

Získá prázdný WebHeaderCollection objekt.Gets an empty WebHeaderCollection object.

ImpersonationLevel

Získá nebo nastaví úroveň zosobnění pro aktuální požadavek.Gets or sets the impersonation level for the current request.

(Zděděno od WebRequest)
KeepAlive

Získává nebo nastavuje Boolean hodnotu, která určuje, jestli se připojení ovládacího prvku k serveru FTP po dokončení žádosti zavřelo.Gets or sets a Boolean value that specifies whether the control connection to the FTP server is closed after the request completes.

Method

Získá nebo nastaví příkaz, který se odešle na server FTP.Gets or sets the command to send to the FTP server.

PreAuthenticate

Vždy vyvolá výjimku NotSupportedException .Always throws a NotSupportedException.

Proxy

Získá nebo nastaví proxy server, který se používá ke komunikaci se serverem FTP.Gets or sets the proxy used to communicate with the FTP server.

ReadWriteTimeout

Získá nebo nastaví časový limit při čtení nebo zápisu do datového proudu.Gets or sets a time-out when reading from or writing to a stream.

RenameTo

Získá nebo nastaví nový název souboru, který se má přejmenovat.Gets or sets the new name of a file being renamed.

RequestUri

Načte identifikátor URI, který požaduje tato instance.Gets the URI requested by this instance.

ServicePoint

Získá ServicePoint objekt používaný pro připojení k serveru FTP.Gets the ServicePoint object used to connect to the FTP server.

Timeout

Získá nebo nastaví počet milisekund, po které se má čekat na požadavek.Gets or sets the number of milliseconds to wait for a request.

UseBinary

Získává nebo nastavuje Boolean hodnotu, která určuje datový typ pro přenosy souborů.Gets or sets a Boolean value that specifies the data type for file transfers.

UseDefaultCredentials

Vždy vyvolá výjimku NotSupportedException .Always throws a NotSupportedException.

UsePassive

Získá nebo nastaví chování procesu přenosu dat klientské aplikace.Gets or sets the behavior of a client application's data transfer process.

Metody

Abort()

Ukončí asynchronní operaci FTP.Terminates an asynchronous FTP operation.

BeginGetRequestStream(AsyncCallback, Object)

Spustí asynchronní otevírání streamu obsahu žádosti pro zápis.Begins asynchronously opening a request's content stream for writing.

BeginGetResponse(AsyncCallback, Object)

Začíná odesílat žádosti a přijímat odpovědi ze serveru FTP asynchronně.Begins sending a request and receiving a response from an FTP server asynchronously.

CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace požadované pro vygenerování proxy serveru, který se používá ke komunikaci se vzdáleným objektem.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Zděděno od MarshalByRefObject)
EndGetRequestStream(IAsyncResult)

Ukončí probíhající asynchronní operaci spuštěnou v BeginGetRequestStream(AsyncCallback, Object) .Ends a pending asynchronous operation started with BeginGetRequestStream(AsyncCallback, Object).

EndGetResponse(IAsyncResult)

Ukončí probíhající asynchronní operaci spuštěnou v BeginGetResponse(AsyncCallback, Object) .Ends a pending asynchronous operation started with BeginGetResponse(AsyncCallback, Object).

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetLifetimeService()

Načte aktuální objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)

Naplní SerializationInfo data potřebná k serializaci cílového objektu.Populates a SerializationInfo with the data needed to serialize the target object.

(Zděděno od WebRequest)
GetRequestStream()

Načte datový proud, který slouží k nahrání dat na server FTP.Retrieves the stream used to upload data to an FTP server.

GetRequestStreamAsync()

Při přepsání v odvozené třídě vrátí hodnotu Stream pro zápis dat do internetového prostředku jako asynchronní operace.When overridden in a descendant class, returns a Stream for writing data to the Internet resource as an asynchronous operation.

(Zděděno od WebRequest)
GetResponse()

Vrátí odpověď serveru FTP.Returns the FTP server response.

GetResponseAsync()

Při přepsání v odvozené třídě vrátí odpověď na požadavek na Internet jako asynchronní operaci.When overridden in a descendant class, returns a response to an Internet request as an asynchronous operation.

(Zděděno od WebRequest)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
InitializeLifetimeService()

Získá objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Obtains a lifetime service object to control the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří kopii aktuálního objektu bez podstruktury MarshalByRefObject .Creates a shallow copy of the current MarshalByRefObject object.

(Zděděno od MarshalByRefObject)
ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Při přepsání v odvozené třídě naplní SerializationInfo instanci daty potřebnými k serializaci WebRequest .When overridden in a descendant class, populates a SerializationInfo instance with the data needed to serialize the WebRequest.

(Zděděno od WebRequest)

Platí pro

Viz také