httpllistener和文件上传

HttpListenerContext context = listener.GetContext();
HttpListenerRequest request = context.Request;
StreamReader r = new StreamReader(request.InputStream, System.Text.Encoding.Default);
// this is the retrieved file from streamreader
string file = null;
while ((line = r.ReadLine()) != null){
     // i read the stream till i retrieve the filename
     // get the file data out and break the loop 
}
// A byststream is created by converting the string,
Byte[] bytes = request.ContentEncoding.GetBytes(file);
MemoryStream mstream = new MemoryStream(bytes);
// do the rest

我认为您使用HttpListener而不是使用ASP.Net的内置功能使事情变得更加困难。但如果你必须这样做，这里有一些示例代码。注:1)我假设您在<form>上使用enctype="multipart/form-data"。2)此代码被设计为仅包含您的<input type="file" />的表单使用，如果您想发布其他字段或多个文件，您将不得不更改代码。3)这是一个概念证明/示例，它可能有bug，并且不是特别灵活。

static void Main(string[] args)
{
    HttpListener listener = new HttpListener();
    listener.Prefixes.Add("http://localhost:8080/ListenerTest/");
    listener.Start();
    HttpListenerContext context = listener.GetContext();
    SaveFile(context.Request.ContentEncoding, GetBoundary(context.Request.ContentType), context.Request.InputStream);
    context.Response.StatusCode = 200;
    context.Response.ContentType = "text/html";
    using (StreamWriter writer = new StreamWriter(context.Response.OutputStream, Encoding.UTF8))
        writer.WriteLine("File Uploaded");
    context.Response.Close();
    listener.Stop();
}
private static String GetBoundary(String ctype)
{
    return "--" + ctype.Split(';')[1].Split('=')[1];
}
private static void SaveFile(Encoding enc, String boundary, Stream input)
{
    Byte[] boundaryBytes = enc.GetBytes(boundary);
    Int32 boundaryLen = boundaryBytes.Length;
    using (FileStream output = new FileStream("data", FileMode.Create, FileAccess.Write))
    {
        Byte[] buffer = new Byte[1024];
        Int32 len = input.Read(buffer, 0, 1024);
        Int32 startPos = -1;
        // Find start boundary
        while (true)
        {
            if (len == 0)
            {
                throw new Exception("Start Boundaray Not Found");
            }
            startPos = IndexOf(buffer, len, boundaryBytes);
            if (startPos >= 0)
            {
                break;
            }
            else
            {
                Array.Copy(buffer, len - boundaryLen, buffer, 0, boundaryLen);
                len = input.Read(buffer, boundaryLen, 1024 - boundaryLen);
            }
        }
        // Skip four lines (Boundary, Content-Disposition, Content-Type, and a blank)
        for (Int32 i = 0; i < 4; i++)
        {
            while (true)
            {
                if (len == 0)
                {
                    throw new Exception("Preamble not Found.");
                }
                startPos = Array.IndexOf(buffer, enc.GetBytes("'n")[0], startPos);
                if (startPos >= 0)
                {
                    startPos++;
                    break;
                }
                else
                {
                    len = input.Read(buffer, 0, 1024);
                }
            }
        }
        Array.Copy(buffer, startPos, buffer, 0, len - startPos);
        len = len - startPos;
        while (true)
        {
            Int32 endPos = IndexOf(buffer, len, boundaryBytes);
            if (endPos >= 0)
            {
                if (endPos > 0) output.Write(buffer, 0, endPos-2);
                break;
            }
            else if (len <= boundaryLen)
            {
                throw new Exception("End Boundaray Not Found");
            }
            else
            {
                output.Write(buffer, 0, len - boundaryLen);
                Array.Copy(buffer, len - boundaryLen, buffer, 0, boundaryLen);
                len = input.Read(buffer, boundaryLen, 1024 - boundaryLen) + boundaryLen;
            }
        }
    }
}
private static Int32 IndexOf(Byte[] buffer, Int32 len, Byte[] boundaryBytes)
{
    for (Int32 i = 0; i <= len - boundaryBytes.Length; i++)
    {
        Boolean match = true;
        for (Int32 j = 0; j < boundaryBytes.Length && match; j++)
        {
            match = buffer[i + j] == boundaryBytes[j];
        }
        if (match)
        {
            return i;
        }
    }
    return -1;
}

为了帮助您更好地理解上面代码的作用，下面是HTTP POST的正文:

Content-Type: multipart/form-data; boundary=----WebKitFormBoundary9lcB0OZVXSqZLbmv
------WebKitFormBoundary9lcB0OZVXSqZLbmv
Content-Disposition: form-data; name="my_file"; filename="Test.txt"
Content-Type: text/plain
Test
------WebKitFormBoundary9lcB0OZVXSqZLbmv--

我省略了不相关的标题。如您所见，您需要通过扫描查找开始和结束边界序列来解析正文，并删除位于文件内容之前的子标题。不幸的是，您不能使用StreamReader，因为它可能包含二进制数据。另一个不幸的事实是，没有每个文件的Content-Length(请求的Content-Length头指定正文的总长度，包括边界、子头和空格)。

您不能使用StreamReader，因为它意味着读取字节为UTF8的流。相反，您希望将流的内容读取到接收缓冲区，删除所有不需要的内容，获取上传文件的文件扩展名，提取上传文件的内容，然后将文件内容保存到新文件中。我在这篇文章中展示的代码假设您的表单看起来像这样:

<form enctype="multipart/form-data" method="POST" action="/uploader">
    <input type="file" name="file">
    <input type="submit">
</form>

如您所见，该代码仅用于处理只有该文件的表单。由于无法从application/x-www-form-urlencoded表单中提取服务器上文件的内容，因此必须包含"multipart/form-data"。

首先，对于处理上传文件的方法，您首先需要这一小段代码:

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

其次，您需要将request.InputStream的内容读取到接收缓冲区或byte[]。我们通过使用浏览器发送的Content-Length头的长度创建byte[]缓冲区来实现这一点。然后，我们将request.InputStream的内容读入缓冲区。代码看起来像这样:

int len = int.Parse(request.Headers["Content-Length"]);
byte[] buffer = new byte[len];
request.InputStream.Read(buffer, 0, len);

流看起来像这样:

------WebKitFormBoundary9lcB0OZVXSqZLbmv
Content-Disposition: form-data; name="file"; filename="example-file.txt"
Content-Type: text/plain
file contents here
------WebKitFormBoundary9lcB0OZVXSqZLbmv--

接下来，您需要获得上传文件的文件扩展名。我们可以使用下面的代码:

string fileExtension = Encoding.UTF8.GetString(bytes).Split("'r'n")[1].Split("filename='"")[1].Replace("'"", "").Split('.')[^1];

然后，我们需要获取文件的内容。为此，我们删除开头的内容(-----WebKitFormBoundary、Content-Disposition、Content-Type和空白行)，然后删除请求体的最后一行，再加上末尾的一个额外的'r'n。下面的代码就是这样做的:

// note that the variable buffer is the byte[], and the variable bytes is the List<byte>
string stringBuffer = Encoding.UTF8.GetString(buffer);
List<byte> bytes = new List<byte>(buffer);
string[] splitString = stringBuffer.Split(''n');
int lengthOfFourLines = splitString[0].Length + splitString[1].Length + 
splitString[2].Length + splitString[3].Length + 4;
bytes.RemoveRange(0, lengthOfFourLines);
int lengthOfLastLine = splitString[^2].Length+2;
bytes.RemoveRange(bytes.Count - lengthOfLastLine, lengthOfLastLine);
buffer = bytes.ToArray();

最后，我们需要将内容保存到一个文件中。下面的代码生成一个带有用户指定的文件扩展名的随机文件名，并将文件内容保存到该文件名中。

string fname = "";
string[] chars = "q w e r t y u i o p a s d f g h j k l z x c v b n m Q W E R T Y U I O P A S D F G H J K L Z X C V B N M 1 2 3 4 5 6 7 8 9 0".Split(" ");
for (int i = 0; i < 10; i++)
{
    fname += chars[new Random().Next(chars.Length)];
}
fname += fileExtension;
FileStream file = File.Create(fname);
file.Write(buffer);
file.Close();

下面是完整的代码:

public static void Main()
{
    var listener = new HttpListener();
    listener.Prefixes.Add("http://localhost:8080/");
    listener.Start();
    while(true)
    {
        HttpListenerContext context = listener.GetContext();
        HttpListenerRequest request = context.Request;
        HttpListenerResponse response = context.Response;
        if(request.HttpMethod=="POST") SaveFile(request);
        response.OutputStream.Write(Encoding.UTF8.GetBytes("file successfully uploaded"));
        response.OutputStream.Close();
    }
}
void SaveFile(HttpListenerRequest request)
{
    int len = (int)request.ContentLength64;
    Console.WriteLine(len);
    byte[] buffer = new byte[len];
    request.InputStream.Read(buffer, 0, len);
    string stringBuffer = Encoding.UTF8.GetString(buffer);
    Console.WriteLine(stringBuffer.Replace("'r'n","''r''n'n"));
    string fileExtension = stringBuffer.Split("'r'n")[1]
        .Split("filename='"")[1]
        .Replace("'"", "")
        .Split('.')[^1]
    ;
    List<byte> bytes = new List<byte>(buffer);
    string[] splitString = stringBuffer.Split(''n');
    int lengthOfFourLines = splitString[0].Length + splitString[1].Length + splitString[2].Length + splitString[3].Length + 4;
    bytes.RemoveRange(0, lengthOfFourLines);
    int lengthOfLastLine = splitString[^2].Length+2;
    bytes.RemoveRange(bytes.Count - lengthOfLastLine, lengthOfLastLine);
    buffer = bytes.ToArray();
    
    string fname = "";
    string[] chars = "q w e r t y u i o p a s d f g h j k l z x c v b n m Q W E R T Y U I O P A S D F G H J K L Z X C V B N M 1 2 3 4 5 6 7 8 9 0".Split(" ");
    for (int i = 0; i < 10; i++)
    {
        fname += chars[new Random().Next(chars.Length)];
    }
    fname += "." + fileExtension;
    FileStream file = File.Create(fname);
    file.Write(buffer);
    file.Close();
}

同样，如果你想发送一个上传的文件到客户端，这里有一个有用的函数，可以将文件发送到客户端。

// Make sure you are using System.IO, and System.Net when making this function.
// Also make sure you set the content type of the response before calling this function.
// fileName is the name of the file you want to send to the client, and output is the response.OutputStream.
public static void SendFile(string fileName, Stream output)
{
    FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
    fs.CopyTo(output);
    fs.Close();
    output.Close();
}

问题是您将文件读取为文本。

您需要将文件读取为字节数组，而使用BinaryReader比StreamReader:

更好，更容易使用。

Byte[] bytes;
using (System.IO.BinaryReader r = new System.IO.BinaryReader(request.InputStream))
{
    // Read the data from the stream into the byte array
    bytes = r.ReadBytes(Convert.ToInt32(request.InputStream.Length));
}
MemoryStream mstream = new MemoryStream(bytes);

可能有bug，彻底测试。这个获取所有post、get和文件。

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Text;
using System.Web;
namespace DUSTLauncher
{
    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 _get;
        private Dictionary<string, File> _files;
        private readonly HttpListenerContext _ctx;
        public NameValueCollection Get { get { return _get ?? (_get = new NameValueCollection()); } set { _get = value; } }
        public NameValueCollection Post { 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 raw_post_strings = new List<string>();
            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;
                    raw_post_strings.Add(current_string.ToString().Remove(current_string.Length - 3, 3));
                    current_string.Clear();
                    continue;
                }
                current_string.Append(post_string[x]);
                var post_variable_string = current_string.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) continue;
                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 });
                continue;
            }
        }
        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
                Get = HttpUtility.ParseQueryString(post_string);
        }
        public HttpNameValueCollection(ref HttpListenerContext ctx)
        {
            _ctx = ctx;
            PopulatePost();
        }

    }
}

我喜欢@paul-wheeler的回答。然而，我需要修改他们的代码，以包含一些额外的数据(在本例中，是目录结构)。

我使用下面的代码来上传文件:

var myDropzone = $("#fileDropZone");
myDropzone.dropzone(
    {
        url: "http://" + self.location.hostname + "/Path/Files.html,
        method: "post",
        createImageThumbnails: true,
        previewTemplate: document.querySelector('#previewTemplateId').innerHTML,
        clickable: false,
        init: function () {
            this.on('sending', function(file, xhr, formData){
                // xhr is XMLHttpRequest
                var name = file.fullPath;
                if (typeof (file.fullPath) === "undefined") {
                    name = file.name;
                }
                formData.append('fileNameWithPath', name);
            });
        }
    });

这是@paul-wheeler修改的代码。谢谢@paul-wheeler。

public class FileManager
{
    public static void SaveFile(HttpListenerRequest request, string savePath)
    {
        var tempFileName = Path.Combine(savePath, $"{DateTime.Now.Ticks}.tmp");
        if (!Directory.Exists(savePath))
        {
            Directory.CreateDirectory(savePath);
        }
        var (res, fileName) = SaveTmpFile(request, tempFileName);
        if (res)
        {
            var filePath = Path.Combine(savePath, fileName);
            var fileDir = filePath.Substring(0, filePath.LastIndexOf(Path.DirectorySeparatorChar));
            if (!Directory.Exists(fileDir))
            {
                Directory.CreateDirectory(fileDir);
            }
            if (File.Exists(filePath))
            {
                File.Delete(filePath);
            }
            File.Move(tempFileName, filePath);
        }
    }
    private static (bool, string) SaveTmpFile(HttpListenerRequest request, string tempFileName)
    {
        var enc = request.ContentEncoding;
        var boundary = GetBoundary(request.ContentType);
        var input = request.InputStream;
        byte[] boundaryBytes = enc.GetBytes(boundary);
        var boundaryLen = boundaryBytes.Length;
        using (FileStream output = new FileStream(tempFileName, FileMode.Create, FileAccess.Write))
        {
            var buffer = new byte[1024];
            var len = input.Read(buffer, 0, 1024);
            var startPos = -1;
            // Get file name and relative path
            var strBuffer = Encoding.Default.GetString(buffer);
            var strStart = strBuffer.IndexOf("fileNameWithPath") + 21;
            if (strStart < 21)
            {
                Logger.LogError("File name not found");
                return (false, null);
            }
            var strEnd = strBuffer.IndexOf(boundary, strStart) - 2;
            var fileName = strBuffer.Substring(strStart, strEnd - strStart);
            fileName = fileName.Replace('/', Path.DirectorySeparatorChar);
            // Find start boundary
            while (true)
            {
                if (len == 0)
                {
                    Logger.LogError("Find start boundary not found");
                    return (false, null);
                }
                startPos = IndexOf(buffer, len, boundaryBytes);
                if (startPos >= 0)
                {
                    break;
                }
                else
                {
                    Array.Copy(buffer, len - boundaryLen, buffer, 0, boundaryLen);
                    len = input.Read(buffer, boundaryLen, 1024 - boundaryLen);
                }
            }
            // Advance to data
            var foundData = false;
            while (!foundData)
            {
                while (true)
                {
                    if (len == 0)
                    {
                        Logger.LogError("Preamble not Found");
                        return (false, null);
                    }
                    startPos = Array.IndexOf(buffer, enc.GetBytes("'n")[0], startPos);
                    if (startPos >= 0)
                    {
                        startPos++;
                        break;
                    }
                    else
                    {
                        // In case read in line is longer than buffer
                        len = input.Read(buffer, 0, 1024);
                    }
                }
                var currStr = Encoding.Default.GetString(buffer).Substring(startPos);
                if (currStr.StartsWith("Content-Type:"))
                {
                    // Go past the last carriage-return'line-break. ('r'n)
                    startPos = Array.IndexOf(buffer, enc.GetBytes("'n")[0], startPos) + 3;
                    break;
                }
            }
            Array.Copy(buffer, startPos, buffer, 0, len - startPos);
            len = len - startPos;
            while (true)
            {
                var endPos = IndexOf(buffer, len, boundaryBytes);
                if (endPos >= 0)
                {
                    if (endPos > 0) output.Write(buffer, 0, endPos - 2);
                    break;
                }
                else if (len <= boundaryLen)
                {
                    Logger.LogError("End Boundaray Not Found");
                    return (false, null);
                }
                else
                {
                    output.Write(buffer, 0, len - boundaryLen);
                    Array.Copy(buffer, len - boundaryLen, buffer, 0, boundaryLen);
                    len = input.Read(buffer, boundaryLen, 1024 - boundaryLen) + boundaryLen;
                }
            }
            return (true, fileName);
        }
    }
    private static int IndexOf(byte[] buffer, int len, byte[] boundaryBytes)
    {
        for (int i = 0; i <= len - boundaryBytes.Length; i++)
        {
            var match = true;
            for (var j = 0; j < boundaryBytes.Length && match; j++)
            {
                match = buffer[i + j] == boundaryBytes[j];
            }
            if (match)
            {
                return i;
            }
        }
        return -1;
    }
    private static string GetBoundary(string ctype)
    {
        return "--" + ctype.Split(';')[1].Split('=')[1];
    }
}

using Microsoft.AspNetCore.WebUtilities;
using Microsoft.Net.Http.Headers;
    
var contentType = MediaTypeHeaderValue.Parse(context.Request.ContentType);
var boundary = HeaderUtilities.RemoveQuotes(contentType.Boundary).Value;
var multipartReader = new MultipartReader(boundary, context.Request.InputStream);
var section = (await multipartReader.ReadNextSectionAsync()).AsFileSection();
var fileName = section.FileName;
var fileStream = section.FileStream;

对于给定的HttpListenerRequest req和string path，下面的代码保存一个文件(适用于文本文件，也适用于png文件)

int len = (int)req.ContentLength64;
                         
byte[] buffer = new byte[len];
int totalRead = 0;
while(totalRead < len){
    // InputStream.Read does not read always read full stream (so loop until it has)
    totalRead += req.InputStream.Read(buffer, totalRead, len - totalRead);
}
string stringBuffer = Encoding.UTF8.GetString(buffer);
                            
string startTag = stringBuffer.Substring(0, stringBuffer.IndexOf("'r'n'r'n") + 4);
string endTag = stringBuffer.Substring(stringBuffer.IndexOf("'r'n------WebKitFormBoundary"));
List<byte> bytes = new List<byte>(buffer);
bytes = bytes.GetRange(startTag.Length, len - (startTag.Length + endTag.Length));
                            
buffer = bytes.ToArray();
File.WriteAllBytes(path, buffer);

(构建在copee moo解决方案之上)