Framework .Net 2.0 : les nouveautés pour le réseau

Date de publication : 27/09/2005

Par Ronald VASSEUR (autres articles)
 

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.


Introduction
1. Les capacités réseau du Framework .Net 2.0
2. Pinger un hôte sur le réseau
2.1. Présentation des fonctionnalités de Ping
2.2. Exemple d'utilisation du Ping
3. Information sur les interfaces réseau
3.1. Présentation du namespace System.Net.NetworkInformation
3.2. L'exemple par le code
3.2.1. Récupérer l'adresse IP
3.2.2. Récupérer les adresses des DNS
3.2.3. Récupérer l'adresse du serveur DHCP
3.2.4. Récupérer l'ensemble des informations relatives au protocole IP pour une interface réseau
3.2.5. Récupération des statistiques d'une interface réseau
4. Envoi et réception de fichier en FTP
4.1. Classes et principes de fonctionnement du FTP dans le Framework .Net 2.0
4.2. Téléchargement d'un fichier depuis un serveur FTP
4.3. Envoi d'un fichier vers un serveur FTP
4.4. Lister les fichiers sur un serveur FTP
4.5. Effacer un fichier sur un serveur FTP
5. Ressources
5.1. Téléchargements
5.2. Liens vers le MSDN
5.3. Liens vers Developpez.com
Conclusion


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'exemple comment réaliser un certain nombre d'opération. 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 de suite aux choses sérieuses !

warning 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 codes présents dans cet article. A l'heure où j'écris ces lignes, le Framework se trouve actuellement disponible en version Beta 2 et sera disponible en version finale début novembre 2005 (parallèlement à la sortie de Visual Studio 2005 et SQL Server 2005).

1. Les capacités réseau du Framework .Net 2.0

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éseaux des machines auxquelles j'ajouterai le Ping dans cet article.

Framework .Net 2.0
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éseaux
  • ...
D'entrée, je vous annonce que je ne pourrai pas être exhaustif et me bornerai à trois sujets : le Ping, les interfaces réseaux et le FTP, mais vous allez voir qu'il y a déjà de quoi faire !


2. Pinger un hôte sur le réseau

Commençons par le Ping, qui est le plus facile à mettre en oeuvre !


2.1. Présentation des fonctionnalités de Ping

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 en la matière avec de nouvelles classes dont le nom commence, tout simplement, par "Ping". Voyons plus en détails 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 comme 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és 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.


2.2. Exemple d'utilisation du Ping

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 suffisant, à mon avis, largement à comprendre le fonctionnement de ces fonctionnalités.

info 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.
Méthode permettant d'effectuer un Ping sur un hôte distant :
    ' Obtient le délai du Ping en millisecondes
    Private Function getPingTime(ByVal adresseIP As String) As String
        ' AdresseIP : chaîne de caractère contenant l'adresse IP de l'hôte à "pinger"
        ' Instanciation d'un objet Ping
        Dim monPing As New Ping
        ' Objet PingReply qui nous permettra de récupérer le résultat
        Dim maReponsePing As PingReply
        Dim resultatPing As String = Nothing
        Try
            ' Récupération du résultat obtenu par la méthode Send()
            maReponsePing = monPing.Send(adresseIP, Nothing)
            ' Formatage du résultat avec récupération du temps en millisecondes
            ' grâce à la propriété RoundtripTime.
            resultatPing = "Réponse de " & adresseIP & " en " & maReponsePing._
			               RoundtripTime.ToString & " ms."
            Return resultatPing
        Catch ex As PingException
            ' Formatage de l'exception affichée
            resultatPing = "Impossible de joindre l'hôte : " & ex.Message
            Return resultatPing
        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éseaux.


3. Information sur les interfaces réseau


3.1. Présentation du namespace System.Net.NetworkInformation

Notre objectif est, ici, de récupérer tout un tas d'informations relatives aux interfaces réseaux de votre machine : cela va de l'adresse IP à la vitesse de la connexion en passant par la quantité de données qui y transite. 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éseaux. 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 vu 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 !


3.2. L'exemple par le code


3.2.1. Récupérer l'adresse IP

Tout d'abord, commençons par une question banale et que chaque développeur digne de ce nom a rencontré 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
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim maListe As ArrayList = Nothing
        Try
            ' Récupération de la totalité des propriétés IP 
			' de l'interface sélectionnée
            Dim mesProprietesReseau As IPInterfaceProperties = monInterface_
                                       .GetIPProperties()
            ' Récupère les adresses unicast liées à cette interface
            Dim infosUnicast As UnicastIPAddressInformationCollection =_
                                mesProprietesReseau.UnicastAddresses
            Dim adresseIp As IPAddressInformation
            ' Récupère l'adresse IP de l'interface
            For Each adresseIp In infosUnicast
                maListe.Add(adresseIp.ToString)
            Next
        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 codes 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 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 informtations vues ici, en une fois.

Allons voir maintenant du côté des DNS...


3.2.2. Récupérer les adresses 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.

Récupérer les adresses des DNS
	' Obtient la liste des adresses DNS de l'interface
    Public Function getAdressesDNS() As ArrayList
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim listeDns As ArrayList = Nothing
        Try
            ' Récupération de la totalité des propriétés IP 
            ' de l'interface sélectionnée
            Dim mesProprietesReseau As IPInterfaceProperties = _
                                       monInterface.GetIPProperties()
            ' Récupère les informations relatives au DNS
            Dim infosDns As IPAddressCollection = mesProprietesReseau_
                            .DnsAddresses
            Dim adresseDns As IPAddress
            ' Récupère dans une ArrayList la liste des 
            ' adresses DNS de l'interface
            For Each adresseDns In infosDns
                listeDns.Add(adresseDns.ToString)
            Next
        Catch ex As Exception
            MessageBox.Show("Une erreur est survenue : " & ex.Message)
        End Try
        Return listeDns
    End Function

3.2.3. Récupérer l'adresse du serveur DHCP

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.

Récupérer l'adresse du serveur DHCP
    ' Obtient la liste des adresses de serveurs DHCP pour l'interface
    Public Function getAdresseDHCP() As ArrayList
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim listeDhcp As ArrayList = Nothing
        Try
            ' Récupération de la totalité des propriétés IP de l'interface sélectionnée
            Dim mesProprietesReseau As IPInterfaceProperties = _
                                       monInterface.GetIPProperties()
            ' Récupère les informations relatives au DHCP
            Dim infosDhcp As IPAddressCollection = mesProprietesReseau.DhcpServerAddresses
            Dim adresseDhcp As IPAddress
            ' 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

3.2.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és. Dans ce code, nous récupérons tout d'abord la liste complète des interfaces réseaux 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 ensuite, 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.

Récupération d'informations relatives à une interface réseau
    ' Obtient les informations relatives au protocole IP
    Public Function getAllInfos() As ArrayList
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim maListeGlobale As ArrayList = Nothing
        Try
            ' Récupération de la totalité des propriétés IP de l'interface sélectionnée
            Dim mesProprietesReseau As IPInterfaceProperties = _
                                       monInterface.GetIPProperties()
            ' Récupère les adresses unicast liées à cette interface
            Dim infosUnicast As UnicastIPAddressInformationCollection = _
                                mesProprietesReseau.UnicastAddresses
            Dim adresseIp As IPAddressInformation
            ' Affichage de l'adresse IP de l'interface
            For Each adresseIp In infosUnicast
                maListeGlobale.Add("Adresse IP : " & adresseIp.Address.ToString())
            Next
            ' Récupère les informations relatives au DNS
            Dim infosDns As IPAddressCollection = mesProprietesReseau.DnsAddresses
            Dim adresseDns As IPAddress
            ' Ajoute à notre ArrayList les adresses DNS de l'interface
            For Each adresseDns In infosDns
                maListeGlobale.Add("Adresse DNS : " & adresseDns.ToString)
            Next
            ' Si protocole DHCP activé sur l'interface alors 
            ' recherche de l'adresse du serveur DHCP
            If mesProprietesReseau.GetIPv4Properties.IsDhcpEnabled = True Then
            Dim infosDhcp As IPAddressCollection = mesProprietesReseau_
                             .DhcpServerAddresses
                Dim adresseDhcp As IPAddress
                ' Ajoute à notre ArrayList les adresses de serveur DHCP
                For Each adresseDhcp In infosDhcp
                    maListeGlobale.Add("Adresse DHCP : " & adresseDhcp.ToString)
                Next
            End If
            ' Récupération des propriétés relatives à la passerelle
            Dim infosPasserelle As GatewayIPAddressInformationCollection = _
                                   mesProprietesReseau.GatewayAddresses
            Dim ipPasserelle As GatewayIPAddressInformation
            ' Ajoute à notre ArrayList l'adresse de la passerelle IP
            For Each ipPasserelle In infosPasserelle
                maListeGlobale.Add("Passerelle IP : " & ipPasserelle_
                              .Address.ToString())
            Next
            ' Récupéartion des adresses de multicast de l'interface sélectionnée
            Dim infosMulticast As MulticastIPAddressInformationCollection = _
                                  mesProprietesReseau.MulticastAddresses
            Dim multicastAdresse As MulticastIPAddressInformation
            ' Ajoute à notre ArrayList les adresses de multicast
            For Each multicastAdresse In infosMulticast
                maListeGlobale.Add("IP multicast : " & multicastAdresse_
                              .Address.ToString())
            Next
        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.


3.2.5. Récupération des statistiques d'une interface réseau

Précisons 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 informtaions qui peuvent être très utiles lorsque l'on développe des applications se connectant au travers de réseaux locaux ou distants.

  • Le statut d'une interface réseau :
Obtenir le statut d'une interface réseau
    ' Obtient le statut de la connexion réseau
    Public Function getStatutConnexion() As String
        ' Récupère la liste des interfaces
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        ' Retourne le statut de l'interface réseau
        Return monInterface.OperationalStatus.ToString
    End Function
Voyons d'un peu plus près les différentes classes et objets que nous avons utilisés. Pour obtenir le statut d'une interface réseau, il suffit simplement de lire sa propriété "OperationalStatus". Comme précédemmment pour obtenir la liste des interfaces réseaux, 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.

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.

  • La vitesse d'une interface réseau :
Pour récupérer la vitesse d'une interface réseau, rien de difficile, il suffit juste de lire sa propriété "Speed", elle est de type "Long" et représente le nombre de bits par seconde, typiquement pour une connexion à 100Mbits/s par seconde, on obtiendra par le biais de la propriété "Speed" une vitesse de 100 000 000.

Vitesse de l'interface réseau
    ' Obtient la vitesse d'une interface donnée
    Private Function getVitesseBrute() As Long
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim monResultat As Long
        ' Récupération de la vitesse de l'interface sélectionnée
        monResultat = monInterface.Speed
        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.

Formatage de la vitesse brute
    ' Formatte la vitesse pour qu'elle soit plus 'lisible'
    Private Function formateVitesseConnexion(ByVal vitesseBrute As Long) As String
        Dim vitesse As String = Nothing
        ' Formatage de la vitesse de la connexion
        Try
            Select Case vitesseBrute
                Case 10000000
                    vitesse = "10 Mbits/s"
                Case 11000000
                    vitesse = "11 Mbits/s"
                Case 54000000
                    vitesse = "54 Mbits/s"
                Case 100000000
                    vitesse = "100 Mbits/s"
                Case 108000000
                    vitesse = "108 Mbits/s"
                Case 1000000000
                    vitesse = "1 Gbits/s"
                Case Else
                    vitesse = vitesse = (vitesseBrute / 1000000)_
                                        .ToString & " Mbits/s"
            End Select
        Catch ex As Exception
            vitesse = "Non dispo."
        End Try
        Return vitesse & " Mbits/s"
    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 émise et reçue 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.

  • Quantité de données envoyées sur le réseau :
Données émises par l'interface réseau
    ' Obtient le nombre de Ko envoyés
    Public Function getOctetsEnvoyes() As String
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim octetsEnvoyes As Double = Nothing
        Dim octetsEnvoyesFormate As String = Nothing
        Try
            Dim mesStats As IPv4InterfaceStatistics = monInterface.GetIPv4Statistics
            ' Récupération et conversion du nombre d'octets envoyés en Mo
            octetsEnvoyes = Math.Round(mesStats.BytesSent / 1024)
            octetsEnvoyesFormate = octetsEnvoyes & " Ko"
        Catch ex As Exception
            octetsEnvoyesFormate = "Non dispo."
        End Try
        Return octetsEnvoyesFormate
    End Function
  • Quantité de données reçues par le réseau :
Données reçues par l'interface réseau
    ' Obtient le nombre de Ko reçus
    Public Function getOctetsRecus() As String
        Dim mesInterfaces() As NetworkInterface
        mesInterfaces = NetworkInterface.GetAllNetworkInterfaces
        Dim monInterface As NetworkInterface
        ' "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")
        Dim octetsRecus As Double = Nothing
        Dim octetsRecusFormate As String = Nothing
        Try
            Dim mesStats As IPv4InterfaceStatistics = monInterface.GetIPv4Statistics
            ' Récupération et conversion du nombre d'octets reçus en Mo
            octetsRecus = Math.Round(mesStats.BytesReceived / 1024)
            octetsRecusFormate = octetsRecus & " Ko"
        Catch ex As Exception
            octetsRecusFormate = "Non dispo."
        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 !

Microsoft®

4. Envoi et réception de fichier en FTP


4.1. Classes et principes de fonctionnement du FTP dans le 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 pour envoyer vers, ou recevoir un fichier depuis, un serveur FTP; et enfin nous terminerons sur comment lister ou effacer un fichier.

  • Les classes utilisées :
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, par exemple, 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.

  • Les Imports à effectuer :
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écessaire :
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 surchages du constructeur qui nous permettent entre autre 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.

  • Les exemples étudiés :
Voyont ce que cela donne dans la réalité du code au travers d'une série de quatres exemples, exemples que vous pourrez voir implémentés dans une petite application que j'ai réalisé 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 Beta 2 au minimum. Dernière précision, si vous voulez utiliser le code ci-dessous, n'oubliez 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écessaire :
	Imports System.IO
	Imports System.Net
	Imports System.Text

4.2. Téléchargement d'un fichier depuis un serveur FTP

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ématiqument, 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 de suite à la lecture du code commenté qui vous montrera en détails comment implémenter une telle fonctionnalité dans vos applications .Net 2.0 .

Download d'un fichier depuis un serveur FTP
    ' Download d'un fichier depuis un serveur FTP
    Private Sub downloadFichier(ByVal strUrlFichier As String, _
                                ByVal strCheminDestinationFichier As String, _
                                ByVal identifiant As String, _
                                ByVal motDePasse As String)
        ' strUrlFichier : Uri du fichier sur le serveur FTP
        ' strCheminDestinationFichier : Uri du fichier sur le disque dur
        ' identifiant : login du compte FTP utilisé
        ' motDePasse : mot de passe du compte FTP utilisé
        ' 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)
        ' Vérification de la validité de l'Uri du fichier sur le serveur FTP
        If Not (monUriFichier.Scheme = Uri.UriSchemeFtp) Then
            MessageBox.Show("L'Uri du fichier sur le serveur FTP n'est pas valide", _
                            "Une erreur est surevnue", MessageBoxButtons.OK, MessageBoxIcon.Warning)
            ' Si Uri non valide, arrêt du téléchargement
            Exit Sub
        End If
        ' Vérification de la validité de l'Uri de l'emplacement du fichier de destination
        If Not (monUriDestinationFichier.Scheme = Uri.UriSchemeFile) Then
            MessageBox.Show("Le chemin de destination n'est pas valide !", _
                            "Une erreur est surevnue", _
                            MessageBoxButtons.OK, MessageBoxIcon.Warning)
            ' Si Uri non valide, arrêt du téléchargement
            Exit Sub
        End If
        ' Création des 2 flux et du reader nécessaire pour la récupération du fichier
        Dim monResponseStream As Stream = Nothing
        Dim monFileStream As FileStream = Nothing
        Dim monReader As StreamReader = Nothing
        Try
            ' Requête demandant le fichier se trouvant sur le serveur FTP
            Dim downloadRequest As FtpWebRequest = CType(WebRequest.Create_
                                                   (monUriFichier), FtpWebRequest)
            ' Vérification de la présence des identifiants d'un compte, si aucun alors
            ' la connexion se fait en mode anonyme
            If Not identifiant.Length = 0 Then
                Dim monCompteFtp As New NetworkCredential(identifiant, motDePasse)
                downloadRequest.Credentials = monCompteFtp
            End If
            ' Flux de données issu du fichier sur le serveur FTP
            Dim downloadResponse As FtpWebResponse = CType(downloadRequest_
                                                     .GetResponse(), FtpWebResponse)
            monResponseStream = downloadResponse.GetResponseStream()
            ' Chemin de destination du fichier sur le disque dur
            Dim nomFichier As String = monUriDestinationFichier.LocalPath.ToString
            ' Création du fichier de destination sur le disque dur
            monFileStream = File.Create(nomFichier)
            ' Tableau d'octets qui va contenir les données issues du flux
            Dim monBuffer(1024) As Byte
            Dim octetsLus As Integer
            ' Lecture du buffer, puis écriture des données dans le fichier
            While True
                ' Lecture du flux
                octetsLus = monResponseStream.Read(monBuffer, 0, monBuffer.Length)
                If octetsLus = 0 Then
                    Exit While
                End If
                ' Ecriture dans le fichier
                monFileStream.Write(monBuffer, 0, octetsLus)
            End While
            MessageBox.Show("Téléchargement effectué.")
            ' Gestion des exceptions
        Catch ex As UriFormatException
            MessageBox.Show(ex.Message)
        Catch ex As WebException
            MessageBox.Show(ex.Message)
        Catch ex As IOException
            MessageBox.Show(ex.Message)
        Finally
            ' Fermeture du reader et des deux streams si nécessaire
            If monReader IsNot Nothing Then
                monReader.Close()
            ElseIf monResponseStream IsNot Nothing Then
                monResponseStream.Close()
            End If
            ' Fermeture du flux et du fichier
            If monFileStream IsNot Nothing Then
                monFileStream.Close()
            End If
        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 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.


4.3. Envoi d'un fichier vers un serveur FTP

Je serai 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 de sera plus entrant mais sortant, et son émission vers le serveur FTP distant sera à nôtre charge. Comme précédemment voilà un résumé schématique du déroulement de l'upload d'un fichier.

  • Instanciation d'un objet FtpWebRequest avec une commande FTP d'upload
  • Envoi de cette requête vers le serveur
  • Récépetion de l'autorisation du serveur FTP
  • Lecture du fichier à uploader (création d'un FileStream)
  • Emission du flux (Stream) de données vers le serveur
  • Fermeture du flux lors apèés l'envoi de la totalité du fichier
Voyons comment tout cela se traduit dans le code suivant :

Upload d'un fichier sur un serveur FTP
    ' Upload un fichier sur un serveur FTP
    Private Sub uploadFichier(ByVal cheminSource As String, _
                              ByVal urlDestination As String, _
                              ByVal identifiant As String, _
                              ByVal motDePasse As String)
        ' cheminSource : Uri du fichier sur le disque dur
        ' urlDestination : Uri du fichier de destination sur le serveur FTP
        ' identifiant : login du compte FTP utilisé
        ' motDePasse : mot de passe du compte FTP utilisé
        Dim monUriFichierLocal As System.Uri = Nothing
        Dim monUriFichierDistant As System.Uri = Nothing
        ' Vérification de la validité de l'Uri de l'emplacement du fichier source
        If Not (monUriFichierLocal.Scheme = Uri.UriSchemeFile) Then
            MessageBox.Show("Le chemin du fichier local n'est pas valide !", "Une _
             erreur est survenue", MessageBoxButtons.OK, MessageBoxIcon.Warning)
            Exit Sub
        End If
        ' Vérification de la validité de l'Uri de l'emplacement du fichier de destination
        If Not (monUriFichierDistant.Scheme = Uri.UriSchemeFtp) Then
            MessageBox.Show("Le chemin du fichier sur le serveur FTP n'est pas _
            valide !", "Une erreur est surevnue", MessageBoxButtons.OK, _
            MessageBoxIcon.Warning)
            Exit Sub
        End If
        ' Création des 2 flux et du reader nécessaire pour l'envoi du fichier
        Dim monRequestStream As Stream = Nothing
        Dim fileStream As FileStream = Nothing
        Dim uploadResponse As FtpWebResponse = Nothing
        Try
            ' Requête d'upload d'un fichier vers le serveur
            Dim uploadRequest As FtpWebRequest = CType(WebRequest_
                                 .Create(urlDestination), FtpWebRequest)
            ' Vérification de la présence des identifiants d'un compte, si aucun alors
            ' la connexion se fait en mode anonyme
            If Not identifiant.Length = 0 Then
                Dim monCompte As New NetworkCredential(identifiant, motDePasse)
                uploadRequest.Credentials = monCompte
            End If
            uploadRequest.Method = WebRequestMethods.Ftp.UploadFile
            ' Désactivation du proxy http incompatible avec cette requête
            uploadRequest.Proxy = Nothing
            monRequestStream = uploadRequest.GetRequestStream()
            fileStream = File.Open(cheminSource, FileMode.Open)
            ' Tableau d'octets qui va contenir les données issues du fichier
            Dim buffer(1024) As Byte
            Dim bytesRead As Integer
            ' Lecture des données et envoi de celle-ci dans le flux
            While True
                bytesRead = fileStream.Read(buffer, 0, buffer.Length)
                If bytesRead = 0 Then
                    Exit While
                End If
                ' Ecriture des données dans le flux d'upload vers le serveur FTP
                monRequestStream.Write(buffer, 0, bytesRead)
            End While
            'L'objet requestStream dot être fermé avant de récupérer la réponse
            monRequestStream.Close()
            uploadResponse = CType(uploadRequest.GetResponse(), FtpWebResponse)
            MessageBox.Show("Upload terminé.")
            ' Gestion des exceptions
        Catch ex As UriFormatException
            MessageBox.Show(ex.Message)
        Catch ex As WebException
            MessageBox.Show(ex.Message)
        Catch ex As IOException
            MessageBox.Show(ex.Message)
        Finally
            ' Fermeture des différents flux utilisés
            If uploadResponse IsNot Nothing Then
                uploadResponse.Close()
            End If
            If fileStream IsNot Nothing Then
                fileStream.Close()
            End If
            If monRequestStream IsNot Nothing Then
                monRequestStream.Close()
            End If
        End Try
    End Sub
Une fois de plus, rien de bien complexe, mais ça c'est quand 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.


4.4. Lister les fichiers sur 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é 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 retourver 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 :

Lister les fichiers sur un serveur FTP
    ' Obtient la liste des fichiers d'un répertoire donné
    Public Function listeFichiers(ByVal serveurCible As String, _
                                  ByVal identifiant As String, _
                                  ByVal motDePasse As String) As Array
        Dim monResponseStream As Stream = Nothing
        Dim monStreamReader As StreamReader = Nothing
        Dim monResultat As Array = Nothing
        ' Instanciation de deux Uri qui vont contenir les chemins source et destination
        Dim monUriServeur As New System.Uri(serveurCible)
        ' Vérification de la validité de l'Uri du fichier sur le serveur FTP
        If Not (monUriServeur.Scheme = Uri.UriSchemeFtp) Then
            MessageBox.Show("L'Uri du serveur FTP n'est pas valide", _
                            "Une erreur est surevnue", _
                            MessageBoxButtons.OK, MessageBoxIcon.Warning)
            'Si Uri non valide, arrêt du listage
            Return monResultat
            Exit Function
        End If
        Try
            ' Création de la requête de récupération de la liste des fichiers
            Dim maRequeteListe As FtpWebRequest = CType(WebRequest.Create_
                                                  (monUriServeur), FtpWebRequest)
            maRequeteListe.Method = WebRequestMethods.Ftp.ListDirectoryDetails
            ' Vérification de la présence des identifiants d'un compte, si aucun alors
            ' la connexion se fait en mode anonyme
            If Not identifiant.Length = 0 Then
                Dim monCompteFtp As New NetworkCredential(identifiant, motDePasse)
                maRequeteListe.Credentials = monCompteFtp
            End If
            ' Récupération de la liste de fichiers
            Dim maResponseListe As FtpWebResponse = CType(maRequeteListe_
                                                    .GetResponse, FtpWebResponse)
            ' Placement du flux provenant du serveur dans un streamreader
            monStreamReader = New StreamReader(maResponseListe.GetResponseStream, _
                                               Encoding.Default)
            ' Lecture du stream reader
            Dim listeBrute As String = monStreamReader.ReadToEnd
            ' Découpage de chaque fichier dans la liste concaténée de fichiers
            Dim separateur() As String = {Environment.NewLine} ' -> retour chariot
            ' Découpage et récupération des noms de fichiers
            Dim tableauListe() As String = listeBrute.Split(separateur, _
                                           StringSplitOptions.RemoveEmptyEntries)
            Dim listeFinale As New List(Of String)
            ' Lecture du tableau et tri des noms de fichiers
            Dim i As Integer = 0
            While i < tableauListe.Length
                ' Les répertoires se différencient des fichiers par le fait que  
                ' la chaîne que l'on récupère commence par un "d".
                If Not tableauListe(i).StartsWith("d") Then
                    ' On place les noms de fichiers dans une liste
                    listeFinale.Add(tableauListe(i).Substring(tableauListe(i)_
                                                   .LastIndexOf(" ") + 1))
                End If
                i += 1
            End While
            monResultat = listeFinale.ToArray
            MessageBox.Show("Liste terminée")
            ' Gestion des exceptions
        Catch ex As UriFormatException
            MessageBox.Show(ex.Message)
        Catch ex As WebException
            MessageBox.Show(ex.Message)
        Finally
            ' Fermeture des différents flux utilisés
            If monResponseStream IsNot Nothing Then
                monResponseStream.Close()
            End If
            If monStreamReader IsNot Nothing Then
                monStreamReader.Close()
            End If
        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.


4.5. 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 prends 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 3 autres exemples donnés pour la partie FTP de l'article. Je vous laisse maintenant lire ce bout de code commenté.

Effacer un fichier sur un serveur FTP
    ' Efface un fichier donné sur un serveur FTP
    Public Function effaceFichier(ByVal uriFichier As String, _
                                  ByVal identifiant As String, _
                                  ByVal motDePasse As String) As Boolean
        ' Création d'un URI à partir de la chaine contenant l'URL du serveur FTP
        Dim monUriFichier As New Uri(uriFichier)
        ' Vérification de la validité de l'adresse FTP
        If Not (monUriFichier.Scheme = Uri.UriSchemeFtp) Then
            MessageBox.Show("L'URI du fichier à effacer n'est pas valide", _
                            "Une erreur est surevnue", _
                            MessageBoxButtons.OK, MessageBoxIcon.Warning)
            'Si Uri non valide, arrêt du listage
            Return False
            Exit Function
        End If
        Try
            ' Création de la requête d'effacement du fichier
            Dim maRequeteEffacement As FtpWebRequest = CType(WebRequest_
                                       .Create(uriFichier), FtpWebRequest)
            maRequeteEffacement.Method = WebRequestMethods.Ftp.DeleteFile
            ' Vérification de la présence des identifiants d'un compte, si aucun alors
            ' la connexion se fait en mode anonyme
            If Not identifiant.Length = 0 Then
                Dim monCompteFtp As New NetworkCredential(identifiant, motDePasse)
                maRequeteEffacement.Credentials = monCompteFtp
            End If
            ' Effacement du fichier et récupération du résultat
            Dim maResponseFtp As FtpWebResponse = CType(maRequeteEffacement_
                                                  .GetResponse, FtpWebResponse)
            MessageBox.Show("Résultat action : " & maResponseFtp.StatusDescription)
            Return True
        Catch ex As Exception
            Return False
            MessageBox.Show("Une erreur est surevnue : " & ex.Message, _
                            "Une erreur est surevnue", _
                            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étails 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 Beta 2 au minimum. Vous pouvez voir une image de cette mini-application immédiatement à la suite de ce paragraphe :

Impression d'écran de la mini-application fournie avec cet article.

5. Ressources


5.1. Téléchargements


5.2. Liens vers le MSDN


5.3. Liens vers 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.

Un très très grand merci à Freegreg pour la relecture de cet article.


Microsoft, Windows and the Windows logo are either registered trademarks or trademarks of Microsoft Corporation in the United States and/or other countries.


Valid XHTML 1.1!Valid CSS!

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'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

Vos questions techniques : forum d'entraide Microsoft DotNET - Publiez vos articles, tutoriels et cours
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Hébergement - Participez - Copyright © 2000-2009 www.developpez.com - Legal informations.