Use Webclient to Upload File to Web Service

Introduction

This article shall describe an arroyo that may be used to upload whatsoever sort of a file through a web service from a Windows Forms application. The approach demonstrated does not rely on the ASP.Cyberspace file uploader control and allows the developer the opportunity to upload files programmatically and without user intervention. Such an approach may be useful for doing something like processing out the contents of a local message queue when internet service is available (if the user base were mobile and had merely intermittent connectivity). The article besides addresses the use of a file size check as a forerunner to allowing a file to upload through the service.

Figure 1: Test Application Shown Uploading a File.

Figure two: Mixed pocketbook of different file types in transient storage folder.

Getting Started

The solution contains two projects; i is an ASP.Cyberspace Spider web Service project (Uploader) and the other is a Win Forms test awarding (TestUploader) used to demonstrate uploading files through the web method provided in the spider web service project.

The web service project contains only a unmarried web service ( FileUploader ) which in turn contains only a single Spider web Method ( UploadFile ). The Win Forms application contains simply a single form which contains the controls (one textbox and two buttons used in conjunction with an OpenFileDialog control) and code necessary to select and upload files through the web service.

Figure iii: Solution Explorer with the both Projects Visible.

Code:  Uploader Web Service Project

The Uploader spider web service project is an ASP.Net web service projection containing a single web service called, "FileUploader"; this web service exposes a single web method called, "UploadFile".

The lawmaking for this web service begins with the following:

1. using  System;
2. using  System.Data;
3. using  System.Web;
4. using  Arrangement.Collections;
5. using  System.Web.Services;
6. using  System.Spider web.Services.Protocols;
7. using  System.ComponentModel;
8. using  Arrangement.IO;
9. namespace  Uploader
10. {
16.     [WebService(Namespace ="http://tempuri.org/" )]
17.     [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
18.     [ToolboxItem(false )]
19. public class  FileUploader : Organisation.Web.Services.WebService
20.     {

The class starts out with the default imports; I added System.IO to the defaults to back up the use of file and memory streams. The web service namespace is left as the default http://tempuri.org/ which of course volition have to updated if the service were deployed.

The residuum of the code supplied in this class is used to define the web method used to upload the file; the code is annotated. The essential process is that, files converted to byte arrays are passed along with the total name of the file (not the path) including the extension as arguments to the UploadFile web method. The byte array is passed to a retentivity stream, and a file stream is opened pointing to a newly created file (named the name of the original file) inside the target folder used to shop the files. In one case the file stream has been created, the memory stream is written into the file stream then the memory stream and file stream are disposed of.

The web method is setup to return a string; if all goes well, the string returned will read, "OK", if not, the error message encountered will be returned to the caller.

1. [WebMethod]
2. public string  UploadFile( byte [] f, string  fileName)
3. {
7. endeavour
8.     {
11.         MemoryStream ms =new  MemoryStream(f);
15.         FileStream fs =new  FileStream(System.Web.Hosting.HostingEnvironment.MapPath
16.                     ("~/TransientStorage/" ) +fileName, FileMode.Create);
19.         ms.WriteTo(fs);
21.         ms.Close();
22.         fs.Close();
23.         fs.Dispose();
25. return "OK" ;
26.     }
27. catch  (Exception ex)
28.     {
30. return  ex.Bulletin.ToString();
31.     }
32. }

Lawmaking:  Test Uploader Win Forms Application

The test application contains a unmarried Windows Form class; this form contains a text box used to display the proper noun of the file selected for upload, a scan push button used to launch an open file dialog box which is used to navigate to and select a file for upload, and an upload button which is used to laissez passer the file to web service so that the selected file may be stored on the server.

The lawmaking for this class begins with the post-obit:

1. using  System;
2. using  System.Collections.Generic;
3. using  System.ComponentModel;
4. using  System.Data;
5. using  System.Drawing;
6. using  System.Text;
7. using  Organization.Windows.Forms;
8. using  Arrangement.IO;
9. namespace  TestUploader
10. {
15. public  partial class  Form1 : Course
16.     {
17. public  Form1()
18.         {
19.             InitializeComponent();
20.         }
21. private void  Form1_Load( object  sender, EventArgs e)
22.         {
24.         }

Aside from the default imports, I accept added only System.IO to the list. This being necessary to back up working with files. The namespace and grade declarations are in the default configuration. In addition to Organization.IO, the project also adds in a web reference pointing to the File Uploader spider web service, the reference is given the allonym of Uploader.

The next bit of lawmaking in the class is private method used to prepare the file for submittal to the spider web service and to really brand that submittal. The lawmaking below is annotated to describe the activity merely the essential parts of the functioning are to check the file size to see if the web service will accept the file (by default, the spider web server will have uploads smaller than 4 MB in size, the spider web config file must exist updated in order to back up larger uploads), and to catechumen the file to a byte array. When everything is ready, the byte array and the proper name of the file including the extension is passed to an instance of the web service web method.

Note that, when setting upward the demo, y'all volition have remove and add the spider web reference back into the projection in order for it to work for you lot.

7. private void  UploadFile( string  filename)
8. {
9. try
10.     {
12.         String strFile = System.IO.Path.GetFileName(filename);
14.         TestUploader.Uploader.FileUploader srv =new
15.         TestUploader.Uploader.FileUploader();
17.         FileInfo fInfo =new  FileInfo(filename);
20. long  numBytes = fInfo.Length;
21. double  dLen = Convert.ToDouble(fInfo.Length / 1000000);
25. if  (dLen < four)
26.         {
29.             FileStream fStream =new  FileStream(filename,
30.             FileMode.Open, FileAccess.Read);
31.             BinaryReader br =new  BinaryReader(fStream);
33. byte [] information = br.ReadBytes(( int )numBytes);
34.             br.Close();
36. string  sTmp = srv.UploadFile(data, strFile);
37.             fStream.Close();
38.             fStream.Dispose();
41.             MessageBox.Show("File Upload Status: "  + sTmp, "File Upload" );
42.         }
43. else
44.         {
46.              MessageBox.Bear witness("The file selected exceeds the size limit for uploads." , "File Size" );
47.          }
48.     }
49. catch  (Exception ex)
50.     {
52.          MessageBox.Evidence(ex.Message.ToString(),"Upload Error" );
53.     }
54. }

Post-obit the UploadFile method, the next scrap of code is used to handle the browse push's click event. This lawmaking is used merely to display an open file dialog to the user and to take the file selected through that dialog and display the file name in the course's file proper noun text box.

6. private void  btnBrowse_Click( object  sender, EventArgs e)
7. {
8.     openFileDialog1.Title ="Open File" ;
9.     openFileDialog1.Filter ="All Files|*.*" ;
10.     openFileDialog1.FileName ="" ;
11. try
12.     {
13.         openFileDialog1.InitialDirectory ="C:\\Temp" ;
14.     }
15. catch
16.     {
18.     }
19.     openFileDialog1.ShowDialog();
20. if  (openFileDialog1.FileName == "" )
21. render ;
22. else
23.         txtFileName.Text = openFileDialog1.FileName;
24. }

The course wraps up with the button click result handler for the Upload button. This handler merely checks for text in the file name text box and, if something is at that place, it sends the value to the Upload method.

8. individual void  btnUpload_Click( object  sender, EventArgs east)
9. {
10. if  (txtFileName.Text != cord .Empty)
11.         UploadFile(txtFileName.Text);
12. else
13.         MessageBox.Testify("You must select a file first." , "No File Selected" );
14. }

That wraps upward all of the client and server side code necessary to upload any sort of file to a server from a Win Forms application.

SummaryThis commodity was intended to demonstrate an easy approach to uploading whatsoever sort of a file to a web server from a Win Forms application. This instance uses the default upload size of 4096 KB, if you demand to upload larger files, you will need to alter this value by changing the httpRuntime maxRequestLength property to the desired value; at the same time you may need to increase the executionTimeout property to a greater value as well in social club to support longer upload times. Take intendance when altering the values as Microsoft has established the default 4 MB limit to provide some rubber against attempts to upload extremely large files that may hamper access to the server.

rollinpongle.blogspot.com

Source: https://www.c-sharpcorner.com/article/upload-any-type-of-file-through-a-C-Sharp-web-service/

Share this post