1. 新增创建单例接口方法，为了在反射或获取参数的情况下使用所有功能

README.md

@@ -82,6 +82,42 @@ namespace YSAI.Core.@interface
 3.应用代码如下
 4.协议包内还有内部公共方法，请自行研究使用
 
+
+------------------------------------------------------
+实例创建的几种方式
+
+//第一种方式
+BeckhoffOperate beckhoffOperate1 = new BeckhoffOperate();
+//第二种方式（单例模式）
+BeckhoffOperate? beckhoffOperate2 = new BeckhoffOperate().CreateInstance(new BeckhoffData.Basics()).GetRData<BeckhoffOperate>();
+//第三种方式（单例模式）
+BeckhoffOperate beckhoffOperate3 = BeckhoffOperate.Instance(new BeckhoffData.Basics());
+//第四种方式
+using (BeckhoffOperate beckhoffOperate4 = new BeckhoffOperate())
+{
+    //使用完直接释放
+}
+//第五种方式
+using (BeckhoffOperate beckhoffOperate5 = BeckhoffOperate.Instance(new BeckhoffData.Basics()))
+{
+    //使用完直接释放这个单例
+}
+//第六种方式
+using (BeckhoffOperate? beckhoffOperate6 = new BeckhoffOperate().CreateInstance(new BeckhoffData.Basics()).GetRData<BeckhoffOperate>())
+{
+    //使用完直接释放这个单例
+}
+
+//第一种的应用场景是获取库参数信息时当这个对象已经实例化了，但是实际功能无法使用，就可以直接使用 CreateInstance 创建一个单例模式
+//先获取参数
+beckhoffOperate1.GetParam();
+//在生成单例后赋值
+beckhoffOperate1 = beckhoffOperate1.CreateInstance(new BeckhoffData.Basics()).GetRData<BeckhoffOperate>();
+//这样当前实例就已经可以使用所有功能，并且是单例的存在
+
+//第二种与第三种就是直接创建单例模式，但第二种是为了在反射的情况下使用单例模式，第二种也是为第一种情况而产生
+
+
 ------------------------------------------------------
 
 //采集协议
@@ -359,4 +395,7 @@ while(true)
 3. 移除单独生成库配置文件
 4. 细节优化
 5. 新增结构参数类
-6. 版本更新
+6. 版本更新
+
+#### 2023-11-02
+1. 新增创建单例接口方法，为了在反射或获取参数的情况下使用所有功能

src/YSAI.DAQ/YSAI.Beckhoff/BeckhoffOperate.cs

@@ -841,5 +841,31 @@ namespace YSAI.Beckhoff
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(BeckhoffData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as BeckhoffData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Can/CanOperate.cs

@@ -578,5 +578,31 @@ namespace YSAI.Can
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(CanData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as CanData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Core/YSAI.Core.csproj

@@ -5,7 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <Version>1.0.0.78</Version>
+    <Version>1.0.0.79</Version>
     <Authors>Shun</Authors>
     <Company>YSAI</Company>
     <Product>SCADA</Product>

src/YSAI.DAQ/YSAI.Core/interface/ICreateInstance.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using YSAI.Core.data;
+
+namespace YSAI.Core.@interface
+{
+    /// <summary>
+    /// 创建实例接口（单例模式）
+    /// </summary>
+    public interface ICreateInstance
+    {
+        /// <summary>
+        /// 创建一个实例
+        /// </summary>
+        /// <typeparam name="T">泛型基础数据</typeparam>
+        /// <param name="Basics">基础数据</param>
+        /// <returns>统一返回包含自身单例对象</returns>
+        OperateResult CreateInstance<T>(T Basics);
+
+        /// <summary>
+        /// 创建一个实例
+        /// </summary>
+        /// <typeparam name="T">泛型基础数据</typeparam>
+        /// <param name="Basics">基础数据</param>
+        /// <returns>统一返回包含自身单例对象</returns>
+        Task<OperateResult> CreateInstanceAsync<T>(T Basics);
+    }
+}

src/YSAI.DAQ/YSAI.Core/interface/IDaq.cs

@@ -5,6 +5,6 @@ namespace YSAI.Core.@interface
     /// <summary>
     /// 数采接口
     /// </summary>
-    public interface IDaq : IOn, IOff, IRead, IWrite, ISubscribe, IGetStatus, IEvent, IGetParam, IDisposable
+    public interface IDaq : IOn, IOff, IRead, IWrite, ISubscribe, IGetStatus, IEvent, IGetParam, ICreateInstance, IDisposable
     { }
 }

src/YSAI.DAQ/YSAI.Core/interface/IRelay.cs

@@ -5,6 +5,6 @@ namespace YSAI.Core.@interface
     /// <summary>
     /// 转发接口
     /// </summary>
-    public interface IRelay : IOn, IOff, IProducer, IConsumer, IGetStatus, IEvent, IGetParam, IDisposable
+    public interface IRelay : IOn, IOff, IProducer, IConsumer, IGetStatus, IEvent, IGetParam, ICreateInstance, IDisposable
     { }
 }

src/YSAI.DAQ/YSAI.DB/DBOperate.cs

@@ -956,5 +956,31 @@ namespace YSAI.DB
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(DBData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as DBData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Kafka/KafkaOperate.cs

@@ -633,5 +633,31 @@ namespace YSAI.Kafka
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(KafkaData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as KafkaData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Modbus/ModbusOperate.cs

@@ -2339,5 +2339,31 @@ namespace YSAI.Modbus
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(ModbusData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as ModbusData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Mqtt/client/MqttClientOperate.cs

@@ -521,5 +521,31 @@ namespace YSAI.Mqtt.client
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(MqttClientData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as MqttClientData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Netty/client/NettyClientOperate.cs

@@ -623,5 +623,31 @@ namespace YSAI.Netty.client
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(NettyClientData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as NettyClientData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Opc/YSAI.Opc.csproj

@@ -5,7 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 	  <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-	  <Version>1.0.0.41</Version>
+	  <Version>1.0.0.42</Version>
 	  <Authors>Shun</Authors>
 	  <Company>YSAI</Company>
 	  <Product>SCADA</Product>

src/YSAI.DAQ/YSAI.Opc/da/client/OpcDaClientOperate.cs

@@ -1154,5 +1154,31 @@ namespace YSAI.Opc.da.client
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(OpcDaClientData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as OpcDaClientData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Opc/da/http/OpcDaHttpOperate.cs

@@ -643,5 +643,31 @@ namespace YSAI.Opc.da.http
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(OpcDaHttpData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as OpcDaHttpData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Opc/ua/client/OpcUaClientData.cs

@@ -102,14 +102,14 @@ namespace YSAI.Opc.ua.client
             /// </summary>
             [Description("寿命计数")]
             [Display(true, true, true, Core.data.ParamStructure.dataCate.unmber)]
-            public int LifetimeCount { get; set; } = byte.MaxValue * 1024 * 3;
+            public int LifetimeCount { get; set; } = (byte.MaxValue * 1024) * 3;
 
             /// <summary>
             /// 队列大小
             /// </summary>
             [Description("队列大小")]
             [Display(true, true, true, Core.data.ParamStructure.dataCate.unmber)]
-            public int QueueSize { get; set; } = 1024 * 64;
+            public int QueueSize { get; set; } = byte.MaxValue * 4;
 
             /// <summary>
             /// 订阅单组最大数，

src/YSAI.DAQ/YSAI.Opc/ua/client/OpcUaClientOperate.cs

@@ -1973,5 +1973,31 @@ namespace YSAI.Opc.ua.client
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(OpcUaClientData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as OpcUaClientData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.RabbitMQ/RabbitMQOperate.cs

@@ -596,5 +596,31 @@ namespace YSAI.RabbitMQ
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(RabbitMQData.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as RabbitMQData.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.S7/S7Operate.cs

@@ -601,5 +601,31 @@ namespace YSAI.S7
         {
             return Task.Run(() => GetParam());
         }
+
+        public OperateResult CreateInstance<T>(T Basics)
+        {
+            string SN = Depart("CreateInstance");
+            try
+            {
+                //先判断对象类型是否一致
+                if (typeof(T).FullName.Equals(typeof(S7Data.Basics).FullName))
+                {
+                    return Break(SN, true, RData: Instance(Basics as S7Data.Basics));
+                }
+                else
+                {
+                    return Break(SN, false, "对象类型错误，无法创建实例");
+                }
+            }
+            catch (Exception ex)
+            {
+                return Break(SN, false, ex.Message, Exception: ex);
+            }
+        }
+
+        public Task<OperateResult> CreateInstanceAsync<T>(T Basics)
+        {
+            return Task.Run(() => CreateInstance(Basics));
+        }
     }
 }

src/YSAI.DAQ/YSAI.Test.All/Program.cs

@@ -1,4 +1,36 @@
-Console.WriteLine();
+using YSAI.Beckhoff;
+
+//第一种方式
+BeckhoffOperate beckhoffOperate1 = new BeckhoffOperate();
+//第二种方式（单例模式）
+BeckhoffOperate? beckhoffOperate2 = new BeckhoffOperate().CreateInstance(new BeckhoffData.Basics()).GetRData<BeckhoffOperate>();
+//第三种方式（单例模式）
+BeckhoffOperate beckhoffOperate3 = BeckhoffOperate.Instance(new BeckhoffData.Basics());
+//第四种方式
+using (BeckhoffOperate beckhoffOperate4 = new BeckhoffOperate())
+{
+    //使用完直接释放
+}
+//第五种方式
+using (BeckhoffOperate beckhoffOperate5 = BeckhoffOperate.Instance(new BeckhoffData.Basics()))
+{
+    //使用完直接释放这个单例
+}
+//第六种方式
+using (BeckhoffOperate? beckhoffOperate6 = new BeckhoffOperate().CreateInstance(new BeckhoffData.Basics()).GetRData<BeckhoffOperate>())
+{
+    //使用完直接释放这个单例
+}
+
+//第一种的应用场景是获取库参数信息时当这个对象已经实例化了，但是实际功能无法使用，就可以直接使用 CreateInstance 创建一个单例模式
+//先获取参数
+beckhoffOperate1.GetParam();
+//在生成单例后赋值，这样当前实例就已经可以使用所有功能，并且是单例的存在
+beckhoffOperate1 = beckhoffOperate1.CreateInstance(new BeckhoffData.Basics()).GetRData<BeckhoffOperate>();
+
+//第二种与第三种就是直接创建单例模式，但第二种是为了在反射的情况下使用单例模式，第二种也是为第一种情况而产生
+
+Console.WriteLine();
 //using YSAI.Beckhoff;
 //using YSAI.Core.data;
 //using YSAI.Log;