Wie eine multipart / form-data HTTP POST-Anforderung von C # einreichen

Question

Was ist der einfachste Weg, um eine HTTP-POST-Anfrage mit einem multipart / form-data Inhaltstyp von C # schreiben? Es muss ein besserer Weg sein, als meinen eigenen Wunsch zu bauen.

Der Grund ist, ich frage Fotos auf Flickr mit dieser api laden:

http://www.flickr.com/services/api/upload. api.html

Answer 1

Zunächst einmal gibt es nichts falsch mit rein manueller Implementierung der HTTP-Befehle des .Net Framework. Halten Sie daran, dass es ein Rahmen ist, und es soll ziemlich generisch sein.

Zweitens denke ich, können Sie versuchen, für einen Browser Implementierung in .NET zu suchen. Ich sah diese , vielleicht ist es die Frage deckt Sie gefragt Über. Oder Sie können einfach nach „ C # http setzen post request bekommen“. Eines der Ergebnisse führt zu einer nicht-freie Bibliothek, die hilfreich sein können ( Chilkat Http)

Wenn Sie Ihren eigenen Rahmen von HTTP-Befehle auf der .Net passieren schreiben - ich denke, wir alle es genießen kann, wenn man es teilt: -)

Answer 2

Wenn Sie .NET 4.5 Anwendung verwenden diese:

public string Upload(string url, NameValueCollection requestParameters, MemoryStream file)
        {

            var client = new HttpClient();
            var content = new MultipartFormDataContent();

            content.Add(new StreamContent(file));
            System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>> b = new List<KeyValuePair<string, string>>();
            b.Add(requestParameters);
            var addMe = new FormUrlEncodedContent(b);

            content.Add(addMe);
            var result = client.PostAsync(url, content);
            return result.Result.ToString();
        }

Ansonsten Basierend auf Ryans Antwort, die ich heruntergeladen habe, die Bibliothek und zwickte es ein wenig.

  public class MimePart
        {
            NameValueCollection _headers = new NameValueCollection();
            byte[] _header;

            public NameValueCollection Headers
            {
                get { return _headers; }
            }

            public byte[] Header
            {
                get { return _header; }
            }

            public long GenerateHeaderFooterData(string boundary)
            {
                StringBuilder sb = new StringBuilder();

                sb.Append("--");
                sb.Append(boundary);
                sb.AppendLine();
                foreach (string key in _headers.AllKeys)
                {
                    sb.Append(key);
                    sb.Append(": ");
                    sb.AppendLine(_headers[key]);
                }
                sb.AppendLine();

                _header = Encoding.UTF8.GetBytes(sb.ToString());

                return _header.Length + Data.Length + 2;
            }

            public Stream Data { get; set; }
        }

        public string Upload(string url, NameValueCollection requestParameters, params MemoryStream[] files)
        {
            using (WebClient req = new WebClient())
            {
                List<MimePart> mimeParts = new List<MimePart>();

                try
                {
                    foreach (string key in requestParameters.AllKeys)
                    {
                        MimePart part = new MimePart();

                        part.Headers["Content-Disposition"] = "form-data; name=\"" + key + "\"";
                        part.Data = new MemoryStream(Encoding.UTF8.GetBytes(requestParameters[key]));

                        mimeParts.Add(part);
                    }

                    int nameIndex = 0;

                    foreach (MemoryStream file in files)
                    {
                        MimePart part = new MimePart();
                        string fieldName = "file" + nameIndex++;

                        part.Headers["Content-Disposition"] = "form-data; name=\"" + fieldName + "\"; filename=\"" + fieldName + "\"";
                        part.Headers["Content-Type"] = "application/octet-stream";

                        part.Data = file;

                        mimeParts.Add(part);
                    }

                    string boundary = "----------" + DateTime.Now.Ticks.ToString("x");
                    req.Headers.Add(HttpRequestHeader.ContentType, "multipart/form-data; boundary=" + boundary);

                    long contentLength = 0;

                    byte[] _footer = Encoding.UTF8.GetBytes("--" + boundary + "--\r\n");

                    foreach (MimePart part in mimeParts)
                    {
                        contentLength += part.GenerateHeaderFooterData(boundary);
                    }

                    //req.ContentLength = contentLength + _footer.Length;

                    byte[] buffer = new byte[8192];
                    byte[] afterFile = Encoding.UTF8.GetBytes("\r\n");
                    int read;

                    using (MemoryStream s = new MemoryStream())
                    {
                        foreach (MimePart part in mimeParts)
                        {
                            s.Write(part.Header, 0, part.Header.Length);

                            while ((read = part.Data.Read(buffer, 0, buffer.Length)) > 0)
                                s.Write(buffer, 0, read);

                            part.Data.Dispose();

                            s.Write(afterFile, 0, afterFile.Length);
                        }

                        s.Write(_footer, 0, _footer.Length);
                        byte[] responseBytes = req.UploadData(url, s.ToArray());
                        string responseString = Encoding.UTF8.GetString(responseBytes);
                        return responseString;
                    }
                }
                catch
                {
                    foreach (MimePart part in mimeParts)
                        if (part.Data != null)
                            part.Data.Dispose();

                    throw;
                }
            }
        }

Answer 3

Ich habe das selbst nicht ausprobiert, aber es scheint dafür eine integrierte Möglichkeit, in C # zu sein (wenn auch nicht sehr bekannt, ein scheinbar ...):

private static HttpClient _client = null;

private static void UploadDocument()
{
    // Add test file 
    var httpContent = new MultipartFormDataContent();
    var fileContent = new ByteArrayContent(File.ReadAllBytes(@"File.jpg"));
    fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
    {
        FileName = "File.jpg"
    };

    httpContent.Add(fileContent);
    string requestEndpoint = "api/Post";

    var response = _client.PostAsync(requestEndpoint, httpContent).Result;

    if (response.IsSuccessStatusCode)
    {
        // ...
    }
    else
    {
        // Check response.StatusCode, response.ReasonPhrase
    }
}

Versuchen Sie es aus und lassen Sie mich wissen, wie es geht.

Cheers!

Answer 4

Ich habe Erfolg bei aspnetupload .com . Ich beendete meine eigene Version ihrer UploadHelper Bibliothek bis zu machen, die mit dem Compact Framework kompatibel ist. Funktioniert gut, scheint genau das zu tun, was Sie benötigen.

Answer 5

Die System.Net.WebClient Klasse kann sein, was Sie suchen. Überprüfen Sie die Dokumentation für WebClient.UploadFile, sollte es ermöglichen, eine Datei zu einer bestimmten Ressource über eine der Upload Überlastungen zu laden. Ich denke, dies ist die Methode Sie suchen verwenden, um die Daten zu veröffentlichen ...

Es kann wie verwendet werden .... beachten Sie, das nur Beispielcode ist nicht getestet ...

WebClient WebClient = new WebClient ();

webClient.UploadFile ( " http://www.url.com/ReceiveUploadedFile.aspx“, "POST", @ "c: \ myfile.txt");

Hier ist die MSDN Referenz, wenn Sie interessiert sind.

http://msdn.microsoft.com /en-us/library/system.net.webclient.uploadfile.aspx

Hope, das hilft.

Answer 6

Ich finde normalerweise Fiddler das beste Werkzeug für diesen Job sein. Sehr erleichtern Anfragen zu erstellen und sie erzeugt auch einige der Header für Sie.

Fiddler - Wie eine Anfrage erstellen