C# UDP通讯接口定义和实现
一、接口定义
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
namespace SocketCOM
{
public interface ISmartCardSDK
{
/// <summary>
/// 接收信息
/// </summary>
event Action<CommonInfo> Info_Received;
/// <summary>
/// 发送信息
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
bool SendInfo(CommonInfo info);
/// <summary>
/// 初始化UPD发送
/// </summary>
/// <param name="socketParameter"></param>
void InitUdpSockt(SocketParameter weightParameter);
/// <summary>
/// 启用UDP发送
/// </summary>
void TurnOnUdpSockt();
/// <summary>
/// 停止UDP发送
/// </summary>
void TurnOffUdpSockt();
/// <summary>
/// 初始化UPD接收
/// </summary>
/// <param name="weightParameter"></param>
void InitUdpClient(SocketParameter weightParameter);
/// <summary>
/// 启用UDP接收
/// </summary>
void TurnOnUdpClient();
/// <summary>
/// 停止UDP接收
/// </summary>
void TurnOffUdpClient();
}
}二、接口实现
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SocketCOM
{
public class SmartCardSDK: ISmartCardSDK
{
private UdpSocketHelper UdpSkt;
private UdpClientHelper udpListener;
private SocketParameter socketParameter;
public event Action<CommonInfo> Info_Received;
#region UdpSocke通讯
/// <summary>
/// 初始化发送UDP
/// </summary>
public void InitUdpSockt(SocketParameter weightParameter)
{
socketParameter = weightParameter;
if (string.IsNullOrWhiteSpace(socketParameter.SktLocalPort))
throw new Exception("本地端口号格式有误！");
try
{
UdpSkt = new UdpSocketHelper(int.Parse(socketParameter.SktLocalPort), ReceiveCmd);
UdpSkt.Init();
}
catch (Exception ex)
{
throw new Exception(#34;UDP通讯初始化异常，{ex.Message}");
}
}
/// <summary>
/// 打开发送UDP
/// </summary>
public void TurnOnUdpSockt()
{
try
{
UdpSkt.Start();
}
catch (Exception ex)
{
throw new Exception(#34;UDP通讯启动异常，{ex.Message}");
}
}
/// <summary>
/// 关闭发送UDP
/// </summary>
public void TurnOffUdpSockt()
{
try
{
if (UdpSkt != null)
UdpSkt.Stop();
}
catch (Exception ex)
{
throw new Exception(#34;UDP通讯停止异常，{ex.Message}");
}
}
#endregion
#region UdpClien通讯
/// <summary>
/// 初始化发送UDP
/// </summary>
public void InitUdpClient(SocketParameter weightParameter)
{
socketParameter = weightParameter;
if (string.IsNullOrWhiteSpace(socketParameter.SktLocalPort))
throw new Exception("本地端口号格式有误！");
try
{
udpListener = new UdpClientHelper(int.Parse(socketParameter.SktLocalPort), ReceiveCmd);
}
catch (Exception ex)
{
throw new Exception(#34;UDP通讯初始化异常，{ex.Message}");
}
}
/// <summary>
/// 打开发送UDP
/// </summary>
public void TurnOnUdpClient()
{
try
{
udpListener.Init();
udpListener.Start();
}
catch (Exception ex)
{
throw new Exception(#34;UDP通讯启动异常，{ex.Message}");
}
}
/// <summary>
/// 关闭发送UDP
/// </summary>
public void TurnOffUdpClient()
{
try
{
if (udpListener != null)
udpListener.Stop();
}
catch (Exception ex)
{
throw new Exception(#34;UDP通讯停止异常，{ex.Message}");
}
}
#endregion
/// <summary>
/// 接收
/// </summary>
/// <param name="cmd"></param>
private void ReceiveCmd(string cmd)
{
try
{
CommonInfo commonInfo = Tools.ConvertJsonToObj<CommonInfo>(cmd);
Info_Received?.Invoke(commonInfo);
}
catch (Exception ex)
{
throw new Exception(#34;接收信息异常，{ex.Message}");
}
}
/// <summary>
/// 发送
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public bool SendInfo(CommonInfo info)
{
try
{
string cmd = Tools.ConvertToJsonStr(info);
if (UdpSkt != null)
UdpSkt.SendCmd(cmd, socketParameter.SktRemoteIP1, int.Parse(socketParameter.SktRemotePort1));
return true;
}
catch (Exception ex)
{
throw new Exception(#34;发送信息异常，{ex.Message}");
}
}
}
/// <summary>
/// 发送数据
/// </summary>
public class FillingInfo
{
public string ProductName { get; set; }
public string Specification { get; set; }
public string PlateNumber { get; set; }
public string Slot { get; set; }
public decimal TargetValue { get; set; }
public string Operator { get; set; }
public string Receiver { get; set; }
public string Note { get; set; }
public decimal FillingValue { get; set; }
public string StartTime { get; set; }
public string EndTime { get; set; }
}
/// <summary>
/// 通讯参数
/// </summary>
public class SocketParameter
{
/// <summary>
/// 本地端口
/// </summary>
public string SktLocalPort { get; set; }
/// <summary>
/// 发送IP
/// </summary>
public string SktRemoteIP1 { get; set; }
/// <summary>
/// 发送端口
/// </summary>
public string SktRemotePort1 { get; set; }
}
/// <summary>
/// 接收数据
/// </summary>
public class CommonInfo
{
/// <summary>
/// 发送代码 自定义功能代码
/// 返回代码 如果成功返回:0； 普通信息返回>=1 <1000（默认1）； 错误信息>=1000（默认1000）； 异常信息<=-1（默认-1）；
/// </summary>
public string Code { get; set; }
/// <summary>
/// 消息内容.
/// </summary>
public string Msg { get; set; }
/// <summary>
/// 时间戳
/// </summary>
public string TimeStamp { get; set; }
/// <summary>
/// 数据
/// </summary>
public object Data { get; set; }
}
}三、UdpHelper.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
namespace SocketCOM
{
#region UdpSocket通讯
/// <summary>
/// Socket通讯
/// </summary>
public class UdpSocketHelper
{
/// <summary>
/// 变量
/// </summary>
private int _localPort;
private bool _isStop = false;
private Socket _udpServer;
Action<string> _callback;
/// <summary>
/// 构造
/// </summary>
/// <param name="localPort"></param>
/// <param name="callback"></param>
public UdpSocketHelper(int localPort, Action<string> callback)
{
_localPort = localPort;
_callback = callback;
}
/// <summary>
/// 初始
/// </summary>
public void Init()
{
try
{
//1,创建socket
_udpServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
//2,绑定ip跟端口号
_udpServer.Bind(new IPEndPoint(IPAddress.Any, _localPort));
}
catch (Exception e)
{
throw new Exception(#34;UDP初始化失败，{e.Message}");
}
}
/// <summary>
/// 开始接收
/// </summary>
public void Start()
{
_isStop = false;
Task.Run(new Action(() =>
{
EndPoint remote = new IPEndPoint(IPAddress.Any, _localPort);
while (true)
{
if (_isStop)
continue;
if (_udpServer.Available < 1)
continue;
try
{
byte[] data = new byte[1024];
//接收
int len = _udpServer.ReceiveFrom(data, ref remote);
if (len == 0)
continue;
string receivemsg = Encoding.Default.GetString(data, 0, len);
if (string.IsNullOrEmpty(receivemsg))
continue;
_callback?.Invoke(receivemsg);
}
catch (Exception)
{
continue;
}
}
}));
}
/// <summary>
/// 停止
/// </summary>
public void Stop()
{
try
{
_isStop = true;
if (_udpServer != null)
_udpServer.Close();
}
catch (Exception e)
{
throw new Exception(#34;UDP停止失败，{e.Message}");
}
}
/// <summary>
/// 发送
/// </summary>
/// <param name="cmd"></param>
/// <param name="remoteIp"></param>
/// <param name="remotePort"></param>
public void SendCmd(string cmd, string remoteIp, int remotePort)
{
try
{
_udpServer.SendTo(Encoding.Default.GetBytes(cmd), new IPEndPoint(IPAddress.Parse(remoteIp), remotePort) as EndPoint);
}
catch (Exception e)
{
throw new Exception(#34;UDP发送指令失败，{e.Message}");
}
}
}
#endregion
#region UdpClient通讯
/// <summary>
/// UdpClient通讯
/// </summary>
public class UdpClientHelper
{
/// <summary>
/// 变量
/// </summary>
private int _remotePort;
private bool _isStop = false;
private UdpClient _udpClient;
Action<string> _callback;
/// <summary>
/// 构造
/// </summary>
/// <param name="remotPort"></param>
/// <param name="callback"></param>
public UdpClientHelper(int remotPort, Action<string> callback)
{
_remotePort = remotPort;
_callback = callback;
}
/// <summary>
/// 初始
/// </summary>
public void Init()
{
try
{
//1,创建socket
_udpClient = new UdpClient(_remotePort);
}
catch (Exception ex)
{
throw new Exception(#34;UCP初始化失败，{ex.Message}");
}
}
/// <summary>
/// 开始接收
/// </summary>
public void Start()
{
_isStop = false;
Task.Run(new Action(() =>
{
var remote = new IPEndPoint(IPAddress.Any, _remotePort);
while (true)
{
if (_isStop)
continue;
if (_udpClient.Available < 1)
continue;
try
{
byte[] data = new byte[1024];
//接收
data = _udpClient.Receive(ref remote);
if (data.Length == 0)
continue;
string receivemsg = Encoding.Default.GetString(data, 0, data.Length);
if (string.IsNullOrEmpty(receivemsg))
continue;
_callback?.Invoke(receivemsg);
}
catch (Exception)
{
continue;
}
}
}));
}
/// <summary>
/// 停止
/// </summary>
public void Stop()
{
_isStop = true;
try
{
if (_udpClient != null)
_udpClient.Close();
}
catch (Exception ex)
{
throw new Exception(#34;UCP停止失败，{ex.Message}");
}
}
/// <summary>
/// 发送
/// </summary>
/// <param name="cmd"></param>
/// <param name="remoteIp"></param>
/// <param name="remotePort"></param>
public void SendCmd(string cmd, string remoteIp, int remotePort)
{
try
{
byte[] data = Encoding.Default.GetBytes(cmd);
_udpClient.Send(data, data.Length, new IPEndPoint(IPAddress.Parse(remoteIp), remotePort));
}
catch (Exception e)
{
throw new Exception(#34;UDP发送指令失败，{e.Message}");
}
}
}
#endregion
}四、Tools.cs
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Management;
using System.IO.Ports;
using System.Web.Script.Serialization;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Security.Cryptography;
using System.Runtime.Serialization.Json;
namespace SocketCOM
{
/// <summary>
/// 常用工具类
/// </summary>
internal static class Tools
{
/// <summary>
/// json字符串转数据字典
/// </summary>
/// <param name="jsonString"></param>
/// <returns></returns>
public static Dictionary<string, object> JsonToDictionary(string jsonString)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
try
{
return jss.Deserialize<Dictionary<string, object>>(jsonString);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// 数据字典转json字符串
/// </summary>
/// <param name="dic"></param>
/// <returns></returns>
public static string DictionaryToJson(Dictionary<string, object> dic)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
try
{
return jss.Serialize(dic);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// json字符串转对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonStr"></param>
/// <returns></returns>
public static T ConvertJsonToObj<T>(string jsonStr)
{
try
{
JavaScriptSerializer jss = new JavaScriptSerializer();
return jss.Deserialize<T>(jsonStr);
}
catch (Exception)
{
return default(T);
}
}
/// <summary>
/// 对象转json字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonStr"></param>
/// <returns></returns>
public static string ConvertToJsonStr(object val)
{
try
{
JavaScriptSerializer jss = new JavaScriptSerializer();
return jss.Serialize(val);
}
catch (Exception)
{
return null;
}
}
}
}在 C# 中，接口（interface）是一种定义行为契约的机制，它规定了实现类或结构体必须包含的成员（如方法、属性、事件等）。接口本身不提供实现，而是由实现接口的类来具体实现这些成员。
1. 接口定义
- 使用 interface 关键字定义。
- 接口命名通常以 I 开头（约定）。
- 接口成员默认是 public，且不能显式添加访问修饰符。
- 可以包含方法、属性、索引器、事件，但不能包含字段。
2. 接口实现
- 类或结构体通过 : 继承接口。
- 必须实现接口中声明的所有成员。
- 实现接口的成员必须为 public。
