Verarbeitung von binären Daten in der Web-API aus einer POST-oder PUT-REST-Anforderung

Ich bin derzeit an der Entwicklung einer REST web service mit Web-API. Ich habe ein problem festgestellt Verarbeitung binäre Daten (ein Bild), die übermittelt wurden, über eine POST-Anfrage.

Aus der Sicht des client, habe ich es geschafft zum senden von binären Daten mit Hilfe der jQuery Form Plugin. Aber da bin ich sehr neu auf .NET (ich bin ein PHP-Entwickler), bin ich Schwierigkeiten haben, die Verarbeitung dieser Binär-Daten über die Web-API auf dem server.

Um zu bestätigen, dass die jQuery Form Plugin sendet die Bilddaten richtig, ich habe geschrieben eine Arbeit PHP handler, macht Gebrauch von der einfachen $_FILE Globale variable.

Nun bin ich versucht zu erreichen, das gleiche über die Web-API. Hier ist ein überblick von dem, was ich ausprobiert habe. Wie kann ich den Zugriff auf die binären Daten, die gesendet wurde?

Modell:

namespace EDHDelivery.Models
{
    public class Oferta
    {
        public int OfertaID { get; set; }
        public string Nombre { get; set; }
        public string Imagen { get; set; }
        public int ComercioID { get; set; }
    }
}

Controller (teilweise gezeigten code):

public Oferta Add(Oferta item)
{
    /*here my item will have the POST body with form values, 
    automatically serialized by the framework and I think an image binary*/
    var n = item.Nombre; //...etc.
}
InformationsquelleAutor goseta | 2013-02-06
  1. 9

    Kurz gesagt, Sie senden die Daten als multipart/form-data (die, ich bin mir ziemlich sicher, Sie tun dies bereits über das plugin, die Sie erwähnt) und dann haben Sie, um zu extrahieren, die Daten über eine Web-API MultipartContent Anbieter.

    Gibt es viele Ressourcen, die erklären, wie das:

    InformationsquelleAutor Filip W
  2. 2

    Das gleiche habe ich erreicht

    Dies ist mein upload Benutzer-Klasse

    public class UploadUserFile
{
    string _Token;
    string _UserId;
    string _IPAddress;
    string _DeviceInfo;
    string _FileName;
    string _ContentType;
    Stream _PhotoStream;

   public string Token
    {
        get
        {
            return _Token;

        }

        set
        {
            _Token = value;
        }
    }
    public string UserId
    {
        get
        {
            return _UserId;
        }
        set
        {
            _UserId = value;
        }
    }
    public string IPAddress
    {
        get
        {
            return _IPAddress;
        }
        set
        {
            _IPAddress = value;
        }
    }
    public string DeviceInfo
    {
        get
        {
            return _DeviceInfo;
        }
        set
        {
            _DeviceInfo = value;
        }

    }
    public string FileName
    {
        get
        {
            return _FileName;
        }
        set
        {
            _FileName = value;
        }
    }
    public string ContentType
    {
        get
        {
            return _ContentType;

        }
        set
        {
            _ContentType = value;
        }

    }

    public Stream PhotoStream
    {
        get
        {
            return _PhotoStream;
        }
        set
        {
            PhotoStream = value;
        }
    }

}

    Dies ist mein API Controller Klasse 

     public class UploadUserPhotoController : ApiController
{


    ///<summary>
    ///</summary>
    ///<param name="request">
    ///HttpRequestMessage, on the other hand, is new in .NET 4.5. 
    ///It is part of System.Net. 
    ///It can be used both by clients and services to create, send and receive requests and 
    ///responses over HTTP. 
    ///It replaces HttpWebRequest, which is obsolete in .NET 4.5 
    ///</param>
    ///<returns>return the response of the Page <returns>
    [HttpPost]
    public async Task<HttpResponseMessage> Post(HttpRequestMessage request)
    {

        var httpRequest = HttpContext.Current.Request;
        var UploadUserFileObj = new UploadUserFile
        {
            Token = request.GetQueryNameValuePairs().AsEnumerable().Where(x => x.Key == "Token").FirstOrDefault().Value.ToString(),
            UserId = request.GetQueryNameValuePairs().AsEnumerable().Where(x => x.Key == "UserId").FirstOrDefault().Value.ToString(),
            IPAddress = request.GetQueryNameValuePairs().AsEnumerable().Where(x => x.Key == "IPAddress").FirstOrDefault().Value.ToString(),
            ContentType = request.GetQueryNameValuePairs().AsEnumerable().Where(x => x.Key == "ContentType").FirstOrDefault().Value.ToString(),
            DeviceInfo = request.GetQueryNameValuePairs().AsEnumerable().Where(x => x.Key == "DeviceInfo").FirstOrDefault().Value.ToString(),
            FileName = request.GetQueryNameValuePairs().AsEnumerable().Where(x => x.Key == "FileName").FirstOrDefault().Value.ToString()
        };
        Stream requestStream = await request.Content.ReadAsStreamAsync();
        HttpResponseMessage result = null;

        if (requestStream!=null)
        {
            try
            {
                if(string.IsNullOrEmpty(UploadUserFileObj.FileName))
                {
                    UploadUserFileObj.FileName = "DefaultName.jpg";
                }

                //Create a FileStream object to write a stream to a file
                using (FileStream fileStream = System.IO.File.Create(HttpContext.Current.Server.MapPath("~/locker/" + UploadUserFileObj.FileName), (int)requestStream.Length))
                {
                    //Fill the bytes[] array with the stream data
                    byte[] bytesInStream = new byte[requestStream.Length];
                    requestStream.Read(bytesInStream, 0, (int)bytesInStream.Length);
                    //Use FileStream object to write to the specified file
                    fileStream.Write(bytesInStream, 0, bytesInStream.Length);
                    result = Request.CreateResponse(HttpStatusCode.Created, UploadUserFileObj.FileName);
                }
            }
            catch (HttpException ex)
            {
                return result = Request.CreateResponse(HttpStatusCode.BadGateway,"Http Exception Come"+ ex.Message);
            }
            catch(Exception ex)
            {
                return result = Request.CreateResponse(HttpStatusCode.BadGateway, "Http Exception Come" + ex.Message);
            }
        }
        else
        {
            return result = Request.CreateResponse(HttpStatusCode.BadGateway, "Not eble to upload the File ");
        }
        return result;
    }
}

    In diesem code verwende ich den

    HttpRequestMessage zum Übertragen von Daten zwischen clinet server zu server zu client.

    InformationsquelleAutor mukesh UN singh
Schreibe einen Kommentar