Post byte array to Web API server using HttpClient

Question

I want to post this data to Web API server:

public sealed class SomePostRequest
{
    public int Id { get; set; }
    public byte[] Content { get; set; }
}

Using this code for server:

[Route("Incoming")]
[ValidateModel]
public async Task<IHttpActionResult> PostIncomingData(SomePostRequest requestData)
{
    // POST logic here
}

and this - for client:

var client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:25001/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
    new MediaTypeWithQualityHeaderValue("application/json"));

var content = new FormUrlEncodedContent(new Dictionary<string, string>
{
    { "id", "1" },
    { "content", "123" }
});

var result = await client.PostAsync("api/SomeData/Incoming", content);
result.EnsureSuccessStatusCode();

everything works fine (at least, debugger stops at breakpoint in PostIncomingData).

Since there is a byte array, I don't want to serialize it as JSON, and want to post it as binary data to decrease network traffic (something like application/octet-stream).

How this can be achieved?

I've tried to play with MultipartFormDataContent, but looks like I just can't understand, how MultipartFormDataContent will match signature of controller's method.

E.g., replacing content to this:

var content = new MultipartFormDataContent();
content.Add(new FormUrlEncodedContent(new Dictionary<string, string> { { "id", "1" } }));

var binaryContent = new ByteArrayContent(new byte[] { 1, 2, 3 });
binaryContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
content.Add(binaryContent, "content");

var result = await client.PostAsync("api/SomeData/Incoming", content);
result.EnsureSuccessStatusCode();

leads to error 415 ("Unsupported media type").

Yuval Itzchakov · Accepted Answer · 2017-01-24 09:25:27Z

39

WebAPI v2.1 and beyond supports BSON (Binary JSON) out of the box, and even has a MediaTypeFormatter included for it. This means you can post your entire message in binary format.

If you want to use it, you'll need to set it in WebApiConfig:

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.Formatters.Add(new BsonMediaTypeFormatter());
    }
}

Now, you an use the same BsonMediaTypeFormatter at the client side to serialize your request:

public async Task SendRequestAsync()
{
    var client = new HttpClient
    {
        BaseAddress = new Uri("http://www.yourserviceaddress.com");
    };

    // Set the Accept header for BSON.
    client.DefaultRequestHeaders.Accept.Clear();
    client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/bson"));

    var request = new SomePostRequest
    {
        Id = 20,
        Content = new byte[] { 2, 5, 7, 10 }
    };

    // POST using the BSON formatter.
    MediaTypeFormatter bsonFormatter = new BsonMediaTypeFormatter();
    var result = await client.PostAsync("api/SomeData/Incoming", request, bsonFormatter);

    result.EnsureSuccessStatusCode();
}

Or, you can use Json.NET to serialize your class to BSON. Then, specify you want to use "application/bson" as your "Content-Type":

public async Task SendRequestAsync()
{   
    using (var stream = new MemoryStream())
    using (var bson = new BsonWriter(stream))
    {
        var jsonSerializer = new JsonSerializer();

        var request = new SomePostRequest
        {
            Id = 20,
            Content = new byte[] { 2, 5, 7, 10 }
        };

        jsonSerializer.Serialize(bson, request);

        var client = new HttpClient
        {
            BaseAddress = new Uri("http://www.yourservicelocation.com")
        };

        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/bson"));

        var byteArrayContent = new ByteArrayContent(stream.ToArray());
        byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/bson");

        var result = await client.PostAsync(
                "api/SomeData/Incoming", byteArrayContent);

        result.EnsureSuccessStatusCode();
    }
}

edited Jan 24, 2017 at 9:25

answered Aug 24, 2015 at 15:00

Yuval Itzchakov

150k32 gold badges275 silver badges333 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Dennis Over a year ago

Thanks, it works perfectly. Actually, the link you've provided contains more simple example for the client side.

Yuval Itzchakov Over a year ago

@Dennis It uses the BsonMediaTypeFormatter to serialize. I guess you can have it either way. I'll add another example to my answer.

Minh Nguyen Over a year ago

Your second code sample missing content type:

var byteArrayContent = new ByteArrayContent(stream.ToArray()); byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/bson");  var result = await client.PostAsync(                 "api/SomeData/Incoming", byteArrayContent);

PandaWood Over a year ago

How are you consuming this in the controller...? using your 2nd example there, I get UnsupportedMediaType exception on the server - .Net5 web api

yu yang Jian · Accepted Answer · 2019-10-30 04:59:27Z

20

I convert Byte Array into Base64 String to post:

await client.PostAsJsonAsync( apiUrl,  
    new  {
        message = "",
        content = Convert.ToBase64String(yourByteArray),
    }
);

and receiver can convert the Base64 String back to Byte Array by:

string base64Str = (string)postBody.content;
byte[] fileBytes = Convert.FromBase64String(base64Str);

edited Oct 30, 2019 at 4:59

answered Oct 2, 2018 at 9:01

yu yang Jian

7,2938 gold badges61 silver badges88 bronze badges

5 Comments

Ray Cheng Over a year ago

I would say it's simple but not effective since the base64 string will be about 30% larger. Nevertheless, a working quick solution.

Eike Over a year ago

@RayCheng I'd say it's simple and effective but not efficient.

John Lord Over a year ago

it also assumes you have control over the api, which you probably don't

Iver Cold Over a year ago

How should reciever method look like? Where postBody variable is taken from?

yu yang Jian Over a year ago

it may be like: stackoverflow.com/questions/37842231/…

Minh Nguyen · Accepted Answer · 2017-12-22 08:59:35Z

7

I have created this generic and cross platform method to support the BSON format using the Json.NET library so we can reuse it easier later. It works fine in Xamarin platform as well.

public static async HttpResponseMessage PostBsonAsync<T>(string url, T data)
{
    using (var client = new HttpClient())
    {
        //Specifiy 'Accept' header As BSON: to ask server to return data as BSON format
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/bson"));

        //Specify 'Content-Type' header: to tell server which format of the data will be posted
        //Post data will be as Bson format                
        var bSonData = HttpExtensions.SerializeBson<T>(data);
        var byteArrayContent = new ByteArrayContent(bSonData);
        byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/bson");

        var response = await client.PostAsync(url, byteArrayContent);

        response.EnsureSuccessStatusCode();

        return response;
    }
}

The method to help to serialise data to BSON format:

public static byte[] SerializeBson<T>(T obj)
{
    using (MemoryStream ms = new MemoryStream())
    {
        using (BsonWriter writer = new BsonWriter(ms))
        {
            JsonSerializer serializer = new JsonSerializer();
            serializer.Serialize(writer, obj);
        }

        return ms.ToArray();
    }
}

Then you can use the Post method like this:

var response = await PostBsonAsync<SamplePostRequest>("api/SomeData/Incoming", requestData);

edited Dec 22, 2017 at 8:59

answered Feb 29, 2016 at 13:25

Minh Nguyen

2,2112 gold badges31 silver badges34 bronze badges

1 Comment

PandaWood Over a year ago

This is good but HttpClient is intended to be instantiated once per application - this code will likely exhaust the number of sockets available under heavy loads - see Microsoft docs - any version of .NET - learn.microsoft.com/en-us/dotnet/api/…

iowatiger08 · Accepted Answer · 2017-08-17 16:12:43Z

3

Fyi, for protobuf serialization to request body posts

        LoginRequest loginRequest = new LoginRequest()
        {
            Code = "UserId",
            Password = "myPass",
            CMToken = "eIFt4lYTKGU:APA91bFZPe3XCDL2r1JUJuEQLlN3FoeFw9ULpw8ljEavNdo9Lc_-Qua4w9pTqdOFLTb92Kf03vyWBqkcvbBfYEno4NQIvp21kN9sldDt40eUOdy0NgMRXf2Asjp6FhOD1Kmubx1Hq7pc",
        };
        byte[] rawBytes = ProtoBufSerializer.ProtoSerialize<LoginRequest>(loginRequest);

        var client = new HttpClient();
        client.BaseAddress = new Uri("http://localhost:9000/");
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/x-protobuf"));

        //var bSonData = HttpExtensions.SerializeBson<T>(data);
        var byteArrayContent = new ByteArrayContent(rawBytes);
        byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-protobuf");

        var result = client.PostAsync("Api/Login", byteArrayContent).Result;

        Console.WriteLine(result.IsSuccessStatusCode);

answered Aug 17, 2017 at 16:12

iowatiger08

1,96224 silver badges32 bronze badges

1 Comment

user1034912 Over a year ago

How to consume??

Bart Vanseer · Accepted Answer · 2023-01-31 10:41:32Z

I wanted to send it truly binary like I did with WebClient before not make it multipart.

Using inspiration from this question I got it working this way:

HttpClient InternalHttpClient = new HttpClient();
HttpContent BinaryContent = new ByteArrayContent(new byte[] { 1, 2, 3 });
byte[] ReceivedData = new byte[0];

using (HttpResponseMessage ResponseMessage = InternalHttpClient.PostAsync("apiurl/binarycomms.aspx", BinaryContent).Result)
{
    using (HttpContent ResponseBytes = ResponseMessage.Content)
    {
        ReceivedData = ResponseBytes.ReadAsByteArrayAsync().Result;
    }
}

On the server side the code is also fully binary:

protected void Page_Load(object sender, EventArgs e)
{
    Page.Response.ContentType = "application/octet-stream";

    byte[] Challenge = Page.Request.BinaryRead(Request.TotalBytes);

    Page.Response.BinaryWrite(new byte[] { 10, 20, 30 });
}

You can easily add compression to this communication to make the bandwidth usage even smaller.

Love to hear comments should I have missed something or if this is off topic, but it works like a charm for me.

Collectives™ on Stack Overflow

Post byte array to Web API server using HttpClient

5 Answers 5

4 Comments

5 Comments

1 Comment

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

4 Comments

5 Comments

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related