Setting Request Content (Body)

Supports setting any type of request content.

HTTP declarative requests configure request content via the BodyAttribute attribute. The corresponding HTTP declarative extractor is the BodyDeclarativeExtractor type, which is responsible for parsing a single BodyAttribute attribute and building the request content configuration required by the HttpRequestBuilder instance.

1234567891011121314151617181920212223242526272829303132333435363738394041

public interface IHttpService : IHttpDeclarative{    // Marks the parameter as the request content    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body] object body);   // Automatically infers Content-Type    // Supports setting Content-Type    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body("application/json")] object body);   // or use [Body(MediaTypeNames.Application.Json)]    // Supports setting Content-Type and character set    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body("application/json; charset=utf-8")] object body);    // URL-encoded form    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body("application/x-www-form-urlencoded")] object body);    // Uses StringContent to build the URL-encoded form    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body("application/x-www-form-urlencoded", UseStringContent = true)] object body);    // Can be configured to skip URL encoding    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body("application/x-www-form-urlencoded", urlEncode = false)] object body);    // Supports raw string content    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body(RawString = true)] string body); // Default content type text/plain    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body("application/json", RawString = true)] string body);    // Supports configuring a file path (or internet address)    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body(AsFile = true)] string filePath);    // Frozen parameter types will be ignored    [Post("https://furion.net/")]    Task<string> PostStringAsync([Body] CancellationToken cancellationToken);}

Default Behavior When Content-Type Is Not Provided

When Content-Type is not specified, the framework determines Content-Type according to the following priority:

Request content headers: if Content-Type has been set via WithHeader or similar, it takes priority.
Automatic content type inference: if no content header is set, the framework automatically infers it based on the specific type of RawContent according to the following rules:
- JsonContent: application/json
- JsonNode or JsonElement
  - If it represents a JSON object or array, then application/json
  - Otherwise (e.g., a JSON scalar value), it falls back to text/plain
- FormUrlEncodedContent: application/x-www-form-urlencoded
- StringContent: text/plain
- MultipartFormDataContent: multipart/form-data
- MultipartContent (non-FormData subclasses): multipart/mixed
- ByteArrayContent, StreamContent, ReadOnlyMemoryContent: application/octet-stream
- byte[], Stream, ReadOnlyMemory<byte>: application/octet-stream
- Other custom HttpContent subclasses (no header set and none of the specific types above matched): application/octet-stream
- MultipartFile: application/octet-stream
- FileInfo: inferred from the file extension via FileTypeMapper, defaulting to application/octet-stream if it cannot be identified
- Other complex objects (non-primitive, non-enum, non-collection): application/json (assumed to be serialized to JSON)
Global default fallback value: if none of the above rules match, the value configured in HttpClientOptions.DefaultContentType is used. This value defaults to text/plain; to change this fallback value, configure it with the following code:

services.AddHttpRemote(builder => {})    .ConfigureOptions(options =>    {        // Sets the default request content type (final fallback value)        options.DefaultContentType = "application/json";    });

Parameters marked with BodyAttribute are set through the underlying httpRequestBuilder.SetContent method, and any non-frozen parameter type is supported.

Notes on URL-Encoded Form Content

By default, URL-encoded forms are built via the FormUrlEncodedContent type, but this type does not support custom request content encoding; it uses Encoding.Latin1 rather than UTF-8 by default. This may cause exceptions when submitting to certain endpoints.

To resolve this issue, set the UseStringContent property to true to build the form data using StringContent, thereby allowing a custom encoding of UTF-8.
cs
```
12345
```
public interface IHttpService : IHttpDeclarative{ [Post("https://furion.net/")] Task<string> PostStringAsync([Body("application/x-www-form-urlencoded", UseStringContent = true)] object body); // body also supports URL-encoded strings, e.g.: id=1&name=furion}
Some servers require the character set (charset) to be declared explicitly, in which case the encoding can be specified via the contentEncoding parameter, for example using UTF-8:
cs
```
12345
```
public interface IHttpService : IHttpDeclarative{ [Post("https://furion.net/")] Task<string> PostStringAsync([Body("application/x-www-form-urlencoded", "UTF-8")] object body); // body also supports URL-encoded strings, e.g.: id=1&name=furion}
When sending a remote request, this setting generates the following Content-Type request header: application/x-www-form-urlencoded; charset=UTF-8.

BodyAttribute contains the following constructors and properties:

Constructors:
- new(): applies to a parameter, treating the parameter as the request content.
- new(contentType): applies to a parameter, treating the parameter as the request content, and supports setting the content type.
- new(contentType, contentEncoding): applies to a parameter, treating the parameter as the request content, and supports setting the content type and encoding.
Properties:
- ContentType: the content type (of type string).
- ContentEncoding: the content encoding (of type string).
- UseStringContent: whether to use StringContent to build FormUrlEncodedContent, defaulting to false, and only effective when ContentType is application/x-www-form-urlencoded.
- UrlEncode: whether to URL-encode the form data (of type bool), defaulting to true.
- RawString: whether the content is a raw string (of type bool), defaulting to false, and only effective when the parameter is a string type and this property is true.
- AsFile: treats the string as a file path (internet addresses supported) (of type bool), defaulting to false, and only effective when the parameter is a string type and this property is true.
- DisposeResourcesOnRequestCompletion: whether to automatically release resources after the request completes (of type bool), defaulting to false.