FtpWebRequest Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Implémente un client FTP (File Transfer Protocol).
public ref class FtpWebRequest sealed : System::Net::WebRequestpublic sealed class FtpWebRequest : System.Net.WebRequesttype FtpWebRequest = class
inherit WebRequestPublic NotInheritable Class FtpWebRequest
Inherits WebRequest- Héritage
Exemples
L’exemple de code suivant illustre la suppression d’un fichier d’un serveur 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;
}
L’exemple de code suivant illustre le téléchargement d’un fichier à partir d’un serveur FTP à l’aide de la WebClient classe .
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;
}
L’exemple de code suivant illustre l’utilisation d’opérations asynchrones pour charger un fichier sur un serveur 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();
}
}
}
}
Remarques
Important
Nous vous déconseillons d’utiliser la classe pour le FtpWebRequest nouveau développement. Pour plus d’informations et des alternatives à FtpWebRequest, consultez WebRequest ne doit pas être utilisé sur GitHub.
Pour obtenir une instance de FtpWebRequest, utilisez la Create méthode . Vous pouvez également utiliser la WebClient classe pour charger et télécharger des informations à partir d’un serveur FTP. À l’aide de l’une de ces approches, lorsque vous spécifiez une ressource réseau qui utilise le schéma FTP (par exemple, "ftp://contoso.com"), la FtpWebRequest classe offre la possibilité d’interagir par programmation avec des serveurs FTP.
L’URI peut être relatif ou absolu. Si l’URI est de la forme "ftp://contoso.com/%2fpath" (%2f est un échappement '/'), l’URI est absolu et le répertoire actif est /path. Toutefois, si l’URI est de la forme "ftp://contoso.com/path", le .NET Framework se connecte d’abord au serveur FTP (à l’aide du nom d’utilisateur et du mot de passe définis par la Credentials propriété ), puis le répertoire actif est défini sur <UserLoginDirectory>/path.
Vous devez disposer d’un nom d’utilisateur et d’un mot de passe valides pour le serveur ou le serveur doit autoriser l’ouverture de session anonyme. Vous pouvez spécifier les informations d’identification utilisées pour se connecter au serveur en définissant la Credentials propriété ou vous pouvez les inclure dans la UserInfo partie de l’URI passée à la Create méthode. Si vous incluez des UserInfo informations dans l’URI, la Credentials propriété est définie sur les nouvelles informations d’identification réseau avec le nom d’utilisateur et les informations de mot de passe spécifiés.
Attention
Sauf si la EnableSsl propriété est true, toutes les données et commandes, y compris vos informations de nom d’utilisateur et de mot de passe, sont envoyées au serveur en texte clair. Toute personne surveillant le trafic réseau peut voir vos informations d’identification et les utiliser pour se connecter au serveur. Si vous vous connectez à un serveur FTP qui nécessite des informations d’identification et prend en charge ssl (Secure Sockets Layer), vous devez définir sur EnableSsltrue.
Vous devez WebPermission accéder à la ressource FTP ; sinon, une SecurityException exception est levée.
Spécifiez la commande FTP à envoyer au serveur en définissant la Method propriété sur une valeur définie dans la WebRequestMethods.Ftp structure. Pour transmettre des données de texte, remplacez la UseBinary propriété de sa valeur par défaut (true) par false. Pour plus d’informations et de restrictions, consultez Method.
Lorsque vous utilisez un FtpWebRequest objet pour charger un fichier sur un serveur, vous devez écrire le contenu du fichier dans le flux de requête obtenu en appelant la GetRequestStream méthode ou ses équivalents asynchrones, les BeginGetRequestStream méthodes et EndGetRequestStream . Vous devez écrire dans le flux et fermer le flux avant d’envoyer la demande.
Les demandes sont envoyées au serveur en appelant la GetResponse méthode ou ses équivalents asynchrones, les BeginGetResponse méthodes et EndGetResponse . Une fois l’opération demandée terminée, un FtpWebResponse objet est retourné. L’objet FtpWebResponse fournit l’état de l’opération et toutes les données téléchargées à partir du serveur.
Vous pouvez définir une valeur de délai d’attente pour la lecture ou l’écriture sur le serveur à l’aide de la ReadWriteTimeout propriété . Si le délai d’attente est dépassé, la méthode appelante lève un WebException avec WebExceptionStatus défini sur Timeout.
Lors du téléchargement d’un fichier à partir d’un serveur FTP, si la commande a réussi, le contenu du fichier demandé est disponible dans le flux de l’objet de réponse. Vous pouvez accéder à ce flux en appelant la GetResponseStream méthode . Pour plus d'informations, consultez FtpWebResponse.
Si la Proxy propriété est définie, directement ou dans un fichier de configuration, les communications avec le serveur FTP sont effectuées via le proxy spécifié. Si le proxy spécifié est un proxy HTTP, seules les DownloadFilecommandes , ListDirectoryet ListDirectoryDetails sont prises en charge.
Seul le contenu binaire téléchargé est mis en cache ; autrement dit, le contenu reçu à l’aide de la DownloadFile commande avec la UseBinary propriété définie sur true.
Plusieurs FtpWebRequests réutilisent les connexions existantes, si possible.
Pour plus d’informations sur le protocole FTP, consultez RFC 959 : Protocole de transfert de fichiers.
Propriétés
| AuthenticationLevel |
Obtient ou définit des valeurs indiquant les niveaux d'authentification et d'emprunt d'identité utilisés pour cette demande. (Hérité de WebRequest) |
| CachePolicy |
Obtient ou définit la stratégie de cache de cette demande. (Hérité de WebRequest) |
| ClientCertificates |
Obtient ou définit les certificats utilisés pour établir une connexion chiffrée au serveur FTP. |
| ConnectionGroupName |
Obtient ou définit le nom du groupe de connexions contenant le point de service utilisé pour envoyer la demande actuelle. |
| ContentLength |
Obtient ou définit une valeur ignorée par la classe FtpWebRequest. |
| ContentOffset |
Obtient ou définit un décalage d'octet dans le fichier actuellement téléchargé par cette demande. |
| ContentType |
Lève toujours une exception NotSupportedException. |
| CreatorInstance |
Obsolète.
En cas de remplacement dans une classe descendante, obtient l'objet de fabrique dérivé de la classe IWebRequestCreate utilisé pour créer l'élément WebRequest instancié pour créer la demande à l'URI spécifié. (Hérité de WebRequest) |
| Credentials |
Obtient ou définit les informations d'identification utilisées pour communiquer avec le serveur FTP. |
| DefaultCachePolicy |
Définit la stratégie de cache par défaut pour toutes les demandes FTP. |
| EnableSsl |
Obtient ou définit un élément Boolean qui spécifie qu'il faut utiliser une connexion SSL. |
| Headers |
Obtient un objet WebHeaderCollection vide. |
| ImpersonationLevel |
Obtient ou définit le niveau d'emprunt d'identité pour la demande en cours. (Hérité de WebRequest) |
| KeepAlive |
Obtient ou définit une valeur Boolean qui spécifie si la connexion de contrôle au serveur FTP doit être fermée une fois la demande terminée. |
| Method |
Obtient ou définit la commande à envoyer au serveur FTP. |
| PreAuthenticate |
Lève toujours une exception NotSupportedException. |
| Proxy |
Obtient ou définit le proxy utilisé pour communiquer avec le serveur FTP. |
| ReadWriteTimeout |
Obtient ou définit un délai d'expiration lors de la lecture ou de l'écriture d'un flux. |
| RenameTo |
Obtient ou définit le nouveau nom d'un fichier qui est renommé. |
| RequestUri |
Obtient l'URI demandé par cette instance. |
| ServicePoint |
Obtient l'objet ServicePoint utilisé pour la connexion au serveur FTP. |
| Timeout |
Obtient ou définit le nombre de millisecondes d'attente d'une demande. |
| UseBinary |
Obtient ou définit une valeur Boolean qui spécifie le type de données pour les transferts de fichiers. |
| UseDefaultCredentials |
Lève toujours une exception NotSupportedException. |
| UsePassive |
Obtient ou définit le comportement du processus de transfert de données d'une application cliente. |
Méthodes
| Abort() |
Met fin à une opération FTP asynchrone. |
| BeginGetRequestStream(AsyncCallback, Object) |
Commence l'ouverture asynchrone du flux de contenu d'une demande en vue de l'écriture. |
| BeginGetResponse(AsyncCallback, Object) |
Commence à envoyer une demande et à recevoir une réponse d'un serveur FTP de façon asynchrone. |
| CreateObjRef(Type) |
Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject) |
| EndGetRequestStream(IAsyncResult) |
Met fin à une opération asynchrone en attente commencée avec BeginGetRequestStream(AsyncCallback, Object). |
| EndGetResponse(IAsyncResult) |
Met fin à une opération asynchrone en attente commencée avec BeginGetResponse(AsyncCallback, Object). |
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetLifetimeService() |
Obsolète.
Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject) |
| GetObjectData(SerializationInfo, StreamingContext) |
Obsolète.
Remplit SerializationInfo avec les données nécessaires pour sérialiser l'objet cible. (Hérité de WebRequest) |
| GetRequestStream() |
Récupère le flux utilisé pour télécharger des données vers un serveur FTP. |
| GetRequestStreamAsync() |
En cas de remplacement dans une classe descendante, retourne un élément Stream pour l'écriture de données dans la ressource Internet sous forme d'opération asynchrone. (Hérité de WebRequest) |
| GetResponse() |
Retourne la réponse du serveur FTP. |
| GetResponseAsync() |
En cas de substitution dans une classe descendante, retourne une réponse à une demande Internet en tant qu'opération asynchrone. (Hérité de WebRequest) |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| InitializeLifetimeService() |
Obsolète.
Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| MemberwiseClone(Boolean) |
Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject) |
| ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
Implémentations d’interfaces explicites
| ISerializable.GetObjectData(SerializationInfo, StreamingContext) |
Obsolète.
En cas de remplacement dans une classe descendante, remplit une instance de SerializationInfo avec les données nécessaires à la sérialisation de l'élément WebRequest. (Hérité de WebRequest) |
