Wie implementiert man einen MediaTypeFormatter korrekt, um Anfragen vom Typ 'multipart / mixed' zu behandeln?

Betrachten ein web service geschrieben ASP.NET Web-API akzeptiert eine beliebige Anzahl von Dateien als "multipart/mixed" - Anforderung. Die helper-Methode mat wie folgt Aussehen (unter der Annahme _client ist eine Instanz von System.Net.Http.HttpClient):

public T Post<T>(string requestUri, T value, params Stream[] streams)
{
    var requestMessage = new HttpRequestMessage();
    var objectContent = requestMessage.CreateContent(
        value,
        MediaTypeHeaderValue.Parse("application/json"),
        new MediaTypeFormatter[] {new JsonMediaTypeFormatter()},
        new FormatterSelector());

    var content = new MultipartContent();
    content.Add(objectContent);
    foreach (var stream in streams)
    {
        var streamContent = new StreamContent(stream);
        streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        streamContent.Headers.ContentDisposition =
            new ContentDispositionHeaderValue("form-data")
            {
                Name = "file",
                FileName = "mystream.doc"
            };
        content.Add(streamContent);
    }

    return _httpClient.PostAsync(requestUri, content)
        .ContinueWith(t => t.Result.Content.ReadAsAsync<T>()).Unwrap().Result;
}

Die Methode, die die Anforderung akzeptiert, in der Unterklasse von ApiController hat eine Signatur wie folgt:

public HttpResponseMessage Post(HttpRequestMessage request)
{
    /* parse request using MultipartFormDataStreamProvider */
}

Im Idealfall würde ich mag, um zu definieren, wie diese, in denen Kontakt, Quelle und Ziel sind entnommen aus den 'multipart/mixed' - Inhalt auf der Grundlage der 'name' - Eigenschaft des 'Content-Disposition" - header.

public HttpResponseMessage Post(Contact contact, Stream source, Stream target)
{
    //process contact, source and target
}

Allerdings mit meiner bereits vorhandenen Unterschrift, Veröffentlichung die Daten an die server-Ergebnisse in eine InvalidOperationException mit einer Fehlermeldung:

Kein 'MediaTypeFormatter' Lesen Sie ein Objekt vom Typ
'HttpRequestMessage' mit dem media-type 'multipart/mixed'.

Gibt es eine Reihe von Beispielen, die auf das internet zum senden und empfangen von Dateien über das ASP.NET Web-API und HttpClient. Allerdings habe ich keine gefunden, die zeigen, wie mit diesem problem umzugehen.

Schaute ich mir die Implementierung einer benutzerdefinierten MediaTypeFormatter und registrieren Sie es mit der globalen Konfiguration. Jedoch, während es ist leicht zu Bearbeiten serialisieren von XML-und JSON in eine benutzerdefinierte MediaTypeFormatter es ist unklar, wie man mit 'multipart/mixed' Anfragen, die können so ziemlich alles sein.

InformationsquelleAutor der Frage bloudraak | 2012-04-05

  1. 13

    Haben Sie einen Blick auf dieses forum: http://forums.asp.net/t/1777847.aspx/1?MVC4+Beta+Web+API+und+mehrteilige+form+Daten

    Hier ist ein code-snippet (geschrieben von imran_ku07), die helfen könnten, Sie implementieren eine benutzerdefinierte formatter-Griff multipart/form-data:

    public class MultiFormDataMediaTypeFormatter : FormUrlEncodedMediaTypeFormatter
{
    public MultiFormDataMediaTypeFormatter() : base()
    {
        this.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/form-data"));
    }

    protected override bool CanReadType(Type type)
    {
        return true;
    }

    protected override bool CanWriteType(Type type)
    {
        return false;
    }

    protected override Task<object> OnReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, FormatterContext formatterContext)
    {
        var contents = formatterContext.Request.Content.ReadAsMultipartAsync().Result;
        return Task.Factory.StartNew<object>(() =>
        {
            return new MultiFormKeyValueModel(contents);
        });
    }

    class MultiFormKeyValueModel : IKeyValueModel
    {
        IEnumerable<HttpContent> _contents;
        public MultiFormKeyValueModel(IEnumerable<HttpContent> contents)
        {
            _contents = contents;
        }


        public IEnumerable<string> Keys
        {
            get
            {
                return _contents.Cast<string>();
            }
        }

        public bool TryGetValue(string key, out object value)
        {
            value = _contents.FirstDispositionNameOrDefault(key).ReadAsStringAsync().Result;
            return true;
        }
    }
}

    Anschließend müssen Sie dieses Formatierungsprogramm auf Ihre Bewerbung. Wenn dabei self-host können Sie einfach fügen Sie es hinzu, indem einschließlich:

    config.Formatters.Insert(0, new MultiFormDataMediaTypeFormatter());

    vor dem instanziieren der HttpSelfHostServer Klasse.

    -- EDIT --

    Analysieren Binär-streams benötigen Sie ein anderes Formatierungsprogramm. Hier ist eine, die ich benutze, um analysieren Bilder in einem von meinen Projekten arbeiten.

    class JpegFormatter : MediaTypeFormatter
{
    protected override bool CanReadType(Type type)
    {
        return (type == typeof(Binary));
    }

    protected override bool CanWriteType(Type type)
    {
        return false;
    }

    public JpegFormatter()
    {
        SupportedMediaTypes.Add(new MediaTypeHeaderValue("image/jpeg"));
        SupportedMediaTypes.Add(new MediaTypeHeaderValue("image/jpg"));
        SupportedMediaTypes.Add(new MediaTypeHeaderValue("image/png"));
    }

    protected override Task<object> OnReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, FormatterContext formatterContext)
    {
        return Task.Factory.StartNew(() =>
            {
                byte[] fileBytes = new byte[stream.Length];
                stream.Read(fileBytes, 0, (int)fileBytes.Length);

               return (object)new Binary(fileBytes);
            }); 
    }

    protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, FormatterContext formatterContext, TransportContext transportContext)
    {
        throw new NotImplementedException();
    }
}

    In Ihrem controller/action, Sie wollen zu tun, etwas entlang der Linien von:

    public HttpResponseMessage UploadImage(Binary File) {
 //do something with your file
}

    InformationsquelleAutor der Antwort Jed

  2. 1

    Werfen Sie einen Blick auf diese post https://stackoverflow.com/a/17073113/1944993 die Antwort von Kiran Challa ist wirklich schön!

    Den wesentlichen Teil :

    Custom In-memory-MultiaprtFormDataStreamProvider:

        public class InMemoryMultipartFormDataStreamProvider : MultipartStreamProvider
{
    private NameValueCollection _formData = new NameValueCollection();
    private List<HttpContent> _fileContents = new List<HttpContent>();

    //Set of indexes of which HttpContents we designate as form data
    private Collection<bool> _isFormData = new Collection<bool>();

    ///<summary>
    ///Gets a <see cref="NameValueCollection"/> of form data passed as part of the multipart form data.
    ///</summary>
    public NameValueCollection FormData
    {
        get { return _formData; }
    }

    ///<summary>
    ///Gets list of <see cref="HttpContent"/>s which contain uploaded files as in-memory representation.
    ///</summary>
    public List<HttpContent> Files
    {
        get { return _fileContents; }
    }

    public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
    {
        //For form data, Content-Disposition header is a requirement
        ContentDispositionHeaderValue contentDisposition = headers.ContentDisposition;
        if (contentDisposition != null)
        {
            //We will post process this as form data
            _isFormData.Add(String.IsNullOrEmpty(contentDisposition.FileName));

            return new MemoryStream();
        }

        //If no Content-Disposition header was present.
        throw new InvalidOperationException(string.Format("Did not find required '{0}' header field in MIME multipart body part..", "Content-Disposition"));
    }

    ///<summary>
    ///Read the non-file contents as form data.
    ///</summary>
    ///<returns></returns>
    public override async Task ExecutePostProcessingAsync()
    {
        //Find instances of non-file HttpContents 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);
            }
            else
            {
                _fileContents.Add(Contents[index]);
            }
        }
    }

    ///<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;
    }}

    Können Sie dann die "MemoryMultiPartDataStreamProvider" webapi wie diese :

    var provider = await Request.Content.ReadAsMultipartAsync<InMemoryMultipartFormDataStreamProvider>(new InMemoryMultipartFormDataStreamProvider());

    //access form data
    NameValueCollection formData = provider.FormData;

    //access files
    IList<HttpContent> files = provider.Files;

    InformationsquelleAutor der Antwort HoefMeistert

Schreibe einen Kommentar