简单的C# Socket 通讯，可传文件

最新推荐文章于 2023-10-31 08:20:31 发布
最新推荐文章于 2023-10-31 08:20:31 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jian200801/article/details/8250269
版权

三个项目：服务端XJFtpServer，客户端XJFtpServerClient，公共程序集XJFtpServerLib

 

先是公共程序集：

 public class FtpServerDefine
    {
        public const int LISTEN_PORT = 5000;
        public const int MESSAGE_LENGTH=419;
    }
 public enum MsgCommand
    {
        None,
        Login,
        Exit,
        List,
        Upload,
        Download,
        Msg,
        DirInfo,
        File,
        Close
    }
  public enum MsgSendState
    {
        None,
        Single,
        Start,
        Sending,
        End
    }
 public enum MsgType
    {
        None,
        Text,
        Class,
        File
    }
 [Serializable]
    public class Message
    {
        public MsgCommand Command;
        public MsgType Type;
        public MsgSendState SendState;
        public int DataLength;

        public Message()
        {
            Command = MsgCommand.None;
            Type = MsgType.None;
            SendState = MsgSendState.None;
            DataLength = 0;
        }
    }
 [Serializable]
    public class UserInfo
    {
        public string Name;
        public string Password;

        public UserInfo()
        {
            Name = string.Empty;
            Password = string.Empty;
        }
    }
  [Serializable]
    public class PathInfo
    {
        public string Path;

        public PathInfo()
        {
            Path = string.Empty;
        }
    }
 [Serializable]
    public class DirectoryInfo
    {
        public string Name;
        public string FullPath;
        public long Size;
        public DateTime CreateTime;
        public DateTime LastAccessTime;
        public List<string> SubDirectory;
        public List<string> Files;

        public DirectoryInfo()
        {
            SubDirectory = new List<string>();
            Files = new List<string>();
        }

        public override string ToString()
        {
            string str = string.Empty;
            str += string.Format("Name:{0}\tFullPath:{1}\tSize:{2}\tCreateTime:{3}\tLastAccessTime:{4}"
                , Name
                , FullPath
                , Size
                , CreateTime.ToString("yyyy-MM-dd HH:mm:ss")
                , LastAccessTime.ToString("yyyy-MM-dd HH:mm:ss"));
            return str;
        }
    }
 [Serializable]
    public class FileInfo
    {
        public string Name;
        public string FullName;
        public long Size;
        public DateTime CreateTime;
        public DateTime LastAccessTime;

        public FileInfo()
        {

        }

        public override string ToString()
        {
            return string.Format("Name:{0}\tFullName:{1}\tSize:{2}\tCreateTime:{3}\tLastUpdateTime:{4}"
                , Name
                , FullName
                , Size
                , CreateTime.ToString("yyyy-MM-dd HH:mm:ss")
                , LastAccessTime.ToString("yyyy-MM-dd HH:mm:ss"));
        }
    }
 [Serializable]
    public class CloseInfo
    {
        /// <summary>
        /// Close type
        /// 0   Unkown close request
        /// 1   Server close request
        /// 2   Client close request
        /// </summary>
        public int Type;
        public string Message;

        public CloseInfo()
        {
            Type = 0;
            Message = string.Empty;
        }
    }
 public class Utils
    {
        public static byte[] Serialize<T>(T obj)
        {
            try
            {
                IFormatter formatter = new BinaryFormatter();
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, obj);
                stream.Position = 0;
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Flush();
                stream.Close();
                return buffer;
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("Serialize fail.\r\n{0}", ex.Message));
            }
        }

        public static T Deserialize<T>(T obj, byte[] data)
        {
            try
            {
                obj = default(T);
                IFormatter formatter = new BinaryFormatter();
                byte[] buffer = data;
                MemoryStream stream = new MemoryStream(buffer);
                stream.Seek(0, SeekOrigin.Begin);
                obj = (T)formatter.Deserialize(stream);
                stream.Flush();
                stream.Close();
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("Deserialize fail.\r\n{0}", ex.Message));
            }
            return obj;
        }
    }


 

 

 public interface IFtpServer
    {
        event Action<string> Debug;
        int Port { get; set; }
        bool IsRunning { get; }
        string RootDir { get; set; }
        bool Start();
        bool Start(int port);
        bool Stop();
        void Dispose();
    }
 public interface IFtpSession
    {
        event Action<string, string> Debug;
        event Action<string> Disconnected;
        string RootDir { get; set; }
        string CurrentDir { get; set; }
        string Client { get; set; }
        bool Start();
        bool Close();
        void Dispose();
    }
 public interface IFtpClient:IDisposable
    {
        event Action<string, string> Debug;
        event Action<string, Message, byte[]> MessageReceived;
        string Host { get; set; }
        int Port { get; set; }
        bool Connect();
        bool Connect(string host, int port);
        bool Close();
        bool Send(Message message, int length, byte[] data);
        void Dispose();
    }


服务端：

 

class FtpServer : IFtpServer
    {
        private TcpListener mFtpListener;
        private List<FtpSession> mFtpSessions;
        private int mCheckSessionInterval;
        private Timer mCheckActiveTimer;
        private int mListenPort;
        private bool mIsRunning;
        private string mRootDir;

        public FtpServer()
        {
            mFtpSessions = new List<FtpSession>();
            mCheckSessionInterval = Common.CHECK_CLIENT_INTEVAL;
            mListenPort = FtpServerDefine.LISTEN_PORT;
            mIsRunning = false;
            mRootDir = AppDomain.CurrentDomain.BaseDirectory;
        }

        private void SubAcceptClient(IAsyncResult result)
        {
            try
            {
                TcpListener listener = result.AsyncState as TcpListener;
                Socket socketClient = listener.EndAcceptSocket(result);
                SubDebug(string.Format("New client connected.\tClient:{0}", socketClient.RemoteEndPoint));
                FtpSession session = new FtpSession(socketClient);
                session.Debug += new Action<string, string>(session_Debug);
                session.Disconnected += new Action<string>(session_Disconnected);
                session.RootDir = mRootDir;
                mFtpSessions.Add(session);
                session.Start();
                listener.BeginAcceptSocket(SubAcceptClient, listener);
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Accept client fail.\tAccept client breaked."));
                mIsRunning = false;
            }
        }

        void session_Disconnected(string client)
        {
            try
            {
                SubDebug(string.Format("Session:{0} disconnected.", client));
                FtpSession session = mFtpSessions.Where(s => s.Client == client).First();
                mFtpSessions.Remove(session);
                SubDebug(string.Format("Session:{0} has removed.", client));
                session.Dispose();
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Remove session fail.\r\n{0}", ex.ToString()));
            }
        }

        void session_Debug(string client, string msg)
        {
            SubDebug(string.Format("Session:{0}\t{1}", client, msg));
        }

        void mCheckActiveTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            SubDebug(string.Format("Check online client.\tCount:{0}", mFtpSessions.Count));
            try
            {
                for (int i = mFtpSessions.Count - 1; i >= 0; i--)
                {
                    FtpSession session = mFtpSessions[i];
                    SubDebug(string.Format("Online client:{0}", session.Client));
                    if (session.LastActiveTime.AddSeconds(20) < DateTime.Now)
                    {
                        mFtpSessions.Remove(session);
                        SubDebug(string.Format("Session:{0} has removed.", session.Client));
                        session.Close();
                    }
                }
            }
            catch { }
        }

        private void SubDebug(string msg)
        {
            if (Debug != null)
            {
                Debug(msg);
            }
        }

        #region IFtpServer 成员

        public event Action<string> Debug;

        public int Port
        {
            get { return mListenPort; }
            set { mListenPort = value; }
        }

        public bool IsRunning
        {
            get { return mIsRunning; }
        }

        public string RootDir
        {
            get
            {
                return mRootDir;
            }
            set
            {
                mRootDir = value;
            }
        }

        public bool Start()
        {
            try
            {
                SubDebug(string.Format("Ftp server starting..."));
                if (mFtpListener != null)
                {
                    try
                    {
                        mFtpListener.Stop();
                        mFtpListener = null;
                    }
                    catch { }
                }
                mFtpListener = new TcpListener(IPAddress.Any, mListenPort);
                mFtpListener.Start();
                mIsRunning = true;
                SubDebug(string.Format("Listener started.\tLocal endpoint:{0}", mFtpListener.LocalEndpoint));
                mFtpListener.BeginAcceptSocket(new AsyncCallback(SubAcceptClient), mFtpListener);
                mCheckActiveTimer = new Timer(mCheckSessionInterval * 1000);
                mCheckActiveTimer.Elapsed += new ElapsedEventHandler(mCheckActiveTimer_Elapsed);
                mCheckActiveTimer.Start();
                SubDebug(string.Format("Check active timer started."));
                SubDebug(string.Format("Ftp Server started.\tRootDir:{0}", mRootDir));
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Ftp server start fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        public bool Start(int port)
        {
            mListenPort = port;
            return Start();
        }

        public bool Stop()
        {
            Dispose();
            SubDebug(string.Format("Ftp server stopped."));
            return true;
        }

        public void Dispose()
        {
            if (mFtpSessions != null)
            {
                foreach (FtpSession session in mFtpSessions)
                {
                    session.Dispose();
                }
                mFtpSessions.Clear();
                SubDebug(string.Format("All session removed."));
            }
            if (mFtpListener != null)
            {
                try
                {
                    mFtpListener.Stop();
                    mFtpListener = null;
                    SubDebug(string.Format("Ftp Listener stopped."));
                }
                catch { }
            }
            if (mCheckActiveTimer != null)
            {
                try
                {
                    mCheckActiveTimer.Stop();
                    SubDebug(string.Format("Check active timer stopped."));
                }
                catch { }
            }
        }

        #endregion
    }
 class FtpSession : IFtpSession
    {
        private string mClient;
        private Socket mSocket;
        private bool mIsLogined;
        private string mRootDir;
        private string mCurrentDir;
        private byte[] mMsgBuffer;
        private byte[] mDataBuffer;
        private int mMsgLength;
        private DateTime mLastActiveTime;

        public DateTime LastActiveTime
        {
            get { return mLastActiveTime; }
        }

        public FtpSession(Socket socket)
        {
            mSocket = socket;
            mClient = mSocket.RemoteEndPoint.ToString();
            mIsLogined = false;
            mRootDir = AppDomain.CurrentDomain.BaseDirectory;
            mCurrentDir = string.Empty;
            mMsgLength = FtpServerDefine.MESSAGE_LENGTH;
            mMsgBuffer = new byte[mMsgLength];
            mLastActiveTime = DateTime.Now;
        }

        private void SubReceiveMessage(IAsyncResult result)
        {
            mLastActiveTime = DateTime.Now;
            int iReceiveLength = 0;
            Socket socket = result.AsyncState as Socket;
            try
            {
                iReceiveLength = socket.EndReceive(result);
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("End receive message fail.\tClient disconected.\tReceive message break"));
                    SubDisconnected();
                }
                else
                {
                    SubDebug(string.Format("End receive message fail.\tReceive message break."));
                }
                return;
            }
            Message message = new Message();
            int dataLength = 0;
            if (iReceiveLength == mMsgLength)
            {
                try
                {
                    message = Utils.Deserialize<Message>(message, mMsgBuffer);
                    dataLength = message.DataLength;
                    mDataBuffer = new byte[dataLength];
                }
                catch (Exception ex)
                {
                    SubDebug(string.Format("Receive message fail.\r\n{0}", ex.ToString()));
                }
            }
            else
            {
                SubDebug(string.Format("Receive message length invalid.\tLength:{0}\tReceive message break.", iReceiveLength));
            }
            try
            {
                if (dataLength > 0)
                {
                    socket.BeginReceive(mDataBuffer, 0, dataLength, SocketFlags.None, new AsyncCallback(SubReceiveData), message);
                }
                else
                {
                    socket.BeginReceive(mMsgBuffer, 0, mMsgLength, SocketFlags.None, new AsyncCallback(SubReceiveMessage), socket);
                }
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("Begin receive fail.\tClient disconnected."));
                    SubDisconnected();
                }
                else
                {
                    SubDebug(string.Format("Begin receive fail.\tReceive message break."));
                }
            }
        }

        private void SubReceiveData(IAsyncResult result)
        {
            int iReceiveLength = 0;
            Socket socket;
            Message message;
            try
            {
                socket = mSocket;
                message = result.AsyncState as Message;
                iReceiveLength = socket.EndReceive(result);
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("End receive data fail.\tClient disconected.\tReceive data break"));
                    SubDisconnected();
                }
                else
                {
                    SubDebug(string.Format("End receive data fail.\tReceive data break."));
                }
                return;
            }
            if (iReceiveLength == message.DataLength)
            {
                switch (message.Command)
                {
                    case MsgCommand.Login:
                        DealLogin(message, mDataBuffer);
                        break;
                    case MsgCommand.List:
                        DealList(message, mDataBuffer);
                        break;
                    case MsgCommand.Download:
                        DealDowloadCommand(mDataBuffer);
                        break;
                    case MsgCommand.Close:
                        DealCloseCommand(message, mDataBuffer);
                        break;
                    default:
                        SubDebug(string.Format("Invalid command.\tCommand:{0}", message.Command));
                        break;
                }
            }
            else
            {
                SubDebug(string.Format("Receive data length invalid.\tLength:{0}\tNeed:{1}\tReceive data breaked.", iReceiveLength, message.DataLength));
            }
            try
            {
                socket.BeginReceive(mMsgBuffer, 0, mMsgLength, SocketFlags.None, new AsyncCallback(SubReceiveMessage), socket);
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("Begin receive fail.\tClient disconnected."));
                    SubDisconnected();
                }
                else
                {
                    SubDebug(string.Format("Begin receive fail.\tReceive message break."));
                }
            }
        }

        private bool SendMessage(Message message, int length, byte[] data)
        {
            if (mSocket == null && !mSocket.Connected)
            {
                SubDebug(string.Format("Send message fail.\tMsg:{0}\tSocket is null or not connected.", message.Command));
                return false;
            }
            try
            {
                message.DataLength = length;
                byte[] bMsg = Utils.Serialize<Message>(message);
                mSocket.Send(bMsg);
                mSocket.Send(data, length, SocketFlags.None);
                mLastActiveTime = DateTime.Now;
            }
            catch (Exception ex)
            {
                //SubDebug(string.Format("Send message fail.\tMsg:{0}\r\n{1}", message.Command, ex.ToString()));
                return false;
            }
            return true;
        }

        private bool DealLogin(Message message, byte[] data)
        {
            SubDebug(string.Format("Deal login command."));
            try
            {
                UserInfo userInfo = new UserInfo();
                userInfo = Utils.Deserialize<UserInfo>(userInfo, data);
                Message retMessage = new Message();
                retMessage.Command = MsgCommand.Msg;
                retMessage.Type = MsgType.Text;
                byte[] msg;
                if (userInfo.Name != "administrator")
                {
                    msg = Encoding.UTF8.GetBytes("User not exist.");
                    SendMessage(retMessage, msg.Length, msg);
                    return false;
                }
                if (userInfo.Password != "voicecyber")
                {
                    msg = Encoding.UTF8.GetBytes("Password error.");
                    SendMessage(retMessage, msg.Length, msg);
                    return false;
                }
                mIsLogined = true;
                msg = Encoding.UTF8.GetBytes(string.Format("{0}\t Logined", userInfo.Name));
                SendMessage(retMessage, msg.Length, msg);
                SubDebug(string.Format("{0} Logined.", userInfo.Name));
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Deal Login command fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        private bool DealList(Message message, byte[] data)
        {
            SubDebug(string.Format("Deal list command."));
            try
            {
                Message retMessage = new Message();
                retMessage.Command = MsgCommand.Msg;
                retMessage.Type = MsgType.Text;
                byte[] retData;
                if (!mIsLogined)
                {
                    retData = Encoding.UTF8.GetBytes("Not login.");
                    SendMessage(retMessage, retData.Length, retData);
                    return false;
                }
                PathInfo pathInfo = new PathInfo();
                pathInfo = Utils.Deserialize<PathInfo>(pathInfo, data);
                string path = pathInfo.Path;
                path = System.IO.Path.Combine(mRootDir, mCurrentDir, path);

                if (!System.IO.Directory.Exists(path))
                {
                    retData = Encoding.UTF8.GetBytes(string.Format("Directory not exist.\t{0}", path));
                    SendMessage(retMessage, retData.Length, retData);
                    return false;
                }
                DirectoryInfo dirInfo = GetDirInfo(path);
                retMessage.Command = MsgCommand.DirInfo;
                retMessage.Type = MsgType.Class;
                retData = Utils.Serialize<DirectoryInfo>(dirInfo);
                SendMessage(retMessage, retData.Length, retData);
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Deal List command fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        private bool DealDowloadCommand(byte[] data)
        {
            SubDebug(string.Format("Deal Download command."));
            try
            {
                PathInfo pathInfo = new PathInfo();
                pathInfo = Utils.Deserialize<PathInfo>(pathInfo, data);
                Message retMessage = new Message();
                retMessage.Command = MsgCommand.Msg;
                retMessage.Type = MsgType.Text;
                byte[] msg;
                string filePath = System.IO.Path.Combine(mRootDir, pathInfo.Path);
                if (!System.IO.File.Exists(filePath))
                {
                    msg = Encoding.UTF8.GetBytes(string.Format("File not exist.\t{0}", filePath));
                    SendMessage(retMessage, msg.Length, msg);
                    return false;
                }
                using (System.IO.FileStream fs = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read))
                {
                    long iLength = fs.Length;
                    byte[] buffer = new byte[1024];
                    int iRead = 0;
                    while (true)
                    {
                        iRead = fs.Read(buffer, 0, 1024);
                        if (iRead <= 0)
                        {
                            break;
                        }
                        if (iRead < 1024)
                        {
                            retMessage.Command = MsgCommand.File;
                            retMessage.Type = MsgType.File;
                            retMessage.SendState = MsgSendState.End;
                            SendMessage(retMessage, iRead, buffer);
                            break;
                        }
                        retMessage.Command = MsgCommand.File;
                        retMessage.Type = MsgType.File;
                        retMessage.SendState = MsgSendState.Sending;
                        SendMessage(retMessage, 1024, buffer);
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Deal Download command fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        private bool DealCloseCommand(Message message, byte[] data)
        {
            SubDebug(string.Format("Deal Close command."));
            try
            {
                CloseInfo closeInfo = new CloseInfo();
                closeInfo = Utils.Deserialize<CloseInfo>(closeInfo, data);
                SubDebug(string.Format("Receive close command.\tType:{0}\tMessage:{1}", closeInfo.Type, closeInfo.Message));
                Close();
                SubDisconnected();
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Deal Close command fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        private DirectoryInfo GetDirInfo(string path)
        {
            System.IO.DirectoryInfo dirInfo = new System.IO.DirectoryInfo(path);
            DirectoryInfo diretoryInfo = new DirectoryInfo();
            diretoryInfo.Name = dirInfo.Name;
            diretoryInfo.FullPath = dirInfo.FullName;
            //diretoryInfo.CreateTime = dirInfo.CreationTime;
            //diretoryInfo.LastAccessTime = dirInfo.LastAccessTime;
            diretoryInfo.Size = 0;
            foreach (System.IO.DirectoryInfo subDir in dirInfo.GetDirectories())
            {
                DirectoryInfo subDirectory = GetDirInfo(subDir.FullName);
                diretoryInfo.Size += subDirectory.Size;
                //diretoryInfo.SubDirectory.Add(subDirectory);
                diretoryInfo.SubDirectory.Add(subDirectory.Name);
            }
            foreach (System.IO.FileInfo subFile in dirInfo.GetFiles())
            {
                FileInfo fileInfo = new FileInfo();
                fileInfo.Name = subFile.Name;
                fileInfo.FullName = subFile.FullName;
                fileInfo.Size = subFile.Length;
                //fileInfo.CreateTime = subFile.CreationTime;
                //fileInfo.LastAccessTime = subFile.LastAccessTime;
                diretoryInfo.Size += fileInfo.Size;
                //diretoryInfo.Files.Add(fileInfo);
                diretoryInfo.Files.Add(fileInfo.Name);
            }
            return diretoryInfo;
        }

        private void SubDebug(string msg)
        {
            if (Debug != null)
            {
                Debug(mClient, msg);
            }
        }
        private void SubDisconnected()
        {
            if (Disconnected != null)
            {
                Disconnected(mClient);
            }
        }

        #region IFtpSession 成员

        public event Action<string, string> Debug;

        public event Action<string> Disconnected;

        public string RootDir
        {
            get
            {
                return mRootDir;
            }
            set
            {
                mRootDir = value;
            }
        }

        public string CurrentDir
        {
            get
            {
                return mCurrentDir;
            }
            set
            {
                mCurrentDir = value;
            }
        }

        public string Client
        {
            get { return mClient; }
            set { mClient = value; }
        }

        public bool Start()
        {
            if (mSocket == null || !mSocket.Connected)
            {
                SubDebug(string.Format("Session start fail.\tSocket is null or not connected."));
                return false;
            }
            try
            {
                mSocket.BeginReceive(mMsgBuffer, 0, mMsgLength, SocketFlags.None, new AsyncCallback(SubReceiveMessage), mSocket);
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("Begin receive fail.\tClient disconnected."));
                    SubDisconnected();
                }
                else
                {
                    SubDebug(string.Format("Begin receive fail.\tReceive message break."));
                }
                return false;
            }
            Message message = new Message();
            message.Command = MsgCommand.Msg;
            message.Type = MsgType.Text;
            byte[] data = Encoding.UTF8.GetBytes(string.Format("Welcome MDMSFtpServer!\tCurrent directory:{0}", mCurrentDir));
            SendMessage(message, data.Length, data);
            return true;
        }

        public bool Close()
        {
            if (mSocket != null && mSocket.Connected)
            {
                try
                {
                    mSocket.Close();
                    SubDebug(string.Format("Socket closed."));
                }
                catch (Exception ex)
                {
                    SubDebug(string.Format("Socket close fail.\r\n{0}", ex.ToString()));
                    return false;
                }
            }
            return true;
        }

        public void Dispose()
        {
            if (mSocket != null)
            {
                try
                {
                    mSocket.Close();
                }
                catch { }
            }
        }

        #endregion
    }


 

客户端：

 

 public class FtpClient : IFtpClient
    {
        private string mClient;
        private Socket mSocket;
        private string mHost;
        private int mPort;
        private int mMsgLength;
        private byte[] mBuffer;
        private int mReceiveLength;
        private bool mIsReceiveMessage;
        private Message mMessage;

        public FtpClient()
        {
            mClient = string.Empty;
            mHost = string.Empty;
            mPort = FtpServerDefine.LISTEN_PORT;
            mMsgLength = FtpServerDefine.MESSAGE_LENGTH;
            mIsReceiveMessage = true;
            mMessage = new Message();
        }

        public FtpClient(string client)
            : this()
        {
            mClient = client;
        }

        public bool Send(Message message, byte[] data)
        {
            return Send(message, data.Length, data);
        }

        private bool ConnectToServer()
        {
            try
            {
                Dispose();
                mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                mSocket.Connect(mHost, mPort);
                if (mSocket.Connected)
                {
                    mReceiveLength = mMsgLength;
                    mBuffer = new byte[mReceiveLength];
                    mIsReceiveMessage = true;
                    mSocket.BeginReceive(mBuffer, 0, mReceiveLength, SocketFlags.None, new AsyncCallback(SubReceiveMessage), mSocket);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("Begin receive fail.\tClient disconnected."));
                }
                SubDebug(string.Format("Connect to server fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        private void SubReceiveMessage(IAsyncResult result)
        {
            int iReceiveLength = 0;
            Socket socket = result.AsyncState as Socket;
            try
            {
                iReceiveLength = socket.EndReceive(result);
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("End receive message fail.\tServer disconected.\tReceive data break"));
                }
                else
                {
                    SubDebug(string.Format("End receive message fail.\tReceive data break."));
                }
                return;
            }
            if (iReceiveLength == 0)
            {
                SubDebug(string.Format("Receive 0 bytes.\tReceive message break."));
                return;
            }
            int index = 0;
            if (iReceiveLength < mReceiveLength)
            {
                mReceiveLength = mReceiveLength - iReceiveLength;
                index = iReceiveLength;
            }
            else
            {
                if (mIsReceiveMessage)
                {
                    mIsReceiveMessage = false;
                    Message message = new Message();
                    message = Utils.Deserialize<Message>(message, mBuffer);
                    mMessage = message;
                    mReceiveLength = message.DataLength;
                    mBuffer = new byte[mReceiveLength];
                }
                else
                {
                    mIsReceiveMessage = true;
                    SubMessageReceived(mMessage, mBuffer);
                    mReceiveLength = mMsgLength;
                    mBuffer = new byte[mReceiveLength];
                }
            }
            try
            {
                socket.BeginReceive(mBuffer, index, mReceiveLength, SocketFlags.None, new AsyncCallback(SubReceiveMessage), socket);
            }
            catch (Exception ex)
            {
                SocketException sex = ex as SocketException;
                if (sex != null)
                {
                    SubDebug(string.Format("Begin receive fail.\tClient disconnected."));
                }
                else
                {
                    SubDebug(string.Format("Begin receive fail.\tReceive message break."));
                }
            }
        }

        private bool SendMessage(Message message, int length, byte[] data)
        {
            try
            {
                message.DataLength = length;
                byte[] bMsg = Utils.Serialize<Message>(message);
                mSocket.Send(bMsg);
                mSocket.Send(data, length, SocketFlags.None);
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Send message fail.\tMsg:{0}\r\n{1}", message.Command, ex.ToString()));
                return false;
            }
            return true;
        }

        private void SubMessageReceived(Message message, byte[] data)
        {
            if (MessageReceived != null)
            {
                MessageReceived(mClient, message, data);
            }
        }
        public void SubDebug(string msg)
        {
            if (Debug != null)
            {
                Debug(mClient, msg);
            }
        }

        #region IFtpClient 成员

        public event Action<string, string> Debug;

        public event Action<string, Message, byte[]> MessageReceived;

        public string Host
        {
            get { return mHost; }
            set { mHost = value; }
        }

        public int Port
        {
            get { return mPort; }
            set { mPort = value; }
        }

        public bool Connect()
        {
            if (!ConnectToServer())
            {
                return false;
            }
            return true;
        }

        public bool Connect(string host, int port)
        {
            mHost = host;
            mPort = port;
            return Connect();
        }

        public bool Close()
        {
            if (mSocket != null && mSocket.Connected)
            {
                try
                {
                    mSocket.Close();
                    SubDebug(string.Format("Socket closed."));
                }
                catch (Exception ex)
                {
                    SubDebug(string.Format("Socket close fail.\r\n{0}", ex.ToString()));
                    return false;
                }
            }
            return true;
        }

        public bool Send(Message message, int length, byte[] data)
        {
            return SendMessage(message, length, data);
        }

        public void Dispose()
        {
            if (mSocket != null && mSocket.Connected)
            {
                try
                {
                    mSocket.Close();
                    mSocket = null;
                }
                catch { }
            }
        }

        #endregion

    }


 

 文件操作：

 

public class FileOperator : IDisposable
    {
        public event Action<string> Debug;

        private string mPath;
        private FileStream mFileStream;

        public FileOperator()
        {

        }

        public bool Create(string path)
        {
            if (!Path.IsPathRooted(path))
            {
                mPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path);
            }
            else
            {
                mPath = path;
            }
            try
            {
                if (File.Exists(mPath))
                {
                    File.Delete(mPath);
                }
                mFileStream = new FileStream(mPath, FileMode.OpenOrCreate, FileAccess.Write);
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Create file fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        public bool WriteData(int length, byte[] data)
        {
            try
            {
                if (mFileStream == null)
                {
                    mFileStream = new FileStream(mPath, FileMode.OpenOrCreate, FileAccess.Write);
                }
                mFileStream.Write(data, 0, length);
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Write data fail.\r\n{0}", ex.ToString()));
                return false;
            }

        }
        public bool Close()
        {
            try
            {
                if (mFileStream != null)
                {
                    mFileStream.Close();
                    mFileStream = null;
                }
                return true;
            }
            catch (Exception ex)
            {
                SubDebug(string.Format("Write data fail.\r\n{0}", ex.ToString()));
                return false;
            }
        }

        private void SubDebug(string msg)
        {
            if (Debug != null)
            {
                Debug(msg);
            }
        }

        #region IDisposable 成员

        public void Dispose()
        {
            if (mFileStream != null)
            {
                try
                {
                    mFileStream.Close();
                    mFileStream = null;
                }
                catch { }
            }
        }
        #endregion
    }


 

仙剑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# Socket 网络信息传输
againknow的博客
01-24 3101
C# Socket 网络信息传输
C#基于Socket的局域网即时通信和传输文件程序
阿修罗汉果茶的博客
07-21 3790
只要挂个阿里云，把IP地址和端口改一下，也可以实现内网穿透了。利用了Socket搭建了一个服务端和客户端，两个端之间可以通信。虽然很稚嫩，但是是当时的心血之作，那就放上来博客了。
C# 搭建WebSocket（服务端）
昔木的博客
07-23 1万+
C# 搭建WebSocket（服务端） 第一篇博客，简要介绍一下用SuperWebSocket搭建WebSocket的服务端 依赖NuGet包 - SuperWebSocket 做了一个WebSocket的Demo，但是我不建议用 SuperWebSocket实现 ，原因有几个，如果有别的更好用的框架，也请大家留言。（肯定是有的，只是我现在没时间去研究） SuperWebSocket 缺点（个人观...
C# 实现超大文件传输、断点续传等功能
热门推荐
若汝棋茗 的博客
09-04 1万+
经常有小伙伴在开发控制台、winform、WPF等C/S软件时，会有文件传输的需求。正好RRQMSocket.RPC完美支持这个，所以给大家介绍一波。文档首页Nuget安装即可，具体步骤详看链接博客。VS、Unity安装和使用Nuget包RRQM文件传输使用的是特殊传输协议，与FTP，HTTP等协议完全不兼容，所以如果使用文件传输，则服务器与客户端必须均使用RRQM组件。因为RRQM使用的是特殊协议，所以性能、功能上要远强于FTP，且搭建简单，支持多通道传输等。演示： 可以看到，下图正在上传一个Window
C# Socket文件上传至服务器
很多问题不见得会出在你身上，但你亦需要想法解决问题，否则就会变成你的问题。
09-12 1959
文件上传有FTP、WebApi、WebService等等，这次我们来实现一个基于socket通信的本地客户端上传文件到服务器的例子。
C# Socket简单编程实现文件传送
irkj_csdn的博客
10-04 510
发送端:   截图:     需添加的引用: using System.Net ; using System.IO ; using System.Net.Sockets ; private System.Windows.Forms.Label lblIP; private System.Window...
C# Socket通讯/TCP通讯，完整代码demo
01-20
本示例提供了一个完整的C# Socket通讯/TCP通讯的代码demo，旨在帮助开发者理解和应用网络通信技术。 首先，我们要理解Socket的基本概念。Socket在计算机网络中扮演着桥梁的角色，它允许两台计算机通过网络进行数据...
C#简易Socket通讯工具
07-18
文件列表中的"简易Socket通讯工具"可能包含以下组件： - 客户端代码：实现Socket连接，数据发送和接收的逻辑。 - 服务器代码：监听客户端连接，接收并响应数据。 - UI界面：提供用户友好的交互界面，允许输入和显示...
C#串口通讯和socket通讯demo
10-20
总结起来，`CSharpPort`提供的代码示例涵盖了C#环境下串口通讯和Socket通讯的基础应用。通过学习和分析这些代码，开发者可以更好地掌握如何在C#环境中实现设备间的串口通信和网络间的Socket通信，为开发相关项目打下...
C# WPF Socket UDP通讯
05-12
在本文中，我们将深入探讨如何使用C#的WPF（Windows Presentation Foundation）框架结合Socket UDP通信来实现与康耐视相机的实时无协议通讯。这是一个关键的技术应用，尤其是在工业自动化和图像处理领域。 首先，...
C#Socket文件传输简单例子（将文件名和文件同时传输）
04-09
C#Socket文件传输，将文件名和文件保存到一个byte[]中传输，再通过解析获取文件名和文件保存到本地文件夹中
c# socket 传输文件
10-23
c# socket 传输文件，c# socket 传输文件，c# socket 传输文件
C# socket发送(接收）文件
06-23
C#使用socket发送（接收）文件的程序，任何文件均可。 其中SingleSendForm是一次发送一个文件，MultiSendForm可以一次选择多个文件，然后依次发送。
Socket通信 能够发送文件，实体类，字符串等多种发送方式
09-05
Scoket通迅，在实际项目中用过，现在整理出，稳定性还好，能够发送文件，实体类，字符串，等多种发送方式，能发送大文件，等.....
c# socket与基恩士plc通讯、和扫码枪通讯程序源码
01-06
【亲测实用】c# socket与基恩士plc通讯、和扫码枪通讯程序源码 文件类型：程序源代码 主要功能： 工业通讯，c# socket与基恩士plc通讯、和扫码枪通讯 适合人群：新手及有一定经验的开发人员
C# socket(TCP/IP协议)通信
p878934160的博客
12-16 1022
C# socket(TCP/IP协议)通信 转载https://www.cnblogs.com/z178443085/p/13757579.html ##服务端 using System; using System.Text; using System.Net; using System.Net.Sockets; namespace socketServer { class Program { //1、创建一个用于监听连接的Socket对像； //2、将服务器的字符串ip地址转换为网络地址(IPAddres
C#实现文件传输？
最新发布
weixin_68436326的博客
10-31 674
在C#中，您可以使用Socket类来实现文件传输。以下是一个基于Socket的简单文件传输示例：1. 客户端代码客户端代码使用Socket类连接服务器，读取文件内容并发送到服务器。以下是一个客户端代码示例：```csharp using System.IO; using System.Net; using System.Net.Sockets; public static void Mai...
文件传输
见证大牛成长之路的专栏
04-20 3854
文件传输   前面的案例都是传输字符串.还有一种常见的情况,就是在服务端和客户端之间传输文件.   计入,客户端显示了一个菜单:当输入S1,S2或S3时,分别向服务端发送文件Client01.jpg,Client02.jpg,Client02.jpg;当输入R1,R2或R3时,分别从服务端接受文件Server01.jpg,Server02.jpg,Serve
c#socket通讯协议
10-19
C#中常用的Socket通讯协议有TCP和UDP。其中TCP是面向连接的协议，保证数据传输的可靠性，但是会有一定的延迟；而UDP是无连接的协议，传输速度快，但是不保证数据传输的可靠性。 在C#中，可以使用System.Net.Sockets...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值