Comment soumettre une demande HTTP POST multipart / form-data à partir de C #

Question

Quel est le moyen le plus simple de soumettre une demande HTTP POST avec un type de contenu multipart / form-data à partir de C #? Il doit y avoir un meilleur moyen que de formuler ma propre demande.

La raison pour laquelle je demande est de télécharger des photos sur Flickr en utilisant cette API:

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

Answer 1

Tout d’abord, l’implémentation manuelle pure des commandes HTTP à l’aide du framework .Net n’est pas un problème. N'oubliez pas qu'il s'agit d'un cadre, qui est censé être assez générique.

Deuxièmement, je pense que vous pouvez essayer de rechercher une implémentation de navigateur dans .Net. J'ai consulté celui-ci , peut-être qu'il couvre le problème que vous avez demandé sur. Vous pouvez également rechercher le lien suivant: C # http put obtenir demande de publication " ;. L'un des résultats mène à une bibliothèque non-libre qui peut être utile ( Chilkat Http)

Si vous écrivez votre propre cadre de commandes HTTP au-dessus de .Net, je pense que nous pourrons tous en profiter si vous le partagez: -)

Answer 2

Si vous utilisez .NET 4.5, utilisez ceci:

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();
        }

Sinon, en fonction de la réponse de Ryan, j'ai téléchargé la bibliothèque et l'ai légèrement modifiée.

  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

Je n'ai pas essayé cela moi-même, mais il semble exister un moyen intégré en C # pour cela (bien que ce ne soit pas très connu apparemment ...):

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

Essayez-le et dites-moi comment ça se passe.

Salut!

Answer 4

Le code a été publié avec succès à l'adresse aspnetupload .com . J'ai fini par créer ma propre version de leur bibliothèque UploadHelper, compatible avec Compact Framework. Fonctionne bien, semble faire exactement ce dont vous avez besoin.

Answer 5

La classe System.Net.WebClient peut être ce que vous recherchez. Consultez la documentation de WebClient.UploadFile. Elle devrait vous permettre de télécharger un fichier sur une ressource spécifiée via l’une des surcharges UploadFile. Je pense que c'est la méthode que vous souhaitez utiliser pour publier les données ...

Il peut être utilisé comme .... Remarque: ceci est juste un exemple de code non testé ...

WebClient webClient = new WebClient ();

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

Voici la référence MSDN si vous êtes intéressé.

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

J'espère que cela vous aidera.

Answer 6

Normalement, je trouve Fiddler le meilleur outil pour ce travail. Très facile à créer des demandes et génère même certains des en-têtes pour vous.

Fiddler - Comment créer une demande