C# 如何从C提交多部分/表单数据HTTP POST请求#

从C#提交具有多部分/表单数据内容类型的HTTP POST请求的最简单方法是什么？必须有一个更好的方法，而不是构建我自己的请求

我请求的原因是使用以下api将照片上载到Flickr：

---

首先，使用.Net framework纯手工实现HTTP命令没有什么错。请记住，它是一个框架，应该是非常通用的

其次，我认为您可以尝试在.Net中搜索浏览器实现。我看到了，也许它涵盖了你所问的问题。或者您可以只搜索“”。其中一个结果导致了一个可能有用的非免费库（Http）

---

如果您碰巧在.Net之上编写了自己的HTTP命令框架-我想如果您共享它，我们都会喜欢它：-）

System.Net.WebClient类可能就是您想要的。检查WebClient.UploadFile的文档，它应该允许您通过其中一个UploadFile重载将文件上载到指定的资源。我想这就是你想要用来发布数据的方法

它可以像……一样使用。。。。注意，这只是未测试的示例代码

WebClient WebClient=新的WebClient（）

webClient.UploadFile（“，”POST“，@“c:\myfile.txt”）

如果您感兴趣，这里是MSDN参考

---

希望这有帮助。

我已经成功地使用了发布在的代码。我最终制作了自己版本的UploadHelper库，该库与Compact框架兼容。运行良好，似乎完全符合您的要求。

如果您使用的是.NET 4.5，请使用以下选项：

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

公共字符串上载（字符串url、NameValueCollection请求参数、MemoryStream文件）
{
var client=新的HttpClient（）；
var content=新的MultipartFormDataContent（）；
添加（新的StreamContent（文件））；
System.Collections.Generic.List b=新列表（）；
b、 添加（请求参数）；
var addMe=新的FormUrlEncodedContent（b）；
content.Add（addMe）；
var result=client.PostAsync（url、内容）；
返回result.result.ToString（）；
}

否则，根据Ryan的回答，我下载了库并对其进行了一些调整

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

公共类MimePart
{
NameValueCollection_headers=新的NameValueCollection（）；
字节[]_头；
public NameValueCollection标头
{
获取{return\u headers；}
}
公共字节[]头
{
获取{return_header；}
}
公共长GenerateHeaderFooterData（字符串边界）
{
StringBuilder sb=新的StringBuilder（）；
某人加上（“—”）；
某人附加（边界）；
（某人）；
foreach（字符串键在_headers.AllKeys中）
{
某人附加（钥匙）；
某人加上（“：”）；
sb.附录（_头[键]）；
}
（某人）；
_header=Encoding.UTF8.GetBytes（sb.ToString（））；
返回_header.Length+Data.Length+2；
}
公共流数据{get；set；}
}
公共字符串上载（字符串url、NameValueCollection请求参数、参数MemoryStream[]文件）
{
使用（WebClient req=new WebClient（））
{
List mimeParts=新列表（）；
尝试
{
foreach（requestParameters.AllKeys中的字符串键）
{
MimePart part=新的MimePart（）；
part.Headers[“内容处置”]=“表单数据；名称=\”“+key+\”；
part.Data=newmemoryStream（Encoding.UTF8.GetBytes（requestParameters[key]）；
添加（部分）；
}
int nameIndex=0；
foreach（文件中的MemoryStream文件）
{
MimePart part=新的MimePart（）；
string fieldName=“file”+nameIndex++；
part.Headers[“内容处置”]=“表单数据；名称=\”“+fieldName+”\“文件名=\”“+fieldName+”\”；
part.Headers[“内容类型”]=“应用程序/八位字节流”；
part.Data=文件；
添加（部分）；
}
字符串边界=“------------”+DateTime.Now.Ticks.ToString（“x”）；
请求头.Add（HttpRequestHeader.ContentType，“多部分/表单数据；边界=”+boundary）；
长contentLength=0；
byte[]\u footer=Encoding.UTF8.GetBytes（“--”+boundary+“--\r\n”）；
foreach（MimePart中的MimePart部分）
{
contentLength+=零件.GenerateHeaderFooterData（边界）；
}
//req.ContentLength=ContentLength+_footer.Length；
字节[]缓冲区=新字节[8192]；
字节[]afterFile=Encoding.UTF8.GetBytes（“\r\n”）；
int-read；
使用（MemoryStream s=new MemoryStream（））
{
foreach（MimePart中的MimePart部分）
{
s、 写入（part.Header，0，part.Header.Length）；
而（（read=part.Data.read（buffer，0，buffer.Length））>0）
s、 写入（缓冲区，0，读取）；
part.Data.Dispose（）；
s、 写入（afterFile，0，afterFile.Length）；
}
s、 写入（_footer，0，_footer.Length）；
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
    }
}