Web-API-Modellbindung mit mehrteiligen Formeldaten

Ist es ein Weg, um in der Lage sein, um das Modell binden (oder was auch immer) zu geben, der das Modell aus einer multipart-form-data request in ASP.NET MVC-Web-API?

Sehe ich verschiedene blog-Beiträge, aber entweder die Dinge haben sich geändert zwischen der post und dem tatsächlichen release oder Sie nicht zeigen-Modell verbindlich arbeiten.

Dies ist ein veralteter post: Senden von HTML-Formular-Daten

und daher wird dies: Asynchrone Datei-Upload verwenden ASP.NET Web-API

Ich fand diesen code (und ein bisschen modifiziert) irgendwo liest die Werte manuell ein:

Modell:

public class TestModel
{
    [Required]
    public byte[] Stream { get; set; }

    [Required]
    public string MimeType { get; set; }
}

Controller:

    public HttpResponseMessage Post()
    {
        if (!Request.Content.IsMimeMultipartContent("form-data"))
        {
            throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
        }

        IEnumerable<HttpContent> parts = Request.Content.ReadAsMultipartAsync().Result.Contents;


        string mimeType;
        if (!parts.TryGetFormFieldValue("mimeType", out mimeType))
        {
            return Request.CreateResponse(HttpStatusCode.BadRequest);
        }

        var media = parts.ToArray()[1].ReadAsByteArrayAsync().Result;

        //create the model here
        var model = new TestModel()
            {
                MimeType = mimeType,
                Stream = media
            };
        //save the model or do something with it
        //repository.Save(model)

        return Request.CreateResponse(HttpStatusCode.OK);
    }

Test:

[DeploymentItem("test_sound.aac")]
[TestMethod]
public void CanPostMultiPartData()
{
    var content = new MultipartFormDataContent { { new StringContent("audio/aac"),  "mimeType"}, new ByteArrayContent(File.ReadAllBytes("test_sound.aac")) };

    this.controller.Request = new HttpRequestMessage {Content = content};
    var response = this.controller.Post();

    Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
}

Dieser code ist im Grunde zerbrechlich, un-wartbar und weitere, nicht durchsetzen, das Modell, die verbindlich oder Daten Anmerkung Einschränkungen.

Gibt es einen besseren Weg, dies zu tun?

Update: ich habe gesehen, dass dieses post und das macht mich denken - muss ich haben, schreiben Sie eine neue Formatierer für jedes einzelne Modell, die ich unterstützen möchte?

InformationsquelleAutor der Frage Mrchief | 2012-09-26

@Mark Jones verlinkt zu meinem blog-post http://lonetechie.com/2012/09/23/web-api-generic-mediatypeformatter-for-file-upload/ das führte mich hier. Ich habe, um darüber nachzudenken, wie zu tun, was Sie wollen.

Ich glaube, wenn Sie kombinieren meine Methode zusammen mit TryValidateProperty() sollten Sie in der Lage sein zu vollbringen, was Sie brauchen. Meine Methode bekommt ein Objekt deserialisiert wird, jedoch nicht der Griff einer Validierung. Sie müssten, um evtl reflektion verwenden, um eine Schleife durch die Eigenschaften des Objekts dann manuell aufrufen TryValidateProperty() auf jeden. Diese Methode ist ein wenig mehr die Hände auf, aber ich bin mir nicht sicher wie sonst, es zu tun.

http://msdn.microsoft.com/en-us/library/dd382181.aspx
http://www.codeproject.com/Questions/310997/TryValidateProperty-not-work-with-generic-function

Edit: Jemand anderes diese Frage gestellt und ich beschlossen, diese zu Programmieren, nur um sicherzustellen, dass es funktionieren würde. Hier ist meine aktuelle code aus meinem blog mit der Validierung überprüft.

public class FileUpload<T>
{
    private readonly string _RawValue;

    public T Value { get; set; }
    public string FileName { get; set; }
    public string MediaType { get; set; }
    public byte[] Buffer { get; set; }

    public List<ValidationResult> ValidationResults = new List<ValidationResult>(); 

    public FileUpload(byte[] buffer, string mediaType, 
                      string fileName, string value)
    {
        Buffer = buffer;
        MediaType = mediaType;
        FileName = fileName.Replace("\"","");
        _RawValue = value;

        Value = JsonConvert.DeserializeObject<T>(_RawValue);

        foreach (PropertyInfo Property in Value.GetType().GetProperties())
        {
            var Results = new List<ValidationResult>();
            Validator.TryValidateProperty(Property.GetValue(Value),
                                          new ValidationContext(Value) 
                                          {MemberName = Property.Name}, Results);
            ValidationResults.AddRange(Results);
        }
    }

    public void Save(string path, int userId)
    {
        if (!Directory.Exists(path))
        {
            Directory.CreateDirectory(path);
        }

        var SafeFileName = Md5Hash.GetSaltedFileName(userId,FileName);
        var NewPath = Path.Combine(path, SafeFileName);

        if (File.Exists(NewPath))
        {
            File.Delete(NewPath);
        }

        File.WriteAllBytes(NewPath, Buffer);

        var Property = Value.GetType().GetProperty("FileName");
        Property.SetValue(Value, SafeFileName, null);
    }
}

InformationsquelleAutor der Antwort Particleman

7

Es ist ein gutes Beispiel für einen generischen Formatierung für die Datei-uploads hier http://lonetechie.com/2012/09/23/web-api-generic-mediatypeformatter-for-file-upload/. Wenn ich gehen zu müssen, mehrere Controller akzeptieren, Datei-uploads, dann wäre dies der Ansatz, den ich nehmen würde.

P. S. suchte, wie es scheint, ein besseres Beispiel für deinen upload in den controller http://www.strathweb.com/2012/08/a-guide-to-asynchronous-file-uploads-in-asp-net-web-api-rtm/

Update

Re: Die Nützlichkeit der Mehrteiligen Ansatz, dies wird abgedeckt hier aber effektiv das läuft darauf hinaus, die multipart-Ansatz, der gut zu bauen, für deutlich zu große binäre payloads etc...

Ist STANDARD-Modell verbindlich, zur Arbeit zu gehen?

Den standard/default-Modell-binder für die WebApi ist nicht dazu gebaut, fertig mit dem Modell, das Sie angegeben haben, d.h. ein Mix von einfachen Typen und Streams & byte-arrays (nicht so einfach)... Dies ist ein Zitat aus der Artikel inspiriert, die der lonetechie:

"Einfache Typen" verwendet-Modell verbindlich. Komplexe Typen verwendet der Formatierer.
Eine "einfache Art" beinhaltet: primitive, TimeSpan, DateTime, Guid,
Decimal, String, oder etwas mit einem TypeConverter konvertiert von
strings

Ihre Verwendung von einem byte-array auf Ihr Modell und die Notwendigkeit zu erstellen, die aus einem stream/Inhalt der Anfrage gehen Sie direkt zu verwenden Formatierer statt.

Senden Modell und Dateien separat?

Ich persönlich würde schauen das separate Datei hochladen aus dem Modell... vielleicht nicht eine option für dich... so würden Sie POST an den gleichen Controller und die route, wenn Sie eine MultiPart-Daten content-Typ dieser ruft den Datei-Upload-formatter und wenn Sie application/json "oder" x-www-form-urlencoded dann tut es einfach Typ Modell binden... Zwei POST ' s können aus der Frage für Sie, aber es ist eine option...

Benutzerdefinierte binder Modell?

Ich hatte einige kleinere Erfolge mit einem benutzerdefinierte binder Modell, Sie können etwas tun mit diesem vielleicht... könnte dies gemacht werden generische (mit moderatem Aufwand) und konnte registriert werden weltweit in den binder-Anbieter für die Wiederverwendung...

Dieser Wert sein, um einen spielen zu können?
```
public class Foo
{
    public byte[] Stream { get; set; }
    public string Bar { get; set; }
}

public class FoosController : ApiController
{

    public void Post([ModelBinder(typeof(FileModelBinder))] Foo foo)
    {
        //
    }
}
```
Benutzerdefinierte binder Modell:
```
public class FileModelBinder : System.Web.Http.ModelBinding.IModelBinder
{
    public FileModelBinder()
    {

    }

    public bool BindModel(
        System.Web.Http.Controllers.HttpActionContext actionContext,
        System.Web.Http.ModelBinding.ModelBindingContext bindingContext)
    {
        if (actionContext.Request.Content.IsMimeMultipartContent())
        {
            var inputModel = new Foo();

            inputModel.Bar = "";  //From the actionContext.Request etc
            inputModel.Stream = actionContext.Request.Content.ReadAsByteArrayAsync()
                                            .Result;

            bindingContext.Model = inputModel;
            return true;
        }
        else
        {
            throw new HttpResponseException(actionContext.Request.CreateResponse(
             HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
        }
    }
}
```
InformationsquelleAutor der Antwort Mark Jones

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.