Receive-Datei und andere Daten in das Formular zusammen in ASP.NET Kern-Web-API (boundary-based request parsing)

Wie würdest du deine Parameter für die action Methode, die Sie empfangen sollten eine file und eine text Wert aus der Anfrage?

Habe ich versucht, dieses

public string Post([FromBody]string name, [FromBody]IFormFile imageFile)

Und versucht, es zu schlagen aus den Briefträger, aber es gibt mir 500 Internal Server Error. Ich kann mir auch nicht Debuggen, weil es nie zuvor auf die erste Anweisung innerhalb der action-Methode, wo habe ich mein Haltepunkt.

Irgendeine Idee, wie können wir analysieren Grenze basierte Anforderungen und extrahieren der Datei(en) und anderen textlichen Bereich(en)? Ich bin neu ASP.NET Core.

Jede Lösung für dieses Problem?
Ich hatte entwickelt, die separate API für die form von Daten und Bildern, aber Sie sollten versuchen, Antworten, die von Benutzern veröffentlicht.

InformationsquelleAutor shashwat | 2016-11-16

Ich hatte das ähnliche Problem und ich habe das problem gelöst, indem Sie mit [FromForm] - Attribut und FileUploadModelView in der Funktion wie folgt:

[HttpPost]
        [Route("upload")]
        public async Task<IActionResult> Upload([FromForm] FileUploadViewModel model, [FromForm] string member_code)
        {
            var file = model.File;

            ...
        }

InformationsquelleAutor Ye Yint

Ich bin mit dem folgenden code, um dies zu erreichen, um zu analysieren eine Antwort von Mailgun, der aus den beiden Dateien und text-Werte.

Bitte beachten Sie, dass "dashifying" ist nur, damit property-Namen wie "MessageHeaders" erhalten verwandelte sich in "message-Header"; natürlich sollten Sie verwenden, was Logik Sinn macht, für Ihren Fall.

Controller:

using System;
using Microsoft.AspNetCore.Mvc;
using NuGet.Protocol.Core.v3;

namespace Potato
{
    [Route("api/[controller]")]
    public class MailgunController : Controller
    {
        [HttpPost]
        public IActionResult Post()
        {
            MailgunEmail email = new MailgunEmail(Request);

            return Ok(email.ToJson());
        }
    }
}

Modell:

using System;
using System.Reflection;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;

namespace Potato
{
    public class MailgunEmail
    {
        public IEnumerable<IFormFile> Attachments { get; set; }

        public string Recipient { get; set; }
        public string Sender { get; set; }
        public string From { get; set; }
        public string Subject { get; set; }
        public string BodyPlain { get; set; }
        public string StrippedText { get; set; }
        public string StrippedSignature { get; set; }
        public string BodyHtml { get; set; }
        public string StrippedHtml { get; set; }
        public int? AttachmentCount { get; set; }
        public int Timestamp { get; set; }
        public string Token { get; set; }
        public string Signature { get; set; }
        public string MessageHeaders { get; set; }
        public string ContentIdMap { get; set; }

        public MailgunEmail(HttpRequest request)
        {
            var form = request.Form;

            Attachments = new List<IFormFile>(form.Files);

            foreach (var prop in typeof(MailgunEmail).GetProperties()) {
                string propName = Dashify(prop.Name);
                var curVal = form[propName];
                if (curVal.Count > 0) {
                    prop.SetValue(this, To(curVal[0], prop.PropertyType), null);
                }
            }
        }

        private object To(IConvertible obj, Type t)
        {
            Type u = Nullable.GetUnderlyingType(t);

            if (u != null) {
                return (obj == null) ? GetDefaultValue(t) : Convert.ChangeType(obj, u);
            } else {
                return Convert.ChangeType(obj, t);
            }
        }

        private object GetDefaultValue(Type t)
        {
            if (t.GetTypeInfo().IsValueType) {
                return Activator.CreateInstance(t);
            }
            return null;
        }

        private string Dashify(string source)
        {
            string result = "";
            var chars = source.ToCharArray();
            for (int i = 0; i < chars.Length; ++i) {
                var c = chars[i];
                if (i > 0 && char.IsUpper(c)) {
                    result += '-';
                }
                result += char.ToLower(c);
            }
            return result;
        }
    }
}

InformationsquelleAutor Daniel Centore

1

Diese Seite hat mir sehr geholfen https://docs.microsoft.com/en-us/aspnet/core/mvc/models/file-uploads

so, jetzt in meinem code habe ich die controller-Methode:
```
 public async Task<IActionResult> UploadFiles(UploadedFile ups)
```
und eine Klasse für das Modell
```
public class UploadedFile
    {
        public string UploadName { get; set; }
        public List<IFormFile> Files { get; set; }
    }
```
und die form wie
```
<form method="post" enctype="multipart/form-data" asp-controller="Files" asp-action="UploadFiles">
```
danke @mslliviu, ich werde versuchen, und aktualisieren, wenn es für mich funktioniert oder nicht
Es funktioniert nicht auf einem asp.net core-2-Aktion mit Postboten. Alle die nicht Eigenschaften von Dateien gefüllt werden, die Files-Eigenschaft, es ist null. Anfrage-Objekt enthält die Dateien.

InformationsquelleAutor mslliviu
-1

Ich denke, du bist übertragung der Datei und den text in der richtigen JSON-format.

Erstellen Sie eine neue Klasse, die enthält die Datei-und text als Eigenschaften vom Typ string. Fügen Sie die neue Klasse, um Ihre Methode Argumente, die mit dem Attribut[FromBody] und Sie werden in der Lage sein, um eine Analyse der image-Zeichenfolge entsprechend Ihrer Bedürfnisse.

Andere Möglichkeit wäre der Zugriff auf die gesamten Inhalte anfordern, über
```
await Request.Content.ReadAsStringAsync();
```
Würden Sie dann analysieren den gesamten Inhalt, obwohl.

Ich habe nicht Content Eigenschaft in Request Objekt. Ich bin auch nicht die übertragung der Datei und text im JSON-Format. Ich Frage mich, ob es möglich ist, leicht. Ich sende in multipart/form-data (boundary-based-Anfragen). Sorry, aber deine Lösung kann nicht für mich arbeiten.

InformationsquelleAutor FelschR

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.