ftpsample dot net 2.0

 

1. //Author             : Mohammed Habeeb - [e-mail]  
2. //Date Created       : 17th January 2007 
3. //Description        : This class demonstartes common FTP functionalities using .net 2.0.
4. using System;
5. using System.IO;
6. using System.Collections.Generic;
7. using System.ComponentModel;
8. using System.Data;
9. using System.Drawing;
10. using System.Text;
11. using System.Windows.Forms;
12. using System.Net;
14. namespace FTP24CP
15. {
16.     public partial class Form1 : Form
17.     {
18.         string ftpServerIP;
19.         string ftpUserID;
20.         string ftpPassword;
22.         public Form1()
23.         {
24.             InitializeComponent();
25.         }
27.         private void Form1_Load(object sender, EventArgs e)
28.         {
29.             ftpServerIP = "192.168.1.21";
30.             ftpUserID = "administrator";
31.             ftpPassword = "xxxxx";
32.             txtServerIP.Text = ftpServerIP;
33.             txtUsername.Text = ftpUserID;
34.             txtPassword.Text = ftpPassword;
35.             this.Text += ftpServerIP;
37.             btnFTPSave.Enabled = false;
38.         }
40.         /// <summary>
41.         /// Method to upload the specified file to the specified FTP Server
42.         /// </summary>
43.         /// <param name="filename">file full name to be uploaded</param>
44.         private void Upload(string filename)
45.         {
46.             FileInfo fileInf = new FileInfo(filename);
47.             string uri = "ftp://" + ftpServerIP + "/" + fileInf.Name;
48.             FtpWebRequest reqFTP;
50.             // Create FtpWebRequest object from the Uri provided
51.             reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + fileInf.Name));
53.             // Provide the WebPermission Credintials
54.             reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
56.             // By default KeepAlive is true, where the control connection is not closed
57.             // after a command is executed.
58.             reqFTP.KeepAlive = false;
60.             // Specify the command to be executed.
61.             reqFTP.Method = WebRequestMethods.Ftp.UploadFile;
63.             // Specify the data transfer type.
64.             reqFTP.UseBinary = true;
66.             // Notify the server about the size of the uploaded file
67.             reqFTP.ContentLength = fileInf.Length;
69.             // The buffer size is set to 2kb
70.             int buffLength = 2048;
71.             byte[] buff = new byte[buffLength];
72.             int contentLen;
74.             // Opens a file stream (System.IO.FileStream) to read the file to be uploaded
75.             FileStream fs = fileInf.OpenRead();
76.            
77.             try
78.             {
79.                 // Stream to which the file to be upload is written
80.                 Stream strm = reqFTP.GetRequestStream();
81.                 
82.                 // Read from the file stream 2kb at a time
83.                 contentLen = fs.Read(buff, 0, buffLength);
85.                 // Till Stream content ends
86.                 while (contentLen != 0)
87.                 {
88.                     // Write Content from the file stream to the FTP Upload Stream
89.                     strm.Write(buff, 0, contentLen);
90.                     contentLen = fs.Read(buff, 0, buffLength);
91.                 }
93.                 // Close the file stream and the Request Stream
94.                 strm.Close();
95.                 fs.Close();
96.             }
97.             catch(Exception ex)
98.             {
99.                 MessageBox.Show(ex.Message, "Upload Error");
100.             }
101.         }
103.         public void DeleteFTP(string fileName)
104.         {
105.             try
106.             {
107.                 string uri = "ftp://" + ftpServerIP + "/" + fileName;
108.                 FtpWebRequest reqFTP;
109.                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + fileName));
111.                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
112.                 reqFTP.KeepAlive = false;
113.                 reqFTP.Method = WebRequestMethods.Ftp.DeleteFile;
115.                 string result = String.Empty;
116.                 FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
117.                 long size = response.ContentLength;
118.                 Stream datastream = response.GetResponseStream();
119.                 StreamReader sr = new StreamReader(datastream);
120.                 result = sr.ReadToEnd();
121.                 sr.Close();
122.                 datastream.Close();
123.                 response.Close();
124.             }
125.             catch (Exception ex)
126.             {
127.                 MessageBox.Show(ex.Message, "FTP 2.0 Delete");
128.             }
129.         }
131.         private string[] GetFilesDetailList()
132.         {
133.             string[] downloadFiles;
134.             try
135.             {
136.                 StringBuilder result = new StringBuilder();
137.                 FtpWebRequest ftp;
138.                 ftp = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/"));
139.                 ftp.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
140.                 ftp.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
141.                 WebResponse response = ftp.GetResponse();
142.                 StreamReader reader = new StreamReader(response.GetResponseStream());
143.                 string line = reader.ReadLine();
144.                 while (line != null)
145.                 {
146.                     result.Append(line);
147.                     result.Append("/n");
148.                     line = reader.ReadLine();
149.                 }
150.                 
151.                 result.Remove(result.ToString().LastIndexOf("/n"), 1);
152.                 reader.Close();
153.                 response.Close();
154.                 return result.ToString().Split('/n');
155.                 //MessageBox.Show(result.ToString().Split('/n'));
156.             }
157.             catch (Exception ex)
158.             {
159.                 System.Windows.Forms.MessageBox.Show(ex.Message);
160.                 downloadFiles = null;
161.                 return downloadFiles;
162.             }
163.         }
165.         public string[] GetFileList()
166.         {
167.             string[] downloadFiles;
168.             StringBuilder result = new StringBuilder();
169.             FtpWebRequest reqFTP;
170.             try
171.             {
172.                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/"));
173.                 reqFTP.UseBinary = true;
174.                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
175.                 reqFTP.Method = WebRequestMethods.Ftp.ListDirectory;
176.                 WebResponse response = reqFTP.GetResponse();
177.                 StreamReader reader = new StreamReader(response.GetResponseStream());
178.                 //MessageBox.Show(reader.ReadToEnd());
179.                 string line = reader.ReadLine();
180.                 while (line != null)
181.                 {
182.                     result.Append(line);
183.                     result.Append("/n");
184.                     line = reader.ReadLine();
185.                 }
186.                 result.Remove(result.ToString().LastIndexOf('/n'), 1);
187.                 reader.Close();
188.                 response.Close();
189.                 //MessageBox.Show(response.StatusDescription);
190.                 return result.ToString().Split('/n');
191.             }
192.             catch (Exception ex)
193.             {
194.                 System.Windows.Forms.MessageBox.Show(ex.Message);
195.                 downloadFiles = null;
196.                 return downloadFiles;
197.             }
198.         }
199.         private void Download(string filePath, string fileName)
200.         {
201.             FtpWebRequest reqFTP;
202.             try
203.             {
204.                 //filePath = <<The full path where the file is to be created.>>, 
205.                 //fileName = <<Name of the file to be created(Need not be the name of the file on FTP server).>>
206.                 FileStream outputStream = new FileStream(filePath + "//" + fileName, FileMode.Create);
208.                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + fileName));
209.                 reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;
210.                 reqFTP.UseBinary = true;
211.                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
212.                 FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
213.                 Stream ftpStream = response.GetResponseStream();
214.                 long cl = response.ContentLength;
215.                 int bufferSize = 2048;
216.                 int readCount;
217.                 byte[] buffer = new byte[bufferSize];
219.                 readCount = ftpStream.Read(buffer, 0, bufferSize);
220.                 while (readCount > 0)
221.                 {
222.                     outputStream.Write(buffer, 0, readCount);
223.                     readCount = ftpStream.Read(buffer, 0, bufferSize);
224.                 }
226.                 ftpStream.Close();
227.                 outputStream.Close();
228.                 response.Close();
229.             }
230.             catch (Exception ex)
231.             {
232.                 MessageBox.Show(ex.Message);
233.             }
234.         }
235.         private void btnUpload_Click(object sender, EventArgs e)
236.         {
237.             OpenFileDialog opFilDlg = new OpenFileDialog();
238.             if (opFilDlg.ShowDialog() == DialogResult.OK)
239.             {
240.                 Upload(opFilDlg.FileName);
241.             }
242.         }
244.         private void btnDownload_Click(object sender, EventArgs e)
245.         {
246.             FolderBrowserDialog fldDlg = new FolderBrowserDialog();
247.             if (txtUpload.Text.Trim().Length > 0)
248.             {
249.                 if (fldDlg.ShowDialog() == DialogResult.OK)
250.                 {
251.                     Download(fldDlg.SelectedPath, txtUpload.Text.Trim());
252.                 }
253.             }
254.             else
255.             {
256.                 MessageBox.Show("Please enter the File name to download");
257.             }
258.         }
260.         private void btnLstFiles_Click(object sender, EventArgs e)
261.         {
262.             string[] filenames = GetFileList();
263.             lstFiles.Items.Clear();
264.             foreach (string filename in filenames)
265.             {
266.                 lstFiles.Items.Add(filename);
267.             }
268.         }
270.         private void btndelete_Click(object sender, EventArgs e)
271.         {
272.             OpenFileDialog fldDlg = new OpenFileDialog();
273.             if (txtUpload.Text.Trim().Length > 0)
274.             {
275.                 DeleteFTP(txtUpload.Text.Trim());
276.             }
277.             else
278.             {
279.                 MessageBox.Show("Please enter the File name to delete");
280.             }
281.         }
283.         private long GetFileSize(string filename)
284.         {
285.             FtpWebRequest reqFTP;
286.             long fileSize = 0;
287.             try
288.             {
289.                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + filename));
290.                 reqFTP.Method = WebRequestMethods.Ftp.GetFileSize;
291.                 reqFTP.UseBinary = true;
292.                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
293.                 FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
294.                 Stream ftpStream = response.GetResponseStream();
295.                 fileSize = response.ContentLength;
296.                 
297.                 ftpStream.Close();
298.                 response.Close();
299.             }
300.             catch (Exception ex)
301.             {
302.                 MessageBox.Show(ex.Message);
303.             }
304.             return fileSize;
305.         }
307.         private void Rename(string currentFilename, string newFilename)
308.         {
309.             FtpWebRequest reqFTP;
310.             try
311.             {
312.                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + currentFilename));
313.                 reqFTP.Method = WebRequestMethods.Ftp.Rename;
314.                 reqFTP.RenameTo = newFilename;
315.                 reqFTP.UseBinary = true;
316.                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
317.                 FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
318.                 Stream ftpStream = response.GetResponseStream();
319.                 
320.                 ftpStream.Close();
321.                 response.Close();
322.             }
323.             catch (Exception ex)
324.             {
325.                 MessageBox.Show(ex.Message);
326.             }
327.         }
329.         private void MakeDir(string dirName)
330.         {
331.             FtpWebRequest reqFTP;
332.             try
333.             {
334.                 // dirName = name of the directory to create.
335.                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + dirName));
336.                 reqFTP.Method = WebRequestMethods.Ftp.MakeDirectory;
337.                 reqFTP.UseBinary = true;
338.                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
339.                 FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
340.                 Stream ftpStream = response.GetResponseStream();
342.                 ftpStream.Close();
343.                 response.Close();
344.             }
345.             catch (Exception ex)
346.             {
347.                 MessageBox.Show(ex.Message);
348.             }
349.         }
350.         private void btnFileSize_Click(object sender, EventArgs e)
351.         {
352.             long size = GetFileSize(txtUpload.Text.Trim());
353.             MessageBox.Show(size.ToString()+" bytes");
354.         }
356.         private void button1_Click(object sender, EventArgs e)
357.         {
358.             Rename(txtCurrentFilename.Text.Trim(), txtNewFilename.Text.Trim());
359.         }
361.         private void btnewDir_Click(object sender, EventArgs e)
362.         {
363.             MakeDir(txtNewDir.Text.Trim());
364.         }
366.         private void txtPassword_TextChanged(object sender, EventArgs e)
367.         {
368.             btnFTPSave.Enabled = true;
369.         }
371.         private void txtServerIP_TextChanged(object sender, EventArgs e)
372.         {
373.             btnFTPSave.Enabled = true;
374.         }
376.         private void txtUsername_TextChanged(object sender, EventArgs e)
377.         {
378.             btnFTPSave.Enabled = true;
379.         }
381.         private void btnFTPSave_Click(object sender, EventArgs e)
382.         {
383.             ftpServerIP = txtServerIP.Text.Trim();
384.             ftpUserID = txtUsername.Text.Trim();
385.             ftpPassword = txtPassword.Text.Trim();
386.             btnFTPSave.Enabled = false;
387.         }
389.         private void btnFileDetailList_Click(object sender, EventArgs e)
390.         {
391.             string[] filenames = GetFilesDetailList();
392.             lstFiles.Items.Clear();
393.             foreach (string filename in filenames)
394.             {
395.                 lstFiles.Items.Add(filename);
396.             }
397.         }
399.         private void lstFiles_SelectedIndexChanged(object sender, EventArgs e)
400.         {
402.         }
403.     }
404. }