艺萌TCP文件上传下载及自动更新系统介绍（TCP文件传输）（一）

艺萌TCP文件上传下载及自动更新系统介绍（TCP文件传输）

该系统基于开源的networkComms通讯框架，此通讯框架以前是收费的，目前已经免费并开元，作者是英国的，开发时间5年多，框架很稳定。

项目地址：http://www.51aspx.com/code/MSDCArtMengFileUpload

咨询qq:286275658

演示程序下载地址：http://pan.baidu.com/s/1geVfmcr

服务器端运行效果图：

服务器端配置文件：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="DirectoryPath" value="D:\"/>    //客户端上传的文件的保存路径
    <add key="IPAddress" value="127.0.0.1"/>  //服务器端的IP  需要修改真实的IP
    <add key="Port" value="6006"/>            //监听的端口号
  </appSettings>
</configuration>

服务器端接收文件的部分代码：

  // 处理文件数据
        private void IncomingPartialFileData(PacketHeader header, Connection connection, byte[] data)
        {
            try
            {
                SendInfo info = null;
                //每次都创建一个对 ReceivedFile对象的引用  引用receivedFilesDict字典中的对象 引用完成后设定为Null
                IReceiveFile receivedFile = null;

                //Perform this in a thread safe way
                lock (syncLocker)
                {

                    //获取数据包的顺序号
                    long sequenceNumber = header.GetOption(PacketHeaderLongItems.PacketSequenceNumber);

                    //如果数据信息字典包含 "连接信息" 和  "包顺序号"

                    if (incomingDataInfoCache.ContainsKey(connection.ConnectionInfo) && incomingDataInfoCache[connection.ConnectionInfo].ContainsKey(sequenceNumber))
                    {
                        //根据顺序号，获取相关SendInfo记录
                        info = incomingDataInfoCache[connection.ConnectionInfo][sequenceNumber];
                        //从信息记录字典中删除相关记录
                        incomingDataInfoCache[connection.ConnectionInfo].Remove(sequenceNumber);

                        if (!recvManager.ContainsFileID(info.FileID))
                        {

                            recvManager.AddFile(info.FileID, info.Filename, info.FilePath, connection.ConnectionInfo, info.TotalBytes);

                        }
                        receivedFile = recvManager.GetFile(info.FileID);
                    }
                    else
                    {
                        //We do not yet have the associated SendInfo so we just add the data to the cache
                        //如果不包含顺序号，也不包含相关"连接信息",添加相关连接信息
                        if (!incomingDataCache.ContainsKey(connection.ConnectionInfo))
                            incomingDataCache.Add(connection.ConnectionInfo, new Dictionary<long, byte[]>());
                        //在数据字典中添加相关"顺序号"的信息
                        incomingDataCache[connection.ConnectionInfo].Add(sequenceNumber, data);
                    }
                }

                if (info != null && receivedFile != null && !receivedFile.IsCompleted)
                {
                    receivedFile.AddData(info.BytesStart, , data.Length, data);
                    receivedFile = null;
                    data = null;

                }
                else if (info == null ^ receivedFile == null)
                    throw new Exception("Either both are null or both are set. Info is " + (info == null ? "null." : "set.") + " File is " + (receivedFile == null ? "null." : "set.") + " File is " + (receivedFile.IsCompleted ? "completed." : "not completed."));
            }
            catch (Exception ex)
            {
                NetworkHelper.LogTools.LogException(ex, "IncomingPartialFileDataError");
            }
        }

IncomingPartialFileData

 private void IncomingPartialFileDataInfo(PacketHeader header, Connection connection, SendInfo info)
        {
            try
            {
                byte[] data = null;
                //每次都创建一个对 ReceivedFile对象的引用  引用receivedFilesDict字典中的对象 引用完成后设定为Null
                IReceiveFile file = null;

                lock (syncLocker)
                {
                    //从 SendInfo类中获取相应数据类的信息号 以便可以对应。
                    long sequenceNumber = info.PacketSequenceNumber;

                    if (incomingDataCache.ContainsKey(connection.ConnectionInfo) && incomingDataCache[connection.ConnectionInfo].ContainsKey(sequenceNumber))
                    {
                        //从字典中获取数据
                        data = incomingDataCache[connection.ConnectionInfo][sequenceNumber];
                        //删除字典中的数据
                        incomingDataCache[connection.ConnectionInfo].Remove(sequenceNumber);

                        if (!recvManager.ContainsFileID(info.FileID))
                        {

                            recvManager.AddFile(info.FileID, info.Filename, info.FilePath, connection.ConnectionInfo, info.TotalBytes);

                        }
                        file = recvManager.GetFile(info.FileID);
                    }
                    else
                    {
                        if (!incomingDataInfoCache.ContainsKey(connection.ConnectionInfo))
                            incomingDataInfoCache.Add(connection.ConnectionInfo, new Dictionary<long, SendInfo>());

                        incomingDataInfoCache[connection.ConnectionInfo].Add(sequenceNumber, info);
                    }
                }

                if (data != null && file != null && !file.IsCompleted)
                {
                    file.AddData(info.BytesStart, , data.Length, data);
                    //Perform a little clean-up
                    file = null;
                    data = null;

                }
                else if (data == null ^ file == null)
                    throw new Exception("Either both are null or both are set. Data is " + (data == null ? "null." : "set.") + " File is " + (file == null ? "null." : "set.") + " File is " + (file.IsCompleted ? "completed." : "not completed."));
            }
            catch (Exception ex)
            {
                NetworkHelper.LogTools.LogException(ex, "IncomingPartialFileDataInfo");
            }
        }

IncomingPartialFileDataInfo

.

部分代码：

 public class SendFile
    {
        //传输过程 事件
        public event EventHandler<FTProgressEventArgs> FileTransProgress;
        //传输完成 事件
        public event EventHandler<FTCompleteEventArgs> FileTransCompleted;
        //传输中断 事件
        public event EventHandler<FTDisruptEventArgs> FileTransDisruptted;

        //取消文件的发送
        private volatile bool canceled = false;

        //传输失败的原因
        private FileTransFailReason fileTransDisrupttedType = FileTransFailReason.Error;

        public string FilePath { get; private set; }

        private Connection tcpConn;

        // 收发参数
        private SendReceiveOptions sendFileOptions = null;

        //文件ID  用于管理文件 和文件的发送 取消发送相关
        private string fileID;
        public string FileID
        {
            get { return fileID; }
            set { fileID = value; }
        }

        //文件传输后存储的路径
        private string destFilePath;
        public string DestFilepath
        {
            get { return destFilePath; }
            set { destFilePath = value; }
        }

        // 文件的字节大小
        public long SizeBytes { get; private set; }

        // 已发送的大小
        public long SentBytes { get; private set; }

        //已经完成的百分比
        public double CompletedPercent
        {
            get { return (double)SentBytes / SizeBytes; }
            set { throw new Exception("An attempt to modify read-only value."); }
        }

        // 是否完成
        public bool IsCompleted
        {
            get { return SentBytes == SizeBytes; }
        }

        // 同步锁
        object SyncRoot = new object();

        /// <summary>
        /// 创建一个文件发送实例
        /// </summary>
        /// <param name="filename">文件名称</param>
        /// <param name="filePath">文件本地路径</param>
        /// <param name="destFilePath">文件在服务器上的相对路径</param>
        public SendFile(string fileID, string filePath, string destFilePath,Connection  conn)
        {
            //文件ID
            this.fileID = fileID;
            this.FilePath = filePath;
            this.destFilePath = destFilePath; 

            this.sendFileOptions = new SendReceiveOptions(DPSManager.GetDataSerializer<ProtobufSerializer>(), null, null);
            this.sendFileOptions.ReceiveHandlePriority = NetworkCommsDotNet.Tools.QueueItemPriority.Highest;
            this.tcpConn = conn;
        }

        //异步发送文件
        public void NowSendFile()
        {
            new Action(this.StartSendFile).BeginInvoke(null, null);
        }

        //发送文件
        public  void StartSendFile()
        {
            FileStream stream = null;
            try
            {
                //根据选择的文件创建一个文件流
                stream = new FileStream(this.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);

                //包装成线程安全的数据流
                StreamTools.ThreadSafeStream safeStream = new StreamTools.ThreadSafeStream(stream);

                //获取不包含路径信息的文件名
                string shortFileName = System.IO.Path.GetFileName(FilePath);

                //根据参数中设定的值来角色发送的数据包的大小 可以根据您的网络环境指定
                ; 

                this.SizeBytes = stream.Length;

                ;

                while ((totalBytesSent < stream.Length) && !this.canceled)

                {
                    //剩下的字节数 如果 大于 指定的字节数（sendChunkSizeBytes），则发送指定的字节数 否则 发送剩下的字节数
                    long bytesToSend = (totalBytesSent + sendChunkSizeBytes < stream.Length ? sendChunkSizeBytes : stream.Length - totalBytesSent);

                    StreamTools.StreamSendWrapper streamWrapper = new StreamTools.StreamSendWrapper(safeStream, totalBytesSent, bytesToSend);

                    //我们希望记录包的顺序号
                    long packetSequenceNumber;

                    //发送文件的数据部分
                    tcpConn.SendObject("PartialFileData", streamWrapper, sendFileOptions, out packetSequenceNumber);

                    //把包的顺序号记录在 SendInfo类中。  destFilePath  是文件在服务器端保存的路径（相对路径）
                    tcpConn.SendObject("PartialFileDataInfo", new SendInfo(fileID, shortFileName, destFilePath, stream.Length, totalBytesSent, packetSequenceNumber), sendFileOptions);

                    totalBytesSent += bytesToSend;

                    //更新已经发送的字节的属性
                    SentBytes += bytesToSend;

                    FileTransProgress.Raise(this, new FTProgressEventArgs(FileID, SizeBytes, totalBytesSent));

                    //发送文件片段后应休息一定的时间  能有效的降低系统cpu
                    if (! this.canceled )
                    {
                        Thread.Sleep();
                    }

                }  

                if (!this.canceled)
                {
                    //触发文件传输完成事件
                    FileTransCompleted.Raise(this, new FTCompleteEventArgs(fileID));
                }
                else
                {
                    //否则触发文件中断事件
                    FileTransDisruptted.Raise(this, new FTDisruptEventArgs(FileID, FileTransFailReason.Error));
                }

            }
            catch (CommunicationException)
            {
                //触发文件中断事件
                FileTransDisruptted.Raise(this, new FTDisruptEventArgs(FileID, FileTransFailReason.Error));
            }
            catch (Exception ex)
            {
                //触发文件中断事件
                FileTransDisruptted.Raise(this, new FTDisruptEventArgs(FileID, FileTransFailReason.Error));

            }

            finally
            {
                if (stream != null)
                {
                    stream.Close();
                }
            }
        } 

        //取消文件的发送
        public void Cancel(FileTransFailReason transFileReason)
        {
            this.canceled = true;
            this.fileTransDisrupttedType = transFileReason;

            //给服务器发一个消息，说明文件发送中断 传送fileID给服务器端即可
            FileContract filecontract = new FileContract(this.fileID, "FileName", "Comment");

            //通知对方 让对方取消当期文件的接收 并清理相关缓存
           tcpConn.SendObject("CancelSendFile", filecontract);

        }

    }

SendFile

客户端介绍了如何上传下载文件，如何启用自动升级程序

上传文件：

   private void button1_Click(object sender, EventArgs e)
        {
            //获取要上传的文件的本地地址
            string filePath = GetFileToOpen("上传文件");
            //新建一个文件ID
            string fileID = FileIDCreator.GetNextFileID(NetworkCommsDotNet.NetworkComms.NetworkIdentifier.ToString());
            //定义文件在服务器的保存位置（相对目录）
            string destFilePath = itemID + @"\" + Path.GetFileName(filePath);
            //把文件添加到文件发送管理器中
            sendFileDict.AddSendFile(fileID, filePath, destFilePath,AppOutter.TcpConn);

        }

下载文件：

 openFlag = false;

            )
            {

                string fileName = (listBox1.SelectedItem as FileDetail).Name;

                long fileSize = (listBox1.SelectedItem as FileDetail).Size;

                ulong theFileSize = Convert.ToUInt32(fileSize);

                //获取当前文件扩展名
                string extentName = Path.GetExtension(fileName);

                string savePath = FileHelper.GetPathToSave("选择保存路径", fileName, null);

                if (savePath != null)
                {

                    //如果在弹出窗口中，用户改动了名字，需要手动加上扩展名
                    if (!savePath.EndsWith(extentName))
                    {
                        savePath = savePath + extentName;
                    }

                    //取得目录所在的相对位置 如： 201011\123456\文件.txt
                    string fileUri = itemID + @"\" + fileName;

                    try
                    {

                        FileInfoContract contract = new FileInfoContract(savePath, fileUri);

                        AppOutter.TcpConn.SendObject("DownloadFile", contract);

                    }
                    catch (Exception ee)
                    {
                        MessageBox.Show(ee.Message);
                    }
                }
            }

上传界面：

文章地址：www.cnblogs.com/networkcomms