web-dev-qa-db-ja.com

multipart / form-dataからのファイル入力の読み取りPOST

HTMLフォームを介してWCF RESTサービスにファイルをPOSTします。enctypeはmultipart/form-dataに設定され、単一のコンポーネントは<input type="file" name="data">です。サーバーによって読み取られる結果のストリームには、次のものが含まれます。

------WebKitFormBoundary
Content-Disposition: form-data; name="data"; filename="DSCF0001.JPG"
Content-Type: image/jpeg

<file bytes>
------WebKitFormBoundary--

問題は、ストリームからファイルバイトを抽出する方法がわからないことです。ファイルをディスクに書き込むためにこれを行う必要があります。

c#wcfhttp-postforms
43
rafale

ブログの投稿に続く をご覧ください。これは Multipart Parser を使用してサーバー上のmultipart/form-dataを解析するために使用できるテクニックを示しています。

public void Upload(Stream stream)
{
    MultipartParser parser = new MultipartParser(stream);
    if (parser.Success)
    {
        // Save the file
        SaveFile(parser.Filename, parser.ContentType, parser.FileContents);
    }
}

もう1つの可能性は、 aspnet互換性 を有効にしてHttpContext.Current.Requestを使用することですが、これはあまりWCF的な方法ではありません。

31
Darin Dimitrov

パーティーに遅れて参加してすみませんが、MicrosoftパブリックAPIでこれを行う方法があります。

必要なものは次のとおりです。

  1. System.Net.Http.dll
    • .NET 4.5に含まれています
    • .NET 4の場合は NuGet で取得します
  2. System.Net.Http.Formatting.dll

注Nugetパッケージにはさらに多くのアセンブリが付属していますが、執筆時点では上記のもののみが必要です。

アセンブリを参照すると、コードは次のようになります（便宜上、.NET 4.5を使用）。

public static async Task ParseFiles(
    Stream data, string contentType, Action<string, Stream> fileProcessor)
{
    var streamContent = new StreamContent(data);
    streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);

    var provider = await streamContent.ReadAsMultipartAsync();

    foreach (var httpContent in provider.Contents)
    {
        var fileName = httpContent.Headers.ContentDisposition.FileName;
        if (string.IsNullOrWhiteSpace(fileName))
        {
            continue;
        }

        using (Stream fileContents = await httpContent.ReadAsStreamAsync())
        {
            fileProcessor(fileName, fileContents);
        }
    }
}

使用方法については、次のWCF RESTメソッドがあるとします。

[OperationContract]
[WebInvoke(Method = WebRequestMethods.Http.Post, UriTemplate = "/Upload")]
void Upload(Stream data);

次のように実装できます

public void Upload(Stream data)
{
    MultipartParser.ParseFiles(
           data, 
           WebOperationContext.Current.IncomingRequest.ContentType, 
           MyProcessMethod);
}
41
Ohad Schneider

特に大きなファイルでの文字列解析に基づいたパーサーにいくつかの問題がありました。メモリが不足し、バイナリデータの解析に失敗することがわかりました。

これらの問題に対処するために、C＃multipart/form-dataパーサーでの私自身の試みをオープンソースにしました here

特徴：

  • 非常に大きなファイルを適切に処理します。 （読み取り中にデータがストリームインおよびストリームアウトされます）
  • 複数のファイルのアップロードを処理でき、セクションがファイルかどうかを自動的に検出します。
  • ファイルをbyte []ではなくストリームとして返します（大きなファイルに適しています）。
  • MSDNスタイルで生成されたWebサイトを含むライブラリの完全なドキュメント。
  • 完全な単体テスト。

制限事項：

  • 非マルチパートデータを処理しません。
  • コードはロレンツォよりも複雑です

次のようにMultipartFormDataParserクラスを使用するだけです。

Stream data = GetTheStream();

// Boundary is auto-detected but can also be specified.
var parser = new MultipartFormDataParser(data, Encoding.UTF8);

// The stream is parsed, if it failed it will throw an exception. Now we can use
// your data!

// The key of these maps corresponds to the name field in your
// form
string username = parser.Parameters["username"].Data;
string password = parser.Parameters["password"].Data

// Single file access:
var file = parser.Files.First();
string filename = file.FileName;
Stream data = file.Data;

// Multi-file access
foreach(var f in parser.Files)
{
    // Do stuff with each file.
}

WCFサービスのコンテキストでは、次のように使用できます。

public ResponseClass MyMethod(Stream multipartData)
{
    // First we need to get the boundary from the header, this is sent
    // with the HTTP request. We can do that in WCF using the WebOperationConext:
    var type = WebOperationContext.Current.IncomingRequest.Headers["Content-Type"];

    // Now we want to strip the boundary out of the Content-Type, currently the string
    // looks like: "multipart/form-data; boundary=---------------------124123qase124"
    var boundary = type.Substring(type.IndexOf('=')+1);

    // Now that we've got the boundary we can parse our multipart and use it as normal
    var parser = new MultipartFormDataParser(data, boundary, Encoding.UTF8);

    ...
}

または、このように（少し遅くなりますが、コードに優しい）：

public ResponseClass MyMethod(Stream multipartData)
{
    var parser = new MultipartFormDataParser(data, Encoding.UTF8);
}

リポジトリを複製する場合は、単にHttpMultipartParserDocumentation/Help/index.html

25
Jake Woods

C＃Httpフォームパーサー here をオープンソース化しました。

これは、CodePlexに記載されている他のコードよりもわずかに柔軟性があります。Multipartと非Multipartの両方に使用できるためですform-data、およびDictionaryオブジェクトでフォーマットされた他のフォームパラメーターも提供します。

これは次のように使用できます。

non-multipart

public void Login(Stream stream)
{
    string username = null;
    string password = null;

    HttpContentParser parser = new HttpContentParser(stream);
    if (parser.Success)
    {
        username = HttpUtility.UrlDecode(parser.Parameters["username"]);
        password = HttpUtility.UrlDecode(parser.Parameters["password"]);
    }
}

multipart

public void Upload(Stream stream)
{
    HttpMultipartParser parser = new HttpMultipartParser(stream, "image");

    if (parser.Success)
    {
        string user = HttpUtility.UrlDecode(parser.Parameters["user"]);
        string title = HttpUtility.UrlDecode(parser.Parameters["title"]);

        // Save the file somewhere
        File.WriteAllBytes(FILE_PATH + title + FILE_EXT, parser.FileContents);
    }
}
16
Lorenzo Polidori

これを解決した人がLGPLとして投稿したので、修正することはできません。私はそれを見たときにそれさえクリックしませんでした。これが私のバージョンです。これをテストする必要があります。おそらくバグがあります。アップデートを投稿してください。無保証。これを必要に応じて変更し、独自に呼び出して、紙に印刷して、犬小屋のスクラップに使用できます。

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Text;
using System.Web;

namespace DigitalBoundaryGroup
{
    class HttpNameValueCollection
    {
        public class File
        {
            private string _fileName;
            public string FileName { get { return _fileName ?? (_fileName = ""); } set { _fileName = value; } }

            private string _fileData;
            public string FileData { get { return _fileData ?? (_fileName = ""); } set { _fileData = value; } }

            private string _contentType;
            public string ContentType { get { return _contentType ?? (_contentType = ""); } set { _contentType = value; } }
        }

        private NameValueCollection _post;
        private Dictionary<string, File> _files;
        private readonly HttpListenerContext _ctx;

        public NameValueCollection Post { get { return _post ?? (_post = new NameValueCollection()); } set { _post = value; } }
        public NameValueCollection Get { get { return _ctx.Request.QueryString; } }
        public Dictionary<string, File> Files { get { return _files ?? (_files = new Dictionary<string, File>()); } set { _files = value; } }

        private void PopulatePostMultiPart(string post_string)
        {
            var boundary_index = _ctx.Request.ContentType.IndexOf("boundary=") + 9;
            var boundary = _ctx.Request.ContentType.Substring(boundary_index, _ctx.Request.ContentType.Length - boundary_index);

            var upper_bound = post_string.Length - 4;

            if (post_string.Substring(2, boundary.Length) != boundary)
                throw (new InvalidDataException());

            var current_string = new StringBuilder();

            for (var x = 4 + boundary.Length; x < upper_bound; ++x)
            {
                if (post_string.Substring(x, boundary.Length) == boundary)
                {
                    x += boundary.Length + 1;

                    var post_variable_string = current_string.Remove(current_string.Length - 4, 4).ToString();

                    var end_of_header = post_variable_string.IndexOf("\r\n\r\n");

                    if (end_of_header == -1) throw (new InvalidDataException());

                    var filename_index = post_variable_string.IndexOf("filename=\"", 0, end_of_header);
                    var filename_starts = filename_index + 10;
                    var content_type_starts = post_variable_string.IndexOf("Content-Type: ", 0, end_of_header) + 14;
                    var name_starts = post_variable_string.IndexOf("name=\"") + 6;
                    var data_starts = end_of_header + 4;

                    if (filename_index != -1)
                    {
                        var filename = post_variable_string.Substring(filename_starts, post_variable_string.IndexOf("\"", filename_starts) - filename_starts);
                        var content_type = post_variable_string.Substring(content_type_starts, post_variable_string.IndexOf("\r\n", content_type_starts) - content_type_starts);
                        var file_data = post_variable_string.Substring(data_starts, post_variable_string.Length - data_starts);
                        var name = post_variable_string.Substring(name_starts, post_variable_string.IndexOf("\"", name_starts) - name_starts);
                        Files.Add(name, new File() { FileName = filename, ContentType = content_type, FileData = file_data });
                    }
                    else
                    {
                        var name = post_variable_string.Substring(name_starts, post_variable_string.IndexOf("\"", name_starts) - name_starts);
                        var value = post_variable_string.Substring(data_starts, post_variable_string.Length - data_starts);
                        Post.Add(name, value);
                    }

                    current_string.Clear();
                    continue;
                }

                current_string.Append(post_string[x]);
            }
        }

        private void PopulatePost()
        {
            if (_ctx.Request.HttpMethod != "POST" || _ctx.Request.ContentType == null) return;

            var post_string = new StreamReader(_ctx.Request.InputStream, _ctx.Request.ContentEncoding).ReadToEnd();

            if (_ctx.Request.ContentType.StartsWith("multipart/form-data"))
                PopulatePostMultiPart(post_string);
            else
                Post = HttpUtility.ParseQueryString(post_string);

        }

        public HttpNameValueCollection(ref HttpListenerContext ctx)
        {
            _ctx = ctx;
            PopulatePost();
        }


    }
}
2
Bluebaron

別の方法は、HttpRequestに.Netパーサーを使用することです。そのためには、WorkerRequestに少しのリフレクションと単純なクラスを使用する必要があります。

最初に、HttpWorkerRequestから派生するクラスを作成します（簡単にするためにSimpleWorkerRequestを使用できます）。

public class MyWorkerRequest : SimpleWorkerRequest
{
    private readonly string _size;
    private readonly Stream _data;
    private string _contentType;

    public MyWorkerRequest(Stream data, string size, string contentType)
        : base("/app", @"c:\", "aa", "", null)
    {
        _size = size ?? data.Length.ToString(CultureInfo.InvariantCulture);
        _data = data;
        _contentType = contentType;
    }

    public override string GetKnownRequestHeader(int index)
    {
        switch (index)
        {
            case (int)HttpRequestHeader.ContentLength:
                return _size;
            case (int)HttpRequestHeader.ContentType:
                return _contentType;
        }
        return base.GetKnownRequestHeader(index);
    }

    public override int ReadEntityBody(byte[] buffer, int offset, int size)
    {
        return _data.Read(buffer, offset, size);
    }

    public override int ReadEntityBody(byte[] buffer, int size)
    {
        return ReadEntityBody(buffer, 0, size);
    }
}

次に、どこにいても、このクラスのメッセージストリームの作成とインスタンスを作成します。私はWCFサービスでそれをやっています：

[WebInvoke(Method = "POST",
               ResponseFormat = WebMessageFormat.Json,
               BodyStyle = WebMessageBodyStyle.Bare)]
    public string Upload(Stream data)
    {
        HttpWorkerRequest workerRequest =
            new MyWorkerRequest(data,
                                WebOperationContext.Current.IncomingRequest.ContentLength.
                                    ToString(CultureInfo.InvariantCulture),
                                WebOperationContext.Current.IncomingRequest.ContentType
                );

そして、アクティベータと非パブリックコンストラクタを使用してHttpRequestを作成します

var r = (HttpRequest)Activator.CreateInstance(
            typeof(HttpRequest),
            BindingFlags.Instance | BindingFlags.NonPublic,
            null,
            new object[]
                {
                    workerRequest,
                    new HttpContext(workerRequest)
                },
            null);

var runtimeField = typeof (HttpRuntime).GetField("_theRuntime", BindingFlags.Static | BindingFlags.NonPublic);
if (runtimeField == null)
{
    return;
}

var runtime = (HttpRuntime) runtimeField.GetValue(null);
if (runtime == null)
{
    return;
}

var codeGenDirField = typeof(HttpRuntime).GetField("_codegenDir", BindingFlags.Instance | BindingFlags.NonPublic);
if (codeGenDirField == null)
{
    return;
}

codeGenDirField.SetValue(runtime, @"C:\MultipartTemp");

その後、r.Filesストリームからファイルを取得します。

2
Lukasz Salamon

正規表現はどうですか？

私はこれをテキストのファイルに書いたが、これはあなたのために働くと信じている

（テキストファイルに、以下の「一致する」もので正確に始まる行が含まれている場合-単に正規表現を適合させてください）

    private static List<string> fileUploadRequestParser(Stream stream)
    {
        //-----------------------------111111111111111
        //Content-Disposition: form-data; name="file"; filename="data.txt"
        //Content-Type: text/plain
        //...
        //...
        //-----------------------------111111111111111
        //Content-Disposition: form-data; name="submit"
        //Submit
        //-----------------------------111111111111111--

        List<String> lstLines = new List<string>();
        TextReader textReader = new StreamReader(stream);
        string sLine = textReader.ReadLine();
        Regex regex = new Regex("(^-+)|(^content-)|(^$)|(^submit)", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline);

        while (sLine != null)
        {
            if (!regex.Match(sLine).Success)
            {
                lstLines.Add(sLine);
            }
            sLine = textReader.ReadLine();
        }

        return lstLines;
    }
1
mork

MultipartReader マルチパートフォームデータを読み取るためのASP.NET 4のNuGetパッケージを実装しました。 Multipart Form Data Parser に基づいていますが、複数のファイルをサポートしています。

1
Václav Dajbych

メモリにデータを保存することはオプションではない大きなファイル（サーバーGB）アップロードでWCFを処理しました。私の解決策は、メッセージストリームを一時ファイルに保存し、seekを使用してバイナリデータの始まりと終わりを見つけることです。

0
Yang Zhang