Upload files with multipart requests¶

internal interface IMultipartApi
{
    [Multipart("sample-boundary")]
    [Post("/upload")]
    Task<HttpResponseMessage> UploadAsync([AliasAs("file")] StreamPart file, string title, [Query] string mode);

    [Multipart]
    [Post("/files")]
    Task<HttpResponseMessage> UploadFilesAsync(ByteArrayPart bytes, FileInfoPart file, IEnumerable<ByteArrayPart> attachments);

    [Multipart]
    [Post("/raw")]
    Task<HttpResponseMessage> UploadRawAsync(HttpContent content, Stream raw, byte[] bytes, FileInfo file);

    [Multipart]
    [Post("/metadata")]
    Task<HttpResponseMessage> UploadMetadataAsync(UploadMetadata metadata, Guid token);

    [Multipart]
    [Post("/custom")]
    Task<HttpRequestMessage> BuildAsync([AliasAs("aliased")] MultipartItem item);
}

await using MemoryStream stream = new(StreamBytes);
StreamPart file = new(stream, "report.txt", TextMediaType, "chosen-field");
using HttpResponseMessage reply = await api.UploadAsync(file, ReportTitle, "preview");
SampleCheck.Equal(Boundary, handler.Boundary);
SampleCheck.Equal("?mode=preview", handler.Query);
SampleCheck.Equal("chosen-field", handler.Parts[0].Name);
SampleCheck.Equal("report.txt", handler.Parts[0].FileName);
SampleCheck.Equal(StreamText, handler.Parts[0].Body);
SampleCheck.Equal("title", handler.Parts[1].Name);
SampleCheck.Equal(ReportTitle, handler.Parts[1].Body);
SampleCheck.Equal(true, stream.CanRead);

await using MemoryStream stream = new(StreamBytes);
StreamPart streaming = new(stream, "source.txt");
using (HttpContent content = streaming.ToContent())
{
    SampleCheck.Equal(StreamText, await content.ReadAsStringAsync());
    SampleCheck.Equal(null, content.Headers.ContentDisposition);
}

SampleCheck.Equal(true, stream.CanRead);
SampleCheck.Equal(stream.Length, stream.Position);
SampleCheck.Equal(stream, streaming.Value);
SampleCheck.Equal("source.txt", streaming.FileName);
SampleCheck.Equal(null, streaming.Name);
SampleCheck.Equal(null, streaming.ContentType);
byte[] value = ByteBytes;
ByteArrayPart bytes = new(value, BytesFileName, TextMediaType, "attachment");
SampleCheck.Equal(value, bytes.Value);
SampleCheck.Equal("attachment", bytes.Name);
SampleCheck.Equal(TextMediaType, bytes.ContentType);
using HttpContent byteContent = bytes.ToContent();
SampleCheck.Equal(ByteText, await byteContent.ReadAsStringAsync());
SampleCheck.Equal(TextMediaType, byteContent.Headers.ContentType?.MediaType);
FileInfoPart disk = new(file, "public-name.txt");
SampleCheck.Equal(file, disk.Value);
using (HttpContent diskContent = disk.ToContent())
{
    SampleCheck.Equal("disk text", await diskContent.ReadAsStringAsync());
    SampleCheck.Equal(null, diskContent.Headers.ContentType);
}

ByteArrayPart bytes = new(ByteBytes, BytesFileName, TextMediaType);
FileInfoPart disk = new(file, "download-name.txt", TextMediaType, "document");
using HttpResponseMessage reply = await api.UploadFilesAsync(bytes, disk, [new([1], "one.bin"), new([SecondByte], "two.bin")]);
SampleCheck.Equal(new MultipartAttribute().BoundaryText, handler.Boundary);
SampleCheck.Equal("bytes", handler.Parts[0].Name);
SampleCheck.Equal(BytesFileName, handler.Parts[0].FileName);
SampleCheck.Equal("document", handler.Parts[1].Name);
SampleCheck.Equal("download-name.txt", handler.Parts[1].FileName);
SampleCheck.Equal("attachments", handler.Parts[2].Name);
SampleCheck.Equal("attachments", handler.Parts[3].Name);
SampleCheck.Equal(Boundary, new MultipartAttribute(Boundary).BoundaryText);

using StringContent content = new("custom body");
content.Headers.ContentDisposition = new("form-data") { Name = "custom-field" };
await using MemoryStream stream = new("raw stream"u8.ToArray());
using HttpResponseMessage reply = await api.UploadRawAsync(content, stream, "raw bytes"u8.ToArray(), file);
SampleCheck.Equal("custom-field", handler.Parts[0].Name);
SampleCheck.Equal("raw", handler.Parts[1].FileName);
SampleCheck.Equal("bytes", handler.Parts[2].FileName);
SampleCheck.Equal(file.Name, handler.Parts[3].FileName);
SampleCheck.Equal(true, stream.CanRead);

internal sealed record UploadMetadata(string Title);

[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
[JsonSerializable(typeof(UploadMetadata))]
internal sealed partial class MultipartJsonContext : JsonSerializerContext;

private static readonly JsonSerializerOptions Options = new(MultipartJsonContext.Default.Options) { TypeInfoResolver = MultipartJsonContext.Default };

private static readonly RefitSettings Settings = new(new SystemTextJsonContentSerializer(Options));

using HttpResponseMessage reply = await api.UploadMetadataAsync(new(ReportTitle), Guid.Empty);
SampleCheck.Equal("metadata", handler.Parts[0].Name);
SampleCheck.Equal("application/json", handler.Parts[0].MediaType);
SampleCheck.Equal("{\"title\":\"Annual report\"}", handler.Parts[0].Body);
SampleCheck.Equal(Guid.Empty.ToString(), handler.Parts[1].Body);
SampleCheck.Equal(TextMediaType, handler.Parts[1].MediaType);

internal sealed class TextPart : MultipartItem
{
    private readonly string _text;

    internal TextPart(string text, string fileName)
        : base(fileName, null) => _text = text;

    internal TextPart(string text, string fileName, string? contentType, string? name)
        : base(fileName, contentType, name) => _text = text;

    protected override HttpContent CreateContent() => new StringContent(_text);
}

TextPart simple = new(Greeting, "hello.txt");
using HttpContent standalone = simple.ToContent();
SampleCheck.Equal(TextMediaType, standalone.Headers.ContentType?.MediaType);
TextPart named = new(Greeting, string.Empty, "application/x-sample", "chosen");
using HttpRequestMessage request = await api.BuildAsync(named);
using IEnumerator<HttpContent> parts = ((MultipartFormDataContent)request.Content!).GetEnumerator();
SampleCheck.Equal(true, parts.MoveNext());
HttpContent part = parts.Current;
SampleCheck.Equal(false, parts.MoveNext());
SampleCheck.Equal("chosen", part.Headers.ContentDisposition?.Name?.Trim('"'));
SampleCheck.Equal("aliased", part.Headers.ContentDisposition?.FileName?.Trim('"'));
SampleCheck.Equal("application/x-sample", part.Headers.ContentType?.MediaType);
SampleCheck.Equal(Greeting, await part.ReadAsStringAsync());

internal sealed class FormFields
{
    [AliasAs("caption")]
    public string Title { get; init; } = "Annual report";

    [Query(CollectionFormat.Multi)]
    public string[] Tags { get; init; } = ["math", "code"];

    [Query(SerializeNull = true)]
    public string? Note { get; init; }
}

internal interface IFormUploadApi
{
    [Multipart]
    [Post("/form")]
    Task<HttpResponseMessage> UploadAsync([FormObject] FormFields fields, ByteArrayPart recipe);
}

using MultipartHandler handler = new();
using HttpClient client = CreateClient(handler);
RefitSettings settings = new(new SystemTextJsonContentSerializer(MultipartJsonContext.Default.Options));
IFormUploadApi api = RestService.For<IFormUploadApi>(client, settings);
using HttpResponseMessage reply = await api.UploadAsync(new(), new("recipe"u8.ToArray(), "recipe.txt"));
SampleCheck.Equal("caption", handler.Parts[0].Name);
SampleCheck.Equal("Annual report", handler.Parts[0].Body);
SampleCheck.Equal("Tags", handler.Parts[1].Name);
SampleCheck.Equal("math", handler.Parts[1].Body);
SampleCheck.Equal("Tags", handler.Parts[2].Name);
SampleCheck.Equal("code", handler.Parts[2].Body);
SampleCheck.Equal("Note", handler.Parts[3].Name);
SampleCheck.Equal(string.Empty, handler.Parts[3].Body);
SampleCheck.Equal("recipe", handler.Parts[4].Name);
SampleCheck.Equal("recipe.txt", handler.Parts[4].FileName);
SampleCheck.Equal(true, new FormObjectAttribute() is Attribute);

const string source = """
    internal sealed class FormFields
    {
        public string Name { get; init; } = "Ada";
    }
    internal interface IFormUpload
    {
        [Refit.Multipart]
        [Refit.Post("/form")]
        System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> UploadAsync([Refit.FormObject] FormFields fields);
    }
    """;
CSharpCompilation compilation = ToolingCompilation.Create(source);
ImmutableArray<Diagnostic> diagnostics = await AnalyzerSample.DiagnoseAsync(compilation);
bool requiresReflection = AnalyzerSample.Contains(diagnostics, "RF006");

const string source = """
    internal interface ILegacyUpload
    {
        [Refit.Multipart]
        [Refit.Post("/form")]
        System.Threading.Tasks.Task UploadAsync([Refit.AttachmentName("sent.bin")] byte[] attachment);
    }
    """;
CSharpCompilation compilation = ToolingCompilation.Create(source);
bool warned = AnalyzerSample.Contains(compilation.GetDiagnostics(), ObsoleteWarning);