net - web api rest c#

¿Es posible anular MultipartFormDataStreamProvider para que no se guarden las cargas en el sistema de archivos?

Question

Tengo una aplicación ASP.Net Web API que permite a los clientes (páginas html y aplicaciones para iPhone) cargar imágenes en. Estoy usando una tarea de carga asíncrona como se describe en este article .

Todo funciona muy bien cuando quiero guardar en el sistema de archivos porque es lo que este código hace automáticamente, detrás de las escenas parece. Pero no quiero guardar los archivos cargados en el sistema de archivos. En su lugar, quiero tomar la transmisión cargada y pasarla a un depósito de Amazon S3 utilizando AWS SDK para .Net.

Tengo el código configurado para enviar la transmisión a AWS. El problema que no puedo resolver es cómo obtener el flujo de contenido cargado desde el método de la API web en lugar de tenerlo automáticamente guardado en el disco.

Esperaba que hubiera un método virtual que pudiera anular en MultipartFormDataStreamProvider que me permitiera hacer algo más con el contenido cargado además de guardarlo en el disco, pero no parece haberlo.

¿Alguna sugerencia?

Answer 1

Dado que @KiranChalla publicó su respuesta, se introdujo una nueva clase abstracta MultipartFormDataRemoteStreamProvider en la reparación 1760: hacer que MultipartFormDataStreamProvider sea más fácil de trabajar con otras aplicaciones. para hacer esto más fácil.

El resumen de la clase hace un buen trabajo al explicar cómo usarlo:

Una implementación MultipartStreamProvider adecuada para su uso con cargas de archivos HTML para escribir contenido de archivos en un Stream almacenamiento remoto. El proveedor de flujo mira el campo de encabezado Content-Disposition y determina un Stream remoto de salida basado en la presencia de un parámetro de nombre de archivo. Si hay un parámetro de nombre de archivo en el campo de encabezado Content-Disposition, la parte del cuerpo se escribe en un Stream remoto proporcionado por GetRemoteStream . De lo contrario, se escribe en un MemoryStream .

Answer 2

Puede anular el método GetStream de MultipartFormDataStreamProvider para devolver una secuencia que no sea una secuencia de archivos sino su secuencia AWS, pero hay algunos problemas (que no detallaré aquí). En su lugar, podría crear un proveedor derivado de la clase base abstracta MultipartStreamProvider. La siguiente muestra se basa en gran medida en el código fuente real de MultipartFormDataStreamProvider y MultipartFileStreamProvider. Puede consultar here y here para obtener más detalles. Muestra a continuación:

public class CustomMultipartFormDataStreamProvider : MultipartStreamProvider
{
    private NameValueCollection _formData = new NameValueCollection(StringComparer.OrdinalIgnoreCase);

    private Collection<bool> _isFormData = new Collection<bool>();

    private Collection<MyMultipartFileData> _fileData = new Collection<MyMultipartFileData>();

    public NameValueCollection FormData
    {
        get { return _formData; }
    }

    public Collection<MultipartFileData> FileData
    {
        get { return _fileData; }
    }

    public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
    {
        // For form data, Content-Disposition header is a requirement
        ContentDispositionHeaderValue contentDisposition = headers.ContentDisposition;
        if (contentDisposition != null)
        {
            // If we have a file name then write contents out to AWS stream. Otherwise just write to MemoryStream
            if (!String.IsNullOrEmpty(contentDisposition.FileName))
            {
                // We won''t post process files as form data
                _isFormData.Add(false);

                 MyMultipartFileData fileData = new MyMultipartFileData(headers, your-aws-filelocation-url-maybe);
                 _fileData.Add(fileData);

                return myAWSStream;//**return you AWS stream here**
            }

            // We will post process this as form data
            _isFormData.Add(true);

            // If no filename parameter was found in the Content-Disposition header then return a memory stream.
            return new MemoryStream();
        }

        throw new InvalidOperationException("Did not find required ''Content-Disposition'' header field in MIME multipart body part..");
    }

    /// <summary>
    /// Read the non-file contents as form data.
    /// </summary>
    /// <returns></returns>
    public override async Task ExecutePostProcessingAsync()
    {
        // Find instances of HttpContent for which we created a memory stream and read them asynchronously
        // to get the string content and then add that as form data
        for (int index = 0; index < Contents.Count; index++)
        {
            if (_isFormData[index])
            {
                HttpContent formContent = Contents[index];
                // Extract name from Content-Disposition header. We know from earlier that the header is present.
                ContentDispositionHeaderValue contentDisposition = formContent.Headers.ContentDisposition;
                string formFieldName = UnquoteToken(contentDisposition.Name) ?? String.Empty;

                // Read the contents as string data and add to form data
                string formFieldValue = await formContent.ReadAsStringAsync();
                FormData.Add(formFieldName, formFieldValue);
            }
        }
    }

    /// <summary>
    /// Remove bounding quotes on a token if present
    /// </summary>
    /// <param name="token">Token to unquote.</param>
    /// <returns>Unquoted token.</returns>
    private static string UnquoteToken(string token)
    {
        if (String.IsNullOrWhiteSpace(token))
        {
            return token;
        }

        if (token.StartsWith("/"", StringComparison.Ordinal) && token.EndsWith("/"", StringComparison.Ordinal) && token.Length > 1)
        {
            return token.Substring(1, token.Length - 2);
        }

        return token;
    }
}

public class MyMultipartFileData
{
    public MultipartFileData(HttpContentHeaders headers, string awsFileUrl)
    {
        Headers = headers;
        AwsFileUrl = awsFileUrl;
    }

    public HttpContentHeaders Headers { get; private set; }

    public string AwsFileUrl { get; private set; }
}