请问如何实现局域网高速文件传输？

Question

请问如何实现局域网高速的文件传输功能·C#的·我自己写了个UDP的··只有140K啊·郁闷·人家MFC的·至少都是1M···有知道的吗？麻烦贴点代码出来学习下·谢谢

Answer 1

因为.net已经在底层做了很多封装了。

Answer 2

因为.NET Framework有几十M，所以.NET程序几十K都是可能的...不要去和MFC比...

Answer 3

文件传输
FTP 比较快！

Answer 4

这和.net没关系程序没写好。。
起码几M

Answer 5

  
您说得对~那么您有这方面的示例吗？我确实很郁闷·这里没人给出一个答案·
我知道是自己的问题·可是问题出现主要是什么原因··不是.NET的问题~所以不应该怪IDE的封装·

Answer 6

正常现象
局域网用FTP就可以了

Answer 7

我写的就是个UDP的通信程序,包大小是1500BYTE
局域网的传输·我不知道是怎么搞了··而且网上找到的局域网的C#代码·都只这么个速度···
包括LANMSG····

Answer 8

用net remoting，速度很快的~

Answer 9

LANMSG的速度不止是140K/S这么慢吧!

Answer 10

我用UDP写出来只140K·我郁闷死了··谁能帮帮忙啊··给个速度快的给我参考下·谢谢了·····

Answer 11

LANMSG之所以也是140K/S左右是因为它每次发送的数据包大小为750字节,所以速度才会如此之慢,在局域网中完全可以把它调到4096这么大,这样速度应该在1M左右!

Answer 12

是不是你写文件的时候是每次关闭/打开，那样速度很慢。主要是读写文件慢，网络传输其实很快了，和.net没关系

Answer 13

是不是你写文件的时候是每次关闭/打开，那样速度很慢。主要是读写文件慢，网络传输其实很快了，和.net没关系

Answer 14

我感觉写这方面的还是用C++，曾经写过，随便用C++封装好的Socket类写写都能达到M，C#没写过，要想提高传输速度，底层的好，我同事用C++底层的写，比我写的快很多

Answer 15

用的都是同样的网络环境,同样的协议吗?我想.net提供的UDP传输类库不可能会限速吧,一定是代码有问题了

Answer 16

谢谢21楼的建议··由于C#的封装原因···只能达到2M左右···已经实现了·2M左右的传输速度··我用的TCP写的··

Answer 17

还有就是最好和LANMSG一样建立一个写文件缓冲区,LANMSG的是10M,满了10M才写进文件,这样也能提高速度!再就是你每次发送的时候是不是用了SLEEP函数来暂停一下线程,这样也会降低速度,不过可以减少出错率,如果不用SLEEP的话则会出现粘包的现象,这就要在接收端做数据包分析了!

Answer 18

我的用tcp有1M左右，不过还是没飞鸽快，找飞鸽代码去了。要是我看明白了就给你说。

Answer 19

C# TCP 单线程在1m 多，这个和语言不大，你算法没写好

Answer 20

把文件压缩……
然后吧传缓冲区修改……
默认是几百BYTE···
改成2KB比较好……

Answer 21

局域网，如果群组的话，用FTP比较好，比如服务器文件同步

Answer 22

1.速度较快     
  2.支持文件夹传输     
  3.支持断点续传。如果您所在的网络经常出现断网，那么选择文件速递小精灵传输文件是最合适了!   
  4.使用方便，可以自动列举出所在局域网的在线用户。另外，用户也可自行添加其他网段的用户。     
  5.可以实时监控每个任务的进展情况。     
  6.提供历史记录的功能     
  7.完全免费，无需安装   
    
  下载地址   
  http://www.xiaotv.com/down/send.rar 
这里有个例子，可以看看

Answer 23

我以前乱写了一个，tcp....很快....估计能有飞鸽快了.....不过这种写法不知道何不合理.........

Answer 24

现在·贴出2M/S左右的代码快·大家帮忙改改·谢谢namespace AsyTcpSocket
{    public class MessageType
    {
        public static string StringMessage = "string";
        public static string FileMessage = "File";
    }
    public class AsySocketMessage
    {
        /// <summary>
        /// 要发送消息的类型
        /// </summary>
        private string _messageType = "";
        /// <summary>
        /// 要发送文件的大小
        /// </summary>
        private int _messageLength = 0;        /// <summary>
        /// 发送文件的名称
        /// </summary>
        private string _fileName = "";        /// <summary>
        /// 文件总大小
        /// </summary>
        private int _totalLength = 0;        /// <summary>
        /// 发送文件的类型
        /// </summary>
        public string MessageType
        {
            get
            {
                return _messageType;
            }
            set
            {
                _messageType = value;
            }
        }
        /// <summary>
        /// 发送文件的大小
        /// </summary>
        public int MessageLength
        {
            get
            {
                return _messageLength;
            }
            set
            {
                _messageLength = value;
            }
        }        /// <summary>
        /// 文件的名称
        /// </summary>
        public string FileName
        {
            get
            {
                return _fileName;
            }
            set
            {
                _fileName = value;
            }
        }
        /// <summary>
        /// 该传输文件的总的大小
        /// </summary>
        public int TotalLength
        {
            get
            {
                return _totalLength;
            }
            set
            {
                _totalLength = value;
            }
        }
        /// <summary>
        /// 无参数构造函数
        /// </summary>
        public AsySocketMessage()
        { 
        
        }        /// <summary>
        /// 带有参数的构造函数
        /// </summary>
        /// <param name="messageType"></param>
        public AsySocketMessage(string messageType)
        {
            try
            {
                string[] message = messageType.Split('-');
                _messageType = message[0];
                _messageLength = Convert.ToInt32(message[1]);
                _fileName = message[2];
            }
            catch (Exception e)
            {
                throw new Exception("转换消息头部发生错误!");       
            }
        }        public override string ToString()
        {
            return _messageType + "-" + _messageLength.ToString() + "-" + _fileName;
        }
    }
}

Answer 25

声明下：这些代码不是我的原创··是我从一个合集的代码包里选出来的 看代码质量很不错· 自己在这个基础上进行的修改 由于字符太长 不能一次贴完·只有贴出部分了·    /// <summary>
        /// 发送文件(发送文件的过程保证每次只发送50000字节，如果文件的大小大于50000的话就该函数就会自动将文件分块传输到远程接收端)
        /// </summary>
        /// <param name="fileName">要发送的文件的全路径</param>
        public void SendFile(string fileName)
        {
            FileStream fs = new FileStream(fileName, FileMode.Open);
            try
            {
                //发送文件之前首先要发送一个消息头部给远程接收端，该头部信息包含了接下来发送的
                //消息的类型（字符串、文件），要发送的数据的大小、发送的文件的文件名（如果发送的是文件）
                AsySocketMessage messagetype = new AsySocketMessage();
                messagetype.MessageType = MessageType.FileMessage;
                messagetype.MessageLength = (int)fs.Length;
                //获取要发送文件的文件名
                string[] splitName = fileName.Split('\\');
                messagetype.FileName = splitName[splitName.Length - 1];                if (BeginSendBufferEvent != null)
                {
                    BeginSendBufferEvent(this, messagetype);
                }
                //向远程接收端发送要发送文件的头部的信息
                SendBuffer(Encoding.Default.GetBytes(messagetype.ToString()));                int bytesSend = 0;
                while (bytesSend < fs.Length)
                {
                    //重新设置信号量
                    _sendEvent.Reset();                    //下面操作为强制将文件分块，每次发送50000字节，如果不足50000字节的话就发送该字节数的字节
                    if (bytesSend + 50000 <= fs.Length)
                    {
                        byte[] sendbuffer = new byte[50000];
                        fs.Read(sendbuffer, 0, 50000);
                        _AsySocket.BeginSend(sendbuffer, 0, 50000, 0, new AsyncCallback(SendMessageCallBack), _AsySocket);
                    }
                    else
                    {
                        byte[] sendbuffer = new byte[fs.Length - bytesSend];
                        fs.Read(sendbuffer, 0, sendbuffer.Length);
                        _AsySocket.BeginSend(sendbuffer, 0, sendbuffer.Length, 0, new AsyncCallback(SendMessageCallBack), _AsySocket);
                    }
                    bytesSend += 50000;
                    Thread.Sleep(10);                    if (SendBufferEvent != null)
                    {
                        try
                        {
                            AsySocketMessage message = new AsySocketMessage();
                            message.FileName = messagetype.FileName;
                            message.MessageType = messagetype.MessageType;
                            message.MessageLength = bytesSend <= fs.Length ? bytesSend : (int)fs.Length;
                            SendBufferEvent(this, message);
                        }
                        catch
                        {
                            ;
                        }
                    }
                    //启用下面的方法在信道被占用时候会出现程序强制琐死的情况
                    //通过信号量控制将发送线程强制挂起
                 //   _sendEvent.WaitOne();  
                }
            }
            catch (IOException e)
            {
                Console.WriteLine(e.Message);
                _recvString = "";
                _isRecvHeadMessage = false;
                _headMessage = null;
                _recvLength = 0;
                if (SocketErrorEvent != null)
                {
                    SocketErrorEvent(this, new AsyTcpSocketEventArgs("发送文件过程中出现错误!"));
                }
                else
                {
                    throw new Exception("发送文件过程中出现错误!");
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                _recvString = "";
                _isRecvHeadMessage = false;
                _headMessage = null;
                _recvLength = 0;
                if (SocketErrorEvent != null)
                {
                    SocketErrorEvent(this, new AsyTcpSocketEventArgs("发送文件过程中出现错误!"));
                }
                else
                {
                    throw new Exception("发送文件过程中出现错误!");
                }
            }
            finally
            {
                fs.Close();
            }
        } 

Answer 26

给你几点建议，首先是用.NET编程实现。
1.类似于FTP协议，服务端开辟两个端口，并持续对这两个端口侦听：一个用于接收字符串，类似于FTP的控制端口，它接收各种命令（接收或发送文件）；一个用于传输数据，也就是发送和接收文件。 
2。服务端只开辟一个端口，用于接收字符串，为控制端口。当接到请求之后，根据请求内容在客户端开辟一个端口专用于文件传输，并在传输结束后关闭端口。 这样应该能节省很多带宽哈。。建议试试。
如果不会请参照例子。。http://www.tracefact.net/CSharp-Programming/Network-Programming-Part4.aspx

Answer 27

局域网上传可以达到几十M的，你上网找个lib用吧。

Answer 28

局域网上传可以达到几十M的，你上网找个lib用吧。

Answer 29

2M的速度是点对点的速度··加入几百个客户端对服务器·那会怎么样？飞鸽传书速度的五分之一啊·
我就不相信C#的效率比C++的慢这么多···所以请大家一起来帮帮忙啊···
我觉得肯定是我的能力问题··
希望能有高手写个更强悍的出来！@

Answer 30

现在我只是想知道C#的局域网通信 基于TCP/IP的 的速度最高能达到多少...100M的局域网内·至于说多客户端通信··就是多线程的问题了·现在就讨论点对点 怎么能提高通信的速度··怎么来提高速度··以及代码的实现··这个是我目前最需要的··

Answer 31

http://www.ipmsg.org/archive/ipmsg206.zip飞鸽的源代码，是小日本用VC++写的，速度很快，源代码166KB！

Answer 32

TCP的缓冲区最大应该是64K,你试着把缓冲区调到60K看看速度!

Answer 33

传文件最好用tcp
udp的确比tcp传输更快，但是传音频视频这类对包顺序不敏感对丢包不敏感的还行，文件，还是tcp保险
C#这么慢肯定是你代码有问题
手头没代码，不过我觉得随便找本C#网络方面的教程都有相关的demo，msdn上应该也有例子...