C# HttpClient 4.5 multipart/form-data upload

问题:

Does anyone know how to use the HttpClient in .Net 4.5 with multipart/form-data upload?

I couldn\'t find any examples on the internet.

回答1:

my result looks like this:

public static async Task<string> Upload(byte[] image)
{
     using (var client = new HttpClient())
     {
         using (var content =
             new MultipartFormDataContent(\"Upload----\" + DateTime.Now.ToString(CultureInfo.InvariantCulture)))
         {
             content.Add(new StreamContent(new MemoryStream(image)), \"bilddatei\", \"upload.jpg\");

              using (
                 var message =
                     await client.PostAsync(\"http://www.directupload.net/index.php?mode=upload\", content))
              {
                  var input = await message.Content.ReadAsStringAsync();

                  return !string.IsNullOrWhiteSpace(input) ? Regex.Match(input, @\"http://\\w*\\.directupload\\.net/images/\\d*/\\w*\\.[a-z]{3}\").Value : null;
              }
          }
     }
}

回答2:

It works more or less like this (example using an image/jpg file):

async public Task<HttpResponseMessage> UploadImage(string url, byte[] ImageData)
{
    var requestContent = new MultipartFormDataContent(); 
    //    here you can specify boundary if you need---^
    var imageContent = new ByteArrayContent(ImageData);
    imageContent.Headers.ContentType = 
        MediaTypeHeaderValue.Parse(\"image/jpeg\");

    requestContent.Add(imageContent, \"image\", \"image.jpg\");

    return await client.PostAsync(url, requestContent);
}

(You can requestContent.Add() whatever you want, take a look at the HttpContent descendant to see available types to pass in)

When completed, you\'ll find the response content inside HttpResponseMessage.Content that you can consume with HttpContent.ReadAs*Async.

回答3:

This is an example of how to post string and file stream with HTTPClient using MultipartFormDataContent. The Content-Disposition and Content-Type need to be specified for each HTTPContent:

Here\'s my example. Hope it helps:

private static void Upload()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add(\"User-Agent\", \"CBS Brightcove API Service\");

        using (var content = new MultipartFormDataContent())
        {
            var path = @\"C:\\B2BAssetRoot\\files\\596086\\596086.1.mp4\";

            string assetName = Path.GetFileName(path);

            var request = new HTTPBrightCoveRequest()
                {
                    Method = \"create_video\",
                    Parameters = new Params()
                        {
                            CreateMultipleRenditions = \"true\",
                            EncodeTo = EncodeTo.Mp4.ToString().ToUpper(),
                            Token = \"x8sLalfXacgn-4CzhTBm7uaCxVAPjvKqTf1oXpwLVYYoCkejZUsYtg..\",
                            Video = new Video()
                                {
                                    Name = assetName,
                                    ReferenceId = Guid.NewGuid().ToString(),
                                    ShortDescription = assetName
                                }
                        }
                };

            //Content-Disposition: form-data; name=\"json\"
            var stringContent = new StringContent(JsonConvert.SerializeObject(request));
            stringContent.Headers.Add(\"Content-Disposition\", \"form-data; name=\\\"json\\\"\");
            content.Add(stringContent, \"json\");

            FileStream fs = File.OpenRead(path);

            var streamContent = new StreamContent(fs);
            streamContent.Headers.Add(\"Content-Type\", \"application/octet-stream\");
            //Content-Disposition: form-data; name=\"file\"; filename=\"C:\\B2BAssetRoot\\files\\596090\\596090.1.mp4\";
            streamContent.Headers.Add(\"Content-Disposition\", \"form-data; name=\\\"file\\\"; filename=\\\"\" + Path.GetFileName(path) + \"\\\"\");
            content.Add(streamContent, \"file\", Path.GetFileName(path));

            //content.Headers.ContentDisposition = new ContentDispositionHeaderValue(\"attachment\");

            Task<HttpResponseMessage> message = client.PostAsync(\"http://api.brightcove.com/services/post\", content);

            var input = message.Result.Content.ReadAsStringAsync();
            Console.WriteLine(input.Result);
            Console.Read();
        }
    }
}

回答4:

Here\'s a complete sample that worked for me. The boundary value in the request is added automatically by .NET.

var url = \"http://localhost/api/v1/yourendpointhere\";
var filePath = @\"C:\\path\\to\\image.jpg\";

HttpClient httpClient = new HttpClient();
MultipartFormDataContent form = new MultipartFormDataContent();

FileStream fs = File.OpenRead(filePath);
var streamContent = new StreamContent(fs);

var imageContent = new ByteArrayContent(streamContent.ReadAsByteArrayAsync().Result);
imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse(\"multipart/form-data\");

form.Add(imageContent, \"image\", Path.GetFileName(filePath));
var response = httpClient.PostAsync(url, form).Result;

回答5:

Try this its working for me.

private static async Task<object> Upload(string actionUrl)
{
    Image newImage = Image.FromFile(@\"Absolute Path of image\");
        ImageConverter _imageConverter = new ImageConverter();
        byte[] paramFileStream= (byte[])_imageConverter.ConvertTo(newImage, typeof(byte[]));

    var formContent = new MultipartFormDataContent
    {
    //send form text values here
         {new StringContent(\"value1\"),\"key1\"},
         {new StringContent(\"value2\"),\"key2\" },
    // send Image Here
         {new StreamContent(new MemoryStream(paramFileStream)),\"imagekey\",\"filename.jpg\"}
    };

    var myHttpClient = new HttpClient();
    var response = await myHttpClient.PostAsync(actionUrl.ToString(), formContent);
    string stringContent = await response.Content.ReadAsStringAsync();

    return response;
}

回答6:

Here is another example on how to use HttpClient to upload a multipart/form-data.

It uploads a file to a REST API and includes the file itself (e.g. a JPG) and additional API parameters. The file is directly uploaded from local disk via FileStream.

See here for the full example including additional API specific logic.

public static async Task UploadFileAsync(string token, string path, string channels)
{
    // we need to send a request with multipart/form-data
    var multiForm = new MultipartFormDataContent();

    // add API method parameters
    multiForm.Add(new StringContent(token), \"token\");
    multiForm.Add(new StringContent(channels), \"channels\");

    // add file and directly upload it
    FileStream fs = File.OpenRead(path);
    multiForm.Add(new StreamContent(fs), \"file\", Path.GetFileName(path));

    // send request to API
    var url = \"https://slack.com/api/files.upload\";
    var response = await client.PostAsync(url, multiForm);
}