When using WithBody(p => p.FileUpload(filePath)) the file is blocked for deletion

[GuilhermeGHN]

After making a simple request by sending a file, it is blocked for manipulation by another process, for example deleting the file itself.

I believe these methods would need some treatment to avoid this problem:

• HttpContent FileUpload(string fullPath);
• HttpContent FileUpload(FileInfo file);
• HttpContent FileUpload(IEnumerable files);

[Pathoschild]

Hi! The file stream is owned by the request message, so we'll need to dispose the request at some point. That would be a breaking change though, since it'll prevent any further access to the request (e.g. when handling the response). I'm not sure off-hand how best to handle that; we'll probably need some API changes.

As a temporary workaround, you can dispose it yourself since you know it won't be accessed later. For example:

IResponse response = null;
try
{
    response = await client
        .PostAsync("api")
        .WithBody(p => p.FileUpload(...))
        .AsResponse();

    return response.As<TModel>();
}
finally
{
    response?.Message.RequestMessage.Dispose();
    response?.Message.Dispose();
}

[GuilhermeGHN]

Hello!

I understood the problem, I am already using the following approach:

IResponse response;

using (var fs = File.OpenRead(file))
{
    var files = new List<KeyValuePair<string, Stream>>
    {
        new KeyValuePair<string, Stream>("filename", fs)
    };

    response = await client
        .PostAsync("api")
        .WithBody(p => p.FileUpload(files))
        .AsResponse();

    fs.Flush();
}

Regarding the solution without a break, I took a look at FileUpload and found that the following adjustment might be possible:

private Stream GetFileStream(FileInfo file)
{
    var memoryStream = new MemoryStream();

    using (var fileStream = file.OpenRead())
    {
        fileStream.CopyTo(memoryStream);
    }

    return memoryStream;
}

public HttpContent FileUpload(IEnumerable<FileInfo> files)
{
    return this.FileUpload(
        files.Select(file => file.Exists
            ? new KeyValuePair<string, Stream>(file.Name, this.GetFileStream(file))
            : throw new FileNotFoundException($"There's no file matching path '{file.FullName}'.")
        )
    );
}

This way, the methods I mentioned initially would be detached from the files sent as parameters, while the method that receives IEnumerable<KeyValuePair<string, Stream>> files would be left as is, being the responsibility of whoever sent the Streams to manage.

I hope I helped in some way.