Académique Documents
Professionnel Documents
Culture Documents
Cet article est consacré aux principales nouveautés apportées par le Framework .Net 2.0
en matière de réseau. Les trois sujets abordés ici seront : le ping, les informations relatives
aux interfaces réseau et enfin à l'interaction avec des serveurs FTP depuis du code .Net.
Tout au long de cet article, j'utiliserai le VB.Net 2005, mais bien sûr les principes restent
les mêmes qu'avec n'importe quel langage .Net (C#, Delphi, C++, J#…) puisque que nous
nous reposons entièrement sur le Framework.
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Introduction...................................................................................................................................................................3
I - Les capacités réseau du Framework .Net 2.0........................................................................................................3
II - Pinger un hôte sur le réseau.................................................................................................................................3
II-A - Présentation des fonctionnalités de Ping..................................................................................................... 3
II-B - Exemple d'utilisation du Ping........................................................................................................................4
III - Information sur les interfaces réseau................................................................................................................... 5
III-A - Présentation du namespace System.Net.NetworkInformation.....................................................................5
III-B - L'exemple par le code................................................................................................................................. 5
III-B-1 - Récupérer l'adresse IP........................................................................................................................ 5
III-B-2 - Récupérer les adresses des DNS.......................................................................................................6
III-B-3 - Récupérer l'adresse du serveur DHCP...............................................................................................7
III-B-4 - Récupérer l'ensemble des informations relatives au protocole IP pour une interface réseau............. 8
III-B-5 - Récupération des statistiques d'une interface réseau.........................................................................9
IV - Envoi et réception de fichier en FTP................................................................................................................. 12
IV-A - Classes et principes de fonctionnement du FTP dans le Framework .Net 2.0..........................................12
IV-B - Téléchargement d'un fichier depuis un serveur FTP................................................................................ 14
IV-C - Envoi d'un fichier vers un serveur FTP.....................................................................................................16
IV-D - Lister les fichiers sur un serveur FTP.......................................................................................................18
IV-E - Effacer un fichier sur un serveur FTP....................................................................................................... 20
V - Ressources.......................................................................................................................................................... 22
V-A - Téléchargements........................................................................................................................................ 22
V-B - Liens vers le MSDN................................................................................................................................... 22
V-C - Liens vers Developpez.com....................................................................................................................... 22
Conclusion..................................................................................................................................................................22
-2-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Introduction
Le Framework .Net 2.0 apporte son lot d'évolutions et de nouveautés par rapport à la version 1.1, c'est ainsi pas moins
de 1500 classes entièrement nouvelles qui font leur apparition. Les domaines concernés sont vastes et nombreux,
et celui qui nous intéresse, le réseau, n'y échappe pas ! Nous allons voir au cours de cet article, les nouveautés
principales apportées par la version 2.0, nous verrons aussi au travers d'exemples comment réaliser un certain
nombre d'opérations. Mais je préfère vous prévenir dès maintenant cela va être simple… je serais tenté de dire
« comme d'habitude » avec le Framework .Net, mais passons tout de suite aux choses sérieuses !
Remarque : je vous précise qu'il faut avoir installé au préalable le Framework 2.0 pour
exécuter les exemples et les morceaux de code présents dans cet article. À l'heure où
j'écris ces lignes, le Framework se trouve actuellement disponible en version Bêta 2 et sera
disponible en version finale début novembre 2005 (parallèlement à la sortie de Visual Studio
2005 et SQL Server 2005).
Les fonctionnalités réseau du Framework .Net 2.0 reposent en grande partie sur le namespace System.Net. Les
grandes nouveautés concernent essentiellement le protocole FTP et les interfaces réseau des machines auxquelles
j'ajouterai le Ping dans cet article.
Les capacités en matière de réseau du Framework .Net 2.0 sont très évoluées et vastes, cela va du remoting au
FTP en passant par les WebServices, bref tout le monde y trouvera son bonheur. Voyons rapidement ce que nous
permet de faire .Net 2.0 :
• Remoting ;
• WebServices ;
• Gestion des sockets ;
• Envoi de mail par SMTP ;
• Ping d'hôtes locaux ou distants ;
• Interactions avec les serveurs FTP ;
• Support des protocoles TCP et UDP ;
• Interactions avec Active Directory ;
• Interactions avec les interfaces réseau ;
• …
D'entrée, je vous annonce que je ne pourrai pas être exhaustif et me bornerai à trois sujets : le Ping, les interfaces
réseau et le FTP, mais vous allez voir qu'il y a déjà de quoi faire !
Utiliser la commande Ping dans l'invite de commande est une opération réalisée très couramment par tous les
administrateurs et les développeurs. Jusqu'à maintenant, utiliser le Ping directement depuis une application .Net était
tout à fait possible, mais relevait un peu du « bricolage »… le Framework .Net 2.0 améliore grandement les choses
-3-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
en la matière avec de nouvelles classes dont le nom commence, tout simplement, par « Ping ». Voyons plus en détail
ce que nous apportent ces classes.
• La classe Ping
Cette classe est la classe principale pour réaliser un Ping sur une machine donnée. Elle nous permet grâce au
protocole ICMP de déterminer si une machine distante est active, du moins si elle répond aux requêtes Ping qui lui
sont transférées. C'est une manière aussi simple que peu fiable (pour tout un tas de raisons) de voir par exemple si
un serveur est opérationnel ou non. La première chose à réaliser lorsque l'on veut implémenter des fonctionnalités de
Ping dans son code est d'instancier un objet de type Ping. Cette classe possède trois méthodes qui méritent que l'on
s'y attarde : Send, SendAsync et SendAsyncCancel. Ces méthodes comme leur nom l'indique, permettent d'envoyer
une requête Ping à un hôte distant (ou même au localhost si nécessaire).
Send : il s'agît de la méthode « de base », elle prend un certain nombre d'arguments par exemple l'adresse de l'hôte
« à Pinger » ou encore le délai avant de déclarer un « Time out », c'est-à-dire de déclarer l'hôte non joignable. Cette
méthode fonctionne de manière synchrone.
SendAsync : cette méthode est identique à la méthode Send, sauf que celle-ci est exécutée de manière asynchrone.
SendAsyncCancel : cette méthode est à utiliser en relation avec la précédente, en effet, elle permet d'annuler toutes
les requêtes ICMP asynchrones en cours.
• La classe PingReply
Cette classe permet de récupérer les résultats issus du ping effectué grâce aux méthodes Send ou SendAsync. Elle
est complémentaire de la classe ping, puisque sans elle, il n'est pas possible de récupérer le résultat de notre requête.
Voici les membres les plus importants de PingReply :
Roundtriptime : cette propriété est de type Long et contient le temps de réponse en millisecondes pour la requête
ICMP ;
Status : cette propriété correspond au statut de la requête ICMP, elle contient une valeur de type IPStatut, qui permet
d'obtenir précisément l'état de la requête, cela s'avère très utile, notamment en cas d'échec pour en analyser la cause.
Vous allez trouver ci-dessous un exemple commenté sur la manière de réaliser un Ping et d'en récupérer le résultat. La
procédure à suivre pour « pinger » un hôte est relativement simple. Il suffit, en effet, d'instancier un objet Ping, un objet
PingReply et de récupérer le résultat de la méthode Send du premier dans le second. Vous pouvez obtenir différentes
informations, mais celle qui nous intéresse en priorité est celle de la propriété RoundtripTime, qui correspond au
délai de ping, donné en millisecondes. Je ne pense pas qu'il soit nécessaire de s'étendre plus en longueur sur les
explications, le code et les commentaires suffisent, à mon avis, largement à comprendre le fonctionnement de ces
fonctionnalités.
Pour utiliser les classes Ping et PingReply, vous devez auparavant faire un « Imports » sur
Imports System.Net.NetworkInformation. Sans cela, vous n'aurez pas accès aux méthodes
et autres propriétés de ces objets.
Try
-4-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Return resultatPing
Catch ex As PingException
End Try
End Function
Après avoir vu comment effectuer un Ping directement depuis votre code .Net, passons maintenant à une autre
nouveauté apportée par le Framework 2.0 : la récupération (aisée) de nombreuses informations relatives aux
interfaces réseau.
Notre objectif est, ici, de récupérer tout un tas d'informations relatives aux interfaces réseau de votre machine :
cela va de l'adresse IP à la vitesse de la connexion en passant par la quantité de données qui y transitent. Avec
le Framework .Net 1.1, on pouvait récupérer un certain nombre d'informations, notamment grâce à WMI, mais cela
n'était pas facile à réaliser, du moins, pas autant qu'aujourd'hui. Cette simplification nous est en grande partie apportée
par un namespace que nous allons immédiatement voir plus en détail.
Le namespace concerné est ici System.Net.NetworkInterface, il contient pas moins de 32 classes dédiées à la
récupération d'informations et de statistiques en tout genre sur les interfaces et connexions réseau. Par le biais de
ce namespace, nous avons facilement accès à de nombreuses informations sur le protocole IP (adresse IP, adresse
de la passerelle, serveurs DNS, serveur DHCP…), mais aussi sur l'état du trafic et des connexions de la machine
locale. Par exemple, la classe ping, que nous avons vue dans la partie précédente, est intégrée à ce namespace.
L'objectif, ici, n'est pas de faire une présentation exhaustive de ce namespace (ce qui d'ailleurs pourrait faire l'objet
d'un livre entier tellement il est riche !), mais plutôt de voir au travers d'un exemple à quel point ces classes peuvent
être utiles et simples d'utilisation. Ne perdons plus de temps, et jetons-nous dans le code !
Tout d'abord, commençons par une question banale et que chaque développeur digne de ce nom a rencontrée au
moins une fois dans sa vie ! je veux bien évidemment dire : quelle est l'adresse IP de la machine où s'exécute mon
application.
Récupérer l'adresse IP
' Obtient l'adresse IP
Public Function getInfosIp() As ArrayList
-5-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Récupérer l'adresse IP
' "nom_de_l'interface_voulue" : correspond à l'interface que vous souhaitez
' qui se trouve dans le tableau mesInterfaces()
monInterface = mesInterfaces("nom_de_l'interface_voulue")
Try
Catch ex As Exception
MessageBox.Show("Une erreur est survenue : " & ex.Message)
End Try
Return maListe
End Function
Vous allez me dire « toutes ces lignes de code pour récupérer une malheureuse adresse IP ! », et je vous répondrai :
vous avez raison ! En effet, tout ça pour ça ! On complique, mais en fait, ici, mon code est volontairement « complexe »,
car en général on ne se contente pas de récupérer une seule information. Vous allez voir, par la suite, la foule de
données que l'on retrouve par ce procédé. Passons tout de suite aux autres éléments que nous pouvons récupérer,
et dès à présent, je vous signale qu'à la fin de cette partie, je mettrai un code complet qui permettra de récupérer et
d'afficher, toutes les informations vues ici, en une fois.
Allons voir maintenant du côté des DNS…
Pas la peine de s'attarder, en effet, le code se suffit à lui-même, de plus, les commentaires expliquent les quelques
subtilités, mais pas de quoi s'affoler, ce code est à la portée de tous, même des débutants en .Net.
Try
-6-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Catch ex As Exception
MessageBox.Show("Une erreur est survenue : " & ex.Message)
End Try
Return listeDns
End Function
Après les DNS, continuons notre tour d'horizon en nous arrêtant sur le DHCP, ici, pas la peine de plus commenter,
en effet, le code est quasiment le même que dans la sous-partie précédente.
Try
' Récupère dans une ArrayList la liste des adresses DHCP de l'interface
For Each adresseDhcp In infosDhcp
listeDhcp.Add(adresseDhcp.ToString)
Next
Catch ex As Exception
MessageBox.Show("Une erreur est survenue : " & ex.Message)
End Try
Return listeDhcp
End Function
-7-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
III-B-4 - Récupérer l'ensemble des informations relatives au protocole IP pour une interface
réseau
Après avoir vu les différents éléments séparément, voyons maintenant un code beaucoup plus intéressant et qui,
cette fois, justifie réellement un nombre de lignes (très) relativement élevé. Dans ce code, nous récupérons tout
d'abord la liste complète des interfaces réseau de votre machine, puis nous en choisissons une (une liste déroulante
semble un bon moyen de procéder, si vous travaillez sur une application WebForms ou WinForms), puis, tour à tour,
nous récupérons de nombreuses informations que nous ajoutons au fur et à mesure dans une ArrayList. La fonction
retourne donc une ArrayList contenant les informations relatives au protocole IP de l'interface sélectionnée.
Try
-8-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Catch ex As Exception
MessageBox.Show("Une erreur est survenue : " & ex.Message)
End Try
Return maListeGlobale
End Function
Le code n'est pas très différent des exemples donnés précédemment, il en fait la synthèse. Après avoir étudié les
informations récupérables sur IP, voyons quelles sont les statistiques accessibles pour une interface.
Précisons tout de suite ce que j'entends par « statistiques », il s'agit en fait de la vitesse de la connexion, de son statut
ou encore de la quantité de données émises ou reçues. Le Framework .Net 2.0 nous offre un accès extrêmement
simple à ces informations qui peuvent être très utiles lorsque l'on développe des applications se connectant au travers
de réseaux locaux ou distants.
End Function
Voyons d'un peu plus près les différents classes et objets que nous avons utilisés. Pour obtenir le statut d'une
interface réseau, il suffit de lire sa propriété « OperationalStatus ». Comme précédemment pour obtenir la liste des
interfaces réseau, nous utilisons la méthode « GetAllNetworkInterfaces » de la classe NetworkInterface. La propriété
OperationalStatus peut contenir l'une des sept valeurs listées ci-dessous.
-9-
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Nom Description
Dormant L'interface réseau n'est pas apte à
transmettre des paquets, en attente d'un
évènement extérieur.
Down L'interface réseau n'est pas apte à
transmettre des paquets.
LowerLayerDown L'interface réseau n'est pas apte à
transmettre des paquets, car au moins
un élément de bas niveau de celle-ci
n'est pas fonctionnel.
NotPresent L'interface réseau n'est pas apte à
transmettre des paquets pour cause d'un
composant manquant, généralement un
composant matériel.
Testing L'interface réseau est en train de
procéder à des tests.
Unknown Le statut de l'interface réseau n'a pas pu
être déterminé.
Up L'interface réseau est fonctionnelle et
apte à transmettre des paquets.
Vous voyez donc que la propriété « OperationalStatus » peut vous aider à obtenir une idée très précise de l'état
actuel d'une interface réseau donnée, et ne se limite pas un simple « Up » ou « Down ». Après avoir vu comment
obtenir le statut d'une interface réseau, voyons maintenant comment procéder pour ce qui concerne sa vitesse.
Pour récupérer la vitesse d'une interface réseau, rien de difficile, il suffit de lire sa propriété « Speed », elle est de type
« Long » et représente le nombre de bits par seconde, typiquement pour une connexion à 100 Mbits/s par seconde,
on obtiendra par le biais de la propriété « Speed » une vitesse de 100 000 000.
Return monResultat
End Function
Le nombre de bits par seconde étant quand même relativement important, il est pratique d'utiliser des Mbits/s comme
unité, cela simplifie quand même beaucoup la vie ! Surtout pour ceux qui ont des difficultés en calcul mental :). Voilà
une petite fonction qui, tout simplement, vous permet de formater cette vitesse, elle prend en paramètre un « Long » et
vous renvoie une « String ». Cette fonction utilise un Select Case en fonction des vitesses habituellement rencontrées
sur les interfaces réseau, je vous laisse voir son fonctionnement de plus près, vous verrez, il n'y a rien de sorcier.
- 10 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Catch ex As Exception
vitesse = "Non dispo."
End Try
End Function
Voilà, vous savez désormais détecter la vitesse de votre interface réseau, avant de conclure cette partie, voyons
comment récupérer la quantité de données émises et reçues sur une interface donnée.
Une fois de plus, à mon grand désespoir de rédacteur, rien de compliqué ! C'est à se demander que vont faire
les développeurs .Net de leurs journées ! Voici comment récupérer le nombre d'octets envoyés et reçus par une
interface réseau déterminée : le Framework .Net par l'intermédiaire de la classe IPv4InterfaceStatistics vous offre
deux propriétés : « BytesSent » et « BytesReceived ». Sans plus tarder, voilà deux bouts de code commentés qui
vous montrent comment réaliser cette opération.
Try
- 11 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Catch ex As Exception
End Try
Return octetsEnvoyesFormate
End Function
Try
Catch ex As Exception
End Try
Return octetsRecusFormate
End Function
Voilà le tour d'horizon rapide des statistiques que l'on peut récupérer au sujet des interfaces réseau. Je n'ai pas
particulièrement détaillé mes explications, car cela n'est pas nécessaire, je n'irai pas jusqu'à dire que c'est un jeu
d'enfant… mais presque. Nous en arrivons à la troisième partie, le FTP, qui, selon moi, est le plus intéressant dans
cet article, mais aussi, en général, dans les nouveautés réseau du Framework .Net 2.0 !
Passons sans plus tarder au gros morceau de cet article : le FTP ! Comme nous l'avons vu, le Framework .Net 2.0
apporte une grosse évolution en la matière. Nous verrons un peu plus loin, dans cet article, la manière de procéder
- 12 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
pour envoyer vers, ou recevoir un fichier depuis, un serveur FTP. Et enfin, nous terminerons sur comment lister ou
effacer un fichier.
Toutes ces opérations reposent essentiellement sur deux classes : FtpWebRequest ou FtpWebResponse; étudions-
les d'un peu plus près. Ces classes vous permettront d'envoyer des requêtes avec n'importe quelle commande FTP
et d'en récupérer le résultat. La technique de base est donc d'instancier un objet FtpWebRequest, puis de lui passer
une commande et éventuellement des informations d'authentification comme l'identifiant et le mot de passe d'un
compte ayant les droits adéquats. Une fois cette requête émise vers le serveur, vous récupérez la réponse de celui-
ci dans un objet FtpWebResponse, dans le cas d'un téléchargement de fichier par exemple, vous récupérez un flux
de données qui correspondent au fichier souhaité.
Tout ceci est abstrait et l'essentiel à retenir est que toute interaction avec un serveur FTP depuis du code .Net doit
passer par les classes FtpWebRequest et FtpWebResponse, elles possèdent pour cela un très grand nombre de
membres vous permettant de réaliser des opérations allant du simple téléchargement de fichiers à la création de
répertoires au travers d'une connexion sécurisée avec SSL.
Pour pouvoir utiliser ces deux classes, vous devez faire un « Imports » du namespace System.Net en début de votre
fichier de classe.
Imports nécessaires :
Imports System.Net
• L'authentification
Comme pour toute autre connexion FTP avec le Framework, .Net nous avons deux possibilités en matière
d'authentification : avec un compte ou en mode anonyme (anonymous). Si l'on ne fournit pas d'informations relatives
à un compte (identifiant et mot de passe), la connexion sera considérée comme anonyme et sera initiée comme telle.
L'autorisation ou non de cette connexion dépendra bien entendu de la politique en la matière établie sur le serveur
FTP, en clair s'il autorise les connexions anonymes ou non.
L'authentification sur un serveur FTP utilise une classe du Framework qui sert en fait à toute authentification basée
sur un mot de passe (basique, digest, NTLM ou encore Kerberos), cette classe se nomme : NetworkCredential.
En créant une instance de NetworkCredential, nous avons accès à plusieurs surcharges du constructeur qui nous
permettent entre autres de fournir un identifiant et un mot de passe (« login » et « password »), en voici un exemple :
NetworkCredential
Dim monAuthentificationFtp As New NetworkCredential("un_identifiant", "un_mot_de_passe")
Une fois cet objet défini et instancié, il suffit de la passer à notre FtpWebRequest grâce à sa propriété Credential.
Voyons ce que cela donne dans la réalité du code au travers d'une série de quatre exemples, exemples que vous
pourrez voir implémentés dans une petite application que j'ai réalisée et mise en téléchargement dans la section
« Ressources » en fin d'article. Cette mini application comprend un client FTP basique. J'ai mis à votre disposition le
fichier *.exe, mais aussi la solution Visual Studio 2005 qui vous permettra de réutiliser ou de voir de plus près le code.
Pour faire fonctionner cette application, vous devez évidemment avoir installé au préalable le Framework .Net 2.0
en version Bêta 2 au minimum. Dernière précision, si vous voulez utiliser le code ci-dessous, n'oubliez pas d'ajouter
les trois lignes suivantes à votre fichier de classe, en effet sans elles, vous auriez inévitablement une erreur lors de
la compilation de votre code.
Imports nécessaires :
Imports System.IO
Imports System.Net
- 13 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Imports nécessaires :
Imports System.Text
Pour mon premier exemple, je vais commencer par l'utilisation la plus courante que l'on fait du protocole FTP, je
veux bien sûr parler du téléchargement d'un fichier depuis un serveur FTP. Voilà comment, très schématiquement,
résumer le fonctionnement de la méthode ci-dessous.
• Envoi d'une requête (FtpWebRequest) vers le serveur demandant le téléchargement d'un fichier donné.
• Réception de la réponse du serveur dans un objet FtpWebResponse.
• Récupération du flux de données (le fichier que nous avons demandé).
• Création d'un fichier sur le disque dur.
• Les données du flux sont écrites dans ce fichier.
• Une fois le flux complètement réceptionné, le fichier est fermé.
Passons tout de suite à la lecture du code commenté qui vous montrera en détail comment implémenter une telle
fonctionnalité dans vos applications .Net 2.0 .
' Instanciation de deux Uri qui vont contenir les chemins source et destination
Dim monUriFichier As New System.Uri(strUrlFichier)
Dim monUriDestinationFichier As New System.Uri(strCheminDestinationFichier)
Try
- 14 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
End While
MessageBox.Show("Téléchargement effectué.")
MessageBox.Show(ex.Message)
Catch ex As WebException
MessageBox.Show(ex.Message)
Catch ex As IOException
MessageBox.Show(ex.Message)
Finally
End Try
End Sub
Bon, j'espère vous aurez eu le courage de lire ce code jusqu'au bout, car il est relativement long, mais c'est surtout,
car j'essaye de gérer au mieux les exceptions et divers paramètres comme la validité de l'URI ou encore le type
- 15 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
de connexion (anonyme ou non). Vous avez pu, j'espère, vous rendre compte que, même avec une longueur toute
relative, ce code reste simple et ne présente aucune complexité insurmontable, même pour des débutants.
Après le téléchargement, il paraît logique de passer à l'envoi de fichier vers un serveur FTP.
Je serais tenté de dire que l'upload (l'envoi) de fichier fonctionne de manière analogue au download (téléchargement)
de fichier, sauf que nous avons juste à prendre le problème à l'envers, en effet le flux de données ne sera plus
entrant, mais sortant, et son émission vers le serveur FTP distant sera à notre charge. Comme précédemment voilà
un résumé schématique du déroulement de l'upload d'un fichier.
Try
- 16 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
End If
uploadRequest.Method = WebRequestMethods.Ftp.UploadFile
monRequestStream = uploadRequest.GetRequestStream()
fileStream = File.Open(cheminSource, FileMode.Open)
End While
Catch ex As WebException
MessageBox.Show(ex.Message)
Catch ex As IOException
MessageBox.Show(ex.Message)
Finally
End Try
End Sub
- 17 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Une fois de plus, rien de bien complexe, mais ça, c'est quand même une (bonne) habitude avec .Net. En admettant
que votre objectif soit de réaliser un petit client FTP, c'est bien pratique de pouvoir downloader et uploader des fichiers,
mais cela ne fait pas tout… voyons donc immédiatement, comment lister les fichiers présents à la racine ou dans
un dossier donné d'un serveur FTP.
Ici, je vais vous montrer comment récupérer la liste des noms des fichiers présents dans un répertoire sur un
serveur FTP, pour cela, nous allons utilisé une commande particulière et bien évidemment spécifique à FTP qui est
implémentée dans le Framework .Net 2.0 grâce aux membres de la classe WebRequestMethods.Ftp . Vous avez
d'ailleurs dû vous rendre compte que l'on a utilisé cette classe un peu plus haut dans le code d'exemple. Cette
classe contient en tout treize membres qui représentent treize commandes FTP différentes en conformité avec la
RFC définissant le protocole FTP. Je vous propose d'ailleurs de retrouver ci-dessous un tableau listant l'ensemble
des membres de cette classe.
Nom Description
AppendFile Méthode permettant d'ajouter un fichier
sur un serveur FTP à un fichier existant.
DeleteFile Méthode permettant d'effacer un fichier
sur un serveur FTP.
DownloadFile Méthode permettant de télécharger un
fichier depuis un serveur FTP.
GetDateTimestamp
GetFileSize Méthode permettant de récupérer la taille
d'un fichier sur un serveur FTP.
ListDirectory Méthode permettant d'obtenir la liste des
fichiers présents sur un serveur FTP.
ListDirectoryDetails Méthode permettant d'obtenir la liste
détaillée des fichiers présents sur un
serveur FTP.
MakeDirectory Méthode permettant de créer un
nouveau répertoire sur un serveur FTP.
PrintWorkingDirectory Méthode permettant de récupérer le nom
du répertoire courant sur le serveur FTP.
RemoveDirectory Méthode permettant d'effacer un
répertoire sur un serveur FTP.
Rename Méthode permettant de renommer un
répertoire sur un serveur FTP.
UploadFile Méthode permettant d'envoyer un fichier
sur un serveur FTP.
UploadFileWithUniqueName Méthode permettant d'envoyer un fichier
avec un nom unique sur un serveur FTP.
Le code commenté, ci-dessous, est un exemple de comment récupérer la liste des fichiers présents dans un répertoire
donné sur un serveur FTP :
- 18 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
' Instanciation de deux Uri qui vont contenir les chemins source et destination
Dim monUriServeur As New System.Uri(serveurCible)
Try
- 19 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
MessageBox.Show("Liste terminée")
Catch ex As WebException
MessageBox.Show(ex.Message)
Finally
End Try
Return monResultat
End Function
Après avoir vu comment lister les fichiers contenus dans un répertoire, passons à notre dernier exemple en ce qui
concerne le FTP : effacer un fichier sur un serveur FTP.
Ici, le but de ce code commenté sera de vous montrer comment effacer un fichier sur un serveur FTP. Comme pour les
exemples précédents, cet exemple est volontairement un peu long, puisqu'en plus il prend en charge l'authentification,
le contrôle de la validité de l'adresse FTP (au plan syntaxique) ainsi que la gestion des exceptions. En fait, si vous
le souhaitez, cet exemple peut être réutilisé en l'état sans retoucher une seule ligne, il en va de même pour les trois
autres exemples donnés pour la partie FTP de l'article. Je vous laisse maintenant lire ce bout de code commenté.
' Création d'un URI à partir de la chaine contenant l'URL du serveur FTP
Dim monUriFichier As New Uri(uriFichier)
Try
- 20 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
Catch ex As Exception
Return False
MessageBox.Show("Une erreur est survenue : " & ex.Message, _
"Une erreur est survenue", _
MessageBoxButtons.OK, MessageBoxIcon.Warning)
End Try
End Function
Voilà, nous finissons au travers de ce quatrième et dernier exemple, cette partie sur l'implémentation de FTP dans
la version 2.0 du Framework .Net. J'espère avoir pu vous montrer à quel point il est aisé d'interagir avec un serveur
FTP et quelles sont les fonctionnalités qui vous sont offertes. Je vous rappelle qu'avec cet article, je vous fournis
un client FTP de base qui s'appuie sur ces nouvelles classes, en plus du fichier .exe vous trouverez dans la section
« ressources » la solution Visual Studio 2005 qui vous permettra de voir plus en détail le code de cette mini application
Windows Forms. Je précise que, bien évidemment, il faut posséder sur sa machine le Framework .Net 2.0 en version
Bêta 2 au minimum. Vous pouvez voir une image de cette mini application immédiatement à la suite de ce paragraphe :
- 21 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/
Framework .Net 2.0 : les nouveautés pour le réseau par Ronald VASSEUR
V - Ressources
V-A - Téléchargements
FtpWebRequest
FtpWebResponse
NetworkCredential
IPAddress
WebResponse
WebRequest
WebRequestMethods.Ftp
Mes articles
Mon blog
Les articles des autres rédacteurs
La section .Net de Developpez.com
Conclusion
J'espère, au travers de cet article, vous avoir permis de découvrir ces nouveautés apportées par la version 2.0 du
Framework .Net dans le domaine des réseaux. Le but ici, vous l'avez bien compris, n'était pas d'être exhaustif, mais
de faire un tour d'horizon de ces fonctionnalités, j'ai d'ailleurs déjà quelques idées pour le futur tant les possibilités
offertes sont vastes. N'hésitez pas à télécharger le code et la mini application que je mets à votre disposition dans
cet article, ils vous permettront de mieux appréhender tous ces concepts.
Merci d'avoir pris le temps de lire cet article, et je vous donne déjà rendez-vous pour un prochain article.
Microsoft, Windows and the Windows logo are either registered trademarks or trademarks of Microsoft Corporation
in the United States and/or other countries.
- 22 -
Copyright ® 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://webman.developpez.com/articles/dotnet/reseau/vb/net/