UploadFile with POST values by WebClient

Question

I want to upload file to a host by using WebClient class. I also want to pass some values which should be displayed in the $_POST array on the server part (PHP). I want to do it by one connect

I've used code bellow

using (WebClient wc = new WebClient())
{
    wc.Encoding = Encoding.UTF8;
    NameValueCollection values = new NameValueCollection();
    values.Add("client", "VIP");
    values.Add("name", "John Doe"); 
    wc.QueryString = values; // this displayes in $_GET
    byte[] ans= wc.UploadFile(address, dumpPath);
}

If i've used QueryString property, the values displayed in $_GET array.But i want to send it by post method

Answer 1

There's nothing built-in that allows you to do that. I have blogged about an extension that you could use. Here are the relevant classes:

public class UploadFile
{
    public UploadFile()
    {
        ContentType = "application/octet-stream";
    }
    public string Name { get; set; }
    public string Filename { get; set; }
    public string ContentType { get; set; }
    public Stream Stream { get; set; }
}

public byte[] UploadFiles(string address, IEnumerable<UploadFile> files, NameValueCollection values)
{
    var request = WebRequest.Create(address);
    request.Method = "POST";
    var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x", NumberFormatInfo.InvariantInfo);
    request.ContentType = "multipart/form-data; boundary=" + boundary;
    boundary = "--" + boundary;

    using (var requestStream = request.GetRequestStream())
    {
        // Write the values
        foreach (string name in values.Keys)
        {
            var buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
            requestStream.Write(buffer, 0, buffer.Length);
            buffer = Encoding.ASCII.GetBytes(string.Format("Content-Disposition: form-data; name=\"{0}\"{1}{1}", name, Environment.NewLine));
            requestStream.Write(buffer, 0, buffer.Length);
            buffer = Encoding.UTF8.GetBytes(values[name] + Environment.NewLine);
            requestStream.Write(buffer, 0, buffer.Length);
        }

        // Write the files
        foreach (var file in files)
        {
            var buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
            requestStream.Write(buffer, 0, buffer.Length);
            buffer = Encoding.UTF8.GetBytes(string.Format("Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"{2}", file.Name, file.Filename, Environment.NewLine));
            requestStream.Write(buffer, 0, buffer.Length);
            buffer = Encoding.ASCII.GetBytes(string.Format("Content-Type: {0}{1}{1}", file.ContentType, Environment.NewLine));
            requestStream.Write(buffer, 0, buffer.Length);
            file.Stream.CopyTo(requestStream);
            buffer = Encoding.ASCII.GetBytes(Environment.NewLine);
            requestStream.Write(buffer, 0, buffer.Length);
        }

        var boundaryBuffer = Encoding.ASCII.GetBytes(boundary + "--");
        requestStream.Write(boundaryBuffer, 0, boundaryBuffer.Length);
    }

    using (var response = request.GetResponse())
    using (var responseStream = response.GetResponseStream())
    using (var stream = new MemoryStream())
    {
        responseStream.CopyTo(stream);
        return stream.ToArray();
    }
}

and now you could use it in your application:

using (var stream = File.Open(dumpPath, FileMode.Open))
{
    var files = new[] 
    {
        new UploadFile
        {
            Name = "file",
            Filename = Path.GetFileName(dumpPath),
            ContentType = "text/plain",
            Stream = stream
        }
    };

    var values = new NameValueCollection
    {
        { "client", "VIP" },
        { "name", "John Doe" },
    };

    byte[] result = UploadFiles(address, files, values);
}

Now in your PHP script you could use the $_POST["client"], $_POST["name"] and $_FILES["file"].

Answer 2

If someone wants to use @darin-dimitrov s solution in an async pattern with progress reporting, that's the way to go (for .NET 4.0):

public void UploadFileAsync(NameValueCollection values, Stream fileStream)
{
    //to fire events on the calling thread
    _asyncOperation = AsyncOperationManager.CreateOperation(null);
    var ms = new MemoryStream();
    //make a copy of the input stream in case sb uses disposable stream
    fileStream.CopyTo(ms);
    //you cannot set stream position often enough to zero
    ms.Position = 0;

    Task.Factory.StartNew(() =>
    {
        try
        {
            const string contentType = "application/octet-stream";

            var request = WebRequest.Create(_url);
            request.Method = "POST";
            var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x", NumberFormatInfo.InvariantInfo);
            request.ContentType = "multipart/form-data; boundary=" + boundary;
            boundary = "--" + boundary;

            var dataStream = new MemoryStream();
            byte[] buffer;
            // Write the values
            foreach (string name in values.Keys)
            {
                buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
                dataStream.Write(buffer, 0, buffer.Length);
                buffer = Encoding.ASCII.GetBytes(string.Format("Content-Disposition: form-data; name=\"{0}\"{1}{1}", name, Environment.NewLine));
                dataStream.Write(buffer, 0, buffer.Length);
                buffer = Encoding.UTF8.GetBytes(values[name] + Environment.NewLine);
                dataStream.Write(buffer, 0, buffer.Length);
            }

            // Write the file
            buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
            dataStream.Write(buffer, 0, buffer.Length);
            buffer = Encoding.UTF8.GetBytes($"Content-Disposition: form-data; name=\"file\"; filename=\"file\"{Environment.NewLine}");
            dataStream.Write(buffer, 0, buffer.Length);
            buffer = Encoding.ASCII.GetBytes(string.Format("Content-Type: {0}{1}{1}", contentType, Environment.NewLine));
            dataStream.Write(buffer, 0, buffer.Length);
            ms.CopyTo(dataStream);
            buffer = Encoding.ASCII.GetBytes(Environment.NewLine);
            dataStream.Write(buffer, 0, buffer.Length);

            buffer = Encoding.ASCII.GetBytes(boundary + "--");
            dataStream.Write(buffer, 0, buffer.Length);


            dataStream.Position = 0;
            //IMPORTANT: set content length to directly write to network socket
            request.ContentLength = dataStream.Length;
            var requestStream = request.GetRequestStream();

            //Write data in chunks and report progress
            var size = dataStream.Length;
            const int chunkSize = 64 * 1024;
            buffer = new byte[chunkSize];
            long bytesSent = 0;
            int readBytes;
            while ((readBytes = dataStream.Read(buffer, 0, buffer.Length)) > 0)
            {
                requestStream.Write(buffer, 0, readBytes);
                bytesSent += readBytes;

                var status = "Uploading... " + bytesSent / 1024 + "KB of " + size / 1024 + "KB";
                var percentage = Tools.Clamp(Convert.ToInt32(100 * bytesSent / size), 0, 100);
                OnFileUploaderProgressChanged(new FileUploaderProgessChangedEventArgs(status, percentage));
            }

            //get response
            using (var response = request.GetResponse())
            using (var responseStream = response.GetResponseStream())
            using (var stream = new MemoryStream())
            {
                // ReSharper disable once PossibleNullReferenceException - exception would get catched anyway
                responseStream.CopyTo(stream);
                var result = Encoding.Default.GetString(stream.ToArray());
                OnFileUploaderCompleted(result == string.Empty
                    ? new FileUploaderCompletedEventArgs(FileUploaderCompletedResult.Failed)
                    : new FileUploaderCompletedEventArgs(FileUploaderCompletedResult.Ok));
            }
        }
        catch (Exception)
        {
            OnFileUploaderCompleted(new FileUploaderCompletedEventArgs(FileUploaderCompletedResult.Failed));
        }
    }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}