C# 应用程序如何在网络上轻松通信和传输文件？

发布于 2024-08-01 19:21:50 字数 276 浏览 4 评论 0原文

C# 应用程序如何轻松地与位于同一网络上的另一台计算机上的自身实例进行通信，并传输文件和数据？

假设网络上的计算机都有固定的本地IP地址，并且它们都知道彼此的IP。如果 IP 未知，还有办法进行通信吗？基于某种发现协议？

我听说 Apple 的“Bonjour”服务是一个很好的协议。我们可以通过它从 Windows 应用程序进行通信吗？或者你必须使用“套接字”。我主要是在寻找可以轻松满足我的需求的库或示例代码，我不想开发自己的基于 TCP 的协议或任何硬核的协议！

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

墨洒年华 2024-08-08 19:21:50

您可以使用 System.Net.Sockets 类进行通信，它有一个发送文件的方法 Socket.SendFile。

更新：
这是文件共享和从 C# 帮助发送文件的一个很好的例子

回复收藏 0 原文

稚然 2024-08-08 19:21:50

C# 中文件和套接字的伟大之处在于它们都作为流公开。将大文件从一个流复制到另一个流非常简单：

byte[] data = new byte[1024];
while(true) {
int bytesRead = filestream.read(data,0,data.Length);
if (bytesRead==0) break;
netstream.write(data,0,bytesRead);
}

完成后只需关闭套接字即可。

如果您想发送元数据（文件名、大小）或不想关闭连接，则需要某种协议来处理此问题。 FTP 使用两个单独的套接字（一个用于元数据，一个用于数据；这称为带外通信）。如果您所在的 LAN 没有防火墙，那么这是完全可以接受的。另一方面，如果你想做互联网传输，打开一个端口是一件很困难的任务，打开两个端口更是难以忍受。如果您不太关心性能，可以使用 base64 编码对字节进行编码，这可确保它们在特定的字节范围内。使用 Base64，您可以用换行符或其他非字母数字字符分隔消息。然后在第一条消息中包含文件名、大小或其他内容，然后将数据作为第二条消息发送，然后发送“这就是整个文件”消息，以便客户端知道它已完成。

消息的另一种策略是使用转义序列。例如，获取字节流并将每个“\0”实例替换为“\0\0”。现在使用“\0\1”来表示消息结束，这保证不会包含在您的数据消息中。在接收端将'\0\0'解码回'\0'。这在 C 中工作得很好，但我发现，在实践中，循环遍历每个字节可能比在 C# 中读取整个缓冲区慢。

最好的方法是采用某种自适应长度协议。例如，以一定大小（例如 512 字节）的块发送数据。在每个块之前，通过 System.BitConverter 发送一个表示块大小的 32 位 int。所以消息看起来像这样（英文）：

Here's 512 bytes:
[data]
Here's 512 bytes:
[data]
Here's 32 bytes:
[data]
Here's 4 bytes:
That was the whole file

这里的优点是您可以让复制/读取缓冲区为您工作（一次读取 512 个字节），这意味着您的吞吐量受到网络堆栈而不是 C# 代码的限制。客户端读取固定长度的 32 位 int，让它知道应该用于下一个 [data] 段的缓冲区的大小。

下面是一些用于编写此类消息的代码：

        logger.logger.debug("Sending message of length " + length);
        byte[] clength = System.BitConverter.GetBytes(buffer.Length);
        plaintextStream.Write(clength,0,clength.Length);
        plaintextStream.Write(buffer,0,buffer.Length);
        plaintextStream.Flush();

下面是一些用于读取消息的代码：

               byte[] intbuf = new byte[int_32_size];
        int offset = 0;
        while (offset < int_32_size)
        {
            int read = 0;

            read = d.plaintextStream.Read(intbuf,offset,int_32_size - offset);
            offset += read;

        }
        int msg_size = System.BitConverter.ToInt32(intbuf,0);
        //allocate a new buffer to fill the message
        byte[] msg_buffer = new byte[msg_size];
        offset = 0;
        while (offset < msg_size)
        {
            int read = 0;

            read = d.plaintextStream.Read(msg_buffer,offset,msg_size - offset);
            offset += read;
        }


        return msg_buffer;

The great thing about files and sockets in C# is that they're both exposed as streams. Copying a large file from one stream to another is pretty simple:

byte[] data = new byte[1024];
while(true) {
int bytesRead = filestream.read(data,0,data.Length);
if (bytesRead==0) break;
netstream.write(data,0,bytesRead);
}

Then just close the socket when you're done.

If you want to send metadata (filenames, sizes) or don't want to close the connection, you need some sort of protocol to handle this. FTP uses two seperate sockets(one for metadata, one for data; this is called out-of-band communication). If you're on a LAN with no firewalls, that can be perfectly acceptable. On the other hand, if you want to do internet transfer, getting a single port open is a difficult-enough task, and two is unbearable. If you don't care too much about performance, you could encode the bytes in base64 encoding, which makes sure that they're within a certain byte range. With base64, you can seperate messages with newlines or other non-alphanumeric characters. Then in the first message include the filename, size, or whatever, then send the data as a second message, then send a "that's the whole file" message so the client knows it's done.

Another tactic for messages is using an escape sequence. For instance, take your bytestream and replace each instance of '\0' with '\0\0'. Now use '\0\1' to signal the end-of-message, which is guaranteed not to be contained in your data message. Decode the '\0\0' back to '\0' on the receiving end. This works well enough in C, but I find that, in practice, looping through each byte can be slower than reading whole buffers in C#.

The best way is to adopt some sort of adaptive-length protocol. For instance, send the data in chunks of a certain size (say 512 bytes). Before each chunk, send a 32bit int representing the size of the chunk via System.BitConverter. So messages look like this (english):

Here's 512 bytes:
[data]
Here's 512 bytes:
[data]
Here's 32 bytes:
[data]
Here's 4 bytes:
That was the whole file

The advantage here is that you can make the copy/read buffers work for you (reading 512 bytes at a time), meaning your throughput is limited by your network stack instead of your C# code. The client reads the fixed-length 32-bit int that lets it know the size of the buffer it should use for the next [data] segment.

Here's some code to write messages like that:

        logger.logger.debug("Sending message of length " + length);
        byte[] clength = System.BitConverter.GetBytes(buffer.Length);
        plaintextStream.Write(clength,0,clength.Length);
        plaintextStream.Write(buffer,0,buffer.Length);
        plaintextStream.Flush();

And here's some code to read them:

               byte[] intbuf = new byte[int_32_size];
        int offset = 0;
        while (offset < int_32_size)
        {
            int read = 0;

            read = d.plaintextStream.Read(intbuf,offset,int_32_size - offset);
            offset += read;

        }
        int msg_size = System.BitConverter.ToInt32(intbuf,0);
        //allocate a new buffer to fill the message
        byte[] msg_buffer = new byte[msg_size];
        offset = 0;
        while (offset < msg_size)
        {
            int read = 0;

            read = d.plaintextStream.Read(msg_buffer,offset,msg_size - offset);
            offset += read;
        }


        return msg_buffer;

回复收藏 0 原文