Udostępnij za pośrednictwem

FtpWebRequest Klasa

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Net
Zestaw:
System.Net.Requests.dll
Zestaw:
System.dll
Zestaw:
netstandard.dll
Źródło:
FtpWebRequest.cs
Źródło:
FtpWebRequest.cs
Źródło:
FtpWebRequest.cs

Implementuje klienta protokołu TRANSFERU plików (FTP).

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
Dziedziczenie
Object
MarshalByRefObject
WebRequest
FtpWebRequest

Przykłady

Poniższy przykład kodu pokazuje usuwanie pliku z serwera FTP.

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

Poniższy przykład kodu przedstawia pobieranie pliku z serwera FTP przy użyciu WebClient klasy .

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

Poniższy przykład kodu przedstawia użycie operacji asynchronicznych w celu przekazania pliku na serwer FTP.

#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();
            }
        }
    }
}

Uwagi

Ważne

Nie zalecamy używania FtpWebRequest klasy do nowego programowania. Aby uzyskać więcej informacji i alternatyw dla FtpWebRequestusługi , zobacz WebRequest nie powinien być używany w usłudze GitHub.

Aby uzyskać wystąpienie klasy FtpWebRequest, użyj Create metody . Możesz również użyć WebClient klasy do przekazywania i pobierania informacji z serwera FTP. Korzystając z jednej z tych metod, podczas określania zasobu sieciowego, który używa schematu FTP (na przykład "ftp://contoso.com"), FtpWebRequest klasa zapewnia możliwość programowej interakcji z serwerami FTP.

Identyfikator URI może być względny lub bezwzględny. Jeśli identyfikator URI ma postać "ftp://contoso.com/%2fpath" (%2f jest ucieczką '/'), identyfikator URI jest bezwzględny, a bieżący katalog to /path. Jeśli jednak identyfikator URI ma postać "ftp://contoso.com/path", najpierw program .NET Framework loguje się do serwera FTP (przy użyciu nazwy użytkownika i hasła ustawionego Credentials przez właściwość), bieżący katalog ma wartość <UserLoginDirectory>/path.

Musisz mieć prawidłową nazwę użytkownika i hasło serwera lub serwer musi zezwolić na logowanie anonimowe. Możesz określić poświadczenia używane do nawiązania połączenia z serwerem, ustawiając Credentials właściwość lub możesz je uwzględnić w UserInfo części identyfikatora URI przekazanego Create do metody. Jeśli uwzględnisz UserInfo informacje w identyfikatorze URI, Credentials właściwość jest ustawiona na nowe poświadczenia sieciowe z określoną nazwą użytkownika i informacjami o haśle.

Przestroga

EnableSsl Jeśli właściwość to true, wszystkie dane i polecenia, w tym nazwa użytkownika i informacje o haśle, są wysyłane do serwera w postaci zwykłego tekstu. Każda osoba monitorująca ruch sieciowy może wyświetlać poświadczenia i używać ich do nawiązywania połączenia z serwerem. Jeśli łączysz się z serwerem FTP, który wymaga poświadczeń i obsługuje protokół Secure Sockets Layer (SSL), należy ustawić wartość EnableSsltrue.

Musisz mieć WebPermission dostęp do zasobu FTP. W przeciwnym razie SecurityException zgłaszany jest wyjątek.

Określ polecenie FTP, które ma być wysyłane do serwera, ustawiając Method właściwość na wartość zdefiniowaną w WebRequestMethods.Ftp strukturze. Aby przesyłać dane tekstowe, zmień UseBinary właściwość na wartość domyślną (true) na false. Aby uzyskać szczegółowe informacje i ograniczenia, zobacz Method.

W przypadku przekazywania pliku do serwera za pomocą FtpWebRequest obiektu należy zapisać zawartość pliku do strumienia żądań uzyskanego przez wywołanie GetRequestStream metody lub jego odpowiedników asynchronicznych, BeginGetRequestStream metod i EndGetRequestStream . Musisz zapisać strumień i zamknąć strumień przed wysłaniem żądania.

Żądania są wysyłane do serwera przez wywołanie GetResponse metody lub jego asynchronicznych odpowiedników, BeginGetResponse metod i EndGetResponse . Po zakończeniu FtpWebResponse żądanej operacji zwracany jest obiekt. Obiekt FtpWebResponse zapewnia stan operacji i wszystkie dane pobrane z serwera.

Możesz ustawić wartość limitu czasu odczytu lub zapisu na serwerze przy użyciu ReadWriteTimeout właściwości . Jeśli przekroczono limit czasu, metoda wywołująca zgłasza wartość z ustawioną wartością WebExceptionWebExceptionStatusTimeout.

Podczas pobierania pliku z serwera FTP, jeśli polecenie zakończyło się pomyślnie, zawartość żądanego pliku jest dostępna w strumieniu obiektu odpowiedzi. Dostęp do tego strumienia można uzyskać, wywołując metodę GetResponseStream . Aby uzyskać więcej informacji, zobacz FtpWebResponse.

Proxy Jeśli właściwość jest ustawiona, bezpośrednio lub w pliku konfiguracji, komunikacja z serwerem FTP odbywa się za pośrednictwem określonego serwera proxy. Jeśli określony serwer proxy jest serwerem proxy HTTP, obsługiwane są tylko DownloadFilepolecenia , ListDirectoryi ListDirectoryDetails .

Buforowana jest tylko pobrana zawartość binarna; oznacza to, że zawartość odebrana przy użyciu DownloadFile polecenia z właściwością ustawioną UseBinary na true.

Wiele FtpWebRequestpołączeń ponownie używa istniejących, jeśli jest to możliwe.

Aby uzyskać więcej informacji na temat protokołu FTP, zobacz RFC 959: Protokół transferu plików.

Właściwości

AuthenticationLevel

Pobiera lub ustawia wartości wskazujące poziom uwierzytelniania i personifikacji używane dla tego żądania.

(Odziedziczone po WebRequest)
CachePolicy

Pobiera lub ustawia zasady pamięci podręcznej dla tego żądania.

(Odziedziczone po WebRequest)
ClientCertificates

Pobiera lub ustawia certyfikaty używane do ustanawiania zaszyfrowanego połączenia z serwerem FTP.
ConnectionGroupName

Pobiera lub ustawia nazwę grupy połączeń, która zawiera punkt usługi używany do wysyłania bieżącego żądania.
ContentLength

Pobiera lub ustawia wartość ignorowaną przez klasę FtpWebRequest .
ContentOffset

Pobiera lub ustawia przesunięcie bajtów do pliku pobieranego przez to żądanie.
ContentType

Zawsze zgłasza wartość NotSupportedException.
CreatorInstance
Przestarzałe.

Po zastąpieniu klasy potomnej pobiera obiekt fabryki pochodzący z IWebRequestCreate klasy użytej do utworzenia WebRequest wystąpienia żądania do określonego identyfikatora URI.

(Odziedziczone po WebRequest)
Credentials

Pobiera lub ustawia poświadczenia używane do komunikowania się z serwerem FTP.
DefaultCachePolicy

Definiuje domyślne zasady pamięci podręcznej dla wszystkich żądań FTP.
EnableSsl

Pobiera lub ustawia element Boolean określający, że należy użyć połączenia SSL.
Headers

Pobiera pusty WebHeaderCollection obiekt.
ImpersonationLevel

Pobiera lub ustawia poziom personifikacji dla bieżącego żądania.

(Odziedziczone po WebRequest)
KeepAlive

Pobiera lub ustawia wartość określającą Boolean , czy połączenie sterujące z serwerem FTP jest zamknięte po zakończeniu żądania.
Method

Pobiera lub ustawia polecenie do wysłania na serwer FTP.
PreAuthenticate

Zawsze zgłasza wartość NotSupportedException.
Proxy

Pobiera lub ustawia serwer proxy używany do komunikowania się z serwerem FTP.
ReadWriteTimeout

Pobiera lub ustawia limit czasu podczas odczytywania lub zapisywania strumienia.
RenameTo

Pobiera lub ustawia nową nazwę pliku, który jest zmieniany.
RequestUri

Pobiera identyfikator URI żądany przez to wystąpienie.
ServicePoint

ServicePoint Pobiera obiekt używany do nawiązywania połączenia z serwerem FTP.
Timeout

Pobiera lub ustawia liczbę milisekund oczekiwania na żądanie.
UseBinary

Pobiera lub ustawia wartość określającą Boolean typ danych dla transferów plików.
UseDefaultCredentials

Zawsze zgłasza wartość NotSupportedException.
UsePassive

Pobiera lub ustawia zachowanie procesu transferu danych aplikacji klienckiej.

Metody

Abort()

Kończy asynchroniczną operację FTP.
BeginGetRequestStream(AsyncCallback, Object)

Rozpoczyna się asynchronicznie otwierając strumień zawartości żądania do pisania.
BeginGetResponse(AsyncCallback, Object)

Rozpoczyna wysyłanie żądania i odbieranie odpowiedzi z serwera FTP asynchronicznie.
CreateObjRef(Type)

Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym.

(Odziedziczone po MarshalByRefObject)
EndGetRequestStream(IAsyncResult)

Kończy oczekującą operację asynchroniczną rozpoczętą za pomocą BeginGetRequestStream(AsyncCallback, Object)polecenia .
EndGetResponse(IAsyncResult)

Kończy oczekującą operację asynchroniczną rozpoczętą za pomocą BeginGetResponse(AsyncCallback, Object)polecenia .
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetLifetimeService()
Przestarzałe.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)
Przestarzałe.

Wypełnia element SerializationInfo danymi potrzebnymi do serializacji obiektu docelowego.

(Odziedziczone po WebRequest)
GetRequestStream()

Pobiera strumień używany do przekazywania danych do serwera FTP.
GetRequestStreamAsync()

Gdy zastąpisz klasę potomną, zwraca wartość do Stream zapisywania danych w zasobie internetowym jako operację asynchroniczną.

(Odziedziczone po WebRequest)
GetResponse()

Zwraca odpowiedź serwera FTP.
GetResponseAsync()

Gdy zastąpisz klasę potomną, zwraca odpowiedź na żądanie internetowe jako operację asynchroniczną.

(Odziedziczone po WebRequest)
GetType()

Type Pobiera bieżące wystąpienie.

(Odziedziczone po Object)
InitializeLifetimeService()
Przestarzałe.

Uzyskuje obiekt usługi okresu istnienia, aby kontrolować zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu.

(Odziedziczone po MarshalByRefObject)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)
Przestarzałe.

Gdy zastąpisz klasę SerializationInfo potomną, wypełnia wystąpienie danymi wymaganymi do serializacji WebRequestklasy .

(Odziedziczone po WebRequest)

Dotyczy

Zobacz też