Discussion :

[zitoun]

Salut,
J'aurais besoin de lire un fichier qui se trouve sur un serveur ftp distant, mais pas de l'uploader sur le disque de mon PC j'ai juste besoin d'un byte[] qui contiendrai le contenu du fichier.
Merci.

[zitoun]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
      public byte[] ReadFromServer(Uri serverUri, string login, string pass)
        {
            byte[] arry = null;
            if (serverUri.Scheme != Uri.UriSchemeFtp)
            {
                MessageBox.Show("Url non conforme !");
                return null;
            }
            WebClient request = new WebClient();
            request.Credentials = new NetworkCredential(login, pass);
            try
            {
                arry = request.DownloadData(serverUri);
            }
            catch (WebException e)
            {
                MessageBox.Show(e.ToString());
            }
            return arry;
        }

Bon j'ai réussi a faire ce bout de code... Il fonctionne assez bien j'usqu'à ce que le fichier devien un peu volumineux ( de l'ordre de 70 Mo ), j'aurai besoin d'une solution pour des fichiers assez gros...
Merci d'avance.

.

[zitoun]

Bon puisque ne n'ai pas trouvé de réponse, j'ai trouvé une petite astuce tout seul comme un grand...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
    class ftpDownload
    {
        /// <summary>
        ///   Le fichier temporaire ou sera stoqué le xml
        /// </summary>
        private string _tmpPath = string.Empty;
        public string tmpPath
        {
            get
            {
                return this._tmpPath;
            }
            set
            {
                this._tmpPath = value;
            }
        }
 
        /// <summary>
        /// Les acces au serveur ftp
        ///     ftpPath: l'adresse ftp du fichier à télécharger
        ///     ftpLogin: Le login
        ///     ftpPass: le mot de passe
        /// </summary>
        private string _ftpPath = string.Empty;
        public string ftpPath
        {
            get
            {
                return this._ftpPath;
            }
        }
        private string _ftpLogin = string.Empty;
        public string ftpLogin
        {
            get
            {
                return this._ftpLogin;
            }
        }
        private string _ftpPass = string.Empty;
        public string ftpPass
        {
            get
            {
                return this._ftpPass;
            }
        }
 
 
        public delegate void EventHandler(object sender, completeEventArgs e);
        public event EventHandler downloadComplete;
 
        /// <summary>
        /// constructeur
        /// </summary>
        /// <param name="ftpPath l'adresse du serveur ftp"></param>
        public ftpDownload(string ftpPath)
        {
            this._ftpPath = ftpPath;
        }
        /// <summary>
        /// constructeur
        /// </summary>
        /// <param name="ftpPath l'adresse du serveur ftp"></param>
        /// <param name="login le login"></param>
        /// <param name="password le mot de passe"></param>
        public ftpDownload(string ftpPath, string login, string password)
        {
            this._ftpPath = ftpPath;
            this._ftpLogin = login;
            this._ftpPass = password;
        }
 
        /// <summary>
        /// fonction pour télécharger un fichier
        /// </summary>
        /// <param name="ftpFileName  le nom du fichier à télécharger"></param>
        public void downloadFile(string ftpFileName)
        {
            // Formatage du lien du fichier pour la méthode de téléchargement de fichier.
            Uri _LienFormate = new Uri(this._ftpPath + "/" + ftpFileName);
 
            // Création du WebClient
            WebClient _ClientWeb = new WebClient();
 
            //identification dans le cas ou c'est necessaire
            if ((this._ftpLogin.Length > 0) && (this._ftpPass.Length > 0))
            {
                _ClientWeb.Credentials = new NetworkCredential(this._ftpLogin,this._ftpPass);
            }
            // Définition de l'action à executer lors de l'évènement de fin de téléchargement.
            _ClientWeb.DownloadFileCompleted += new AsyncCompletedEventHandler(downloadCompleted);
 
            // Télécharemnt du fichier souhaité, sans bloquer l'application.
            _ClientWeb.DownloadFileAsync(_LienFormate, this._tmpPath + "/tmp" + ftpFileName);
        }
 
        private void downloadCompleted(object sender, AsyncCompletedEventArgs e)
        {
            completeEventArgs ex = new completeEventArgs("Download complete.");
            if (ex != null) downloadComplete(this, ex);
        }
 
    }
    public class completeEventArgs : EventArgs
	{
		private string _EventText = null;			
        public string EventText
		{
			get { return this._EventText; }
		}	
 
 
		public completeEventArgs(string eventText)
		{			
			if (eventText == null) throw new NullReferenceException();
			_EventText = eventText; 
		}
	}

au fait c'est une classe qui accede a un serveur ftp et qui télécharge un fichier spécifique ( le traitement se fait dans un autre thread "DownloadFileAsync" donc l'application ne se bloque pas, et lorsque le fichier est téléchargé la classe génére un evenement) qui peut etre assez gros (j'ai essayé avec 130 Mo et ca marche, ca met du temp mais ca ne plante pas) que je stoque dans un repertoir temporaire puis je fais mes traitement dessus et finalement je supprime le fichier.
Je suis pas trop content de cette methode... je laisse le sujet en suspend, histoire de voir si ce que je demande dans le 1er post est faisable (je suppose que oui) si ce que je fait est acceptable, dite le moi que je mette le tag RESOLU...
Merci.

[zitoun]

Je suppose que c'est résolu...

[Hadoul]

Comme ce thread est bien référencé sur le sujet, je me permet une mise à jour pour ceux qui chercherait.
J'ai du moi même créer une page simple qui se connecte à un ftp pour y télécharger un document, voici comment j'ai procédé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
        protected void Page_Load(object sender, EventArgs e)
        {
            string _ftpLogin = "login";
            string _ftpPass = "pwd";
 
            string _ftpPath = "http://nomdedomaine.fr";
            string _ftpFolder = "/dossier/sousdossier/";
            string _ftpFileName = "DoomThemeSong.mp3";
 
            // Formatage du lien du fichier pour la méthode de téléchargement de fichier.
            Uri _LienFormate = new Uri(_ftpPath + "/" + _ftpFolder + _ftpFileName);
 
            // Création du WebClient
            WebClient _ClientWeb = new WebClient();
 
            //identification dans le cas ou c'est necessaire
            if ((_ftpLogin.Length > 0) && (_ftpPass.Length > 0))
            {
                _ClientWeb.Credentials = new NetworkCredential(_ftpLogin, _ftpPass);
            }
 
            byte[] data = _ClientWeb.DownloadData(_LienFormate);
            Response.AddHeader("Content-Disposition", "attachment; filename=" + _ftpFileName + ";");
            Response.ContentType = "application/octet-stream";
 
            Response.BinaryWrite(data);
        }

Ainsi, dès que j'appelle cette page, le document se télécharge avec la fenêtre popup qui demande où je veux enregistrer le document. J'ai testé jusqu'à 150Mo et ça passe bien. Cependant la page télécharge avant le fichier avant de proposer où l'on souhaite enregistrer le document sur notre disque.