Comment soumettre un multipart/form-data requête HTTP POST à partir de C#

Quelle est la meilleure façon de soumettre une requête HTTP POST avec un multipart/form-data type de contenu à partir de C#? Il y a une meilleure façon que la construction de ma propre demande.

La raison pour laquelle je vais poser est de charger les photos sur Flickr l'utilisation de cette api:

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

J'ai surtout été à la recherche à HttpWebRequest, mais toutes les ressources que j'ai trouvé sur internet qui explique comment créer manuellement la demande. Voici un des nombreux exemples de ce genre, j'ai trouvé: social.msdn.microsoft.com/Forums/en-US/netfxnetcom/thread/...
Cette question a une réponse qui permet de résoudre votre problème avec l'affichage multipart/form-data à l'aide de WebRequest. Il fonctionne bien. stackoverflow.com/questions/219827/...

OriginalL'auteur Jesse Weigert | 2009-07-30

  1. 1

    Tout d'abord, il n'y a rien de mal avec de la pure mise en œuvre manuelle des commandes HTTP, en utilisant le .Net framework. Ne gardez à l'esprit que c'est un cadre, et il est censé être assez générique.

    Deuxièmement, je pense que vous pouvez essayer la recherche d'un navigateur de mise en œuvre .Net. J'ai vu cette une, peut-être qu'il couvre la question vous m'avez demandé. Ou vous pouvez simplement recherche pour "C# http put obtenir de la requête post". L'un des résultats conduit à une bibliothèque non libre qui peut être utile (Chilkat Http)

    S'il vous arrive d'écrire votre propre cadre de HTTP commandes sur le dessus de .Net - je pense que nous pouvons tous en profiter si vous le partager 🙂

    Malheureusement, c'est ce que j'avais à faire.

    OriginalL'auteur Ron Klein

  2. 5

    Si vous êtes en utilisant .NET 4.5 utiliser 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();
        }

    Autrement Fondée sur Ryan réponse, j'ai téléchargé la bibliothèque et modifié un peu.

      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;
}
}
}
    La première fonction ne fonctionne pas. Ce qui est "a"?
    Oups, doit avoir été requestParameters. Fixe.
    Je sais que c'est vieux, mais ça n'a pas fonctionné pour moi jusqu'à ce que je enquoted mon manuellement le contenu comme on le voit ici -> stackoverflow.com/a/12034014/885338

    OriginalL'auteur David Silva Smith

  3. 2

    J'ai eu du succès avec le code affiché à aspnetupload.com. J'ai fini par faire ma propre version de leur UploadHelper de la bibliothèque qui est compatible avec le Compact Framework. Fonctionne bien, semble faire exactement ce que vous avez besoin.

    Je dois ajouter que "faire ma propre version" == essayez de compiler la bibliothèque dans un Cadre Compact projet, voir ce qui est cassé, utiliser une autre FC-compatible objet ou d'un segment de code pour faire la même chose, répéter. J'ai été agréablement surpris de voir à quel point il est simple de ce processus.

    OriginalL'auteur Ryan Barton

  4. 2

    Je n'ai pas essayé moi-même, mais il semble être un moyen intégré en C# pour cela (bien que 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
}
}

    L'essayer et laissez-moi savoir comment ça se passe.

    Cheers!

    OriginalL'auteur NoOne

  5. 1

    Le Système.Net.Classe WebClient peut-être ce que vous cherchez. Consultez la documentation de WebClient.UploadFile, il devrait vous permettre de télécharger un fichier à une ressource spécifiée par l'un des UploadFile les surcharges. Je pense que c'est la méthode que vous cherchez à utiliser pour afficher les données...

    Il peut être utilisé comme.... remarque, c'est juste un exemple de code non testé...

    WebClient webClient = new WebClient();

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

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

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

    Espère que cette aide.

    Que si je me permets juste de téléchargement du fichier. Cependant, j'ai besoin d'inclure un tas d'autres variables de formulaire avec elle.

    OriginalL'auteur Wil P

  6. -1

    J'ai l'habitude de trouver Fiddler être le meilleur outil pour ce travail. Très à l'aise pour créer des demandes et il génère même certains en-têtes pour vous.

    Fiddler - Comment créer une demande

    Comment soumettre un multipart/form-data requête HTTP POST à partir de C#

    OriginalL'auteur D.Rosado