参考这两个C#程序(含注释) 2客户

最新推荐文章于 2025-09-12 08:50:01 发布
转载 最新推荐文章于 2025-09-12 08:50:01 发布 · 467 阅读 · 0
文章标签：

#c# #byte #null #服务器 #stream #tcp

本文介绍了一个使用C#实现的TCP客户端类，该类提供了连接服务器、读写数据及发送接收消息等功能。通过示例展示了如何使用此类进行基本的网络通信。 
/// TCP客户端 [C#源代码来自http://www.showjim.com/]
using System;
using System.Net.Sockets;
using System.IO;
using System.Text;
using sys.dataStructure;

namespace sys.net
{
    /// <summary>
    /// TCP客户端
    /// </summary>
    public class tcpClient
    {
        /// <summary>
        /// TCP客户端连接
        /// </summary>
        private TcpClient client = null;
        /// <summary>
        /// 网络数据流
        /// </summary>
        private NetworkStream stream = null;

        #region 构造客户端TCP连接实例并获取数据流
        /// <summary>
        /// 构造客户端TCP连接实例并获取数据流
        /// </summary>
        /// <param name="serverName">服务器名称</param>
        /// <param name="port">端口</param>
        public tcpClient(string serverName, int port)
        {
            try
            {
                if (port > 0 && port < 65536) stream = (client = new TcpClient(serverName, port)).GetStream();
            }
            catch(Exception error)
            {
                close();
                sys.exception.debug.throwException(System.Reflection.MethodBase.GetCurrentMethod(), "客户端TCP连接失败(" + serverName + ":" + port.ToString() + @")
" + error.ToString());
            }
        }
        #endregion

        #region 关闭客户端TCP连接
        /// <summary>
        /// 关闭客户端TCP连接
        /// </summary>
        ~tcpClient() { close(); }
        /// <summary>
        /// 关闭客户端TCP连接
        /// </summary>
        public void close()
        {
            if (client != null)
            {
                try { client.Close(); client = null; }
                catch { }
            }
            if (stream != null)
            {
                try { stream.Close(); stream = null; }
                catch { }
            }
        }
        #endregion

        #region 流刷新
        /// <summary>
        /// 流刷新
        /// </summary>
        public void flush()
        {
            try { stream.Flush(); }
            catch { close(); }
        }
        #endregion

        #region 从数据流读取数据
        /// <summary>
        /// 从数据流读取一个字节(NetworkStream.ReadByte有Bug并且try不到)
        /// </summary>
        /// <returns>-2表示出错,-1表示结束</returns>
        public int readByte()
        {
            int value = -2;
            byte[] bytes = new byte[1];
            int length = _read(bytes, 0, 1);
            if (length == 1)
            {
                if (bytes == null || bytes.Length == 0) value = -3;
                else value = (int)bytes[0];
            }
            else if (length >= 0) value = -1;
            return value;
        }
        /// <summary>
        /// 从数据流读取一个31位整数
        /// </summary>
        /// <returns>-2表示出错,-1表示结束</returns>
        public int readInt31()
        {
            int value = -2;
            byte[] bytes = new byte[4];
            int length = _read(bytes, 0, 4);
            if (length == 4)
            {
                if ((value = BitConverter.ToInt32(bytes, 0)) < 0) value = 0;
            }
            else if (length >= 0) value = -1;
            return value;
        }
        /// <summary>
        /// 从数据流读取数据到字节数组
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <returns>实际读取长度,失败为-1</returns>
        public int read(byte[] bytes)
        {
            return bytes == null || bytes.Length == 0 ? -1 : _read(bytes, 0, bytes.Length);
        }
        /// <summary>
        /// 从数据流读取数据到字节数组的指定位置
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="startIndex">开始位置</param>
        /// <returns>实际读取长度,失败为-1</returns>
        public int read(byte[] bytes, int startIndex)
        {
            return bytes == null || startIndex >= bytes.Length ? -1 : _read(bytes, startIndex, bytes.Length - startIndex);
        }
        /// <summary>
        /// 从数据流读取指定长度到字节数组的指定位置
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="startIndex">开始位置</param>
        /// <param name="length">读取长度</param>
        /// <returns>实际读取长度,失败为-1</returns>
        public int read(byte[] bytes, int startIndex, int length)
        {
            return bytes == null || startIndex < 0 || length <= 0 || startIndex + length > bytes.Length ? -1 : _read(bytes, startIndex, length);
        }
        /// <summary>
        /// 从数据流读取指定长度的字节数组
        /// </summary>
        /// <param name="length">读取长度</param>
        /// <returns>实际读取字节数组</returns>
        public byte[] readBytes(int length)
        {
            byte[] bytes = null;
            if (length > 0)
            {
                int readLength = _read(bytes = new byte[length], 0, length);
                if (readLength != length)
                {
                    if (readLength == -1) bytes = null;
                    else
                    {
                        byte[] newBytes = new byte[readLength];
                        for (int i = 0; i < readLength; i++) newBytes[i] = bytes[i];
                        bytes = newBytes;
                    }
                }
            }
            return bytes;
        }
        /// <summary>
        /// 从数据流读取指定长度到字节数组的指定位置
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="startIndex">开始位置</param>
        /// <param name="length">读取长度</param>
        /// <returns>实际读取长度,失败为-1</returns>
        private int _read(byte[] bytes, int startIndex, int length)
        {
            int readLength = -1;
            try
            {
                for (int nextLength = length; nextLength != 0; nextLength -= readLength)
                {
                    startIndex += (readLength = stream.Read(bytes, startIndex, nextLength));
                    //System.Threading.Thread.Sleep(10);
                }
                readLength = length;
            }
            catch
            {
                readLength = -1;
                close();
            }
            return readLength;
        }
        /// <summary>
        /// 从数据流读取字节数组直到指定字符结束
        /// </summary>
        /// <param name="endByte">结束字符</param>
        /// <returns>字节数组</returns>
        public byte[] readUntilEnd(byte endByte)
        {
            MemoryStream byteStream = new MemoryStream();
            int read = stream.ReadByte(), end = (int)endByte;
            while (read != -1 && read != end)
            {
                byteStream.WriteByte((byte)read);
                read = stream.ReadByte();
            }
            byte[] bytes = (read == -1 ? null : byteStream.ToArray());
            byteStream.Close();
            return bytes;
        }
        /// <summary>
        /// 从数据流读取字节数组直到指定字符结束
        /// </summary>
        /// <param name="endByte">结束字符</param>
        /// <returns>字节数组</returns>
        public byte[] readUntilEnd(byte[] endByte)
        {
            byte[] bytes = null;
            if (endByte != null && endByte.Length != 0)
            {
                int length = endByte.Length;
                if (length == 1) bytes = readUntilEnd(endByte[0]);
                else
                {
                    int read = stream.ReadByte();
                    if (read != -1)
                    {
                        MemoryStream byteStream = new MemoryStream();
                        int endIndex = 0;
                        int[] end = new int[length];
                        for (int i = 0; i < length; i++) end[i] = (byte)endByte[i];
                        do
                        {
                            if (read != end[endIndex])
                            {
                                if (endIndex != 0)
                                {
                                    byteStream.Write(endByte, 0, endIndex);
                                    endIndex = 0;
                                }
                                byteStream.WriteByte((byte)read);
                                read = stream.ReadByte();
                            }
                            else if ((++endIndex) == length) break;
                        }
                        while (read != -1);
                        bytes = (read == -1 ? null : byteStream.ToArray());
                        byteStream.Close();
                    }
                }
            }
            return bytes;
        }
        #endregion

        #region 发送数据到服务器
        /// <summary>
        /// 发送字节数组到服务器
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <returns>是否成功</returns>
        public bool send(byte[] bytes)
        {
            return bytes != null && bytes.Length > 0 && _send(bytes, 0, bytes.Length);
        }
        /// <summary>
        /// 发送字节数组的指定位置数据到服务器
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="startIndex">起始位置</param>
        /// <returns>是否成功</returns>
        public bool send(byte[] bytes, int startIndex)
        {
            return bytes != null && startIndex >= 0 && bytes.Length > startIndex && _send(bytes, startIndex, bytes.Length - startIndex);
        }
        /// <summary>
        /// 发送字节数组的指定位置数据到服务器
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="startIndex">起始位置</param>
        /// <param name="length">发送长度</param>
        /// <returns>是否成功</returns>
        public bool send(byte[] bytes, int startIndex, int length)
        {
            return bytes != null && startIndex >= 0 && length >= 0 && bytes.Length >= startIndex + length && _send(bytes, startIndex, length);
        }
        /// <summary>
        /// 发送字符串到服务器
        /// </summary>
        /// <param name="sendString">字符串</param>
        /// <param name="code">编码方式</param>
        /// <returns>是否成功</returns>
        public bool send(string sendString, Encoding code)
        {
            return sendString != null && sendString.Length != 0 && code != null && _send(code.GetBytes(sendString));
        }
        /// <summary>
        /// 按照默认编码方式发送字符串到服务器
        /// </summary>
        /// <param name="sendString">字符串</param>
        /// <returns>是否成功</returns>
        public bool send(string sendString)
        {
            return sendString != null && sendString.Length != 0 && _send(Encoding.Default.GetBytes(sendString));
        }
        /// <summary>
        /// 发送字节数组到服务器
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <returns>是否成功</returns>
        private bool _send(byte[] bytes)
        {
            bool isSend = true;
            try { stream.Write(bytes, 0, bytes.Length); }
            catch { isSend = false; close(); }
            return isSend;
        }
        /// <summary>
        /// 发送字节数组的指定位置数据到服务器
        /// </summary>
        /// <param name="bytes">字节数组</param>
        /// <param name="startIndex">起始位置</param>
        /// <param name="length">发送长度</param>
        /// <returns>是否成功</returns>
        private bool _send(byte[] bytes, int startIndex, int length)
        {
            bool isSend = true;
            try { stream.Write(bytes, startIndex, length); }
            catch { isSend = false; close(); }
            return isSend;
        }
        #endregion

        #region 读取服务器端指定长度数据保存到文件
        /// <summary>
        /// 读取服务器端指定长度数据保存到文件
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="length">文件字节数</param>
        /// <returns>是否成功</returns>
        public bool saveFile(string fileName, long length)
        {
            bool isSave = false;
            if (fileName != null && fileName.Length != 0 && length > 0)
            {
                FileStream fileStream = null;
                try { fileStream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write, FileShare.None, pub.streamBufferLength); }
                catch { }
                if (fileStream != null)
                {
                    isSave = saveFile(fileStream, 0, length, pub.streamBufferLength);
                    fileStream.Close();
                    if (!isSave) File.Delete(fileName);
                }
            }
            return isSave;
        }
        /// <summary>
        /// 读取服务器端指定长度数据保存到文件流
        /// </summary>
        /// <param name="fileStream">文件流</param>
        /// <param name="startIndex">起始位置</param>
        /// <param name="length">字节长度</param>
        /// <returns>是否成功</returns>
        public bool saveFile(FileStream fileStream, long startIndex, long length)
        {
            return saveFile(fileStream, startIndex, length, pub.streamBufferLength);
        }
        /// <summary>
        /// 读取服务器端指定长度数据保存到文件流
        /// </summary>
        /// <param name="fileStream">文件流</param>
        /// <param name="startIndex">起始位置</param>
        /// <param name="length">字节长度</param>
        /// <param name="bufferLength">缓存区字节长度</param>
        /// <returns>是否成功</returns>
        public bool saveFile(FileStream fileStream, long startIndex, long length, int bufferLength)
        {
            bool isSave = false;
            if (fileStream != null && startIndex >= 0 && length > 0 && bufferLength > 0)
            {
                long endIndex = startIndex + length;
                if (endIndex > 0)
                {
                    try
                    {
                        fileStream.SetLength(endIndex);
                        fileStream.Seek(startIndex, SeekOrigin.Begin);
                    }
                    catch { }

                    int readLength;
                    byte[] bytes = new byte[bufferLength];
                    isSave = true;
                    try
                    {
                        while (isSave && length >= bufferLength)
                        {
                            if (isSave = ((readLength = read(bytes)) == bufferLength))
                            {
                                fileStream.Write(bytes, 0, readLength);
                                length -= readLength;
                            }
                        }
                        if (isSave && length != 0 && (isSave = (read(bytes, 0, readLength = (int)length) == readLength))) fileStream.Write(bytes, 0, readLength);
                    }
                    catch { isSave = false; }
                }
            }
            return isSave;
        }
        #endregion

        #region 用法示例
        /// <summary>
        /// 服务器端IP
        /// </summary>
        private const string exampleIp = "127.0.0.1";
        /// <summary>
        /// 服务器端监听端口
        /// </summary>
        private const int examplePort = 9999;
        /// <summary>
        /// 用法示例
        /// </summary>
        private static void example()
        {
            sys.net.tcpClient exampleClient = new sys.net.tcpClient(exampleIp, examplePort);

            #region 接收服务器端的数据
            int byteValue = exampleClient.readByte();   //接收一个字节
            int int31Value = exampleClient.readInt31();  //接收一个31位整数
            byte[] bytes = exampleClient.readBytes(int31Value); //接收一个字节数组
            int length = exampleClient.read(bytes, 0, int31Value);    //接收一个字节数组
            #endregion

            #region 发送数据到服务器端
            bool isSend = exampleClient.send(bytes, 0, bytes.Length);  //发送一个字节数组
            #endregion
        }
        #endregion
    }
}
C#面试题目含参考答案(四)
dotNet开发技术分享
06-22 1236
面试是应聘一个工作岗位的环节，来考察一个人的工作能力与综合素质。在应聘C#程序员或与C#相关岗位时，我们都会被问到一些与.NET、C#、数据库、业务知识或编程思想等问题。本文列举一些问题及提供参考答案，题目（四）。
三菱PLC与C#上位机冷库温度监控系统源码 plc 触摸屏 程序带注释 三菱PLC与C#开发上位机软件做的冷库温度监控系统，有两
07-09
三菱PLC与C#上位机冷库温度监控系统源码 plc 触摸屏 程序带注释 三菱PLC与C#开发上位机软件做的冷库温度监控系统，有两台三菱fx3uplc，电脑做上位机与主站plc 通讯控制，再配485adp模块读取温度采集器，采集温度数据...
C# Socket 读写数据判断连接状态
qq_14846889的博客
03-07 1292
Socket 读写数据判断连接状态
C#代码注释
qq_37219159的博客
01-18 1052
C#代码的基本注释写法和实例演示
C# 代码注释规范文档
m0_58750788的博客
06-27 1153
C#代码规范
C#【基础篇】 C# 程序结构
星Yeah 的博客
05-24 968
C# 的最小的程序结构： 命名空间声明（Namespace declaration） 一个 class Class 方法 Class 属性 一个 Main 方法 语句（Statements）& 表达式（Expressions） 注释 如何建立一个项目并运行的两种方式：IDE或命令行
C# 注释
ZBlog
01-03 1735
c#中//注释和///注释的区别 ///会被编译， //不会 所以使用///会减慢编译的速度（但不会影响执行速度） ///会在其它的人调用你的代码时提供智能感知 也是一种注释，但是这种注释主要有两种作用： 1.这些注释能够生成一个XML文件。这样呢,看起来会对程序的内容一目了然。 2.以这种方式对你的类，属性，方法等等加上注释之后，当你在其他地方使用以这种方式加上的类，属性，方法等等地时候，...
Unity中C#程序结构和 基本语法(2)
qq_41807260的博客
02-22 1614
C# 程序结构 在我们学习 C# 编程语言的基础构件块之前，让我们先看一下 C# 的最小的程序结构，以便作为接下来章节的参考。 C# Hello World 实例 一个 C# 程序主要包括以下部分： 命名空间声明（Namespace declaration） 一个 class Class 方法 Class 属性 一个 Main 方法 语句（Statements）&amp; 表达式...
C#程序实现软件开机自动启动的两种常用方法
nihaoapengyou的专栏
12-12 2783
C#程序实现软件开机自动启动的两种常用方法 C#/WPF/WinForm/.NET程序代码实现软件程序开机自动启动的两种常用方法函数的示例与实例带详细注释 方法一：将软件的快捷方式创建到计算机的自动启动目录下（不需要管理员权限） 1.必要引用 复制代码 复制代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using IWshRuntimeLibr
编写高质量Dart程序-文档注释参考
Marswill
08-17 2736
注释 要像句子一样格式化评论。 不要在文档中使用块注释。 Doc注释 使用///文档注释来记录成员和类型。 优先为公共api编写文档注释。 考虑写一个库级别的文档注释 考虑为私有api编写文档注释。 用一句话总结开始doc注释。 一定要把“doc注释”的第一句话分隔成自己的段落。 避免与周围的上下文冗余。 优先用第三人称动词开始函数或方法注释。 优先用名词短语开始变量、getter或se...
C# Windows 服务程序的开发
熊思雨的博客
12-23 4761
安装程序将服务的可执行文件注册到系统服务管理器中，并提供安装、卸载和配置服务的功能。在这个类中，需要重写 OnStart 和 OnStop 方法，分别用于处理服务的启动和停止逻辑。通过使用 .NET 提供的相关类和方法，可以轻松地创建、安装、启动和停止 Windows 服务。Windows 服务是一种特殊类型的应用程序，它可以在操作系统启动时自动启动，并在后台持续运行，而无需用户交互。这里重写了一个 OnStart 和 OnStop 方法，意思是程序启动的时候执行一次，和程序关闭的时候执行一次。
C#统计C、C++及C#程序代码行数的方法
01-01
本文实例讲述了C#统计C、C++及C#程序代码行数的方法。分享给大家供大家参考。具体如下： 本文中的两个函数 1）用于统计扩展名为 .h .c .cpp .cs 文件的代码行数 public static int LinesOfCode(string filename) 2）...
Modbus tcp rtu 2个版本读写工具源代码有注释实例参考学习.zip
08-25
这两个工具的开发可能遵循了以下的开发流程：首先，开发者根据Modbus协议的通信机制设计了应用程序架构，确定了必要的功能模块，如连接管理、数据读写、异常处理等。其次，针对每个模块编写了相应的代码，并且在代码...
在VS2017程序设计平台下用c#语言设计一个方位角计算的程序
12-27
在中国石油大学（华东）的课程中，吉吉老师可能布置了这个作业，让学生通过实践提升对C#编程和数学应用的理解。 方位角计算通常涉及到地球上的两点坐标，比如经纬度，然后根据这些坐标确定从一点到另一点的方向。在...
C#语言程序设计基础(第二版)郑宇军部分参考答案 (2).pdf
02-27
1. C#源程序的构成：C#程序由代码和注释两部分组成。代码分为引用部分和主体部分，主体代码都位于命名空间内，其中包含了各种类型（如类、结构体、接口等）及其成员（如方法、属性、字段等）的定义。命名空间是组织...
C++mat传入C#OpencvCSharp的mat
m0_66380820的博客
09-10 212
C++使用opencv的mat图像，将mat传入OpencvCSharp的几种方法。接下里介绍rgb图片和单通道图片传入方法，主要是将图片数据放入数组内，再传出。
c#项目编译时外部依赖文件的同步问题
rocklee的专栏
09-09 176
很多场景因为资源文件太多或太大无法放到资源里面或者是依赖的dll文件，需要编译时同步到bin\debug或bin\release下的，这里面要修改工程文件代码实现。比如，我把这个项目依赖的dll和附加文件放到ref_dll文件夹里面，希望编译的时候将ref_dll里面的所有内容保持结构化地复制至bin\debug下。vs这个功能是非常nice的。
快速学习C# OOP实践
charlie114514191的博客
09-11 408
C# OOP 核心概念总结 类与对象 类包含字段、属性、方法等成员 对象通过 new 实例化 访问修饰符控制可见性 方法特性 支持重载、参数传递方式（ref/out/in） 可选参数与命名参数 表达式体方法简化语法 面向对象三大支柱 封装：通过属性保护字段 继承：子类扩展父类功能 多态：虚方法/接口实现运行时绑定 关键实践 构造函数链简化初始化 属性优于公共字段 方法设计遵循单一职责原则 （全文摘要，共150字）
ABAP 屏幕在自定义容器写多行文本框
最新发布
weixin_44686958的博客
09-12 129
容器等逻辑 屏幕
C#异步编程 - Task的用法总结
GuoGuoABC
09-12 421
C#中的Task是异步编程的核心类型，封装了异步操作的状态和行为。Task有7种状态，包括创建、等待执行、运行中、完成等。创建Task的方式包括Task.Run()、async/await、Task.FromResult等。等待任务可用await（推荐）或阻塞式Wait()/Result。处理多个任务可使用WhenAll/WhenAny或WaitAll/WaitAny。异常处理上，await会自动解包异常，而直接访问Task需处理AggregateException。取消操作通过CancellationTo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值