C# .NET Socket封装

最新推荐文章于 2024-05-29 10:04:18 发布
最新推荐文章于 2024-05-29 10:04:18 发布
阅读量3.3k 收藏 15
点赞数 3
分类专栏： C# Socket 文章标签： socket socket封装 socket多线程 socket大文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s0611163/article/details/52192873
版权
    Socket封装，支持多客户端，支持大文件传输，支持多线程并发，对较大的Socket包进行分块传输。

    封装所要达到的效果，是可以像下面这样使用Socket和服务端通信，调用服务端的方法，让你在使用Socket的时候，感觉不到Socket的存在，就像是调用本地方法一样，并且支持ref参数和out参数：

DemoService demoService = new DemoService();
DemoService2 demoService2 = new DemoService2();
string result = demoService.Test("测试DemoService", 1);
demoService.Test2("测试DemoService", 1);
string result2 = demoService2.RunTest("测试DemoService2", 2);

一、数据结构：

CmdType：
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStruct
{
    /// <summary>
    /// cmd类型
    /// </summary>
    public enum CmdType
    {
        /// <summary>
        /// 执行方法
        /// </summary>
        RunFunction = 1,
        /// <summary>
        /// 心跳
        /// </summary>
        Heartbeat = 2
    }
}
SocketData： 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStruct
{
    /// <summary>
    /// Socket数据
    /// </summary>
    [Serializable]
    public class SocketData
    {
        /// <summary>
        /// 命令类型
        /// </summary>
        public CmdType cmdType { get; set; }
        /// <summary>
        /// 类名
        /// </summary>
        public string className { get; set; }
        /// <summary>
        /// 方法名
        /// </summary>
        public string functionName { get; set; }
        /// <summary>
        /// 方法参数
        /// </summary>
        public object[] funParam { get; set; }
    }
}
SocketResult： 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataStruct
{
    /// <summary>
    /// Socket返回
    /// </summary>
    [Serializable]
    public class SocketResult
    {
        /// <summary>
        /// 方法返回值
        /// </summary>
        public object returnValue { get; set; }
        /// <summary>
        /// 方法参数
        /// </summary>
        public object[] param { get; set; }
    }
}
FunctionUtil(根据SocketData执行服务端的方法)： 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace DataStruct.Utils
{
    /// <summary>
    /// 执行方法
    /// </summary>
    public class FunctionUtil
    {
        /// <summary>
        /// 执行方法
        /// </summary>
        public static object RunFunction(string applicationPath, SocketData socketData)
        {
            Assembly assembly = Assembly.LoadFile(Path.Combine(applicationPath, "DataService.dll"));
            object classObj = assembly.CreateInstance("DataService." + socketData.className);
            Type type = classObj.GetType();
            MethodInfo methodInfo = type.GetMethod(socketData.functionName);
            ParameterInfo[] parameterInfoArr = methodInfo.GetParameters();
            object result = methodInfo.Invoke(classObj, socketData.funParam);
            SocketResult socketResult = new SocketResult();
            socketResult.returnValue = result;
            socketResult.param = new object[socketData.funParam.Length];
            object paramObj;
            for (int i = 0; i < parameterInfoArr.Length; i++)
            {
                paramObj = socketData.funParam[i];
                if (parameterInfoArr[i].ParameterType.IsByRef || parameterInfoArr[i].IsOut)
                {
                    socketResult.param[i] = paramObj;
                }
                else
                {
                    socketResult.param[i] = null;
                }
            }
            return socketResult;
        }
    }
}
二、Socket通信封装： 
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using DataStruct.Utils;

namespace DataStruct
{
    /// <summary>
    /// Socket封装
    /// </summary>
    public static class SocketHelper
    {
        #region 变量
        private static object _lockSend = new object();
        private static Socket serverSocket;
        private static Socket clientSocket;
        private static List<Socket> clientList = new List<Socket>();
        private static System.Timers.Timer heartbeatTimer;
        #endregion

        #region 启动服务
        /// <summary>
        /// 启动服务
        /// </summary>
        public static void StartServer()
        {
            try
            {
                int port = Convert.ToInt32(ConfigurationManager.AppSettings["ServerPort"]);
                IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, port);
                serverSocket = new Socket(ipEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                serverSocket.Bind(ipEndPoint);
                serverSocket.Listen(10);
                new Thread(new ThreadStart(delegate()
                {
                    while (true)
                    {
                        Socket m_Client;
                        try
                        {
                            m_Client = serverSocket.Accept();
                            m_Client.SendTimeout = 20000;
                            m_Client.ReceiveTimeout = 20000;
                            m_Client.SendBufferSize = 10240;
                            m_Client.ReceiveBufferSize = 10240;
                            clientList.Add(m_Client);
                            LogUtil.Log("监听到新的客户端，当前客户端数：" + clientList.Count);
                        }
                        catch { break; }

                        DateTime lastHeartbeat = DateTime.Now;
                        new Thread(new ThreadStart(delegate()
                        {
                            try
                            {
                                while (true)
                                {
                                    byte[] receiveByteArr = null;
                                    try
                                    {
                                        receiveByteArr = Receive(m_Client);
                                    }
                                    catch { break; }
                                    if (receiveByteArr != null)
                                    {
                                        SocketData data = (SocketData)SerializeUtil.Deserialize(receiveByteArr);
                                        if (data.cmdType != CmdType.Heartbeat)
                                        {
                                            object obj = null;
                                            try
                                            {
                                                obj = FunctionUtil.RunFunction(System.Windows.Forms.Application.StartupPath, data);
                                            }
                                            catch (Exception ex)
                                            {
                                                LogUtil.LogError("执行方法出错：" + ex.Message + "\r\n" + ex.StackTrace);
                                                Send(m_Client, SerializeUtil.Serialize("error:执行服务端方法出错"));
                                            }
                                            Send(m_Client, SerializeUtil.Serialize(obj));
                                            LogUtil.Log("接收客户端数据，并向客户端返回数据");
                                        }
                                        else
                                        {
                                            lastHeartbeat = DateTime.Now;
                                            LogUtil.Log("收到心跳包，客户端连接正常");
                                        }
                                    }
                                    else
                                    {
                                        clientList.Remove(m_Client);
                                        LogUtil.Log("客户端正常关闭，当前客户端数：" + clientList.Count);
                                        if (m_Client.Connected) m_Client.Disconnect(false);
                                        m_Client.Close();
                                        m_Client.Dispose();
                                        break;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                LogUtil.LogError(ex.Message + "\r\n" + ex.StackTrace);
                                try
                                {
                                    Send(m_Client, SerializeUtil.Serialize("error:" + ex.Message));
                                }
                                catch { }
                            }
                        })).Start();

                        //检测客户端
                        new Thread(new ThreadStart(delegate()
                        {
                            try
                            {
                                while (true)
                                {
                                    DateTime now = DateTime.Now;
                                    if (now.Subtract(lastHeartbeat).TotalSeconds > 300)
                                    {
                                        clientList.Remove(m_Client);
                                        LogUtil.Log("客户端已失去连接，当前客户端数：" + clientList.Count);
                                        if (m_Client.Connected) m_Client.Disconnect(false);
                                        m_Client.Close();
                                        m_Client.Dispose();
                                        break;
                                    }
                                    Thread.Sleep(500);
                                }
                            }
                            catch (Exception ex)
                            {
                                LogUtil.LogError("检测客户端出错：" + ex.Message + "\r\n" + ex.StackTrace);
                            }
                        })).Start();
                    }
                })).Start();
                LogUtil.Log("服务已启动");
            }
            catch (Exception ex)
            {
                LogUtil.LogError("启动服务出错：" + ex.Message + "\r\n" + ex.StackTrace);
            }
        }
        #endregion

        #region 停止服务
        /// <summary>
        /// 停止服务
        /// </summary>
        public static void StopServer()
        {
            try
            {
                foreach (Socket socket in clientList)
                {
                    if (socket.Connected) socket.Disconnect(false);
                    socket.Close();
                    socket.Dispose();
                }
                clientList.Clear();
                if (serverSocket != null)
                {
                    if (serverSocket.Connected) serverSocket.Disconnect(false);
                    serverSocket.Close();
                    serverSocket.Dispose();
                }
                LogUtil.Log("服务已停止");
            }
            catch (Exception ex)
            {
                LogUtil.LogError("停止服务出错：" + ex.Message + "\r\n" + ex.StackTrace);
            }
        }
        #endregion

        #region 连接服务器
        /// <summary>
        /// 连接服务器
        /// </summary>
        public static void ConnectServer()
        {
            try
            {
                if (clientSocket == null || !clientSocket.Connected)
                {
                    if (clientSocket != null)
                    {
                        clientSocket.Close();
                        clientSocket.Dispose();
                    }
                    string ip = ConfigurationManager.AppSettings["ServerIP"];
                    int port = Convert.ToInt32(ConfigurationManager.AppSettings["ServerPort"]);
                    IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(ip), port);
                    clientSocket = new Socket(ipep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                    clientSocket.SendTimeout = 20000;
                    clientSocket.ReceiveTimeout = 20000;
                    clientSocket.SendBufferSize = 10240;
                    clientSocket.ReceiveBufferSize = 10240;
                    clientSocket.Connect(ipep);
                    LogUtil.Log("已连接服务器");
                }
            }
            catch (Exception ex)
            {
                LogUtil.LogError("连接服务器失败：" + ex.Message);
            }
        }
        #endregion

        #region 断开服务器
        /// <summary>
        /// 断开服务器
        /// </summary>
        public static void DisconnectServer()
        {
            try
            {
                if (clientSocket != null)
                {
                    if (clientSocket.Connected) clientSocket.Disconnect(false);
                    clientSocket.Close();
                    clientSocket.Dispose();
                }
                LogUtil.Log("已断开服务器");
            }
            catch (Exception ex)
            {
                LogUtil.LogError("断开服务器失败：" + ex.Message);
            }
        }
        #endregion

        #region 心跳
        public static void StartHeartbeat()
        {
            heartbeatTimer = new System.Timers.Timer();
            heartbeatTimer.Interval = 5000;
            heartbeatTimer.Elapsed += new System.Timers.ElapsedEventHandler((obj, eea) =>
            {
                try
                {
                    SocketData data = new SocketData();
                    data.cmdType = CmdType.Heartbeat;
                    Send(clientSocket, SerializeUtil.Serialize(data));
                }
                catch (Exception ex)
                {
                    LogUtil.LogError("向服务器发送心跳包出错：" + ex.Message);
                }
            });
            heartbeatTimer.Start();
        }
        #endregion

        #region 停止心跳
        public static void StopHeartbeat()
        {
            heartbeatTimer.Stop();
        }
        #endregion

        #region Send
        /// <summary>
        /// Send
        /// </summary>
        public static void Send(Socket socket, byte[] data)
        {
            lock (_lockSend)
            {
                byte[] lenArr = BitConverter.GetBytes(data.Length);
                int sendTotal = 0;
                while (sendTotal < lenArr.Length)
                {
                    int sendOnce = socket.Send(lenArr, sendTotal, lenArr.Length - sendTotal, SocketFlags.None);
                    sendTotal += sendOnce;
                    Thread.Sleep(1);
                }
                Thread.Sleep(1);

                int block = 10240;
                int count = (data.Length - 1) / block + 1;
                for (int i = 0; i < count; i++)
                {
                    int currentBlock = block;
                    if (i == count - 1)
                    {
                        currentBlock = data.Length - block * i;
                    }
                    sendTotal = 0;
                    while (sendTotal < currentBlock)
                    {
                        int sendOnce = socket.Send(data, i * block + sendTotal, currentBlock - sendTotal, SocketFlags.None);
                        sendTotal += sendOnce;
                        Thread.Sleep(1);
                    }
                    Thread.Sleep(1);
                }
            }
        }
        #endregion

        #region Receive
        /// <summary>
        /// Receive
        /// </summary>
        private static byte[] Receive(Socket socket)
        {
            lock (socket)
            {
                try
                {
                    int block = 4;
                    byte[] buffer = new byte[block];
                    int receiveCount = socket.Receive(buffer, 0, block, SocketFlags.None);
                    if (receiveCount == 0)
                    {
                        return null;
                    }
                    else
                    {
                        while (receiveCount < block)
                        {
                            int revCount = socket.Receive(buffer, receiveCount, buffer.Length - receiveCount, SocketFlags.None);
                            receiveCount += revCount;
                            Thread.Sleep(1);
                        }
                        int dataLength = BitConverter.ToInt32(buffer, 0);
                        block = 10240;
                        receiveCount = 0;
                        byte[] result = new byte[dataLength];
                        while (receiveCount < dataLength)
                        {
                            int revCount = socket.Receive(result, receiveCount, result.Length - receiveCount, SocketFlags.None);
                            receiveCount += revCount;
                            Thread.Sleep(1);
                        }
                        try
                        {
                            SerializeUtil.Deserialize(result);
                        }
                        catch (Exception ex)
                        {
                            LogUtil.LogError("数据检验失败！");
                            string aa = ex.Message;
                        }
                        return result;
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.LogError("接收数据出错：" + ex.Message + "\r\n" + ex.StackTrace);
                    return null;
                }
            }
        }
        #endregion

        #region IsZero
        /// <summary>
        /// IsZero
        /// </summary>
        private static bool IsZero(byte[] data)
        {
            bool bl = true;
            foreach (byte b in data)
            {
                if (b != 0)
                {
                    return false;
                }
            }
            LogUtil.LogError("接收的字节数组内容全是0");
            return bl;
        }
        #endregion

        #region 请求
        /// <summary>
        /// 请求
        /// </summary>
        public static object Request(SocketData data)
        {
            try
            {
                ConnectServer();

                Send(clientSocket, SerializeUtil.Serialize(data));

                byte[] receiveByteArr = null;
                receiveByteArr = Receive(clientSocket);
                if (receiveByteArr != null)
                {
                    object result = SerializeUtil.Deserialize(receiveByteArr);
                    if (result.GetType() == typeof(string) && result.ToString().IndexOf("error:") == 0)
                    {
                        string errMsg = result.ToString().Split(':')[1];
                        LogUtil.LogError(errMsg);
                        throw new Exception(errMsg);
                    }
                    return result;
                }
                else
                {
                    if (clientSocket.Connected) clientSocket.Disconnect(false);
                    clientSocket.Close();
                    clientSocket.Dispose();
                    return Request(data);
                }
            }
            catch (Exception ex)
            {
                if (clientSocket.Connected) clientSocket.Disconnect(false);
                LogUtil.LogError(ex.Message);
                throw ex;
            }
        }
        #endregion

        #region Request 请求
        /// <summary>
        /// 请求
        /// </summary>
        public static object Request(string className, string methodName, object[] param)
        {
            SocketData data = new SocketData();
            data.className = className;
            data.functionName = methodName;
            data.funParam = param;
            return Request(data);
        }
        #endregion

    }
}
三、服务端的服务接口类：
DemoService： 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using DAL;
using Models;

namespace DataService
{
    /// <summary>
    /// socket服务
    /// </summary>
    public class DemoService
    {
        public List<BS_NoticeType_ext> GetList(ref PagerModel pager, out string str)
        {
            NoticeTypeDal noticeTypeDal = new NoticeTypeDal();
            str = "测试123";
            return noticeTypeDal.GetList(ref pager);
        }

        public string Test(string str, int n)
        {
            return str + "：" + n;
        }

        public void Test2(string str, int n)
        {
            string s = str + n;
        }

        public void UploadFile(string fileName, byte[] fileData, int index)
        {
            string path = @"C:\Documents and Settings\Administrator\桌面\XXPLServer\files\";
            //string path = @"D:\_临时文件\文件\";
            //string path = @"C:\Users\Administrator\Desktop\suxtest\file\";
            //string path = @"C:\Documents and Settings\Administrator\桌面\Server\上传文件\";
            if (index == 1)
            {
                using (FileStream fs = new FileStream(path + fileName, FileMode.Create, FileAccess.Write))
                {
                    fs.Write(fileData, 0, fileData.Length);
                    fs.Close();
                }
            }
            else
            {
                using (FileStream fs = new FileStream(path + fileName, FileMode.Append, FileAccess.Write))
                {
                    fs.Write(fileData, 0, fileData.Length);
                    fs.Close();
                }
            }
        }
    }
}
DemoService2： 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataService
{
    public class DemoService2
    {
        public string RunTest(string str, int n)
        {
            return str + "：" + n;
        }
    }
}
四、客户端接口类代码：
DemoService： 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DataStruct;
using Common.Utils;
using System.Reflection;
using Models;

namespace ClientService
{
    public class DemoService
    {
        public List<BS_NoticeType_ext> GetList(ref PagerModel pager, out string str)
        {
            SocketResult result = (SocketResult)ServiceUtil.Request(this.GetType().Name,
                 MethodBase.GetCurrentMethod().Name,
                 new object[] { pager, null });
            pager = (PagerModel)result.param[0];
            str = (string)result.param[1];
            return (List<BS_NoticeType_ext>)result.returnValue;
        }

        public string Test(string str, int n)
        {
            SocketResult result = (SocketResult)ServiceUtil.Request(this.GetType().Name,
                 MethodBase.GetCurrentMethod().Name,
                 new object[] { str, n });
            return result.returnValue.ToString();
        }

        public void Test2(string str, int n)
        {
            SocketResult result = (SocketResult)ServiceUtil.Request(this.GetType().Name,
                 MethodBase.GetCurrentMethod().Name,
                 new object[] { str, n });
        }

        public bool UploadFile(string fileName, byte[] fileData, int index)
        {
            try
            {
                ServiceUtil.Request(this.GetType().Name,
                    MethodBase.GetCurrentMethod().Name,
                    new object[] { fileName, fileData, index });
                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}
DemoService2： 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using Common.Utils;
using DataStruct;

namespace ClientService
{
    public class DemoService2
    {
        public string RunTest(string str, int n)
        {
            SocketResult result = (SocketResult)ServiceUtil.Request(this.GetType().Name,
                MethodBase.GetCurrentMethod().Name,
                new object[] { str, n });
            return result.returnValue.ToString();
        }
    }
}
五：服务端启动服务： 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using DataStruct;
using DataStruct.Utils;
using Newtonsoft.Json;

namespace XXPLServer
{
    public partial class Form1 : Form
    {
        #region 变量
        #endregion

        #region Form1构造函数
        public Form1()
        {
            InitializeComponent();
        }
        #endregion

        #region Form1_Load
        private void Form1_Load(object sender, EventArgs e)
        {

        }
        #endregion

        #region 启动服务
        private void btnStartServer_Click(object sender, EventArgs e)
        {
            btnStopServer.Enabled = true;
            btnStartServer.Enabled = false;
            SocketHelper.StartServer();
        }
        #endregion

        #region 停止服务
        private void btnStopServer_Click(object sender, EventArgs e)
        {
            btnStopServer.Enabled = false;
            btnStartServer.Enabled = true;
            SocketHelper.StopServer();
        }
        #endregion

        #region Form1_FormClosing
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            SocketHelper.StopServer();
            System.Environment.Exit(0);
        }
        #endregion

    }
}

六：客户端测试代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using CommonDll;
using DataStruct;
using ClientService;
using System.IO;
using System.Diagnostics;
using Models;

namespace XXPLClient
{
    public partial class Form1 : Form
    {
        #region 变量
        #endregion

        #region Form1构造函数
        public Form1()
        {
            InitializeComponent();
        }
        #endregion

        #region Form1_Load
        private void Form1_Load(object sender, EventArgs e)
        {
            SocketHelper.ConnectServer(); //连接服务器
            SocketHelper.StartHeartbeat(); //心跳
        }
        #endregion

        #region Form1_FormClosing
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            SocketHelper.DisconnectServer();
            SocketHelper.StopHeartbeat();
            System.Environment.Exit(0);
        }
        #endregion

        private void btnTest_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < 1; i++)
            {
                new Thread(new ParameterizedThreadStart((obj) =>
                {
                    try
                    {
                        for (int j = 0; j < 1; j++)
                        {
                            DemoService demoService = new DemoService();
                            DemoService2 demoService2 = new DemoService2();
                            string str = demoService.Test("测试DemoService", 1) + "\r\n" + demoService2.RunTest("测试DemoService2", 2);
                            MessageBox.Show(str);
                        }
                    }
                    catch (Exception ex)
                    {
                        LogUtil.LogError(ex.Message);
                        MessageBox.Show(ex.Message);
                    }
                })).Start();
            }
        }

        private void btnUpload_Click(object sender, EventArgs e)
        {
            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    new Thread(new ParameterizedThreadStart((obj) =>
                    {
                        int block = 1048576;
                        byte[] bArr = new byte[block];
                        string fileName;
                        using (FileStream fs = new FileStream(openFileDialog1.FileName, FileMode.Open, FileAccess.Read))
                        {
                            fileName = Path.GetFileName(fs.Name);
                            long count = (fs.Length - 1) / block + 1;

                            DemoService demoService = new DemoService();
                            for (int i = 0; i < count; i++)
                            {
                                if (i != count - 1)
                                {
                                    fs.Read(bArr, 0, bArr.Length);
                                }
                                else
                                {
                                    int len = (int)(fs.Length - block * i);
                                    bArr = new byte[len];
                                    fs.Read(bArr, 0, bArr.Length);
                                }
                                bool bl = demoService.UploadFile(fileName, bArr, i + 1);
                                while (!bl)
                                {
                                    bl = demoService.UploadFile(fileName, bArr, i + 1);
                                    LogUtil.LogError("发生错误，重发");
                                    Thread.Sleep(20);
                                }
                                Thread.Sleep(20);
                            }
                            fs.Close();
                        }

                        MessageBox.Show("成功");
                    })).Start();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                DemoService demoService = new DemoService();
                PagerModel pager = new PagerModel();
                pager.page = 1;
                pager.rows = 10;
                string str;
                List<BS_NoticeType_ext> list = demoService.GetList(ref pager, out str);
                MessageBox.Show(string.Format("数据总条数：{0}\r\n页数：{1}\r\nout参数值：{2}\r\n第一条数据：{3}",
                    pager.totalRows, pager.pageCount, str, list[0].name));
            }
            catch (Exception ex)
            {
                string ss = ex.Message;
            }
        }

    }
}

七：大文件分块上传：

服务端DemoService添加如下方法：

public void UploadFile(string fileName, byte[] fileData, int index)
{
    string path = @"C:\Documents and Settings\Administrator\桌面\XXPLServer\files\";
    //string path = @"D:\_临时文件\文件\";
    //string path = @"C:\Users\Administrator\Desktop\suxtest\file\";
    //string path = @"C:\Documents and Settings\Administrator\桌面\Server\上传文件\";
    if (index == 1)
    {
        using (FileStream fs = new FileStream(path + fileName, FileMode.Create, FileAccess.Write))
        {
            fs.Write(fileData, 0, fileData.Length);
            fs.Close();
        }
    }
    else
    {
        using (FileStream fs = new FileStream(path + fileName, FileMode.Append, FileAccess.Write))
        {
            fs.Write(fileData, 0, fileData.Length);
            fs.Close();
        }
    }
}
客户端DemoService添加如下方法： 
public bool UploadFile(string fileName, byte[] fileData, int index)
{
    try
    {
        ServiceUtil.Request(this.GetType().Name,
            MethodBase.GetCurrentMethod().Name,
            new object[] { fileName, fileData, index });
        return true;
    }
    catch
    {
        return false;
    }
}
客户端选择文件上传： 
private void btnUpload_Click(object sender, EventArgs e)
{
    if (openFileDialog1.ShowDialog() == DialogResult.OK)
    {
        try
        {
            new Thread(new ParameterizedThreadStart((obj) =>
            {
                int block = 1048576;
                byte[] bArr = new byte[block];
                string fileName;
                using (FileStream fs = new FileStream(openFileDialog1.FileName, FileMode.Open, FileAccess.Read))
                {
                    fileName = Path.GetFileName(fs.Name);
                    long count = (fs.Length - 1) / block + 1;

                    for (int i = 0; i < count; i++)
                    {
                        if (i != count - 1)
                        {
                            fs.Read(bArr, 0, bArr.Length);
                        }
                        else
                        {
                            int len = (int)(fs.Length - block * i);
                            bArr = new byte[len];
                            fs.Read(bArr, 0, bArr.Length);
                        }
                        DemoService demoService = new DemoService();
                        bool bl = demoService.UploadFile(fileName, bArr, i + 1);
                        while (!bl)
                        {
                            bl = demoService.UploadFile(fileName, bArr, i + 1);
                            LogUtil.LogError("发生错误，重发");
                            Thread.Sleep(20);
                        }
                        Thread.Sleep(20);
                    }
                    fs.Close();
                }

                MessageBox.Show("成功");
            })).Start();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }
}


s0611163
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
常用socket函数封装及使用多进程和多线程实现服务器并发
SDTyuan的博客
08-16 153
注意：accept或者read函数是阻塞函数, 会被信号打断, 此时不应该视为一个错误。2.防止子进程在信号注册前退出，从而产生僵尸进程。注意：1.循环创建子进程最好循环回收，防止产生僵尸进程。>>> 主进程中对子进程进行回收。
c# Socket通讯封装类和DEMO
Pei_hua100的专栏
07-14 2335
socket封装 /// <summary> /// 自定义Socket对象 /// </summary> public class Sockets { /// <summary> /// 空构造 /// </summary> public Sockets() { } /// <summar...
C# .NET Socket SocketHelper 高性能 5000客户端 异步接收数据
余道长的博客
06-05 946
https://www.cnblogs.com/s0611163/p/12936469.html
C# TcpClient
最新发布
fkdw27的博客
05-29 435
TcpClient 自己封装的话，还是比较麻烦的，可以基于线程，也可以基于异步写，最好的办法是网上找个插件，我发现一个插件还是非常好用的：STTech.BytesIO.Tcp。目前网上大部分帖子都是用 PropertyGrid 控件去实现的，其实没必要。下面是这个插件作者的帖子，有兴趣的可以去看看。我做了一个简单的界面，如下。
Socket网络编程，C#对TCP协议和UDP协议的封装（TCPClient、TCPListener、UDPClient）
m0_38143858的博客
07-02 1744
应用程序可以通过TCPClient、TCPListener和UDPClient类使用传输控制协议（TCP）和用户数据文报协议（UDP）服务。 这些协议类建立在System.Net.Sockets.Socket类的基础上，负责数据传送的细节，也就是说TCPClient、TCPListener和UDPClient简化了Socket，让我们更方便的打代码。 TCPClient与TCPListener...
C#中Socket通信用法实例详解
不积跬步，无以至千里
11-02 2073
C#中Socket通信用法实例详解_C#教程_脚本之家  http://www.jb51.net/article/72313.htm 这篇文章主要介绍了C#中Socket通信用法,以实例形式较为详细的分析了UDP及TCP两种通信方式的具体实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下. 本文实例讲述了C#中Socket通信用法。分享给大家供大家参考。具体如下： 一、UDP方式：
给大家带来一个封装好的网络通信库
qq_39534909的博客
11-17 209
【代码】给大家带来一个封装好的网络通信库。
C# .NET中Socket简单实用框架的使用教程
08-29
在C# .NET环境中，Socket是用于网络通信的基础组件，它提供了对TCP/IP协议栈的低级别访问。本文将深入探讨如何在C# .NET中使用Socket构建一个简单实用的框架，以提升项目的可扩展性、健壮性和容错率。 首先，我们...
C# 后端 socket 连接 封装类
03-18
本篇将详细讲解如何使用C#封装一个Socket连接类，以简化开发过程。 首先，我们需要理解Socket的基本概念。Socket在C#中被表示为`System.Net.Sockets.Socket`类，它提供了TCP（传输控制协议）和UDP（用户数据报协议...
C# socket封装类和组件含例程全部开源
06-17
本资源“C# socket封装类和组件含例程全部开源”提供了一套全面且强大的C# Socket封装，旨在简化开发过程，提高代码的可读性和可维护性。以下是对这个开源项目的详细解析： 首先，Socket是TCP/IP协议族的基本组成...
c# socket demo 已经封装成共通
04-07
在.NET框架中，C#语言提供了丰富的库支持网络通信，其中Socket类是核心部分，用于实现TCP/IP协议栈中的各种网络通信。本示例“c# socket demo 已经封装成共通”聚焦于C#中如何使用Socket进行TCP通信，并且已经封装...
C#实现Socket异步通信完整封装库源码
04-17
1、SocketListener封装 2、SocketClient封装 3、TcpService封装 4、异步实现相关类定义
网络类库_socket封装类库
11-13
自主开发的高度封装socket类库，可以直接点对点传送“对象”，数据包过大自动拆分、发送接收进度支持等 也包含低度封装的socket库，方便使用 源码中包含多个Demo
C#Socket 封装了Tcp/Udp传输字串、文件、对象
03-28
网络通信 Tcp/Udp 传输字串、文件、对象 Tcp粘包、半包 1.封装了Tcp/Udp传输字串、文件、对象的细节，处理了Tcp粘包问题 2.测试代码设计原始Socket、TcpListener、TcpClient、UdpClient的使用 3.测试代码包括一个可以发送文本消息和发送文件的聊天室 4.设计网络通信、多线程、异步委托、异步套接字等技术
C#写的Socket通信组件 封装了底层Socket通信
07-09
本人用C#写的Socket通信组建，将底层Socket通信进一步封装，组建提供接口，只需要使用这些接口就可以轻松完成Socket通信而不用关心底层Socket的过程，并提供源码，需要的朋友可以对此改进
HPSocket.Net-develop_hpsocket.net_HPSocket_.net_socket_tcp_
10-04
【标题】"HPSocket.Net-develop_hpsocket.net_HPSocket_.net_socket_tcp_" 提供的知识点主要集中在使用C#编程语言实现基于TCP协议的Socket通信上，并且涉及到一个名为"HPSocket.Net"的库。HPSocket.Net是针对.NET...
C# 基于Socket套接字的网络通信封装
uiuan00的专栏
09-26 2837
摘要 之所以要进行Socket套接字通信库封装，主要是直接使用套接字进行网络通信编程相对复杂，特别对于初学者而言。实际上微软从.net 2.0开始已经提供了TCP、UDP通信高级封装类如下： TcpListener TcpClient UdpClient 微软从.net 4.0开始提供基于Task任务的异步通信接口。而直接使用socket封装库，很多socket本身的细节没办法自行控制，本...
C#进程间通信的几种方式：Socket通信
热门推荐
dnazhd的博客
03-07 1万+
方式二：Socket通信 套接字（Socket）是支持TCP/IP协议（安全）和UDP协议（快速）的网络通信的基本操作单元。套接字包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。为了满足不同程序对通信质量和性能的要求，一般的网络系统都提供了流式、数据报式、原始3种不同类型的套接字。 Socket通信方式： 同步：...
c# socket封装
05-17
C# 中的 Socket 类提供了底层的网络编程接口，但使用起来相对较为繁琐，因此可以进行封装，以便更方便地使用。以下是一个简单的 C# Socket 封装示例： ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; public class SocketClient { private Socket _socket; private byte[] _buffer = new byte[1024]; public SocketClient(string ipAddress, int port) { IPAddress ip = IPAddress.Parse(ipAddress); IPEndPoint remoteEP = new IPEndPoint(ip, port); _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _socket.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), _socket); } private void ConnectCallback(IAsyncResult ar) { Socket socket = (Socket)ar.AsyncState; socket.EndConnect(ar); } public void Send(string data) { byte[] byteData = Encoding.ASCII.GetBytes(data); _socket.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), _socket); } private void SendCallback(IAsyncResult ar) { Socket socket = (Socket)ar.AsyncState; int bytesSent = socket.EndSend(ar); Console.WriteLine("Sent {0} bytes to server.", bytesSent); } public void Receive() { _socket.BeginReceive(_buffer, 0, _buffer.Length, 0, new AsyncCallback(ReceiveCallback), _socket); } private void ReceiveCallback(IAsyncResult ar) { Socket socket = (Socket)ar.AsyncState; int bytesRead = socket.EndReceive(ar); if (bytesRead > 0) { string data = Encoding.ASCII.GetString(_buffer, 0, bytesRead); Console.WriteLine("Received: {0}", data); } } public void Close() { _socket.Shutdown(SocketShutdown.Both); _socket.Close(); } } ``` 这个示例中，我们创建了一个名为 `SocketClient` 的类，该类实现了一个基本的 TCP 客户端。在构造函数中，我们使用指定的 IP 地址和端口号初始化了一个 `IPEndPoint` 对象，并创建了一个 `Socket` 对象。在连接服务器时，我们使用 `BeginConnect` 方法异步地连接服务器，并在连接成功后调用 `ConnectCallback` 方法。在发送数据时，我们使用 `BeginSend` 方法异步地发送数据，并在发送完成后调用 `SendCallback` 方法。在接收数据时，我们使用 `BeginReceive` 方法异步地接收数据，并在接收完成后调用 `ReceiveCallback` 方法。在关闭客户端时，我们使用 `Shutdown` 方法关闭连接并调用 `Close` 方法释放资源。 以上是一个简单的 C# Socket 封装示例，实际应用中，可能需要根据具体需求进行修改。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值