几个C#上位机相关的工具库
一、数据转换
下载地址：
https://gitee.com/fujiajin/xbd.DataConvertTool/repository/archive/master.zip
1、将其加入项目：
将project 复制到 项目中
点击添加现有项
2、测试代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using xbd.DataConvertLib;
namespace ConsoleApp1
{
internal class Program
{
static void Main(string[] args)
{
//Test001();
Test002();
}
private static void Test001()
{
float data = 123.4f;
//按照本机大小端方式转成字节组
byte[] value = BitConverter.GetBytes(data);
Console.WriteLine(StringLib.GetHexStringFromByteArray(value));
byte[] value2 = new byte[value.Length];
for (int i = 0; i < value.Length; i++)
{
value2[i] = value[value.Length - 1 - i];
}
float result = BitConverter.ToSingle(value2, 0);
Console.WriteLine(BitConverter.ToSingle(value, 0));
Console.WriteLine(result.ToString());
}
private static void Test002()
{
//var res = IsConvertSuccess("4.2");
var res = IsConvertSuccess("666");
if (res.IsSuccess)
{
Console.WriteLine("成功转换");
}
else
{
Console.WriteLine(res.Message);
}
}
private static OperateResult IsConvertSuccess(string value)
{
try
{
int result = Convert.ToInt32(value);
return OperateResult.CreateSuccessResult();
}
catch(Exception ex)
{
return OperateResult.CreateFailResult("fffff" + ex.Message);
}
}
}
}
二、控件库
三、其他
1、文件操作、序列化，反序列化
库
using Newtonsoft.Json;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
namespace ToolsLib
{
public class FileHelper
{
#region 文件读写
//写文件
public static void WriteToTxt(string path,string content,bool isAppend = false)
{
//1 创建文件流
FileStream fs = new FileStream(path,isAppend?FileMode.Append:FileMode.Create);
//2 创建写入器
StreamWriter streamWriter = new StreamWriter(fs);
//3 以流的形式写入数据
streamWriter.Write(content);
//4 关闭写入器
streamWriter.Close();
//5 关闭文件流
fs.Close();
}
//读文件
public static string ReadFromTxt(string path)
{
//判断文件是否存在
if (!File.Exists(path))
{
return string.Empty;
}
//1 创建文件流
FileStream fs = new FileStream(path, FileMode.Open);
//2 创建读取器
StreamReader streamReader = new StreamReader(fs);
//3 以流的方式读取
string content = streamReader.ReadToEnd();
//4 关闭读取器
streamReader.Close();
//5 关闭文件流
fs.Close ();
return content;
}
#endregion
#region 序列化
//序列化一个对象到一个文件中
public static void SerializeObject(object obj, string path)
{
using (FileStream fileStream = new FileStream(path, FileMode.Create))
{
string jsonString = JsonConvert.SerializeObject(obj);
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(jsonString);
fileStream.Write(bytes, 0, bytes.Length);
}
}
//反序列化
public static T DeserializeObject<T>(string path)
{
try
{
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
byte[] buffer = new byte[fileStream.Length];
fileStream.Read(buffer, 0, buffer.Length);
string jsonString = System.Text.Encoding.UTF8.GetString(buffer);
return JsonConvert.DeserializeObject<T>(jsonString);
}
}
catch (JsonReaderException ex)
{
Console.WriteLine($"JSON反序列化出现异常: {ex.Message}");
throw;
}
}
#endregion
#region 文件的整体操作
//文件复制
public static void CopyFile(string srcFileName,string desFileName)
{
if (File.Exists(desFileName))
{
File.Delete(desFileName);
}
File.Copy(srcFileName,desFileName);
}
//文件移动
public static void MoveFile(string srcFileName,string desFileName)
{
if (File.Exists(srcFileName))
{
if (File.Exists(desFileName))
{
File.Delete(desFileName);
}
File.Move(srcFileName, desFileName);
}
}
//文件删除
public static void DeleteFile(string fileName)
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
#endregion
#region 对文件夹的操作
//获取指定目录下的所有文件
public static string[] GetFiles(string path)
{
return Directory.GetFiles(path);
}
//获取指定目录的所有子目录
public static string[] GetDirectories(string path)
{
return Directory.GetDirectories(path);
}
//创建文件夹
public static void CreateDirectory(string path)
{
Directory.CreateDirectory(path);
}
//删除指定目录下的所有子目录和文件
public static void DeleteFiles(string path)
{
if(!Directory.Exists(path))return;
DirectoryInfo directory = new DirectoryInfo(path);
directory.Delete(true);
}
#endregion
}
}
测试代码
using System.Diagnostics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using ToolsLib;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
//Test001();
//Test002();
//Test003();
Test004();
}
#region 文件读写
private void Test001()
{
FileHelper.WriteToTxt("sss.txt", "222abc", false);
FileHelper.WriteToTxt("sss.txt", "222abc", true);
Debug.WriteLine(FileHelper.ReadFromTxt("sss.txt"));
}
#endregion
#region 序列化,反序列化
private void Test002()
{
string objPath = "object.txt";
FileHelper.SerializeObject(new Equipment() { EquipId = 100, EquipName = "qwer" }, objPath);
Equipment equipment = FileHelper.DeserializeObject<Equipment>(objPath);
Debug.WriteLine(equipment);
}
/// <summary>
/// 设备实体类
/// </summary>
public class Equipment
{
public int EquipId { get; set; }
public string EquipName { get; set; }
public override string ToString()
{
return $"EquipId: {EquipId}, EquipName: {EquipName}";
}
}
#endregion
#region 对文件整体的操作
private void Test003()
{
FileHelper.WriteToTxt("f1", "积分的就完全fasdf123", false);
FileHelper.CopyFile("f1", "f2");
FileHelper.CopyFile("f2", "../f2");
FileHelper.DeleteFile("f2");
}
#endregion
#region 对文件夹的操作
private void Test004()
{
foreach(string str in FileHelper.GetFiles("./"))
{
Debug.WriteLine(str);
}
foreach (string str in FileHelper.GetDirectories("./"))
{
Debug.WriteLine(str);
}
//FileHelper.CreateDirectory("aaa");
// FileHelper.CreateDirectory("bbb");
//FileHelper.CreateDirectory("ccc");
FileHelper.DeleteFiles("ddd");
}
#endregion
}
}
2、对 Ini 文件的读写
配置文件需要的编码格式—— 不然识别不了中文
库文件
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class IniConfigHelper
{
/// <summary>
/// 文件路径
/// </summary>
public static string IniPath = AppDomain.CurrentDomain.BaseDirectory+ "file.ini";
#region API函数声明
[DllImport("kernel32")]
private static extern long WritePrivateProfileString(string section, string key,
string val, string filePath);
//需要调用GetPrivateProfileString的重载
[DllImport("kernel32", EntryPoint = "GetPrivateProfileString")]
private static extern long GetPrivateProfileString(string section, string key,
string def, StringBuilder retVal, int size, string filePath);
[DllImport("kernel32", EntryPoint = "GetPrivateProfileString")]
private static extern uint GetPrivateProfileStringA(string section, string key,
string def, Byte[] retVal, int size, string filePath);
#endregion
#region 读取INI文件
/// <summary>
/// 根据节点及Key的值返回数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="defaultValue">默认值</param>
/// <param name="path">路径</param>
/// <returns>返回值</returns>
public static string ReadIniData(string Section, string Key, string defaultValue, string path)
{
if (File.Exists(path))
{
StringBuilder stringBuilder = new StringBuilder();
GetPrivateProfileString(Section, Key, defaultValue, stringBuilder, 1024, path);
return stringBuilder.ToString();
}
else
{
return string.Empty;
}
}
/// <summary>
/// 根据节点及Key的值返回数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="defaultValue">默认值</param>
/// <returns>返回值</returns>
public static string ReadIniData(string Section, string Key, string defaultValue)
{
return ReadIniData(Section, Key, defaultValue, IniPath);
}
#endregion
#region 写入Ini文件
/// <summary>
/// 根据节点及Key的值写入数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="Value">值</param>
/// <param name="path">路径</param>
/// <returns>操作结果</returns>
public static bool WriteIniData(string Section, string Key, string Value, string path)
{
long result = WritePrivateProfileString(Section, Key, Value, path);
if (result == 0)
{
return false;
}
else
{
return true;
}
}
/// <summary>
/// 根据节点及Key的值写入数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="Value">值</param>
/// <returns>操作结果</returns>
public static bool WriteIniData(string Section, string Key, string Value)
{
return WriteIniData(Section, Key, Value, IniPath);
}
#endregion
#region 读取所有的Sections
/// <summary>
/// 读取所有的Section
/// </summary>
/// <param name="path">路径</param>
/// <returns>Section集合</returns>
public static List<string> ReadSections(string path)
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(null, null, null, buffer, buffer.Length, path);
int startIndex = 0;
List<string> sections = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
//sections.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
sections.Add(Encoding.UTF8.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return sections;
}
/// <summary>
/// 读取所有的Section
/// </summary>
/// <param name="path">路径</param>
/// <returns>Section集合</returns>
public static List<string> ReadSections()
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(null, null, null, buffer, buffer.Length, IniPath);
int startIndex = 0;
List<string> sections = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
//sections.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
sections.Add(Encoding.UTF8.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return sections;
}
#endregion
#region 根据某个Section读取所有的Keys
/// <summary>
/// 根据某个Section读取所有的Keys
/// </summary>
/// <param name="section">某个section</param>
/// <param name="path">路径</param>
/// <returns>key的集合</returns>
public static List<string> ReadKeys(string section, string path)
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(section, null, null, buffer, buffer.Length, path);
int startIndex = 0;
List<string> keys = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
// keys.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
keys.Add(Encoding.UTF8.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return keys;
}
/// <summary>
/// 根据某个Section读取所有的Keys
/// </summary>
/// <param name="section">某个section</param>
/// <param name="path">路径</param>
/// <returns>key的集合</returns>
public static List<string> ReadKeys(string section)
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(section, null, null, buffer, buffer.Length, IniPath);
int startIndex = 0;
List<string> keys = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
keys.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
//keys.Add(Encoding.ASCII.GetString(buffer, startIndex, i - startIndex));
//var ansiEncoding = Encoding.GetEncoding("windows-1252");
//keys.Add(ansiEncoding.GetString(buffer, startIndex, i - startIndex));
//var gbkEncoding = Encoding.GetEncoding("gbk");
//keys.Add(gbkEncoding.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return keys;
}
#endregion
}
}
测试代码
using System.Diagnostics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using ToolsLib;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
Test004();
}
//读取某个值
public void Test001()
{
//Console.WriteLine(IniConfigHelper.ReadIniData("a", "b", "300"));
Debug.WriteLine(IniConfigHelper.ReadIniData("设备1", "设备ID", "9000"));
Debug.WriteLine(IniConfigHelper.ReadIniData("设备1", "设备名称", "9000"));
Debug.WriteLine(IniConfigHelper.ReadIniData("a", "b", "9000"));
Debug.WriteLine(IniConfigHelper.ReadIniData("a", "b", "9000"));
Debug.WriteLine(IniConfigHelper.ReadIniData("a", "d", "9000"));
Debug.WriteLine(IniConfigHelper.ReadIniData("a", "d", "9000"));
}
//写入某个值
public void Test002()
{
IniConfigHelper.WriteIniData("设备1", "设备ID", "新的值");
}
//读取所有Sections
public void Test003()
{
List<string> list = IniConfigHelper.ReadSections();
Console.WriteLine(list);
//this.richText.DataContext = "123";
foreach (string s in list)
{
this.richText.AppendText(s+'\n');
}
Debug.WriteLine(list);
}
//读取指定 section的所有keys
public void Test004()
{
List<string> list = IniConfigHelper.ReadKeys("a");
foreach (string s in list)
{
this.richText.AppendText(s+'\n');
}
}
}
}
3、Json (序列化和反序列化 | Newtonsoft.Json)
添加 Newtonsoft.Json 的引用
库代码
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class JsonHelper
{
/// <summary>
/// 使用Newtonsoft.json.dll对象序列化成Json字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public static string EntityToJson<T>(T t)
{
try
{
return JsonConvert.SerializeObject(t);
}
catch (Exception)
{
return string.Empty;
}
}
/// <summary>
/// 使用Newtonsoft.json.dll 将Json字符串反序列化成对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="json"></param>
/// <returns></returns>
public static T JsonToEntity<T>(string json)
{
try
{
return (T)JsonConvert.DeserializeObject(json, typeof(T));
}
catch (Exception)
{
return default(T);
}
}
/// <summary>
/// 实体类转换成JSON字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string EntityToJson2<T>(T obj)
{
//序列化
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(T));
MemoryStream msObj = new MemoryStream();
//将序列化之后的Json格式数据写入流中
js.WriteObject(msObj, obj);
msObj.Position = 0;
//从0这个位置开始读取流中的数据
StreamReader sr = new StreamReader(msObj, Encoding.Default);
string json = sr.ReadToEnd();
sr.Close();
msObj.Close();
return json;
}
/// <summary>
/// JSON字符串转换成实体类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="json"></param>
/// <returns></returns>
public static T JsonToEntity2<T>(string json) where T : class
{
//反序列化
using (var ms = new MemoryStream(Encoding.Default.GetBytes(json)))
{
DataContractJsonSerializer deseralizer = new DataContractJsonSerializer(typeof(T));
T model = (T)deseralizer.ReadObject(ms);// //反序列化ReadObject
return model;
}
}
}
}
测试代码
using System.Diagnostics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using ToolsLib;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
Test002();
}
//序列化
public void Test001()
{
Equipment equipment = new Equipment()
{
name = "001",
id = 100
};
this.richText.AppendText(JsonHelper.EntityToJson<Equipment>(equipment));
}
//反序列化
public void Test002()
{
string tempStr = "{ \"name\":\"001\",\"id\":100}";
Equipment equipment = JsonHelper.JsonToEntity<Equipment>(tempStr);
this.richText.AppendText(equipment.id.ToString());
this.richText.AppendText("\n");
this.richText.AppendText(equipment.name);
this.richText.AppendText("\n");
}
private class Equipment
{
public string name;
public int id;
}
}
}
4、xml 文件
库代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using System.Xml;
namespace ToolsLib
{
public class XmlHelper
{
#region 1.Xml序列化反序列化相关的方法
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name="T">需要序列化的对象类型，必须声明[Serializable]特征</typeparam>
/// <param name="obj">需要序列化的对象</param>
/// <param name="omitXmlDeclaration">true:省略XML声明;否则为false.默认false，即编写 XML 声明。</param>
/// <returns>序列化后的字符串</returns>
public static string EntityToXml<T>(T obj, bool omitXmlDeclaration = false)
{
/* This property only applies to XmlWriter instances that output text content to a stream; otherwise, this setting is ignored.
可能很多朋友遇见过 不能转换成Xml不能反序列化成为UTF8XML声明的情况，就是这个原因。
*/
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.OmitXmlDeclaration = omitXmlDeclaration;
xmlSettings.Encoding = new System.Text.UTF8Encoding(false);
MemoryStream stream = new MemoryStream();
XmlWriter xmlwriter = XmlWriter.Create(stream, xmlSettings); //这里如果直接写成：Encoding = Encoding.UTF8 会在生成的xml中加入BOM(Byte-order Mark) 信息(Unicode 字节顺序标记) ， 所以new System.Text.UTF8Encoding(false)是最佳方式，省得再做替换的麻烦
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
xmlns.Add(String.Empty, String.Empty); //在XML序列化时去除默认命名空间xmlns:xsd和xmlns:xsi
XmlSerializer ser = new XmlSerializer(typeof(T));
ser.Serialize(xmlwriter, obj, xmlns);
return Encoding.UTF8.GetString(stream.ToArray());//writer.ToString();
}
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">文件路径</param>
/// <param name="obj">需要序列化的对象</param>
/// <param name="omitXmlDeclaration">true:省略XML声明;否则为false.默认false，即编写 XML 声明。</param>
/// <param name="removeDefaultNamespace">是否移除默认名称空间(如果对象定义时指定了:XmlRoot(Namespace = "http://www.xxx.com/xsd")则需要传false值进来)</param>
/// <returns>序列化后的字符串</returns>
public static void EntityToXmlFile<T>(string path, T obj, bool omitXmlDeclaration = false, bool removeDefaultNamespace = true)
{
XmlWriterSettings xmlSetings = new XmlWriterSettings();
xmlSetings.OmitXmlDeclaration = omitXmlDeclaration;
using (XmlWriter xmlwriter = XmlWriter.Create(path, xmlSetings))
{
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
if (removeDefaultNamespace)
xmlns.Add(String.Empty, String.Empty); //在XML序列化时去除默认命名空间xmlns:xsd和xmlns:xsi
XmlSerializer ser = new XmlSerializer(typeof(T));
ser.Serialize(xmlwriter, obj, xmlns);
}
}
private static byte[] ReadFile(string filePath)
{
byte[] bytes;
//避免"正由另一进程使用,因此该进程无法访问此文件"造成异常 共享锁 flieShare必须为ReadWrite，但是如果文件不存在的话，还是会出现异常，所以这里不能吃掉任何异常，但是需要考虑到这些问题
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
bytes = new byte[fs.Length];
int numBytesToRead = (int)fs.Length;
int numBytesRead = 0;
while (numBytesToRead > 0)
{
int n = fs.Read(bytes, numBytesRead, numBytesToRead);
if (n == 0)
break;
numBytesRead += n;
numBytesToRead -= n;
}
}
return bytes;
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <param name="xmlOfObject">需要反序列化的xml字符串</param>
/// <returns>反序列化后的对象</returns>
public static T XmlToEntity<T>(string xmlOfObject) where T : class
{
XmlReader xmlReader = XmlReader.Create(new StringReader(xmlOfObject), new XmlReaderSettings());
return (T)new XmlSerializer(typeof(T)).Deserialize(xmlReader);
}
/// <summary>
/// 从文件读取并反序列化为对象 （解决: 多线程或多进程下读写并发问题）
/// </summary>
/// <typeparam name="T">返回的对象类型</typeparam>
/// <param name="path">文件地址</param>
/// <returns></returns>
public static T XmlFileToEntity<T>(string path)
{
byte[] bytes = ReadFile(path);
if (bytes.Length < 1)//当文件正在被写入数据时，可能读出为0
for (int i = 0; i < 5; i++)
{
//5次机会
bytes = ReadFile(path); // 采用这样诡异的做法避免独占文件和文件正在被写入时读出来的数据为0字节的问题。
if (bytes.Length > 0) break;
System.Threading.Thread.Sleep(50); //悲观情况下总共最多消耗1/4秒，读取文件
}
XmlDocument doc = new XmlDocument();
doc.Load(new MemoryStream(bytes));
if (doc.DocumentElement != null)
return (T)new XmlSerializer(typeof(T)).Deserialize(new XmlNodeReader(doc.DocumentElement));
return default(T);
}
#endregion
#region 2.Xml文件读写操作的方法
/// <summary>
/// 创建XML文档
/// </summary>
/// <param name="name">根节点名称</param>
/// <param name="type">根节点的一个属性值</param>
/// <returns></returns>
/// .net中调用方法：写入文件中,则：
/// document = XmlOperate.CreateXmlDocument("sex", "sexy");
/// document.Save("c:/bookstore.xml");
public static XmlDocument CreateXmlDocument(string name, string type)
{
XmlDocument doc = null;
XmlElement rootEle = null;
try
{
doc = new XmlDocument();
doc.LoadXml("<" + name + "/>");
rootEle = doc.DocumentElement;
rootEle.SetAttribute("type", type);
}
catch (Exception ex)
{
throw ex;
}
return doc;
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时返回该属性值，否则返回串联值</param>
/// <returns>string</returns>
/**************************************************
* 使用示列:
* XmlHelper.Read(path, "/Node", "")
* XmlHelper.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
************************************************/
public static string Read(string path, string node, string attribute)
{
string value = "";
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
value = (attribute.Equals("") ? xn.InnerText : xn.Attributes[attribute].Value);
}
catch (Exception ex)
{
throw ex;
}
return value;
}
/// <summary>
/// 插入数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="element">元素名，非空时插入新元素，否则在该元素中插入属性</param>
/// <param name="attribute">属性名，非空时插入该元素属性值，否则插入元素值</param>
/// <param name="value">值</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Insert(path, "/Node", "Element", "", "Value")
* XmlHelper.Insert(path, "/Node", "Element", "Attribute", "Value")
* XmlHelper.Insert(path, "/Node", "", "Attribute", "Value")
************************************************/
public static void Insert(string path, string node, string element, string attribute, string value)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
if (element.Equals(""))
{
if (!attribute.Equals(""))
{
XmlElement xe = (XmlElement)xn;
xe.SetAttribute(attribute, value);
}
}
else
{
XmlElement xe = doc.CreateElement(element);
if (attribute.Equals(""))
xe.InnerText = value;
else
xe.SetAttribute(attribute, value);
xn.AppendChild(xe);
}
doc.Save(path);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 修改数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时修改该节点属性值，否则修改节点值</param>
/// <param name="value">值</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Insert(path, "/Node", "", "Value")
* XmlHelper.Insert(path, "/Node", "Attribute", "Value")
************************************************/
public static void Update(string path, string node, string attribute, string value)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
XmlElement xe = (XmlElement)xn;
if (attribute.Equals(""))
xe.InnerText = value;
else
xe.SetAttribute(attribute, value);
doc.Save(path);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时删除该节点属性值，否则删除节点值</param>
/// <param name="value">值</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Delete(path, "/Node", "")
* XmlHelper.Delete(path, "/Node", "Attribute")
************************************************/
public static void Delete(string path, string node, string attribute)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
XmlElement xe = (XmlElement)xn;
if (attribute.Equals(""))
xn.ParentNode.RemoveChild(xn);
else
xe.RemoveAttribute(attribute);
doc.Save(path);
}
catch (Exception ex)
{
throw ex;
}
}
#endregion
}
}
测试代码
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml;
using ToolsLib;
using static System.Net.Mime.MediaTypeNames;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
//Test005();
//Test006();
//Test007();
//Test008();
Test009();
}
//序列化成字符串
public void Test001()
{
Equipment equipment = new Equipment()
{
name = "Test",
id = 97
};
string tempStr = XmlHelper.EntityToXml<Equipment>(equipment);
this.richText.AppendText(tempStr);
}
//序列化 成字符串，到文件中去
public void Test002()
{
Equipment equipment = new Equipment()
{
name = "Test",
id = 97
};
XmlHelper.EntityToXmlFile<Equipment>("xmlfile.xml", equipment);
}
//将字符串，转成对象
public void Test003()
{
Equipment equipment = XmlHelper.XmlToEntity<Equipment>("<?xml version=\"1.0\" encoding=\"utf-8\"?><Equipment><name>Test</name><id>97</id></Equipment>");
this.richText.AppendText("id:"+equipment.id);
this.richText.AppendText("\n");
this.richText.AppendText("name:"+equipment.name);
this.richText.AppendText("\n");
}
//将文件中的内容，转成对象
public void Test004()
{
Equipment equipment = XmlHelper.XmlFileToEntity<Equipment>("xmlfile.xml");
this.richText.AppendText("id:" + equipment.id);
this.richText.AppendText("\n");
this.richText.AppendText("name:" + equipment.name);
this.richText.AppendText("\n");
}
//创建xml文档
public void Test005()
{
XmlDocument xmlDocument = XmlHelper.CreateXmlDocument("ASD","AAA");
this.richText.AppendText(xmlDocument.ToString());
}
//查询指定节点中某个属性的内容
public void Test006()
{
//string tempStr = XmlHelper.Read("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml", "root", "IPsegment");
//也可以多级查询
string tempStr = XmlHelper.Read("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml", "root/Parking/Position", "ClientID");
this.richText.AppendText(tempStr);
}
//给一个指定节点添加新的节点，并给节点添加一个属性名
public void Test007()
{
XmlHelper.Insert("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml","root","Parking","cba","9000");
XmlHelper.Insert("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml","root","Parking","cba","9001");
XmlHelper.Insert("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml","root","Parking","cba","9003");
}
//修改指定节点的属性的内容
public void Test008()
{
XmlHelper.Update("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml","root/Parking","cba","999");
}
//删除属性，或者节点
public void Test009()
{
//删除节点
//XmlHelper.Delete("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml", "root/Parking", "cba");
//删除属性
XmlHelper.Delete("D:\\code\\c_sharp\\tool\\covert\\ConsoleApp1\\ToolsLib\\bin\\Debug\\net8.0-windows\\text.xml", "root/Parking", "");
}
public class Equipment
{
public string name;
public int id;
}
}
}
5、Csv帮助类 CsvHelper
C# CsvHelper 库的官网是 https://joshclose.github.io/CsvHelper/.
读写操作（对文件）
using CsvHelper;
using CsvHelper.Configuration;
using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Windows;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
///
/*
* file.cvs 的内容：
Id,Name
100,Jack
101,Rock
102,Bob
*/
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private string pathStr = AppDomain.CurrentDomain.BaseDirectory + "file.csv";
private string outPathStr = AppDomain.CurrentDomain.BaseDirectory + "outputFile.csv";
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
//Test005();
//Test006();
//Test007();
Test008();
}
#region 读
//读取 CSV文件，将其转为类，第一行是属性名
public void Test001()
{
using (var reader = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "file.csv"))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
IEnumerable<Foo> records = csv.GetRecords<Foo>();
foreach (Foo foo in records)
{
Debug.WriteLine(foo.ToString());
}
}
}
//不指定类型的读取
public void Test002()
{
using (var reader = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "file.csv"))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
IEnumerable<dynamic> tempRecord = csv.GetRecords<dynamic>();
foreach (dynamic record in tempRecord)
{
// 在这里对每一行记录（record）进行处理，提取单元格内容
Debug.WriteLine($"Id:{record.Id},Name:{record.Name}");
}
}
}
//转换成匿名对象
public void Test003()
{
using (var reader = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "file.csv"))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
var anonymousTypeDefinition = new
{
Id = default(int),
Name = string.Empty
};
var records = csv.GetRecords(anonymousTypeDefinition);
foreach (dynamic record in records)
{
// 在这里对每一行记录（record）进行处理，提取单元格内容
Debug.WriteLine($"Id:{record.Id},Name:{record.Name}");
}
}
}
//不用泛型，而是直接用 一个实例化的对象 作为入参
public void Test004()
{
using (var reader = new StreamReader(pathStr))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
var record = new Foo();
var records = csv.EnumerateRecords(record);
foreach (var r in records)
{
// r is the same instance as record.
Debug.WriteLine(r.ToString());
}
}
}
//一种遍历方式（迭代器）
/*
* csv.Read();
在CsvHelper库中，Read方法用于读取 CSV 文件中的下一行数据。
第一次调用Read方法时，它会将读取位置移动到 CSV 文件的第一行数据（如果文件不为空）。这是一个准备步骤，为后续读取标题行或者数据行做铺垫。
如果没有这一步，后续的读取操作（如ReadHeader或者在while循环中的Read）可能无法正确开始，因为读取位置可能没有正确初始化。
csv.ReadHeader();
这个方法用于读取 CSV 文件中的标题行。
标题行通常包含了 CSV 文件中每一列数据的名称。CsvHelper库会使用这些标题名称来建立一个映射，这样在后续读取数据行时，可以通过这些标题名称来获取相应列的数据。
例如，如果标题行包含"Id"和"Name"，那么在后面的while循环中，就可以使用csv.GetField<int>("Id")和csv.GetField("Name")来获取"Id"列和"Name"列的数据，并将其赋值给Foo对象的相应属性。这个过程依赖于ReadHeader方法正确地读取和解析标题行，以建立准确的数据获取映射。
*/
public void Test005()
{
using (var reader = new StreamReader(pathStr))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
var records = new List<Foo>();
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new Foo
{
Id = csv.GetField<int>("Id"),
Name = csv.GetField("Name")
};
records.Add(record);
}
//打印
foreach (Foo r in records)
{
Debug.WriteLine(r);
}
}
}
public class Foo
{
public int Id { get; set; }
public string Name { get; set; }
public override string ToString()
{
return "Id:" + Id + ",Name:" + Name;
}
}
#endregion
#region 写
//将 List<Foo> 的内容写到 csv文件中去
public void Test006()
{
var records = new List<Foo>
{
new Foo { Id = 1, Name = "one" },
};
using (var writer = new StreamWriter(outPathStr))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteRecords(records);
}
}
//将匿名对象写入到文件中去
public void Test007()
{
var records = new List<object>
{
new { Id = 101, Name = "two" },
};
using (var writer = new StreamWriter(outPathStr))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteRecords(records);
}
}
//追加的进行写入
public void Test008()
{
var records = new List<Foo>
{
new Foo { Id = 500, Name = "three" },
};
// Write to a file.
using (var writer = new StreamWriter(outPathStr))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteRecords(records);
}
records = new List<Foo>
{
new Foo { Id = 2, Name = "two" },
};
// Append to the file.
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
// Don't write the header again.
HasHeaderRecord = false,
};
using (var stream = File.Open(outPathStr, FileMode.Append))
using (var writer = new StreamWriter(stream))
using (var csv = new CsvWriter(writer, config))
{
csv.WriteRecords(records);
}
}
#endregion
}
}
6、Excel帮助类 ExcelHelper
先安装 NPOI 库
using NPOI.HSSF.UserModel;
using NPOI.SS.UserModel;
using NPOI.SS.Util;
using NPOI.XSSF.UserModel;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Windows;
using ToolsLib;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
///
/*
* file.cvs 的内容：
Id,Name
100,Jack
101,Rock
102,Bob
*/
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private string pathStr = AppDomain.CurrentDomain.BaseDirectory + "file.xls";
private string outPathStr = AppDomain.CurrentDomain.BaseDirectory + "outputFile.xls";
private void Button_Click(object sender, RoutedEventArgs e)
{
//SimpleRead();
SimpleWrite();
}
/// <summary>
/// 简单读取文件内容
/// </summary>
static void SimpleRead()
{
//文件路径
string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "01.xlsx");
//判断文件路径，存在则继续
if (File.Exists(filePath))
{
//文件流
FileStream fs = null;
//Excel工作簿操作对象
IWorkbook workbook = null;
//开启异常捕捉
try
{
StringBuilder sb = new StringBuilder();
//定义文件流打开
fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
//定义工作簿
workbook = new XSSFWorkbook(fs);
//读取工作表数量
var numberOfSheets = workbook.NumberOfSheets;
//判断工作表数量，大于零则继续
if (numberOfSheets > 0)
{
//获取第一个工作表
var sheet0 = workbook.GetSheetAt(0);
sb.AppendLine($"工作表名称：{sheet0.SheetName}");
sb.AppendLine($"行数量：{sheet0.LastRowNum + 1}");
if (sheet0.LastRowNum >= 0)
{
//读取每一行信息
for (int i = 0; i <= sheet0.LastRowNum; i++)
{
var row = sheet0.GetRow(i);
if (row != null)
{
sb.Append($"第{i + 1}行数据：");
//获取最后一列
var lastCellNum = row.LastCellNum;
for (int j = 0; j < lastCellNum; j++)
{
//获取单元格
var cell = row.GetCell(j);
object cellValue = null;
if (cell != null)
{
#region 根据不同单元格格式提取内容
switch (cell.CellType)
{
case CellType.Boolean: cellValue = cell.BooleanCellValue; break;
case CellType.Numeric: cellValue = cell.NumericCellValue; break;
case CellType.Formula:
var cachedCellType = cell.GetCachedFormulaResultTypeEnum();
switch (cachedCellType)
{
case CellType.Boolean: cellValue = cell.BooleanCellValue; break;
case CellType.Numeric: cellValue = cell.NumericCellValue; break;
default: cellValue = cell.StringCellValue; break;
}
break;
default: cellValue = cell.StringCellValue; break;
}
#endregion
}
sb.Append($"\t{cellValue}");
}
sb.AppendLine();
}
}
}
Debug.WriteLine(sb.ToString());
}
//关闭相关资源
workbook.Close();
workbook = null;
//关闭相关资源
fs.Close();
fs = null;
}
catch (Exception ex)
{
//显示异常信息
Console.WriteLine($"发生异常：{ex.Message}");
}
finally
{
//关闭工作簿
if (workbook != null)
{
workbook.Close();
}
//关闭文件流
if (fs != null)
{
fs.Close();
}
}
}
}
/// <summary>
/// 简单写文件内容
/// </summary>
static void SimpleWrite()
{
//文件路径
string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "02.xlsx");
//文件流
FileStream fs = null;
//Excel工作簿操作对象
IWorkbook workbook = null;
//开启异常捕捉
try
{
#region 判断或创建文件
var dir = Path.GetDirectoryName(filePath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (!File.Exists(filePath))
{
using (FileStream stream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
using (var wb = new XSSFWorkbook())
{
wb.Write(stream);
wb.Close();
stream.Close();
}
}
#endregion
//定义工作簿
workbook = new XSSFWorkbook();
#region 预防性处理工作表
ISheet sheet = workbook.CreateSheet("数据");
#region 第一行，标题：时间，内容
var row1 = sheet.CreateRow(0);
row1.CreateCell(0).SetCellValue("时间");
row1.CreateCell(1).SetCellValue("内容");
#endregion
#region 增加几行数据
int rowIndex = 1;
for (int i = 0; i < 10; i++)
{
var row = sheet.CreateRow(rowIndex++);
row.CreateCell(0).SetCellValue(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
row.CreateCell(1).SetCellValue(Guid.NewGuid().ToString().ToUpper());
}
#region 占多行的单元格
创建一个合并区域，从第1行第1列到第1行第3列
//CellRangeAddress region = new CellRangeAddress(0, 0, 0, 2);
//sheet.AddMergedRegion(region);
创建一个单元格（实际上这个单元格就是合并后的单元格）
//IRow rowX = sheet.CreateRow(0);
//ICell cell = rowX.CreateCell(0);
//cell.SetCellValue("这是一个占三列的单元格");
#endregion
#endregion
//自适应
sheet.AutoSizeColumn(0);
sheet.AutoSizeColumn(1);
#endregion
#region 保存
using (fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
workbook.Write(fs);
}
#endregion
//关闭相关资源
workbook.Close();
workbook = null;
//关闭相关资源
fs.Close();
fs = null;
}
catch (Exception ex)
{
//显示异常信息
Console.WriteLine($"发生异常：{ex.Message}");
}
finally
{
//关闭工作簿
if (workbook != null)
{
workbook.Close();
}
//关闭文件流
if (fs != null)
{
fs.Close();
}
}
}
}
}
7、数据验证
库
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace ToolsLib
{
public class DataValidateHelper
{
/// <summary>
/// 验证是否为整数
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static bool IsInteger(string text)
{
Regex regex = new Regex(@"^[0-9]\d*$");
return regex.IsMatch(text);
}
/// <summary>
/// 验证是否是Email
/// </summary>
/// <param name="txt">字符串</param>
/// <returns>结果</returns>
public static bool IsEmail(string txt)
{
Regex objReg = new Regex(@"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
return objReg.IsMatch(txt);
}
/// <summary>
/// 验证身份证
/// </summary>
/// <param name="txt">字符串</param>
/// <returns>结果</returns>
public static bool IsIdentityCard(string txt)
{
Regex objReg = new Regex(@"^(\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$");
return objReg.IsMatch(txt);
}
/// <summary>
/// 是否为有效IP地址
/// </summary>
/// <param name="ip">字符串</param>
/// <returns>结果</returns>
public static bool IsIPAddress(string ip)
{
if (string.IsNullOrEmpty(ip) || ip.Length < 7 || ip.Length > 15) return false;
string regformat = @"^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$";
Regex regex = new Regex(regformat, RegexOptions.IgnoreCase);
return regex.IsMatch(ip);
}
/// <summary>
/// 是否为有效端口
/// </summary>
/// <param name="port">字符串</param>
/// <returns>结果</returns>
public static bool IsIPPort(string port)
{
bool isPort = false;
int portNum;
isPort = Int32.TryParse(port, out portNum);
if (isPort && portNum >= 0 && portNum <= 65535)
{
isPort = true;
}
else
{
isPort = false;
}
return isPort;
}
}
}
测试代码
using CsvHelper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml;
using ToolsLib;
using static System.Net.Mime.MediaTypeNames;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//验证是否是数字
if(false)
{
this.richText.AppendText(DataValidateHelper.IsInteger("789").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsInteger("958743621").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsInteger("awethf").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsInteger("").ToString());
}
//验证是否是 email
if(false)
{
this.richText.AppendText(DataValidateHelper.IsEmail("123@gfe.com").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsEmail("afewfeqw.com").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsEmail("").ToString());
}
//身份证
if (false)
{
this.richText.AppendText(DataValidateHelper.IsIdentityCard("965236789521549965").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIdentityCard("96523678952154996X").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIdentityCard("1").ToString());
}
//IP 验证
if (false)
{
this.richText.AppendText(DataValidateHelper.IsIPAddress("192.168.100.111").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIPAddress("23.32.43.270").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIPAddress("1").ToString());
}
//Port 验证
if (true)
{
this.richText.AppendText(DataValidateHelper.IsIPPort("65536").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIPPort("65535").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIPPort("100").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(DataValidateHelper.IsIPPort("0").ToString());
}
}
}
}
8、数据加密
库
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
/// <summary>
/// 字符串加密解密类
/// </summary>
public class StringSecurityHelper
{
private static string md5Begin = "Hello";
private static string md5End = "World";
#region SHA1 加密
/// <summary>
/// 使用SHA1加密字符串。
/// </summary>
/// <param name="inputString">输入字符串。</param>
/// <returns>加密后的字符串。（40个字符）</returns>
public static string SHA1Encrypt(string inputString)
{
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] encryptedBytes = sha1.ComputeHash(Encoding.ASCII.GetBytes(inputString));
StringBuilder sb = new StringBuilder();
for (int i = 0; i < encryptedBytes.Length; i++)
{
sb.AppendFormat("{0:x2}", encryptedBytes[i]);
}
return sb.ToString();
}
#endregion
#region DES 加密/解密
private static byte[] key = Encoding.ASCII.GetBytes("uiertysd");
private static byte[] iv = Encoding.ASCII.GetBytes("99008855");
/// <summary>
/// DES加密。
/// </summary>
/// <param name="inputString">输入字符串。</param>
/// <returns>加密后的字符串。</returns>
public static string DESEncrypt(string inputString)
{
MemoryStream ms = null;
CryptoStream cs = null;
StreamWriter sw = null;
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
try
{
ms = new MemoryStream();
cs = new CryptoStream(ms, des.CreateEncryptor(key, iv), CryptoStreamMode.Write);
sw = new StreamWriter(cs);
sw.Write(inputString);
sw.Flush();
cs.FlushFinalBlock();
return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
}
finally
{
if (sw != null) sw.Close();
if (cs != null) cs.Close();
if (ms != null) ms.Close();
}
}
/// <summary>
/// DES解密。
/// </summary>
/// <param name="inputString">输入字符串。</param>
/// <returns>解密后的字符串。</returns>
public static string DESDecrypt(string inputString)
{
MemoryStream ms = null;
CryptoStream cs = null;
StreamReader sr = null;
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
try
{
ms = new MemoryStream(Convert.FromBase64String(inputString));
cs = new CryptoStream(ms, des.CreateDecryptor(key, iv), CryptoStreamMode.Read);
sr = new StreamReader(cs);
return sr.ReadToEnd();
}
catch
{
return string.Empty;
}
finally
{
if (sr != null) sr.Close();
if (cs != null) cs.Close();
if (ms != null) ms.Close();
}
}
#endregion
/// <summary>
/// MD5加密
/// </summary>
/// <param name="str">MD5加密前字符串</param>
/// <returns>MD5加密后字符串</returns>
public static string MD5Encrypt(string str)
{
str = string.Concat(md5Begin, str, md5End);
MD5 md5 = new MD5CryptoServiceProvider();
byte[] fromData = Encoding.Unicode.GetBytes(str);
byte[] targetData = md5.ComputeHash(fromData);
string md5String = string.Empty;
foreach (var b in targetData)
md5String += b.ToString("x2");
return md5String;
}
}
}
测试代码
using CsvHelper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml;
using ToolsLib;
using static System.Net.Mime.MediaTypeNames;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
Test003();
//Test004();
}
//SHA 加密
public void Test001()
{
this.richText.AppendText(StringSecurityHelper.SHA1Encrypt("123"));
this.richText.AppendText("\n");
}
//DES 加密
public void Test002()
{
this.richText.AppendText(StringSecurityHelper.DESEncrypt("123"));
this.richText.AppendText("\n");
}
//DES 解密
public void Test003()
{
this.richText.AppendText(StringSecurityHelper.DESDecrypt("123"));
this.richText.AppendText("\n");
}
//MD5加密
public void Test004()
{
this.richText.AppendText(StringSecurityHelper.MD5Encrypt("123"));
this.richText.AppendText("\n");
}
}
}
9、获取CPU信息
需要先引入库
库
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class CPUInfoHelper
{
private static string defaultValue = "abcdefgh";
/// <summary>
/// 获取计算机信息
/// </summary>
/// <returns>获取结果</returns>
public static string GetComputerInfo()
{
string cpu = GetCPUInfo();
string bios = GetBIOSInfo();
return string.Concat(cpu, bios);
}
public static string GetCPUInfo()
{
return GetHardWareInfo("Win32_Processor", "ProcessorId");
}
public static string GetBIOSInfo()
{
string info = GetHardWareInfo("Win32_BIOS", "SerialNumber");
if (!string.IsNullOrEmpty(info) && info != "To be filled by O.E.M" && !info.Contains("O.E.M") && !info.Contains("OEM") && !info.Contains("Default"))
{
return info;
}
else
{
return defaultValue;
}
}
private static string GetHardWareInfo(string typePath, string key)
{
ManagementClass managementClass = new ManagementClass(typePath);
ManagementObjectCollection mn = managementClass.GetInstances();
PropertyDataCollection properties = managementClass.Properties;
foreach (PropertyData property in properties)
{
if (property.Name == key)
{
foreach (ManagementObject m in mn)
{
return m.Properties[property.Name].Value.ToString();
}
}
}
return string.Empty;
}
/// <summary>
/// 加密结果
/// </summary>
/// <returns>返回加密结果</returns>
public static string Encrypt()
{
return StringSecurityHelper.DESEncrypt(StringSecurityHelper.MD5Encrypt(GetComputerInfo()));
}
/// <summary>
/// 验证是否正确
/// </summary>
/// <param name="Code">字符串</param>
/// <returns>结果</returns>
public static bool Check(string Code)
{
if (StringSecurityHelper.DESDecrypt(Code) == StringSecurityHelper.MD5Encrypt(GetComputerInfo()))
{
return true;
}
else
{
return false;
}
}
}
}
测试代码
using CsvHelper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml;
using ToolsLib;
using static System.Net.Mime.MediaTypeNames;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
Test002();
}
//CPU信息
public void Test001()
{
this.richText.AppendText(CPUInfoHelper.GetComputerInfo());
this.richText.AppendText("\n");
this.richText.AppendText(CPUInfoHelper.GetCPUInfo());
this.richText.AppendText("\n");
this.richText.AppendText(CPUInfoHelper.GetBIOSInfo());
this.richText.AppendText("\n");
}
//加密，及加密验证
public void Test002()
{
this.richText.AppendText(CPUInfoHelper.Encrypt());
this.richText.AppendText("\n");
this.richText.AppendText(CPUInfoHelper.Check("bUo4dtCJT/5V1VLedN/Gn0FEtqYXJcrPtVT1XFsMD+RowW2N+vESNQ==").ToString());
this.richText.AppendText("\n");
this.richText.AppendText(CPUInfoHelper.Check("N+vESNQ==").ToString());
this.richText.AppendText("\n");
}
}
}
10、修改注册表
问题：
如何操作子项
注：方法返回的是这个类本体，可以用链式编程的形式来访问子项
库
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
/// <summary>
/// 注册表
/// </summary>
public class RegeditHelper
{
private const string SUB_KEY = "SOFTWARE";
private static readonly RegistryKey HKML;
private static readonly RegistryKey SOFTWARE;
static RegeditHelper()
{
//Win10 读写LocalMachine权限，没有访问权限
HKML = Registry.CurrentUser;
SOFTWARE = HKML.OpenSubKey(SUB_KEY, true);
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="node">节点</param>
/// <param name="name">名称</param>
/// <returns>返回数据</returns>
public static object ReadData(string node, string name)
{
RegistryKey tmp = SOFTWARE.OpenSubKey(node, true);
object result = tmp?.GetValue(name);
tmp?.Close();
return result;
}
/// <summary>
/// 写入值
/// </summary>
/// <param name="node">节点</param>
/// <param name="item">名称</param>
/// <param name="value">值</param>
public static void WriteData(string node, string item, object value)
{
RegistryKey tmp = SOFTWARE.CreateSubKey(node);
tmp?.SetValue(item, value);
tmp?.Close();
}
/// <summary>
/// 删除
/// </summary>
/// <param name="node">节点</param>
/// <param name="item">名称</param>
/// <param name="value">值</param>
public static void DeleteNode(string node)
{
SOFTWARE.DeleteSubKey(node);
}
}
}
测试代码
using CsvHelper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Xml;
using ToolsLib;
using static System.Net.Mime.MediaTypeNames;
namespace WpfApp1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Test001();
//Test002();
//Test003();
}
//读取
public void Test001()
{
this.richText.AppendText(RegeditHelper.ReadData("360safe", "DefaultSkin").ToString());
//this.richText.AppendText(RegeditHelper.ReadData("7-Zip//Compression", "Archiver").ToString());
//this.richText.AppendText(RegeditHelper.ReadData("7-Zip/FM/Columns", "FSFolder").ToString());
}
//写入删除
public void Test002()
{
RegeditHelper.WriteData("cmm", "DefaultSkin100", "321");
}
//删除
public void Test003()
{
RegeditHelper.DeleteNode("cmm");
}
}
}
四、数据库帮助类
1、SQLite
1、新建一个用于测试的表
create table Equipment (EquipId int primary key,EquipName varchar(20)not null);
2、添加库：
库
using System.Data;
using System.Data.SQLite;
namespace ToolsLib
{
public class SQLiteHelper
{
public static string connString = string.Empty;
/// <summary>
/// 执行insert、update、delete类型的SQL语句
/// </summary>
/// <param name="cmdText">SQL语句或存储过程名称</param>
/// <param name="paramArray">参数数组</param>
/// <returns>受影响的行数</returns>
public static int ExecuteNonQuery(string cmdText, SQLiteParameter[] paramArray = null)
{
SQLiteConnection conn = new SQLiteConnection(connString);
SQLiteCommand cmd = new SQLiteCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
string errorMsg = $"{DateTime.Now} : 执行 public static int ExecuteNonQuery(string cmdText, SqlParameter[] paramArray = null)方法发生异常：{ex.Message}";
//在这个地方写入日志...
throw new Exception("执行public static int ExecuteNonQuery(string cmdText, SqlParameter[] paramArray = null)方法发生异常：" + ex.Message);
}
finally //以上不管是否发生异常，都会执行的代码
{
conn.Close();
}
}
/// <summary>
/// 返回单一结果的查询
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static object ExecuteScalar(string cmdText, SQLiteParameter[] paramArray = null)
{
SQLiteConnection conn = new SQLiteConnection(connString);
SQLiteCommand cmd = new SQLiteCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteScalar();
}
catch (Exception ex)
{
//在这个地方写入日志...
throw new Exception("执行 public object ExecuteScalar(string cmdText, SqlParameter[] paramArray = null方法发生异常：" + ex.Message);
}
finally
{
conn.Close();
}
}
/// <summary>
/// 执行返回一个只读结果集的查询
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static SQLiteDataReader ExecuteReader(string cmdText, SQLiteParameter[] paramArray = null)
{
SQLiteConnection conn = new SQLiteConnection(connString);
SQLiteCommand cmd = new SQLiteCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteReader(CommandBehavior.CloseConnection); //必须添加这个枚举
}
catch (Exception ex)
{
//在这个地方写入日志...
throw new Exception("执行 public object SqlDataReader(string cmdText, SqlParameter[] paramArray = null)方法发生异常：" + ex.Message);
}
}
/// <summary>
/// 返回包含一张数据表的数据集的查询
/// </summary>
/// <param name="sql">查询语句</param>
/// <param name="tableName">数据表的名称</param>
/// <returns></returns>
public static DataSet GetDataSet(string sql, SQLiteParameter[] paramArray = null, string tableName = null)
{
SQLiteConnection conn = new SQLiteConnection(connString);
SQLiteCommand cmd = new SQLiteCommand(sql, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
DataSet ds = new DataSet();
try
{
conn.Open();
if (tableName == null)
da.Fill(ds);
else
da.Fill(ds, tableName);
return ds;
}
catch (Exception ex)
{
throw new Exception("执行 public DataSet GetDataSet(string sql, string tableName = null)方法发生异常：" + ex.Message);
}
finally
{
conn.Close();
}
}
/// <summary>
/// 执行查询，返回一个或多个表的DataSet
/// </summary>
/// <param name="dicTableAndSql"></param>
/// <returns></returns>
public static DataSet GetDataSet(Dictionary<string, string> dicTableAndSql)
{
SQLiteConnection conn = new SQLiteConnection(connString);
SQLiteCommand cmd = new SQLiteCommand();
cmd.Connection = conn;
SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
DataSet ds = new DataSet();
try
{
conn.Open();
foreach (string tbName in dicTableAndSql.Keys)
{
cmd.CommandText = dicTableAndSql[tbName];
da.Fill(ds, tbName);
}
return ds;
}
catch (Exception ex)
{
throw new Exception("执行 public DataSet GetDataSet(Dictionary<string,string> dicTableAndSql)方法发生异常：" + ex.Message);
}
finally
{
conn.Close();
}
}
}
}
测试代码
using System.Data.SQLite;
using System.Windows;
using ToolsLib;
using System.Data;
using System.Data.SQLite;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private string ConnStr = $"Data Source={AppDomain.CurrentDomain.BaseDirectory}SqlLite0001.db;Polling=true;FailIfMissing=false";
//private string ConnStr = $"Data Source = {AppDomain.CurrentDomain.BaseDirectory}SqlLite0001.db;Version=3;";
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
Test005();
}
//插入一条数据
private void Test001()
{
SQLiteHelper.connString = ConnStr;
string sql = "insert into Equipment(EquipId,EquipName) values({0},'{1}')";
sql = string.Format(sql, Convert.ToInt32(352), "Tain3");
SQLiteHelper.ExecuteNonQuery(sql);
}
//防止 sql 注入的方式添加数据
private void Test002()
{
SQLiteHelper.connString = ConnStr;
string sql = "insert into Equipment(EquipId,EquipName) values(@EquipId,@EquipName)";
SQLiteParameter[] parameters = new SQLiteParameter[]
{
new SQLiteParameter("@EquipId", 306),
new SQLiteParameter("@EquipName", "Tain99")
};
SQLiteHelper.ExecuteNonQuery(sql, parameters);
}
//查询
private void Test003()
{
SQLiteHelper.connString = ConnStr;
string sql = "Select EquipId,EquipName from Equipment";
DataSet ds = SQLiteHelper.GetDataSet(sql);
if (ds.Tables.Count > 0)
{
DataTable table = ds.Tables[0];
foreach (DataRow row in table.Rows)
{
// 获取每一行中的列数据，这里根据实际数据库表中列的数据类型进行合适的处理和输出
int equipId = Convert.ToInt32(row["EquipId"]);
string equipName = row["EquipName"].ToString();
Debug.WriteLine($"EquipId: {equipId}, EquipName: {equipName}");
}
}
}
//删除
private void Test004()
{
SQLiteHelper.connString = ConnStr;
string sql = "delete from Equipment where EquipId={0}";
sql = string.Format(sql, Convert.ToInt32(300));
SQLiteHelper.ExecuteNonQuery(sql);
}
//修改
private void Test005()
{
SQLiteHelper.connString = ConnStr;
string sql = "update Equipment Set EquipName='{0}' where EquipId={1}";
sql = string.Format(sql, "XXX", 350);
SQLiteHelper.ExecuteNonQuery(sql);
}
}
}
2、MySql
1、安装数据库
2、设置密码、连接
登录：
在cmd中写：
mysql -u root -p
然后输入密码
退出：
exit
登录进去后设置密码
mysql> create user ‘sa’@‘%’ identified by ‘123456’ ;
Query OK, 0 rows affected (0.01 sec)
mysql -u sa -p
注释：这里的 @‘%’ 是指任何IP都可以访问这个数据库
如果写成 '@‘localhost’ 就是只有本机可以访问这个数据库
5、添加库：
6、添加用于测试的表
show DATABASES;
create DATABASE TestDB;
use TestDB;
show TABLES;
create table Equipment (EquipId int primary key,EquipName varchar(20)not null);
7、连接报错 2058
8、代码
库
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class MySQLHelper
{
public static string connString = string.Empty;
/// <summary>
/// 执行insert、update、delete类型的SQL语句
/// </summary>
/// <param name="cmdText">SQL语句或存储过程名称</param>
/// <param name="paramArray">参数数组</param>
/// <returns>受影响的行数</returns>
public static int ExecuteNonQuery(string cmdText, MySqlParameter[] paramArray = null)
{
MySqlConnection conn = new MySqlConnection(connString);
MySqlCommand cmd = new MySqlCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
string errorMsg = $"{DateTime.Now} : 执行 public static int ExecuteNonQuery(string cmdText, SqlParameter[] paramArray = null)方法发生异常：{ex.Message}";
//在这个地方写入日志...
throw new Exception("执行public static int ExecuteNonQuery(string cmdText, SqlParameter[] paramArray = null)方法发生异常：" + ex.Message);
}
finally //以上不管是否发生异常，都会执行的代码
{
conn.Close();
}
}
/// <summary>
/// 返回单一结果的查询
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static object ExecuteScalar(string cmdText, MySqlParameter[] paramArray = null)
{
MySqlConnection conn = new MySqlConnection(connString);
MySqlCommand cmd = new MySqlCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteScalar();
}
catch (Exception ex)
{
//在这个地方写入日志...
throw new Exception("执行 public object ExecuteScalar(string cmdText, SqlParameter[] paramArray = null方法发生异常：" + ex.Message);
}
finally
{
conn.Close();
}
}
/// <summary>
/// 执行返回一个只读结果集的查询
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static MySqlDataReader ExecuteReader(string cmdText, MySqlParameter[] paramArray = null)
{
MySqlConnection conn = new MySqlConnection(connString);
MySqlCommand cmd = new MySqlCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteReader(CommandBehavior.CloseConnection); //必须添加这个枚举
}
catch (Exception ex)
{
//在这个地方写入日志...
throw new Exception("执行 public object SqlDataReader(string cmdText, SqlParameter[] paramArray = null)方法发生异常：" + ex.Message);
}
}
/// <summary>
/// 返回包含一张数据表的数据集的查询
/// </summary>
/// <param name="sql">查询语句</param>
/// <param name="tableName">数据表的名称</param>
/// <returns></returns>
public static DataSet GetDataSet(string sql, MySqlParameter[] paramArray = null, string tableName = null)
{
MySqlConnection conn = new MySqlConnection(connString);
MySqlCommand cmd = new MySqlCommand(sql, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
MySqlDataAdapter da = new MySqlDataAdapter(cmd);
DataSet ds = new DataSet();
try
{
conn.Open();
if (tableName == null)
da.Fill(ds);
else
da.Fill(ds, tableName);
return ds;
}
catch (Exception ex)
{
throw new Exception("执行 public DataSet GetDataSet(string sql, string tableName = null)方法发生异常：" + ex.Message);
}
finally
{
conn.Close();
}
}
/// <summary>
/// 执行查询，返回一个或多个表的DataSet
/// </summary>
/// <param name="dicTableAndSql"></param>
/// <returns></returns>
public static DataSet GetDataSet(Dictionary<string, string> dicTableAndSql)
{
MySqlConnection conn = new MySqlConnection(connString);
MySqlCommand cmd = new MySqlCommand();
cmd.Connection = conn;
MySqlDataAdapter da = new MySqlDataAdapter(cmd);
DataSet ds = new DataSet();
try
{
conn.Open();
foreach (string tbName in dicTableAndSql.Keys)
{
cmd.CommandText = dicTableAndSql[tbName];
da.Fill(ds, tbName);
}
return ds;
}
catch (Exception ex)
{
throw new Exception("执行 public DataSet GetDataSet(Dictionary<string,string> dicTableAndSql)方法发生异常：" + ex.Message);
}
finally
{
conn.Close();
}
}
}
}
测试代码
using System.Data.SQLite;
using System.Windows;
using ToolsLib;
using System.Data;
using System.Data.SQLite;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private string ConnStr = $"Server=localhost;Port=3306;DataBase=TestDB;Uid=root;Pwd=123456";
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
Test005();
}
//插入一条数据
private void Test001()
{
MySQLHelper.connString = ConnStr;
string sql = "insert into Equipment(EquipId,EquipName) values({0},'{1}')";
sql = string.Format(sql, Convert.ToInt32(2), "Tain3");
MySQLHelper.ExecuteNonQuery(sql);
}
//防止 sql 注入的方式添加数据
private void Test002()
{
MySQLHelper.connString = ConnStr;
string sql = "insert into Equipment(EquipId,EquipName) values(@EquipId,@EquipName)";
MySqlParameter[] parameters = new MySqlParameter[]
{
new MySqlParameter("@EquipId", 306),
new MySqlParameter("@EquipName", "Tain99")
};
MySQLHelper.ExecuteNonQuery(sql, parameters);
}
//查询
private void Test003()
{
MySQLHelper.connString = ConnStr;
string sql = "Select EquipId,EquipName from Equipment";
DataSet ds = MySQLHelper.GetDataSet(sql);
if (ds.Tables.Count > 0)
{
DataTable table = ds.Tables[0];
foreach (DataRow row in table.Rows)
{
// 获取每一行中的列数据，这里根据实际数据库表中列的数据类型进行合适的处理和输出
int equipId = Convert.ToInt32(row["EquipId"]);
string equipName = row["EquipName"].ToString();
Debug.WriteLine($"EquipId: {equipId}, EquipName: {equipName}");
}
}
}
//删除
private void Test004()
{
MySQLHelper.connString = ConnStr;
string sql = "delete from Equipment where EquipId={0}";
sql = string.Format(sql, Convert.ToInt32(1));
MySQLHelper.ExecuteNonQuery(sql);
}
//修改
private void Test005()
{
MySQLHelper.connString = ConnStr;
string sql = "update Equipment Set EquipName='{0}' where EquipId={1}";
sql = string.Format(sql, "XXX", 2);
MySQLHelper.ExecuteNonQuery(sql);
}
}
}
3、SqlServer
1、先安装库
2、创建用于测试的表
use MyDB;
create table Equipment (EquipId int primary key,EquipName varchar(20)not null);
3、代码
库
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;
using System.Web;
//using System.Data.SqlClient;
using System.Data;
using Microsoft.SqlServer.Server;
using Microsoft.Data.SqlClient;
using System.Configuration;
namespace ToolsLib
{
public class SqlServerHelper
{
//用于连接数据库的字符串
//private static string ConnString { get; set; } = ConfigurationManager.ConnectionStrings["connString1"].ToString();
private static string ConnString { get; set; } = ConfigurationManager.AppSettings["connString1"];
/// <summary>
/// 执行 insert\update\delete 类型的 sql 语句
/// </summary>
/// <param name="cmdText">sql语句或存储过程名称</param>
/// <param name="paramArray">参数数组</param>
/// <returns>受影响的行数</returns>
/// <exception cref="Exception"></exception>
public static int ExecuteNonQuery(string cmdText, SqlParameter[] paramArray = null)
{
SqlConnection conn = new SqlConnection(ConnString);
SqlCommand cmd = new SqlCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteNonQuery();//执行
}
catch (Exception ex)
{
//可以在这个地方写入日志（log文件）
string errorMsg = $"{DateTime.Now}:执行public static int ExecuteNonQuery(sting cmdText,SqlParameter[]para---{ex.Message}";
throw new Exception(errorMsg);
}
finally
{
conn.Close();
}
}
/// <summary>
/// 执行查询语句，查询结果是但是一个结果
/// </summary>
/// <param name="cmdText"></param>
/// <param name="paramArray"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static object ExecuteScalar(string cmdText, SqlParameter[] paramArray = null)
{
SqlConnection conn = new SqlConnection(ConnString);
SqlCommand cmd = new SqlCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
return cmd.ExecuteScalar();
}
catch (Exception ex)
{
throw new Exception("执行public staticobjectExecute Scalar（string cmdText,SqlParameter[] paramArray = null)异常" + ex.Message);
}
finally
{
conn.Close();//关闭连接
}
}
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="cmdText"></param>
/// <param name="paramArray"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static SqlDataReader ExecuteReader(string cmdText, SqlParameter[] paramArray = null)
{
SqlConnection conn = new SqlConnection(ConnString);
SqlCommand cmd = new SqlCommand(cmdText, conn);
if (paramArray != null)
{
cmd.Parameters.AddRange(paramArray);
}
try
{
conn.Open();
//这里返回的 SqlDataReader 是用来进行进一步查询的，
//这里的 加的入参是：CommandBehavior.CloseConnection 为了，关闭 SqlDataReader后来自动关闭 conn连接 做设置
//因为 SqlDataReader 是需要在外部进行访问的
return cmd.ExecuteReader(CommandBehavior.CloseConnection);//执行
}
catch (Exception ex)
{
throw new Exception($"执行public staticobjectExecute Scalar（stringcmdText,SqlParameter[] paramArray=null) ---{ex.Message}");
}
}
/// <summary>
/// 返回包含一张数据表的数据集的查询
/// </summary>
/// <param name="sql"></param>
/// <param name="tableName"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static DataSet GetDataSet(string sql, string tableName = null)
{
SqlConnection conn = new SqlConnection(ConnString);
SqlCommand cmd = new SqlCommand(sql, conn);
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
try
{
conn.Open();
if (tableName == null)
{
da.Fill(ds);
}
else
{
da.Fill(ds, tableName);
}
return ds;
}
catch (Exception ex)
{
throw new Exception($"执行public static DataSet GetDataSet(string sql,string tableName=null)方法出现异常{ex.Message}");
}
finally
{
conn.Close();
}
}
public static DataSet GetDataSet(Dictionary<string, string> dicTableAndSql)
{
SqlConnection conn = new SqlConnection(ConnString);
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
try
{
conn.Open();
foreach (string tbName in dicTableAndSql.Keys)
{
cmd.CommandText = dicTableAndSql[tbName];
da.Fill(ds, tbName);//加入多个表
}
return ds;
}
catch (Exception ex)
{
throw new Exception("执行public static DataSet GetDataSet(string ssql,string tableName=null)方法出行异常" + ex.Message);
}
finally
{
conn.Close();
}
}
}
}
测试代码
using System.Data.SQLite;
using System.Windows;
using ToolsLib;
using System.Data;
using System.Data.SQLite;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
using Microsoft.Data.SqlClient;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private string ConnStr = $"Server=.;DataBase=MyDB;Uid=sa;Pwd=123456;TrustServerCertificate=True;";
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
Test005();
}
//插入一条数据
private void Test001()
{
SqlServerHelper.ConnString = ConnStr;
string sql = "insert into Equipment(EquipId,EquipName) values({0},'{1}')";
sql = string.Format(sql, Convert.ToInt32(2), "Tain3");
SqlServerHelper.ExecuteNonQuery(sql);
}
//防止 sql 注入的方式添加数据
private void Test002()
{
SqlServerHelper.ConnString = ConnStr;
string sql = "insert into Equipment(EquipId,EquipName) values(@EquipId,@EquipName)";
SqlParameter[] parameters = new SqlParameter[]
{
new SqlParameter("@EquipId", 306),
new SqlParameter("@EquipName", "Tain99")
};
SqlServerHelper.ExecuteNonQuery(sql, parameters);
}
//查询
private void Test003()
{
SqlServerHelper.ConnString = ConnStr;
string sql = "Select EquipId,EquipName from Equipment";
DataSet ds = SqlServerHelper.GetDataSet(sql);
if (ds.Tables.Count > 0)
{
DataTable table = ds.Tables[0];
foreach (DataRow row in table.Rows)
{
// 获取每一行中的列数据，这里根据实际数据库表中列的数据类型进行合适的处理和输出
int equipId = Convert.ToInt32(row["EquipId"]);
string equipName = row["EquipName"].ToString();
Debug.WriteLine($"EquipId: {equipId}, EquipName: {equipName}");
}
}
}
//删除
private void Test004()
{
SqlServerHelper.ConnString = ConnStr;
string sql = "delete from Equipment where EquipId={0}";
sql = string.Format(sql, Convert.ToInt32(2));
SqlServerHelper.ExecuteNonQuery(sql);
}
//修改
private void Test005()
{
SqlServerHelper.ConnString = ConnStr;
string sql = "update Equipment Set EquipName='{0}' where EquipId={1}";
sql = string.Format(sql, "XXX", 306);
SqlServerHelper.ExecuteNonQuery(sql);
}
}
}
4、redis
安装后添加 环境变量
登录：
redis-server
redis-cli
1、命令行的操作
键值操作：
C:\Users\Jack>redis-cli
127.0.0.1:6379> set mykey "nihao"
OK
127.0.0.1:6379> get mykey
"nihao"
127.0.0.1:6379> del mykey
(integer) 1
127.0.0.1:6379> del key
(integer) 0
注：
查看数据库中的所有键：KEYS *
列表 (List) 操作
127.0.0.1:6379> lpush mylist "element1"
(integer) 1
127.0.0.1:6379> lpush mylist "element2"
(integer) 2
127.0.0.1:6379> rpush mylist "element3"
(integer) 3
127.0.0.1:6379> lrange mylist 0 -1
1) "element2"
2) "element1"
3) "element3"
127.0.0.1:6379> lrange mylist
(error) ERR wrong number of arguments for 'lrange' command
127.0.0.1:6379> lrange mylist 0 1
1) "element2"
2) "element1"
127.0.0.1:6379> lrange mylist 0 0
1) "element2"
127.0.0.1:6379> lpop mylist
"element2"
127.0.0.1:6379> rpop mylist
"element3"
127.0.0.1:6379> lrange mylist 0 -1
1) "element1"
哈希 (Hash) 操作
127.0.0.1:6379> hset myhash field1 value1
(integer) 1
127.0.0.1:6379> hget myhash field1
"value1"
127.0.0.1:6379> hset myhash field2 value2
(integer) 1
127.0.0.1:6379> hset myhash field3 value3
(integer) 1
127.0.0.1:6379> hset myhash field3 value5
(integer) 0
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "value1"
3) "field2"
4) "value2"
5) "field3"
6) "value5"
127.0.0.1:6379>
集合 (Set) 操作
127.0.0.1:6379> sadd myset element1
(integer) 1
127.0.0.1:6379> sadd myset element2
(integer) 1
127.0.0.1:6379> sadd myset element3
(integer) 1
127.0.0.1:6379> sadd myset element3
(integer) 0
127.0.0.1:6379> sadd myset element3
(integer) 0
127.0.0.1:6379> smembers myset
1) "element3"
2) "element2"
3) "element1"
127.0.0.1:6379> sismember myset element1
(integer) 1
127.0.0.1:6379> sismember myset element5
(integer) 0
有序集合操作
127.0.0.1:6379> zadd myzset 1 "element1"
(integer) 1
127.0.0.1:6379> zadd myzset 1 "element12"
(integer) 1
127.0.0.1:6379> zadd myzset 2 "element12"
(integer) 0
127.0.0.1:6379> zadd myzset 3 "element99"
(integer) 1
127.0.0.1:6379> zrangebyscore myzset 0 -1
(empty list or set)
127.0.0.1:6379> zrangebyscore myzset 0 1
1) "element1"
127.0.0.1:6379> zrangebyscore myzset 0 10
1) "element1"
2) "element12"
3) "element99"
切换数据库
切换数据库：Redis 可以有多个数据库，默认有 16 个（编号从 0 到 15）。使用SELECT命令切换数据库。例如，SELECT 1会切换到编号为 1 的数据库。
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> zrangebyscore myzset 0 10
(empty list or set)
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> zrangebyscore myzset 0 10
1) "element1"
2) "element12"
3) "element99"
事务操作
开启事务：使用MULTI命令开启一个事务。在事务中，可以执行多个命令，这些命令不会立即执行。
执行事务：EXEC命令用于执行事务。在执行MULTI之后，所有添加的命令会在执行EXEC时按顺序执行。例如：
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set key1 value1
QUEUED
127.0.0.1:6379> set key2 value2
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379> get key1
"value1"
127.0.0.1:6379> get key2
"value2"
发布/订阅
2、C#调用 redis
1、添加 StackExchange.Redis 库
2、库代码
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using StackExchange.Redis;
using static NPOI.HSSF.Util.HSSFColor;
namespace ToolsLib
{
public class RedisHelper
{
ConnectionMultiplexer conn = null;
IDatabase db = null;
public void Connect()
{
// 创建连接配置选项
ConfigurationOptions options = new ConfigurationOptions
{
EndPoints = { "localhost:6379" },
//注： 或者 EndPoints = { "192.168.1.100:6379" },
// 可以设置密码等其他选项，例如：Password = "your_password"
};
// 创建连接多路复用器
this.conn = ConnectionMultiplexer.Connect(options);
// 获取数据库对象，Redis可以有多个数据库，这里选择默认数据库（编号为0）
this.db = this.conn.GetDatabase();
//注： 这个可以设置选择 1号数据库 this.db = this.conn.GetDatabase(1);
}
public void DisConnect()
{
if (null == this.conn) return;
this.conn.Close();
this.conn = null;
}
public void SaveKeyValue()
{
//存入键值
var res = this.db.StringSet("key_0106", "value");
Debug.WriteLine("write key-value:"+res);
}
public void ReadKeyValue()
{
//读取 key-value
var res = db.StringGet("key_0106");
Debug.WriteLine(res);
}
public void DelKeyValue()
{
var res =db.KeyDelete("key_0106");
Debug.WriteLine("delete:"+res);
}
public void SaveList()
{
string listName = "mmylist";
db.ListLeftPush(listName, 123);
db.ListLeftPush(listName, "asd");
db.ListLeftPush(listName, 456);
db.ListRightPush(listName, "value1");
db.ListRightPush(listName, "value2");
db.ListRightPush(listName, "value3");
db.ListRightPush(listName, "value4");
db.ListRightPush(listName, "value5");
//db.ListRemove(listName,1);
db.ListLeftPop(listName);
}
public void ReadList()
{
var res = db.ListRange("mmylist", 0, -1);
foreach(var item in res)
{
Debug.WriteLine(item);
}
}
public void SaveHash()
{
//存入 hash
HashEntry[] hashEntries = new HashEntry[]
{
new HashEntry("field1", "value1"),
new HashEntry("field2", "value2")
};
db.HashSet("hhhashKey", hashEntries);
}
public void ReadHash()
{
//读取
RedisValue[] values = db.HashValues("hhhashKey");
foreach(var value in values)
{
Debug.WriteLine(value);
}
}
public void SaveSet()
{
bool res = true;
res = db.SetAdd("mmySet", "001");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "002");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "003");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "004");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "005");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "005");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "005");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "006");
Debug.WriteLine(res);
res = db.SetAdd("mmySet", "007");
Debug.WriteLine(res);
}
public void ReadSet()
{
var res = db.SetMembers("mmySet");
foreach(var member in res)
{
Debug.WriteLine(member);
}
}
public void SaveSortedSet()
{
db.SortedSetAdd("mmyZSet", "value1", 1);
db.SortedSetAdd("mmyZSet", "value2", 2);
db.SortedSetAdd("mmyZSet", "value3", 3);
db.SortedSetAdd("mmyZSet", "value4", 4);
db.SortedSetAdd("mmyZSet", "value5", 5);
db.SortedSetAdd("mmyZSet", "value6", 6);
}
public void ReadSortedSet()
{
var res = db.SortedSetRangeByRank("mmyZSet",0,-1);
foreach(var member in res)
{
Debug.WriteLine(member);
}
}
}
}
测试代码
using System.Windows;
using ToolsLib;
using System.Data;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
using Microsoft.Data.SqlClient;
using CommunicationLib;
using NPOI.SS.Formula.Functions;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private RedisHelper redisHelper = null;
public MainWindow()
{
InitializeComponent();
}
//连接
private void Button_Click1(object sender, RoutedEventArgs e)
{
//连接测试
this.redisHelper = new RedisHelper();
this.redisHelper.Connect();
}
//断开连接
private void Button_Click2(object sender, RoutedEventArgs e)
{
redisHelper.DisConnect();
}
//其他测试方法
private void Button_Click3(object sender, RoutedEventArgs e)
{
//存入数据
//redisHelper.SaveKeyValue();
//读取数据
//redisHelper.ReadKeyValue();
//删除数据
//redisHelper.DelKeyValue();
//存入 list
//redisHelper.SaveList();
//读取 list
//redisHelper.ReadList();
//存入
//redisHelper.SaveHash();
//读取
//redisHelper.ReadHash();
//存入
//redisHelper.SaveSet();
//读取
//redisHelper.ReadSet();
//存入
//redisHelper.SaveSortedSet();
//读取
redisHelper.ReadSortedSet();
}
}
}
5、MongoDB
基础操作
1、库的操作
//显示
show databases;
//删除，只有插入数据后才可 进行删除
> use mycollection
switched to db mydb
> db.dropDatabase();
//切换库，不用建，可以直接插入数据
use mycollection
2、集合（Collection）的操作
//插入数据（插入数据的时候就会建立文档）
> db.mycollection.insertOne({name: "John", age: 30});
{
"acknowledged" : true,
"insertedId" : ObjectId("60b8d3a1d9a8b7f789000001")
}
//删除集合
> db.mycollection.drop();
true
3、文档的操作
//插入数据
> db.mycollection.insertOne({name: "John", age: 30});
{
"acknowledged" : true,
"insertedId" : ObjectId("60b8d3a1d9a8b7f789000001")
}
//插入多条数据
> db.users.insertMany([
{
"username": "bob",
"email": "bob@example.com",
"password": "password456"
},
{
"username": "carol",
"email": "carol@example.com",
"password": "789abc"
}
]);
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("60b8d6a1d9a8b7f789000003"),
ObjectId("60b8d6a1d9a8b7f789000004")
]
}
//查询
> db.users.find();
//查询指定 文档
> db.users.find({username: "alice"});
{ "_id" : ObjectId("60b8d5a1d9a8b7f789000002"), "username" : "alice", "email" : "alice@example.com", "password" : "secret123" }
//更新文档
> db.users.updateOne({username: "alice"}, {$set: {password: "newsecret"}});
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.users.updateMany({}, {$set: {email: {$concat: [ "$email", "test"]}}});
{
"acknowledged" : true,
"matchedCount" : 3,
"modifiedCount" : 3
}
//删除文档
> db.users.deleteOne({username: "alice"});
{ "acknowledged" : true, "deletedCount" : 1 }
//deleteMany方法用于删除所有符合条件的文档。例如，删除所有password以secret开头的文档：
> db.users.deleteMany({password: /^secret/});
{ "acknowledged" : true, "deletedCount" : 0 }
4、代码
首先：
安装库：
注：MongoDB.Bson 可以不用安装
库
using MongoDB.Bson;
using MongoDB.Driver;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class MongoDBHelper
{
/* 不需要关闭
* 不需要显式关闭连接：MongoDB 驱动程序会自动管理连接池，你不需要手动关闭连接。
* 使用单例模式：建议在整个应用程序中使用单个 MongoClient 实例，以确保连接池的高效管理和复用。
* 连接复用：连接池中的连接可以被多个请求复用，操作完成后连接会自动返回到连接池中。
*/
private static MongoClient client = new MongoClient("mongodb://localhost:27017");
//插入一条数据
static public void Insert<T>(T model)
{
//连接
//var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<T>("data");
collection.InsertOne(model);
}
//插入一条数据
static public void Insert()
{
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<BsonDocument>("data");
BsonDocument bsonElements = new BsonDocument();
bsonElements.Add(new BsonElement("timestamp", DateTime.Now));
bsonElements.Add(new BsonElement("value", "this is a boy"));
bsonElements.Add(new BsonElement("age", 6));
collection.InsertOne(bsonElements);
}
//插入多条数据
static public void InsertMany<T>(List<T> ListModel)
{
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<T>("data");
collection.InsertMany(ListModel);
}
static public void Query<T>()
{
//连接
//var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<T>("data");
// 查询集合中的所有文档
//var filter = Builders<T>.Filter.Empty;
//查询所有
var result = collection.Find(_ => true).ToList();
//条件查询
//var result = collection.Find(u => u.value == "Test Data 5").ToList();
//条件查询
//var result = collection.Find(u => u.Age > 30).ToList();
// 遍历查询结果并输出
foreach (T item in result)
{
Debug.WriteLine(item);
}
}
//查询,这种不需要 类型绑定性能更高
static public void Query()
{
//var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<BsonDocument>("data");
//查询所有
//var filter = Builders<BsonDocument>.Filter.Empty;
//var result = collection.Find(filter).ToList();
//条件查询
//var filter = Builders<BsonDocument>.Filter.Eq("value", "Test Data 5");
//var result = collection.Find(filter).ToList();
//条件查询
//var filter = Builders<BsonDocument>.Filter.Gt("age", 30);//大于30，不存在此项的也不会进行查询
//var filter = Builders<BsonDocument>.Filter.Lt("age", 30);//小于30，不存在此项的也不会进行查询
//var result = collection.Find(filter).ToList();
//条件查询(时间区间)
// 定义时间区间
var startDate = DateTime.Parse("2025-01-01 00:00:00");
var endDate = DateTime.Parse("2025-01-02 00:00:00");
// 构建时间区间过滤条件
var filter = Builders<BsonDocument>.Filter.Gt("timestamp", startDate)
& Builders<BsonDocument>.Filter.Lt("timestamp", endDate);
//全拿
//var result = collection.Find(filter).ToList();
//投影
var projection = Builders<BsonDocument>.Projection.Exclude("_id").Include("value");
//var projection = Builders<BsonDocument>.Projection.Include("_id").Include("value");
var result = collection.Find(filter).Project(projection).ToList();
foreach (BsonDocument doc in result)
{
if (doc.TryGetValue("_id", out BsonValue x1)) { Debug.WriteLine("id:" + x1); }
if (doc.TryGetValue("timestamp", out BsonValue x2)) { Debug.WriteLine(",timestamp:" + x2); }
if (doc.TryGetValue("value", out BsonValue x3)) { Debug.WriteLine(",value:" + x3); }
if (doc.TryGetValue("age", out BsonValue x4)) { Debug.WriteLine(",age:" + x4); }
Debug.WriteLine("--------------------------");
//dynamic dynDoc = doc.ToDynamic();
//Debug.WriteLine(dynDoc);
// 可以动态地访问字段
//Debug.WriteLine(dynDoc._id);
//Debug.WriteLine(dynDoc.Name);
//Debug.WriteLine(dynDoc.Age);
}
}
//投影
//var projection = Builders<BsonDocument>.Projection.Include("_id").Include("value").Exclude("_id");
//var result = collection.Find(filter).Project(projection).ToList();
//更新数据
static public void Updata()
{
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<BsonDocument>("data");
var filter = Builders<BsonDocument>.Filter.Eq("value", "Test Data 5");
var update = Builders<BsonDocument>.Update.Set("age", 100); // 对值直接进行设置
//var update = Builders<BsonDocument>.Update.Inc("age", 1); // 值增加 1
collection.UpdateOne(filter, update);
}
//删除数据
static public void Delete()
{
var database = client.GetDatabase("myDB");
var collection = database.GetCollection<BsonDocument>("data");
var filter = Builders<BsonDocument>.Filter.Eq("value", "Test Data 1");
collection.DeleteOne(filter);
//var filter = Builders<BsonDocument>.Filter.Lt(u => u.Age, 20);
//collection.DeleteMany(filter);
}
}
}
测试代码
using System.Windows;
using CommunicationLib;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson;
using Siemens1;
using ToolsLib;
namespace WpfApp1
{
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
//连接
private void Button_Click1(object sender, RoutedEventArgs e)
{
}
//断开连接
private void Button_Click2(object sender, RoutedEventArgs e)
{
}
//其他测试方法
private void Button_Click3(object sender, RoutedEventArgs e)
{
//插入 1
//User user = new User()
//{
// timestamp = DateTime.Now,
// value = "qwer"
//};
//MongoDBHelper.Insert<User>(user);
//插入 2
//MongoDBHelper.Insert();
//插入 3
//List<User> listsU = new List<User>();
//listsU.Add(new User() { age=1,value="111",timestamp=DateTime.Now.AddDays(1)});
//listsU.Add(new User() { age=2,value="222",timestamp=DateTime.Now.AddDays(2)});
//listsU.Add(new User() { age=3,value="333",timestamp=DateTime.Now.AddDays(3)});
//MongoDBHelper.InsertMany<User>(listsU);
//查询 1
MongoDBHelper.Query<User>();
//查询 2
//MongoDBHelper.Query();
//修改
//MongoDBHelper.Updata();
//删除
//MongoDBHelper.Delete();
}
//测试实体类
//属性比文档（）中的只能多，不能少，少了异常
private class User()
{
[BsonId]
[BsonRepresentation(BsonType.ObjectId)]
public string Id { get; set; }
public DateTime timestamp { set; get; }
public string value { set; get; }
public int age { set; get; } = 0;
public override string ToString()
{
return $"id:{Id},timestamep{timestamp},value:{value},age:{age}";
}
}
}
}
五、上位机设备通信库
1、西门子S7通信库
1、添加所需的引用
库
using thinger.CommunicationLib;
using thinger.DataConvertLib;
namespace CommunicationLib
{
//西门子
public class TestSiemens
{
//S7.Net.CpuType
//DataType
//通信对象
private SiemensS7 device = null;
//连接正常标志
private bool isConnected = false;
//发起连接
public void Connect()
{
device = new SiemensS7();
string ip = "192.168.31.150";
int port = 102;
S7.Net.CpuType cpuType = S7.Net.CpuType.S7200;
int rack = 0;
int slot = 1;
if (CommonValidate())
{
device.DisConnect();//断开连接
}
OperateResult result = device.Connect(ip, port, cpuType, rack, slot);
if (result.IsSuccess)
{
isConnected = true;
CommonMethods.AddLog(0, "连接成功");
}
else
{
isConnected = false;
CommonMethods.AddLog(0, "连接失败");
}
}
//用于验证
private bool CommonValidate()
{
if(isConnected == false)
{
CommonMethods.AddLog(1, "设备未连接，请检查");
return false;
}
return true;
}
//从PLC 读取信息
public void ReadMessage(string dataTypeIn,string adress,int lenth=1)
{
if (!CommonValidate()) return;
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
switch (dataType)
{
case DataType.Bool:
//var result1 = device.ReadBoolArray(this.txt_Variable.Text, Convert.ToUInt16(this.txt_Count.Text));
//if (result1.IsSuccess)
//{
// CommonMethods.AddLog(this.lst_Info, 0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
//}
//else
//{
// CommonMethods.AddLog(this.lst_Info, 1, "读取失败:" + result1.Message);
//}
var result1 = device.ReadCommon<bool[]>(adress,Convert.ToUInt16(lenth));
if (result1.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result1.Message);
}
break;
case DataType.Byte:
case DataType.SByte:
var result2 = device.ReadCommon<byte[]>(adress, Convert.ToUInt16(lenth));
if (result2.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result2.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result2.Message);
}
break;
case DataType.Short:
var result3 = device.ReadCommon<short[]>(adress, Convert.ToUInt16(lenth));
if (result3.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result3.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result3.Message);
}
break;
case DataType.UShort:
var result4 = device.ReadCommon<ushort[]>(adress,Convert.ToUInt16(lenth));
if (result4.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result4.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result4.Message);
}
break;
case DataType.Int:
var result5 = device.ReadCommon<int[]>(adress, Convert.ToUInt16(lenth));
if (result5.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result5.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result5.Message);
}
break;
case DataType.UInt:
var result6 = device.ReadCommon<uint[]>(adress, Convert.ToUInt16(lenth));
if (result6.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result6.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result6.Message);
}
break;
case DataType.Float:
var result7 = device.ReadCommon<float[]>(adress, Convert.ToUInt16(lenth));
if (result7.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result7.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result7.Message);
}
break;
case DataType.Double:
var result8 = device.ReadCommon<float[]>(adress, Convert.ToUInt16(lenth));
if (result8.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result8.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result8.Message);
}
break;
case DataType.Long:
var result9 = device.ReadCommon<long[]>(adress, Convert.ToUInt16(lenth));
if (result9.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result9.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result9.Message);
}
break;
case DataType.ULong:
var result10 = device.ReadCommon<ulong[]>(adress, Convert.ToUInt16(lenth));
if (result10.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result10.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result10.Message);
}
break;
case DataType.String:
var result11 = device.ReadCommon<string>(adress, Convert.ToUInt16(lenth));
if (result11.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + result11.Content);
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result11.Message);
}
break;
default:
CommonMethods.AddLog(1, "读取失败:不支持的数据类型");
break;
}
}
//向PLC 写入信息
public void WriteMessage(string dataTypeIn, string adress ,string message)
{
if (!CommonValidate()) return;
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
var result = OperateResult.CreateFailResult();
switch (dataType)
{
case DataType.Bool:
result = device.WriteCommon(adress, BitLib.GetBitArrayFromBitArrayString(message));
break;
case DataType.Byte:
case DataType.SByte:
result = device.WriteCommon(adress, ByteArrayLib.GetByteArrayFromHexString(message));
break;
case DataType.Short:
result = device.WriteCommon(adress, ShortLib.GetShortArrayFromString(message));
break;
case DataType.UShort:
result = device.WriteCommon(adress, UShortLib.GetUShortArrayFromString(message));
break;
case DataType.Int:
result = device.WriteCommon(adress, IntLib.GetIntArrayFromString(message));
break;
case DataType.UInt:
result = device.WriteCommon(adress, UIntLib.GetUIntArrayFromString(message));
break;
case DataType.Float:
result = device.WriteCommon(adress, FloatLib.GetFloatArrayFromString(message));
break;
case DataType.Double:
result = device.WriteCommon(adress, DoubleLib.GetDoubleArrayFromString(message));
break;
case DataType.Long:
result = device.WriteCommon(adress, LongLib.GetLongArrayFromString(message));
break;
case DataType.ULong:
result = device.WriteCommon(adress, ULongLib.GetULongArrayFromString(message));
break;
case DataType.String:
result = device.WriteCommon(adress, message);
break;
default:
break;
}
if (result.IsSuccess)
{
CommonMethods.AddLog(0, "写入成功");
}
else
{
CommonMethods.AddLog(0, "写入失败");
}
}
}
}
测试代码
using System.Data.SQLite;
using System.Windows;
using ToolsLib;
using System.Data;
using System.Data.SQLite;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
using Microsoft.Data.SqlClient;
using CommunicationLib;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private TestSiemens testSiemens = null;
public MainWindow()
{
InitializeComponent();
//连接测试
this.testSiemens = new TestSiemens();
this.testSiemens.Connect();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
//Test005();
Test006();
}
//测试读取 I区 Q区
private void Test001()
{
//读取一位
//testSiemens.ReadMessage("Bool", "I0.0", 1);
testSiemens.ReadMessage("Bool", "Q0.0", 1);
//读取三位
//testSiemens.ReadMessage("Bool", "I0.0", 3);
}
//测试读取 M区
private void Test002()
{
//testSiemens.ReadMessage("Bool", "M0.0", 1);
//testSiemens.ReadMessage("Byte", "M0", 1);
//testSiemens.ReadMessage("SByte", "M0", 1);
//testSiemens.ReadMessage("Int", "M0", 1);
//testSiemens.ReadMessage("Short", "M0", 1);
//testSiemens.ReadMessage("UShort", "M0", 1);
//testSiemens.ReadMessage("Int", "M0", 1);
//testSiemens.ReadMessage("UInt", "M0", 1);
//testSiemens.ReadMessage("UInt", "M0", 1);
testSiemens.ReadMessage("Float", "M0", 1);
//testSiemens.ReadMessage("Double", "M0", 1);
//testSiemens.ReadMessage("Long", "M0", 1);
//testSiemens.ReadMessage("ULong", "M0", 1);
}
//测试读取 V区
private void Test003()
{
//testSiemens.ReadMessage("Bool", "DB1.0.0", 1);
testSiemens.ReadMessage("Byte", "DB1.0", 1);
//testSiemens.ReadMessage("SByte", "DB1.0", 1);
//testSiemens.ReadMessage("Short", "DB1.0", 1);
//testSiemens.ReadMessage("UShort", "DB1.0", 1);
//testSiemens.ReadMessage("Int", "DB1.0", 1);
//testSiemens.ReadMessage("UInt", "DB1.0", 1);
//testSiemens.ReadMessage("Float", "DB1.0", 1);
//testSiemens.ReadMessage("Double", "DB1.0", 1);
//testSiemens.ReadMessage("Long", "DB1.0", 1);
//testSiemens.ReadMessage("ULong", "DB1.0", 1);
}
//读取 C区 无法写入
private void Test004()
{
//testSiemens.ReadMessage("Bool", "C1.0", 1);
//testSiemens.ReadMessage("Byte", "C0", 1);
//testSiemens.ReadMessage("SByte", "DB1.0", 1);
//testSiemens.ReadMessage("Short", "DB1.0", 1);
//testSiemens.ReadMessage("UShort", "DB1.0", 1);
//testSiemens.ReadMessage("Int", "C0", 1);
testSiemens.ReadMessage("UInt", "C0", 1);
//testSiemens.ReadMessage("Float", "DB1.0", 1);
//testSiemens.ReadMessage("Double", "DB1.0", 1);
//testSiemens.ReadMessage("Long", "DB1.0", 1);
//testSiemens.ReadMessage("ULong", "DB1.0", 1);
}
//写入 M区
private void Test005()
{
//testSiemens.WriteMessage("Bool", "M0.0","1");
//testSiemens.WriteMessage("Byte", "M0", "1");
//testSiemens.WriteMessage("SByte", "M0", "2");
//testSiemens.WriteMessage("Short", "M0", "3");
//testSiemens.WriteMessage("UShort", "M0", "4");
//testSiemens.WriteMessage("Int", "M0", "5");
//testSiemens.WriteMessage("UInt", "M0", "6");
//testSiemens.WriteMessage("Float", "M0", "1.2");
//testSiemens.WriteMessage("Double", "M0", "1.3");
//testSiemens.WriteMessage("Long", "M0", "0");
testSiemens.WriteMessage("ULong", "M0", "1");
}
//写入 V区
private void Test006()
{
testSiemens.WriteMessage("Bool", "DB1.0.0","0");
//testSiemens.WriteMessage("Byte", "DB1.0", "1");
//testSiemens.WriteMessage("SByte", "DB1.0", "2");
//testSiemens.WriteMessage("Short", "DB1.0", "3");
//testSiemens.WriteMessage("UShort", "DB1.0", "4");
//testSiemens.WriteMessage("Int", "DB1.0", "5");
//testSiemens.WriteMessage("UInt", "DB1.0", "6");
//testSiemens.WriteMessage("Float", "DB1.0", "1.2");
//testSiemens.WriteMessage("Double", "DB1.0", "1.3");
//testSiemens.WriteMessage("Long", "DB1.0", "100");
//testSiemens.WriteMessage("ULong", "DB1.0", "222");
}
}
}
2、modbusRTU
设置 变量类型 大小端
安装包：
库
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using thinger.CommunicationLib;
using thinger.DataConvertLib;
namespace CommunicationLib
{
public class TestModbusRTU
{
//创建通信对象
private ModbusRTU device = null;
//创建连接正常标志位
private bool isConnected = false;
//连接
public void Connect()
{
device = new ModbusRTU();
device.DevAddress = Convert.ToByte("1"); //从站地址
device.IsShortAddress = true; //是否为短地址
device.DataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), "ABCD"); //大小端
//device.DataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), "DCBA"); //大小端
//device.DataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), "BADC"); //大小端
//device.DataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), "CDAB"); //大小端
Parity parity = (Parity)Enum.Parse(typeof(Parity), "None"); //校验
StopBits stopBits = (StopBits)Enum.Parse(typeof(StopBits), "One"); //停止位
int baudRate = Convert.ToInt32("9600"); //波特率
int dataBits = Convert.ToInt32("8"); //数据位
var result = device.Connect("COM9", baudRate, dataBits, parity, stopBits);
if (result)
{
isConnected = true;
CommonMethods.AddLog(0, "设备连接成功");
}
else
{
isConnected = false;
CommonMethods.AddLog(0, "设备连接失败");
}
}
public void DisConneted()
{
if (isConnected)
{
device?.DisConnect();
CommonMethods.AddLog(0, "设备断开连接");
}
else
{
CommonMethods.AddLog(0, "设备未连接");
}
}
/// <summary>
/// 通用验证
/// </summary>
/// <returns></returns>
private bool CommonValidate()
{
if (isConnected == false)
{
CommonMethods.AddLog(1, "设备未连接，请检查");
return false;
}
return true;
}
public void ReadMessage(string dataTypeIn, string adress,ushort length=1)
{
if (CommonValidate())
{
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
switch (dataType)
{
case DataType.Bool:
//var result1 = device.ReadBoolArray(this.txt_Variable.Text, Convert.ToUInt16(this.txt_Count.Text));
//if (result1.IsSuccess)
//{
// CommonMethods.AddLog(this.lst_Info, 0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
//}
//else
//{
// CommonMethods.AddLog(this.lst_Info, 1, "读取失败:" + result1.Message);
//}
var result1 = device.ReadCommon<bool[]>(adress,length);
if (result1.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result1.Message);
}
break;
case DataType.Byte:
case DataType.SByte:
var result2 = device.ReadCommon<byte[]>(adress);
if (result2.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result2.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result2.Message);
}
break;
case DataType.Short:
var result3 = device.ReadCommon<short[]>(adress);
if (result3.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result3.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result3.Message);
}
break;
case DataType.UShort:
var result4 = device.ReadCommon<ushort[]>(adress);
if (result4.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result4.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result4.Message);
}
break;
case DataType.Int:
var result5 = device.ReadCommon<int[]>(adress);
if (result5.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result5.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result5.Message);
}
break;
case DataType.UInt:
var result6 = device.ReadCommon<uint[]>(adress);
if (result6.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result6.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result6.Message);
}
break;
case DataType.Float:
var result7 = device.ReadCommon<float[]>(adress);
if (result7.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result7.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result7.Message);
}
break;
case DataType.Double:
var result8 = device.ReadCommon<float[]>(adress);
if (result8.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result8.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result8.Message);
}
break;
case DataType.Long:
var result9 = device.ReadCommon<long[]>(adress);
if (result9.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result9.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result9.Message);
}
break;
case DataType.ULong:
var result10 = device.ReadCommon<ulong[]>(adress);
if (result10.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result10.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result10.Message);
}
break;
case DataType.String:
var result11 = device.ReadCommon<string>(adress);
if (result11.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + result11.Content);
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result11.Message);
}
break;
default:
CommonMethods.AddLog(1, "读取失败:不支持的数据类型");
break;
}
}
}
public void WriteMessage(string dataTypeIn, string adress, string content)
{
if (CommonValidate())
{
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
var result = OperateResult.CreateFailResult();
switch (dataType)
{
case DataType.Bool:
result = device.WriteCommon(adress, BitLib.GetBitArrayFromBitArrayString(content));
break;
case DataType.Byte:
case DataType.SByte:
result = device.WriteCommon(adress, ByteArrayLib.GetByteArrayFromHexString(content));
break;
case DataType.Short:
result = device.WriteCommon(adress, ShortLib.GetShortArrayFromString(content));
break;
case DataType.UShort:
result = device.WriteCommon(adress, UShortLib.GetUShortArrayFromString(content));
break;
case DataType.Int:
result = device.WriteCommon(adress, IntLib.GetIntArrayFromString(content));
break;
case DataType.UInt:
result = device.WriteCommon(adress, UIntLib.GetUIntArrayFromString(content));
break;
case DataType.Float:
result = device.WriteCommon(adress, FloatLib.GetFloatArrayFromString(content));
break;
case DataType.Double:
result = device.WriteCommon(adress, DoubleLib.GetDoubleArrayFromString(content));
break;
case DataType.Long:
result = device.WriteCommon(adress, LongLib.GetLongArrayFromString(content));
break;
case DataType.ULong:
result = device.WriteCommon(adress, ULongLib.GetULongArrayFromString(content));
break;
case DataType.String:
result = device.WriteCommon(adress, content);
break;
default:
break;
}
if (result.IsSuccess)
{
CommonMethods.AddLog(0, "写入成功");
}
else
{
CommonMethods.AddLog(0, "写入失败");
}
}
}
}
}
测试代码
using System.Windows;
using ToolsLib;
using System.Data;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
using Microsoft.Data.SqlClient;
using CommunicationLib;
using NPOI.SS.Formula.Functions;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private TestModbusRTU TestModbusRTU = null;
public MainWindow()
{
InitializeComponent();
}
//连接
private void Button_Click1(object sender, RoutedEventArgs e)
{
//连接测试
this.TestModbusRTU = new TestModbusRTU();
this.TestModbusRTU.Connect();
}
//断开连接
private void Button_Click2(object sender, RoutedEventArgs e)
{
if (TestModbusRTU != null)
{
this.TestModbusRTU.DisConneted();
}
}
//其他测试方法
private void Button_Click3(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
//Test005();
Test006();
}
//读取 0区
private void Test001()
{
//读取一位
//TestSiemens.Conn
if (TestModbusRTU != null)
{
this.TestModbusRTU.ReadMessage("Bool","00001");
this.TestModbusRTU.ReadMessage("Bool","00001",3);
}
}
//读取 1区
private void Test002()
{
//读取一位
//TestSiemens.Conn
if (TestModbusRTU != null)
{
this.TestModbusRTU.ReadMessage("Bool", "10001");
this.TestModbusRTU.ReadMessage("Bool", "10001", 3);
}
}
//读取 3区
private void Test003()
{
//读取一位
//TestSiemens.Conn
if (TestModbusRTU != null)
{
this.TestModbusRTU.ReadMessage("Byte", "30001");
this.TestModbusRTU.ReadMessage("SByte", "30002");
this.TestModbusRTU.ReadMessage("Short", "30003");
this.TestModbusRTU.ReadMessage("UShort","30004");
this.TestModbusRTU.ReadMessage("Int", "30005");
this.TestModbusRTU.ReadMessage("UInt", "30006");
this.TestModbusRTU.ReadMessage("Float", "30007");
this.TestModbusRTU.ReadMessage("Double","30008");
this.TestModbusRTU.ReadMessage("Long", "30009");
this.TestModbusRTU.ReadMessage("ULong", "30010");
this.TestModbusRTU.ReadMessage("String","30011");
}
}
//读取 4区
private void Test004()
{
//读取一位
//TestSiemens.Conn
if (TestModbusRTU != null)
{
this.TestModbusRTU.ReadMessage("Byte", "40001");
this.TestModbusRTU.ReadMessage("SByte", "40002");
this.TestModbusRTU.ReadMessage("Short", "40003");
this.TestModbusRTU.ReadMessage("UShort","40004");
this.TestModbusRTU.ReadMessage("Int", "40005");
this.TestModbusRTU.ReadMessage("UInt", "40006");
this.TestModbusRTU.ReadMessage("Float", "40007");
this.TestModbusRTU.ReadMessage("Double","40008");
this.TestModbusRTU.ReadMessage("Long", "40009");
this.TestModbusRTU.ReadMessage("ULong", "40010");
this.TestModbusRTU.ReadMessage("String","40011");
}
}
//写入 1区
private void Test005()
{
//读取一位
//TestSiemens.Conn
if (TestModbusRTU != null)
{
this.TestModbusRTU.WriteMessage("Bool", "00001", "1");
}
}
//写入 4区
private void Test006()
{
//读取一位
//TestSiemens.Conn
if (TestModbusRTU != null)
{
this.TestModbusRTU.WriteMessage("Short", "40001", "100");
this.TestModbusRTU.WriteMessage("UShort", "40002", "102");
//this.TestModbusRTU.WriteMessage("Int", "40006", "10");
//this.TestModbusRTU.WriteMessage("UInt", "40003", "11");
//this.TestModbusRTU.WriteMessage("Float", "40007", "1.1");
this.TestModbusRTU.WriteMessage("Double", "40007", "1.2");
//this.TestModbusRTU.WriteMessage("Long", "40009", "1");
//this.TestModbusRTU.WriteMessage("ULong", "40010", "1");
//this.TestModbusRTU.WriteMessage("String", "40011", "1");
}
}
}
}
3、modbusTCP
库
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using thinger.CommunicationLib;
using thinger.DataConvertLib;
namespace CommunicationLib
{
public class TestModbusTCP
{
//创建通信对象
private ModbusTCP device = null;
//创建连接正常标志
private bool isConnected = false;
public void Connect()
{
device = new ModbusTCP();
device.DevAddress = Convert.ToByte("1");
device.IsShortAddress = true;
device.DataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), "ABCD");
var result = device.Connect("127.0.0.1", Convert.ToInt32("503"));
if (result)
{
isConnected = true;
CommonMethods.AddLog(0, "设备连接成功");
}
else
{
isConnected = false;
CommonMethods.AddLog(0, "设备连接失败");
}
}
public void DisConneted()
{
if (isConnected)
{
device?.DisConnect();
CommonMethods.AddLog(0, "设备断开连接");
}
else
{
CommonMethods.AddLog(0,"设备未连接");
}
}
/// <summary>
/// 通用验证
/// </summary>
/// <returns></returns>
private bool CommonValidate()
{
if (isConnected == false)
{
CommonMethods.AddLog(1, "设备未连接，请检查");
return false;
}
return true;
}
public void ReadMessage(string dataTypeIn, string adress, ushort length = 1)
{
if (CommonValidate())
{
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
switch (dataType)
{
case DataType.Bool:
//var result1 = device.ReadBoolArray(this.txt_Variable.Text, Convert.ToUInt16(this.txt_Count.Text));
//if (result1.IsSuccess)
//{
// CommonMethods.AddLog(this.lst_Info, 0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
//}
//else
//{
// CommonMethods.AddLog(this.lst_Info, 1, "读取失败:" + result1.Message);
//}
var result1 = device.ReadCommon<bool[]>(adress, length);
if (result1.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result1.Message);
}
break;
case DataType.Byte:
case DataType.SByte:
var result2 = device.ReadCommon<byte[]>(adress, length);
if (result2.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result2.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result2.Message);
}
break;
case DataType.Short:
var result3 = device.ReadCommon<short[]>(adress, length);
if (result3.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result3.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result3.Message);
}
break;
case DataType.UShort:
var result4 = device.ReadCommon<ushort[]>(adress, length);
if (result4.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result4.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result4.Message);
}
break;
case DataType.Int:
var result5 = device.ReadCommon<int[]>(adress, length);
if (result5.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result5.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result5.Message);
}
break;
case DataType.UInt:
var result6 = device.ReadCommon<uint[]>(adress, length);
if (result6.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result6.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result6.Message);
}
break;
case DataType.Float:
var result7 = device.ReadCommon<float[]>(adress, length);
if (result7.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result7.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result7.Message);
}
break;
case DataType.Double:
var result8 = device.ReadCommon<float[]>(adress, length);
if (result8.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result8.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result8.Message);
}
break;
case DataType.Long:
var result9 = device.ReadCommon<long[]>(adress, length);
if (result9.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result9.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result9.Message);
}
break;
case DataType.ULong:
var result10 = device.ReadCommon<ulong[]>(adress, length);
if (result10.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result10.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result10.Message);
}
break;
case DataType.String:
var result11 = device.ReadCommon<string>(adress, length);
if (result11.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + result11.Content);
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result11.Message);
}
break;
default:
CommonMethods.AddLog(1, "读取失败:不支持的数据类型");
break;
}
}
}
public void WriteMessage(string dataTypeIn, string adress, string content)
{
if (CommonValidate())
{
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
var result = OperateResult.CreateFailResult();
switch (dataType)
{
case DataType.Bool:
result = device.WriteCommon(adress, BitLib.GetBitArrayFromBitArrayString(content));
break;
case DataType.Byte:
case DataType.SByte:
result = device.WriteCommon(adress, ByteArrayLib.GetByteArrayFromHexString(content));
break;
case DataType.Short:
result = device.WriteCommon(adress, ShortLib.GetShortArrayFromString(content));
break;
case DataType.UShort:
result = device.WriteCommon(adress, UShortLib.GetUShortArrayFromString(content));
break;
case DataType.Int:
result = device.WriteCommon(adress, IntLib.GetIntArrayFromString(content));
break;
case DataType.UInt:
result = device.WriteCommon(adress, UIntLib.GetUIntArrayFromString(content));
break;
case DataType.Float:
result = device.WriteCommon(adress, FloatLib.GetFloatArrayFromString(content));
break;
case DataType.Double:
result = device.WriteCommon(adress, DoubleLib.GetDoubleArrayFromString(content));
break;
case DataType.Long:
result = device.WriteCommon(adress, LongLib.GetLongArrayFromString(content));
break;
case DataType.ULong:
result = device.WriteCommon(adress, ULongLib.GetULongArrayFromString(content));
break;
case DataType.String:
result = device.WriteCommon(adress, content);
break;
default:
break;
}
if (result.IsSuccess)
{
CommonMethods.AddLog(0, "写入成功");
}
else
{
CommonMethods.AddLog(0, "写入失败");
}
}
}
}
}
测试代码
using System.Windows;
using ToolsLib;
using System.Data;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
using Microsoft.Data.SqlClient;
using CommunicationLib;
using NPOI.SS.Formula.Functions;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private TestModbusTCP testModbusTCP = null;
public MainWindow()
{
InitializeComponent();
}
//连接
private void Button_Click1(object sender, RoutedEventArgs e)
{
//连接测试
this.testModbusTCP = new TestModbusTCP();
this.testModbusTCP.Connect();
}
//断开连接
private void Button_Click2(object sender, RoutedEventArgs e)
{
if (testModbusTCP != null)
{
testModbusTCP.DisConneted();
}
}
//其他测试方法
private void Button_Click3(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
//Test005();
Test006();
}
//读取 0区
private void Test001()
{
//读取一位
//TestSiemens.Conn
if (testModbusTCP != null)
{
this.testModbusTCP.ReadMessage("Bool","00001");
this.testModbusTCP.ReadMessage("Bool","00001",3);
}
}
//读取 1区
private void Test002()
{
//读取一位
//TestSiemens.Conn
if (testModbusTCP != null)
{
this.testModbusTCP.ReadMessage("Bool", "10001");
this.testModbusTCP.ReadMessage("Bool", "10001", 3);
}
}
//读取 3区
private void Test003()
{
//读取一位
//TestSiemens.Conn
if (testModbusTCP != null)
{
this.testModbusTCP.ReadMessage("Byte", "30001",1);
this.testModbusTCP.ReadMessage("SByte", "30002",2);
this.testModbusTCP.ReadMessage("Short", "30001",2);
this.testModbusTCP.ReadMessage("UShort","30004");
this.testModbusTCP.ReadMessage("Int", "30005");
this.testModbusTCP.ReadMessage("UInt", "30006");
this.testModbusTCP.ReadMessage("Float", "30007");
this.testModbusTCP.ReadMessage("Double","30008");
this.testModbusTCP.ReadMessage("Long", "30009");
this.testModbusTCP.ReadMessage("ULong", "30010");
this.testModbusTCP.ReadMessage("String","30011");
}
}
//读取 4区
private void Test004()
{
//读取一位
//TestSiemens.Conn
if (testModbusTCP != null)
{
this.testModbusTCP.ReadMessage("Byte", "40001");
this.testModbusTCP.ReadMessage("SByte", "40002");
this.testModbusTCP.ReadMessage("Short", "40003");
this.testModbusTCP.ReadMessage("UShort","40004");
this.testModbusTCP.ReadMessage("Int", "40005");
this.testModbusTCP.ReadMessage("UInt", "40006");
this.testModbusTCP.ReadMessage("Float", "40007");
this.testModbusTCP.ReadMessage("Double","40008");
this.testModbusTCP.ReadMessage("Long", "40009");
this.testModbusTCP.ReadMessage("ULong", "40010");
this.testModbusTCP.ReadMessage("String","40011");
}
}
//写入 1区
private void Test005()
{
//读取一位
//TestSiemens.Conn
if (testModbusTCP != null)
{
this.testModbusTCP.WriteMessage("Bool", "00001", "1");
}
}
//写入 4区
private void Test006()
{
//读取一位
//TestSiemens.Conn
if (testModbusTCP != null)
{
this.testModbusTCP.WriteMessage("Short", "40001", "100");
this.testModbusTCP.WriteMessage("UShort", "40002", "102");
//this.testModbusTCP.WriteMessage("Int", "40007", "10");
//this.testModbusTCP.WriteMessage("UInt", "40007", "11");
//this.testModbusTCP.WriteMessage("Float", "40007", "1.1");
this.testModbusTCP.WriteMessage("Double", "40007", "1.2");
//this.testModbusTCP.WriteMessage("Long", "40007", "1");
//this.testModbusTCP.WriteMessage("ULong", "40007", "1");
//this.testModbusTCP.WriteMessage("String", "40007", "1");
}
}
}
}
4、ModbusRTUOverTCP（将串口协议封装到TCP中）
库
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using thinger.CommunicationLib;
using thinger.DataConvertLib;
namespace CommunicationLib
{
//将串口协议封装到TCP中
public class TestModbusRTUOverTCP
{
//创建通信对象
private ModbusRTUOverTCP device = null;
//创建连接正常标志位
private bool isConnected = false;
//连接
public void Connect()
{
device = new ModbusRTUOverTCP();
device.DevAddress = Convert.ToByte("1");
device.IsShortAddress = true;
device.DataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), "ABCD");
var result = device.Connect("127.0.0.1", Convert.ToInt32("503"));
if (result)
{
isConnected = true;
CommonMethods.AddLog(0, "设备连接成功");
}
else
{
isConnected = false;
CommonMethods.AddLog(0, "设备连接失败");
}
}
public void DisConneted()
{
if (isConnected)
{
device?.DisConnect();
CommonMethods.AddLog(0, "设备断开连接");
}
else
{
CommonMethods.AddLog(0, "设备未连接");
}
}
/// <summary>
/// 通用验证
/// </summary>
/// <returns></returns>
private bool CommonValidate()
{
if (isConnected == false)
{
CommonMethods.AddLog(1, "设备未连接，请检查");
return false;
}
return true;
}
public void ReadMessage(string dataTypeIn, string adress, ushort length = 1)
{
if (CommonValidate())
{
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
switch (dataType)
{
case DataType.Bool:
//var result1 = device.ReadBoolArray(this.txt_Variable.Text, Convert.ToUInt16(this.txt_Count.Text));
//if (result1.IsSuccess)
//{
// CommonMethods.AddLog(this.lst_Info, 0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
//}
//else
//{
// CommonMethods.AddLog(this.lst_Info, 1, "读取失败:" + result1.Message);
//}
var result1 = device.ReadCommon<bool[]>(adress, length);
if (result1.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result1.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result1.Message);
}
break;
case DataType.Byte:
case DataType.SByte:
var result2 = device.ReadCommon<byte[]>(adress);
if (result2.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result2.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result2.Message);
}
break;
case DataType.Short:
var result3 = device.ReadCommon<short[]>(adress);
if (result3.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result3.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result3.Message);
}
break;
case DataType.UShort:
var result4 = device.ReadCommon<ushort[]>(adress);
if (result4.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result4.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result4.Message);
}
break;
case DataType.Int:
var result5 = device.ReadCommon<int[]>(adress);
if (result5.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result5.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result5.Message);
}
break;
case DataType.UInt:
var result6 = device.ReadCommon<uint[]>(adress);
if (result6.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result6.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result6.Message);
}
break;
case DataType.Float:
var result7 = device.ReadCommon<float[]>(adress);
if (result7.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result7.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result7.Message);
}
break;
case DataType.Double:
var result8 = device.ReadCommon<float[]>(adress);
if (result8.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result8.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result8.Message);
}
break;
case DataType.Long:
var result9 = device.ReadCommon<long[]>(adress);
if (result9.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result9.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result9.Message);
}
break;
case DataType.ULong:
var result10 = device.ReadCommon<ulong[]>(adress);
if (result10.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + StringLib.GetStringFromValueArray(result10.Content));
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result10.Message);
}
break;
case DataType.String:
var result11 = device.ReadCommon<string>(adress);
if (result11.IsSuccess)
{
CommonMethods.AddLog(0, "读取成功:" + result11.Content);
}
else
{
CommonMethods.AddLog(1, "读取失败:" + result11.Message);
}
break;
default:
CommonMethods.AddLog(1, "读取失败:不支持的数据类型");
break;
}
}
}
public void WriteMessage(string dataTypeIn, string adress, string content)
{
if (CommonValidate())
{
DataType dataType = (DataType)Enum.Parse(typeof(DataType), dataTypeIn);
var result = OperateResult.CreateFailResult();
switch (dataType)
{
case DataType.Bool:
result = device.WriteCommon(adress, BitLib.GetBitArrayFromBitArrayString(content));
break;
case DataType.Byte:
case DataType.SByte:
result = device.WriteCommon(adress, ByteArrayLib.GetByteArrayFromHexString(content));
break;
case DataType.Short:
result = device.WriteCommon(adress, ShortLib.GetShortArrayFromString(content));
break;
case DataType.UShort:
result = device.WriteCommon(adress, UShortLib.GetUShortArrayFromString(content));
break;
case DataType.Int:
result = device.WriteCommon(adress, IntLib.GetIntArrayFromString(content));
break;
case DataType.UInt:
result = device.WriteCommon(adress, UIntLib.GetUIntArrayFromString(content));
break;
case DataType.Float:
result = device.WriteCommon(adress, FloatLib.GetFloatArrayFromString(content));
break;
case DataType.Double:
result = device.WriteCommon(adress, DoubleLib.GetDoubleArrayFromString(content));
break;
case DataType.Long:
result = device.WriteCommon(adress, LongLib.GetLongArrayFromString(content));
break;
case DataType.ULong:
result = device.WriteCommon(adress, ULongLib.GetULongArrayFromString(content));
break;
case DataType.String:
result = device.WriteCommon(adress, content);
break;
default:
break;
}
if (result.IsSuccess)
{
CommonMethods.AddLog(0, "写入成功");
}
else
{
CommonMethods.AddLog(0, "写入失败");
}
}
}
}
}
测试代码
using System.Windows;
using ToolsLib;
using System.Data;
using System.Diagnostics;
using Org.BouncyCastle.Utilities;
using MySql.Data.MySqlClient;
using Microsoft.Data.SqlClient;
using CommunicationLib;
using NPOI.SS.Formula.Functions;
namespace WpfApp1
{
public partial class MainWindow : Window
{
private TestModbusRTUOverTCP testModbusRTUOverTCP = null;
public MainWindow()
{
InitializeComponent();
}
//连接
private void Button_Click1(object sender, RoutedEventArgs e)
{
//连接测试
this.testModbusRTUOverTCP = new TestModbusRTUOverTCP();
this.testModbusRTUOverTCP.Connect();
}
//断开连接
private void Button_Click2(object sender, RoutedEventArgs e)
{
if (testModbusRTUOverTCP != null)
{
testModbusRTUOverTCP.DisConneted();
}
}
//其他测试方法
private void Button_Click3(object sender, RoutedEventArgs e)
{
//Test001();
//Test002();
//Test003();
//Test004();
//Test005();
Test006();
}
//读取 0区
private void Test001()
{
//读取一位
//TestSiemens.Conn
if (testModbusRTUOverTCP != null)
{
this.testModbusRTUOverTCP.ReadMessage("Bool","00001");
this.testModbusRTUOverTCP.ReadMessage("Bool","00001",3);
}
}
//读取 1区
private void Test002()
{
//读取一位
//TestSiemens.Conn
if (testModbusRTUOverTCP != null)
{
this.testModbusRTUOverTCP.ReadMessage("Bool", "10001");
this.testModbusRTUOverTCP.ReadMessage("Bool", "10001", 3);
}
}
//读取 3区
private void Test003()
{
//读取一位
//TestSiemens.Conn
if (testModbusRTUOverTCP != null)
{
this.testModbusRTUOverTCP.ReadMessage("Byte", "30001",1);
this.testModbusRTUOverTCP.ReadMessage("SByte", "30002",2);
this.testModbusRTUOverTCP.ReadMessage("Short", "30001",2);
this.testModbusRTUOverTCP.ReadMessage("UShort","30004");
this.testModbusRTUOverTCP.ReadMessage("Int", "30005");
this.testModbusRTUOverTCP.ReadMessage("UInt", "30006");
this.testModbusRTUOverTCP.ReadMessage("Float", "30007");
this.testModbusRTUOverTCP.ReadMessage("Double","30008");
this.testModbusRTUOverTCP.ReadMessage("Long", "30009");
this.testModbusRTUOverTCP.ReadMessage("ULong", "30010");
this.testModbusRTUOverTCP.ReadMessage("String","30011");
}
}
//读取 4区
private void Test004()
{
//读取一位
//TestSiemens.Conn
if (testModbusRTUOverTCP != null)
{
this.testModbusRTUOverTCP.ReadMessage("Byte", "40001");
this.testModbusRTUOverTCP.ReadMessage("SByte", "40002");
this.testModbusRTUOverTCP.ReadMessage("Short", "40003");
this.testModbusRTUOverTCP.ReadMessage("UShort","40004");
this.testModbusRTUOverTCP.ReadMessage("Int", "40005");
this.testModbusRTUOverTCP.ReadMessage("UInt", "40006");
this.testModbusRTUOverTCP.ReadMessage("Float", "40007");
this.testModbusRTUOverTCP.ReadMessage("Double","40008");
this.testModbusRTUOverTCP.ReadMessage("Long", "40009");
this.testModbusRTUOverTCP.ReadMessage("ULong", "40010");
this.testModbusRTUOverTCP.ReadMessage("String","40011");
}
}
//写入 1区
private void Test005()
{
//读取一位
//TestSiemens.Conn
if (testModbusRTUOverTCP != null)
{
this.testModbusRTUOverTCP.WriteMessage("Bool", "00001", "1");
}
}
//写入 4区
private void Test006()
{
//读取一位
//TestSiemens.Conn
if (testModbusRTUOverTCP != null)
{
this.testModbusRTUOverTCP.WriteMessage("Short", "40001", "100");
this.testModbusRTUOverTCP.WriteMessage("UShort", "40002", "102");
//this.testModbusRTUOverTCP.WriteMessage("Int", "40007", "10");
//this.testModbusRTUOverTCP.WriteMessage("UInt", "40007", "11");
//this.testModbusRTUOverTCP.WriteMessage("Float", "40007", "1.1");
this.testModbusRTUOverTCP.WriteMessage("Double", "40007", "1.2");
//this.testModbusRTUOverTCP.WriteMessage("Long", "40007", "1");
//this.testModbusRTUOverTCP.WriteMessage("ULong", "40007", "1");
//this.testModbusRTUOverTCP.WriteMessage("String", "40007", "1");
}
}
}
}
5、西门子PLC的通信
1、西门子PLC的类型：
2、西门子的存储区
3、西门子PLC 中使用的数据类型：
4、西门子 PLC 仿真
5、S7通信的过程：
1、三次握手
2、两次确认
3、实时通信
4、四次挥手
6、S7netplus的使用：
1、安装库：
2、测试代码：
using S7.Net;
using S7.Net.Types;
using System.Diagnostics;
namespace Siemens1
{
public class SiemensHelper
{
static public void Test000()
{
Plc plc = new Plc(CpuType.S71200, "192.168.37.100", 0, 1);
Debug.WriteLine("连接前："+plc.IsConnected);
try
{
plc.Open();
Debug.WriteLine("连接后：" + plc.IsConnected);
}
catch (Exception ex)
{
}
}
//读取数据
static public void Test001()
{
// 创建PLC对象
Plc plc = new Plc(CpuType.S71200, "192.168.37.100", 0, 1);
try
{
plc.Open();
// 读取DB1.DBX0.0这个位数据
bool value = (bool)plc.Read("DB1.DBX0.0");
//bool value = (bool)plc.Read("M0.0");
//var b1 = await plc.ReadAsync("db2.dbx0.0");
Debug.WriteLine($"value:{value}");
plc.Close();
}
catch (Exception ex)
{
// 处理异常
}
}
//读取多个数据
static public void Test002()
{
// 创建PLC对象
Plc plc = new Plc(CpuType.S71200, "192.168.37.100", 0, 1);
try
{
plc.Open();
List<DataItem> dataItems = new List<DataItem>();
DataItem DI00 = new DataItem()
{
DataType = DataType.DataBlock,
DB = 1,
VarType = VarType.Real,
StartByteAdr = 0,
Count = 1,
Value = new Object()
};
// 添加更多DataItem...
// ...
dataItems.Add(DI00);
// 添加其他DataItem...
plc.ReadMultipleVars(dataItems);
Debug.WriteLine($"value:{dataItems[0].Value}");
plc.Close();
}
catch (Exception ex)
{
// 处理异常
}
}
//池 的设计模式：
//class DataItemPool
//{
// private List<DataItem> pool;
// public DataItemPool(int initialSize)
// {
// pool = new List<DataItem>();
// for (int i = 0; i < initialSize; i++)
// {
// DataItem item = new DataItem();
// pool.Add(item);
// }
// }
// public DataItem GetDataItem()
// {
// if (pool.Count > 0)
// {
// DataItem item = pool[0];
// pool.RemoveAt(0);
// return item;
// }
// else
// {
// return new DataItem();
// }
// }
// public void ReleaseDataItem(DataItem item)
// {
// item.Clear(); // 假设DataItem类有一个方法来重置其属性
// pool.Add(item);
// }
//}
//写入数据
static public void Test003()
{
// 创建PLC对象
Plc plc = new Plc(CpuType.S71200, "192.168.37.100", 0, 1);
try
{
plc.Open();
//plc.Write("MB0", 31);
// 写入 DB1.DBW16 这个位数据
plc.Write("DB1.DBD0", 888.3f);
//异步的写入
//plc.WriteAsync(DataType.DataBlock, 2, 0, true);
//多个值的写入
//WriteMultipleVars
//Debug.WriteLine($"value:{value}");
plc.Close();
}
catch (Exception ex)
{
// 处理异常
}
}
}
}
7、NModbus4的使用：
添加引用：
各区的范围：
一个区 一万个地址
功能码：
0x01: 读线圈状态
0x02: 读离散输入状态
0x03: 读保持寄存器
0x04: 读输入寄存器
0x05: 写单个线圈
0x06: 写单个保持寄存器
0x0F: 写多个线圈
0x10: 写多个保持寄存器
测试代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Xml.Serialization;
using System.IO.Ports;
using Modbus;
using System.IO;
using Modbus.Device;
namespace WindowsFormsApp1
{
class TestModbus
{
byte slaveAddress = 10;
//0x01 功能码
//
public void TestModbusTCP_001()
{
// 创建TCP客户端并连接
TcpClient tcpClient = new TcpClient("127.0.0.1", 503); // PLC的IP和端口
ModbusIpMaster master = ModbusIpMaster.CreateIp(tcpClient); // 创建主站实例[3]()
//读取线圈状态（功能码 0x01）
//bool[] coilds = master.ReadCoils(slaveAddress, 0, 10);
//读取离散输入状态（功能码 0x02）
//bool[] inputs = master.ReadInputs(slaveAddress, 0, 10);
// 读取保持寄存器（功能码 0x03）
//ushort[] registers = master.ReadHoldingRegisters(slaveAddress, 0, 10); // 起始地址0，读取10个寄存器
//读取输入寄存器（功能码 0x04）
//ushort[] InputRegisters = master.ReadInputRegisters(slaveAddress, 0, 10);
//写单个线圈（功能码 0x05）
//master.WriteSingleCoil(slaveAddress, 0, true);
// 写入单个保持寄存器（功能码 0x06）
//master.WriteSingleRegister(slaveAddress,5, 12345); // 地址5写入值12345
//写多个线圈（功能码 0x0F）
//bool[] Colilss = new bool[] { true, false, true, false, true, false, true, false, true, false };
//master.WriteMultipleCoils(slaveAddress, 0, Colilss);
//写多个保持寄存器（功能码 0x10）
ushort[] Registerss = new ushort[] { 1,2,3,4,5,6,7,8,9,999 };
master.WriteMultipleRegisters(slaveAddress, 0, Registerss);
// 释放资源
master.Dispose();
tcpClient.Close();
}
public void TestModbusRTU_Test001()
{
var serialPort = new SerialPort("COM8", 9600, Parity.None, 8, StopBits.One);
try
{
serialPort.Open();
IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(serialPort);
//读取线圈状态（功能码 0x01）
//bool[] coilds = master.ReadCoils(slaveAddress, 0, 10);
//读取离散输入状态（功能码 0x02）
//bool[] inputs = master.ReadInputs(slaveAddress, 0, 10);
// 读取保持寄存器（功能码 0x03）
//ushort[] registers = master.ReadHoldingRegisters(slaveAddress, 0, 10); // 起始地址0，读取10个寄存器
//读取输入寄存器（功能码 0x04）
//ushort[] InputRegisters = master.ReadInputRegisters(slaveAddress, 0, 10);
//写单个线圈（功能码 0x05）
//master.WriteSingleCoil(slaveAddress, 0, true);
// 写入单个保持寄存器（功能码 0x06）
//master.WriteSingleRegister(slaveAddress,5, 12345); // 地址5写入值12345
//写多个线圈（功能码 0x0F）
//bool[] Colilss = new bool[] { true, false, true, false, true, false, true, false, true, false };
//master.WriteMultipleCoils(slaveAddress, 0, Colilss);
//写多个保持寄存器（功能码 0x10）
ushort[] Registerss = new ushort[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 999 };
master.WriteMultipleRegisters(slaveAddress, 0, Registerss);
}
catch (Exception ex)
{
Console.WriteLine($"错误：{ex.Message}");
}
finally
{
serialPort.Close();
}
}
}
}