初始化提交

JinYuan.VirtualDataLibrary/CommonMethods.cs

@@ -0,0 +1,723 @@
+using JinYuan.DAL;
+using JinYuan.Models;
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using System.IO;
+using System.Threading;
+using JinYuan.Helper;
+using JinYuan.MES;
+using PLC;
+using PLC.PLCAlarm;
+using System.Xml.Linq;
+using JinYuan.MES.Models;
+using PLCCommunication.Modbus;
+using System.Collections.Concurrent;
+
+namespace JinYuan.VirtualDataLibrary
+{
+    public class CommonMethods
+    {
+        /// <summary>
+        /// 本地数据库
+        /// </summary>
+        public static ISugarHepler db = new SQLSugarService();
+        /// <summary>
+        /// 远程服务段数据库
+        /// </summary>
+        public static ISugarHepler dbServer = new SQLSugarService();
+        /// <summary>
+        /// 远程服务段数据库2
+        /// </summary>
+        public static ISugarHepler dbServer2 = new SQLSugarService();
+        /// <summary>
+        /// 全局的PLC链接
+        /// </summary>
+        public static List<PlcReadWriteBase> plcDevices;
+        /// <summary>
+        /// plc状态
+        /// </summary>
+        public static readonly Dictionary<PlcReadWriteBase, Dictionary<string, object>> plcStatuses = new Dictionary<PlcReadWriteBase, Dictionary<string, object>>();
+        /// <summary>
+        /// 报警
+        /// </summary>
+        public static AlarmManager alarmManager = new AlarmManager();
+        /// <summary>
+        /// MES接口
+        /// </summary>
+        public static IMes hbgMes = new MesDataProcess();
+        /// <summary>
+        /// 参数
+        /// </summary>
+        public static ProductModelParam parRange = new ProductModelParam();
+        /// <summary>
+        /// 全局钩子
+        /// </summary>
+        public static ScanerHook listener = new ScanerHook();
+
+        /// <summary>
+        /// 创建个全局焊接功率队列数据存储
+        /// </summary>
+        public static List<Queue<double>> QWeldingPowerData = new List<Queue<double>>();
+
+        /// <summary>
+        /// 创建个全局入壳推力队列数据存储
+        /// </summary>
+        public static List<Queue<double>> QPlanenessData = new List<Queue<double>>();
+
+        /// <summary>
+        /// 创建全局的登录对象
+        /// </summary>
+        public static SysAdmin currentAdmin = null;
+        /// <summary>
+        /// 登录是否成功
+        /// </summary>
+        public static bool IsLoginOk = false;
+
+        //创建一个全局的配置对象
+        public static SysConfig sysConfig = new SysConfig();
+
+
+
+
+        public static int InvadTime;
+
+        /// <summary>
+        /// 智能电表
+        /// </summary>
+        public static List<ElectricEnergy> listElectricEnergy = new List<ElectricEnergy>();
+
+        /// <summary>
+        /// 电能表
+        /// </summary>
+        public static EnergyMeterHelper energyMeter = new EnergyMeterHelper();
+
+        /// <summary>
+        ///是否开启刷新
+        /// </summary>
+        public static bool isRefreshTimerWeeding = false;
+
+        /// <summary>
+        /// SQL语句
+        /// </summary>
+        public static DBSQL dBSQL { get; } = new DBSQL();
+
+        public static M_DBCtrl m_DBCtrl { get; } = new M_DBCtrl();
+
+        /// <summary>
+        /// MES配置文件类
+        /// </summary>
+        public static MesConfig mesConfig = new MesConfig();
+
+        ///创建一个全局的连接状态
+        public static bool connectState = false;
+
+        /// <summary>
+        /// 滴答次数
+        /// </summary>
+        public static int tickCount = 0;
+        /// <summary>
+        /// QIEHUAN
+        /// </summary>
+        public static int tickHomeCount = 0;
+        /// <summary>
+        /// 报警信息
+        /// </summary>
+        public static string SlideAlarmText = "当前无报警";
+        /// <summary>
+        /// 退出
+        /// </summary>
+        public static bool IsExit = false;
+        /// <summary>
+        /// 是否登出账户
+        /// </summary>
+        public static bool LoginOut = false;
+        /// <summary>
+        /// 是否上传MES
+        /// </summary>
+        public static bool IsUpMes { get; set; }
+        /// <summary>
+        /// 是否运行
+        /// </summary>
+        public static bool IsRun { get; set; } = false;
+        /// <summary>
+        /// 上一次设备状态
+        /// </summary>
+        public static int DeviceStatus = 0;
+        /// <summary>
+        /// 上一次Guid
+        /// </summary>
+        public static string DeviceGuid = "";
+        /// <summary>
+        ///第一次读取
+        /// </summary>
+        public static bool IsFirst = false;
+        /// <summary>
+        /// 焊接功率波形图显示条数
+        /// </summary>
+        public static int ChatLineCount = 3;
+        /// <summary>
+        /// 员工号
+        /// </summary>
+        public static string strWorker { get; set; }
+        /// <summary>
+        /// 是否开启智能电表
+        /// </summary>
+        public static bool IsStartZNDB { get; set; } = false;
+        /// <summary>
+        /// 白夜班
+        /// </summary>
+        public static string strClass { get; set; } = "白班";
+        /// <summary>
+        /// 时间变更
+        /// </summary>
+        public static string ChangeClassTime { get; set; } = "20:30:00";
+
+        /// <summary>
+        /// 设备状态
+        /// </summary>
+        public static List<bool> Statues { get; set; }
+
+        /// <summary>
+        /// 服务器链接状态
+        /// </summary>
+        public static bool EMCStatues { get; set; }
+
+        #region  小时产能
+        /// <summary>
+        /// 上个时间点的总数
+        /// </summary>
+        public static int LastTotalNum { get; set; } = 0;
+        /// <summary>
+        /// 上个时间点良品数
+        /// </summary>
+        public static int LastOkNum { get; set; } = 0;
+        /// <summary>
+        /// 上一次重置计数的时间
+        /// </summary>
+        public static string LastResetTime { get; set; }
+        /// <summary>
+        ///  上一次的小时
+        /// </summary>
+        public static int LastHour { get; set; }
+        #endregion
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public static List<Group> ListOmronGroups { get; set; }
+
+        /// <summary>
+        /// 12小时产能
+        /// </summary>
+        public static List<Chart12HourData> Lst_Prod12HourData = new List<Chart12HourData>();
+        /// <summary>
+        /// 不良选项(检测项不良)
+        /// </summary>
+        public static List<ChartDataType> Lst_DefectTypeQty = new List<ChartDataType>();
+
+        /// <summary>
+        /// PLC报警前10项
+        /// </summary>
+        public static List<ChartDataType> Lst_AlarmTop10_Qty = new List<ChartDataType>();
+        /// <summary>
+        /// 参数项设置
+        /// </summary>
+        public static List<ParamList> paramlists { get; set; }
+
+        /// <summary>
+        /// 线程控制
+        /// </summary>
+        public static ManualResetEvent ResetEventRecv = new ManualResetEvent(true);
+
+        /// <summary>
+        /// 电表连接
+        /// </summary>
+        public static List<ModbusRtu> EM_modbusRtus = new List<ModbusRtu>();
+        /// <summary>
+        /// 电表连接结果
+        /// </summary>
+        public static List<bool> EM_ComResult = new List<bool>();
+
+        #region 计数项
+        /// <summary>
+        /// 生产总数
+        /// </summary>
+        public static int TotalQty = 0;
+
+        public static int ProOKQty = 0;
+
+        public static int Ppm = 0;
+
+        public static double JiaDL = 0.0;
+
+        public static List<float> AntiDustAirSpeed = new List<float>();
+        /// <summary>
+        /// PLC开机/运行时间
+        /// </summary>
+        public static List<int> PlcOpenAndRunTime = new List<int>();
+        /// <summary>
+        ///  PLC开机/运行时间地址
+        /// </summary>
+        public static List<string> PlcOpenAndRunTimeAdress = new List<string> { "D50", "D52", "D54", "D56", "D58", "D60" };
+        public static int ProdGaoRFIDNgQty = 0;//高托杯 绑定卷心码
+        public static int ProdDiRFIDNgQty = 0;//低托杯 绑定钢壳码
+
+        public static int ProdGangKeRFIDNgQty = 0;//钢壳托杯 绑定出站钢壳码
+        public static int ProdJuanBarNgQty = 0;
+        public static int ProdGangKeBarNgQty = 0;
+
+        public static int ProdRuKeTuiliNgQty = 0;
+        public static int ProdCCDNgQty = 0;
+        public static int ProdMesOutNGQty = 0;
+        #endregion
+
+        #region 配置信息
+        public static string devPath = Application.StartupPath + "\\Config\\Device.ini";
+        public static string groupPath = Application.StartupPath + "\\Config\\Group.xlsx";
+        public static string variablePath = Application.StartupPath + "\\Config\\Variable.xlsx";
+        public static string settingPath = Application.StartupPath + "\\Config\\settings.json";
+
+
+        /// <summary>
+        /// 错误日志路径
+        /// </summary>
+       // public static string strErrorLogspath = System.Windows.Forms.Application.StartupPath + "\\Logs\\ErrorLogs";
+        public static string strErrorLogspath = @"D:\Logs\ErrorLogs";
+       // public static string strSystemLogspath = System.Windows.Forms.Application.StartupPath + "\\Logs\\SystemLogs";
+        public static string strSystemLogspath = @"D:\Logs\SystemLogs";
+        //public static string strAlarmLogspath = System.Windows.Forms.Application.StartupPath + "\\Logs\\AlarmLogs";
+        public static string strAlarmLogspath = @"D:\Logs\AlarmLogs";
+
+        public static string strsqlLogspath = "";
+        /// <summary>
+        /// 删除路径
+        /// </summary>
+        public static string strDeletepath = "";
+        /// <summary>
+        /// 能耗保存路径
+        /// </summary>
+        public static string strWattrMeterpath = System.Windows.Forms.Application.StartupPath + "\\智能电表数据";
+        /// <summary>
+        /// MES路径日志
+        /// </summary>
+        public static string strMesLogspath = System.Windows.Forms.Application.StartupPath + "\\Logs\\MesLogs";
+        /// <summary>
+        /// 设备状态信息路径
+        /// </summary>
+        public static string strDeviceStatusPath = System.Windows.Forms.Application.StartupPath + "\\Config\\DeviceStatus.cfg";
+
+
+        /// <summary>
+        /// PLC读取寄存器配置文件路径
+        /// </summary>
+        public static string ConfigPath = Path.Combine(System.Windows.Forms.Application.StartupPath, "ini\\PlcConfig.ini");
+        /// <summary>
+        /// 系统程序配置文件路径
+        /// </summary>
+        //public static string iniFilePath = Path.Combine(System.Windows.Forms.Application.StartupPath, "ini\\Configure.ini");
+
+        public static string xmlFilePath = Path.Combine(System.Windows.Forms.Application.StartupPath, "Config\\Configure.xml");
+        /// <summary>
+        /// 配置文件字典
+        /// </summary>
+        public static Dictionary<string, Dictionary<string, string>> Configxml = new Dictionary<string, Dictionary<string, string>>();
+
+
+        #region 读取配置文件
+
+        // 读取 XML 配置文件
+        public static Dictionary<string, Dictionary<string, string>> ReadXmlConfig(string filePath)
+        {
+            var config = new Dictionary<string, Dictionary<string, string>>();
+            XDocument xmlDoc = XDocument.Load(filePath);
+
+            foreach (var sectionElement in xmlDoc.Root.Elements())
+            {
+                string sectionName = sectionElement.Name.LocalName;
+                config[sectionName] = new Dictionary<string, string>();
+
+                foreach (var keyElement in sectionElement.Elements())
+                {
+                    string key = keyElement.Name.LocalName;
+                    string value = keyElement.Value;
+                    config[sectionName][key] = value;
+                }
+            }
+
+            return config;
+        }
+
+        // 获取配置值
+        public static string GetConfigValue(Dictionary<string, Dictionary<string, string>> config, string section, string key, string defaultValue)
+        {
+            if (config.ContainsKey(section) && config[section].ContainsKey(key))
+            {
+                return config[section][key];
+            }
+            return defaultValue;
+        }
+
+
+        // 写入 XML 文件
+        public static void WriteXmlFile(Dictionary<string, Dictionary<string, string>> config, string filePath)
+        {
+            XDocument xmlDoc = new XDocument(new XElement("Configuration"));
+
+            foreach (var section in config)
+            {
+                var sectionElement = new XElement(section.Key);
+                foreach (var keyValue in section.Value)
+                {
+                    sectionElement.Add(new XElement(keyValue.Key, keyValue.Value));
+                }
+                xmlDoc.Root.Add(sectionElement);
+            }
+            xmlDoc.Save(filePath);
+        }
+
+        /// <summary>
+        /// 单个配置数据保存
+        /// </summary>
+        /// <param name="INFO"></param>
+        /// <param name="Type"></param>
+        /// <param name="value"></param>
+        public static void UpdateConfig(string INFO, string Type, string value)
+        {
+            // 更新 Configxml 中的 SteelshellCount
+            CommonMethods.Configxml[INFO][Type] = value;
+
+            // 将更新后的 Configxml 写入文件
+            CommonMethods.WriteXmlFile(CommonMethods.Configxml, CommonMethods.xmlFilePath);
+        }
+
+
+        /// <summary>
+        ///读取配置文件
+        /// </summary>
+        public static SysConfig GetSysConfig()
+        {
+            try
+            {
+
+                #region 系统配置文件
+                return sysConfig = new SysConfig
+                {
+                    AutoStart = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "AutoStart", "false")),
+                    AutoLogin = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "AutoLogin", "false")),
+                    AutoLock = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "AutoLockScreen", "false")),
+                    LockPeriod = Convert.ToInt32(GetConfigValue(Configxml, "CONFIG_INFO", "LockIntervalTime", "0")),
+                    AutoQieHuanM = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "AutoSwitchMonitor", "false")),
+                    QieHuanMPeriod = Convert.ToInt32(GetConfigValue(Configxml, "CONFIG_INFO", "SwitchMonitorInterval", "0")),
+                    ShowSeriesCount = Convert.ToInt32(GetConfigValue(Configxml, "CONFIG_INFO", "CurveDisplayCount", "0")),
+                    SwipeCardMode = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "EnableCardMode", "false")),
+                    MesModeSwitching = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "MESModeSwitch", "false")),
+                    GetMesParam = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "FetchMESParams", "false")),
+                    SaveThreadTime = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "SaveThreadTimeLog", "false")),
+                    IsDebugMode = Convert.ToBoolean(GetConfigValue(Configxml, "CONFIG_INFO", "IsDebugMode", "false"))
+                };
+                #endregion
+            }
+            catch (Exception)
+            {
+                return sysConfig = null;
+            }
+        }
+
+        /// <summary>
+        /// 获取MES配置文件
+        /// </summary>
+        public static MesConfig GetMesConfig()
+        {
+            try
+            {
+                #region MES配置文件
+                return mesConfig = new MesConfig
+                {
+                    siteCode = GetConfigValue(Configxml, "MES_CONFIG", "SiteCode", "49J"),
+                    lineCode = GetConfigValue(Configxml, "MES_CONFIG", "LineCode", "PW-491"),
+                    equipNum = GetConfigValue(Configxml, "MES_CONFIG", "EquipNum", "491VIM01"),
+                    MESURLAddressIP = GetConfigValue(Configxml, "MES_CONFIG", "MESURLAddressIP", "10.61.135.254"),
+                    MESURLAddressPort = GetConfigValue(Configxml, "MES_CONFIG", "MESURLAddressPort", "80"),
+                    EmployeeAuthCheck = GetConfigValue(Configxml, "MES_CONFIG", "EmployeeAuthCheck", "491VIM01"),
+                    MaterialInputInfo = GetConfigValue(Configxml, "MES_CONFIG", "MaterialInputInfo", "491VIM01"),
+                    DeviceParamRequest = GetConfigValue(Configxml, "MES_CONFIG", "DeviceParamRequest", "491VIM01"),
+                    DeviceParamChange = GetConfigValue(Configxml, "MES_CONFIG", "DeviceParamChange", "491VIM01"),
+                    ProductInStation = GetConfigValue(Configxml, "MES_CONFIG", "ProductInStation", "491VIM01"),
+                    ProductProcessParams = GetConfigValue(Configxml, "MES_CONFIG", "ProductProcessParams", "491VIM01"),
+                    ProductResultParams = GetConfigValue(Configxml, "MES_CONFIG", "ProductResultParams", "491VIM01"),
+                    ProductOutStation = GetConfigValue(Configxml, "MES_CONFIG", "ProductOutStation", "491VIM01"),
+                    DeviceAlarm = GetConfigValue(Configxml, "MES_CONFIG", "DeviceAlarm", "491VIM01"),
+                    DeviceStatus = GetConfigValue(Configxml, "MES_CONFIG", "DeviceStatus", "491VIM01"),
+                    EnergyConsumption = GetConfigValue(Configxml, "MES_CONFIG", "EnergyConsumption", "491VIM01"),
+                    Anemometer = GetConfigValue(Configxml, "MES_CONFIG", "Anemometer", "491VIM01"),
+                };
+
+
+                #endregion
+            }
+            catch (Exception)
+            {
+                return mesConfig = null;
+            }
+        }
+        #endregion
+
+        #region 保存配置文件
+        /// <summary>
+        /// 保存启动自动登录
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveAutoStart(bool value)
+        {
+            Configxml["CONFIG_INFO"]["AutoStart"] = value.ToString(); // 修改自动登录为 True
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+        /// <summary>
+        /// 保存开机自动启动
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveAutoLogin(bool value)
+        {
+            Configxml["CONFIG_INFO"]["AutoLogin"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 保存无操作自动锁屏
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveAutoLock(bool value)
+        {
+            Configxml["CONFIG_INFO"]["AutoLockScreen"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 保存锁屏间隔时间
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveLockPeriod(int value)
+        {
+            Configxml["CONFIG_INFO"]["LockIntervalTime"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+
+        /// <summary>
+        /// 保存无操作自动切换监控界面
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveAutoQieHuanM(bool value)
+        {
+            Configxml["CONFIG_INFO"]["AutoSwitchMonitor"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+
+        /// <summary>
+        /// 保存无操作自动切换监控界面
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveIsDebug(bool value)
+        {
+            Configxml["CONFIG_INFO"]["IsDebugMode"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 保存切换监控界面间隔时间
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveQieHuanMPeriod(int value)
+        {
+            Configxml["CONFIG_INFO"]["SwitchMonitorInterval"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 保存曲线显示数量
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveShowSeriesCount(int value)
+        {
+            Configxml["CONFIG_INFO"]["CurveDisplayCount"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 开启刷卡模式
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveSwipeCardMode(bool value)
+        {
+            Configxml["CONFIG_INFO"]["EnableCardMode"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+        /// <summary>
+        /// MES/非MES模式
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveOpenMesModel(bool value)
+        {
+            Configxml["CONFIG_INFO"]["MESModeSwitch"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 获取MES参数
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveGetMesParam(bool value)
+        {
+            Configxml["CONFIG_INFO"]["FetchMESParams"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+
+        /// <summary>
+        /// 保存线程耗时操作
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static bool SaveSaveThreadTime(bool value)
+        {
+            Configxml["CONFIG_INFO"]["SaveThreadTimeLog"] = value.ToString();
+            WriteXmlFile(Configxml, xmlFilePath);
+            return true;
+        }
+        #endregion
+
+        #endregion
+
+        #region 委托信息
+        //创建委托
+        // 数据监视委托
+        public static Action<int, string> AddDataMonitorDelegate;
+        /// <summary>
+        /// 系统日志
+        /// </summary>
+        public static Action<bool, string> AddLogDelegate;
+        /// <summary>
+        /// 操作日志
+        /// </summary>
+        public static Action<bool, string> AddOPLogDelegate;
+        /// <summary>
+        /// 报警日志
+        /// </summary>
+        public static Action<SysLog> AddAlarmDelegate;
+        /// <summary>
+        /// 参数更新
+        /// </summary>
+        public static Action ChangeParamDelegate;
+        /// <summary>
+        /// 
+        /// </summary>
+        public static Action<bool> AddHomeDelegate;
+
+        /// <summary>
+        /// 显示上料信息
+        /// </summary>
+        public static Action<List<AGearEntity>> ShowFeedingDelegate;
+        /// <summary>
+        /// 显示钢壳信息
+        /// </summary>
+        public static Action<List<CGearEntity>> ShowSteelShellDelegate;
+        /// <summary>
+        /// 显示下料数据
+        /// </summary>
+        public static Action<List<BGearEntity>> ShowBlankingDelegate;
+        /// <summary>
+        /// 显示结构件料盘信息
+        /// </summary>
+        public static Action<List<DGearEntity>> ShowMaterialDelegate;
+        /// <summary>
+        /// 数据监视委托
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="info"></param>
+        public static void AddDataMonitorLog(int type, string info)
+        {
+            //调用委托
+            if (AddDataMonitorDelegate != null)
+            {
+                AddDataMonitorDelegate(type, info);
+            }
+        }
+
+        /// <summary>
+        /// 写入系统日志
+        /// </summary>
+        /// <param name="isError">是否为错误信息</param>
+        /// <param name="info">日志信息</param>
+        public static void AddLog(bool isError, string info)
+        {
+            //调用委托
+            if (AddLogDelegate != null)
+            {
+                AddLogDelegate(isError, info);
+            }
+        }
+        /// <summary>
+        /// 写入操作日志
+        /// </summary>
+        /// <param name="isError"></param>
+        /// <param name="info"></param>
+        public static void AddOPLog(bool isError, string info)
+        {
+            //调用委托
+            if (AddLogDelegate != null)
+            {
+                AddOPLogDelegate(isError, info);
+            }
+        }
+
+        public static void AddAlarmLog(SysLog sysLog)
+        {
+            //调用委托
+            if (AddAlarmDelegate != null)
+            {
+                AddAlarmDelegate(sysLog);
+            }
+        }
+
+        public static void ChangeParamData()
+        {
+            //调用委托
+            if (ChangeParamDelegate != null)
+            {
+                ChangeParamDelegate();
+            }
+        }
+        #endregion
+
+        /// <summary>
+        /// TODO PLC变量集合
+        /// KEY = VarAddress
+        /// </summary>
+        public static ConcurrentDictionary<string, PLCGroupVariable> PLCVariable = new ConcurrentDictionary<string, PLCGroupVariable>();
+
+
+    }
+}

JinYuan.VirtualDataLibrary/DBSQL.cs

@@ -0,0 +1,801 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JinYuan.VirtualDataLibrary
+{
+    public class DBSQL
+    {
+
+        /// <summary>
+        /// 获取PLC换型参数绑定值
+        /// </summary>
+        /// <param name="modelName"></param>
+        /// <returns></returns>
+        public string GetPlcParamSql(string modelName)
+        {
+            string strSql = $@"SELECT 
+                        '{modelName}' AS `ModelName`,
+                        `pb`.`PLCAddress`,
+                        `pc`.`PLCValue`,
+                        `pc`.`UpdateTime`,
+                        `pb`.`PLCRemark`,
+                        `pb`.`OrderNum`
+                   FROM 
+                        `Plcconfigbase` `pb`
+                   LEFT JOIN 
+                        (SELECT * FROM `Plcconfig` WHERE `ModelName` = '{modelName}') `pc`
+                   ON 
+                        `pb`.`PLCAddress` = `pc`.`PLCAddress`
+                   ORDER BY 
+                        `pb`.`OrderNum`";
+
+            return strSql;
+        }
+
+        /// <summary>
+        /// 获取产品型号参数
+        /// </summary>
+        /// <param name="strModelType"></param>
+        /// <returns></returns>
+        public string GetParamSql(string strModelType)
+        {
+            string strSql = $@"SELECT 
+                        `pb`.`ParaName`,
+                        '{strModelType}' AS `ModelName`,
+                        `pl`.`ParaValueMin`,
+                        `pl`.`ParaValueMax`,
+                        `pl`.`Uint`,
+                        `pb`.`Remark`,
+                        `pl`.`UpdateTime`
+                   FROM 
+                        `Parambase` `pb`
+                   LEFT JOIN 
+                        (SELECT * FROM `ParamList` WHERE `ModelName` = '{strModelType}') `pl`
+                   ON 
+                        `pb`.`ParaName` = `pl`.`ParaName`
+                   ORDER BY 
+                        `pb`.`fNo` ASC";
+
+            return strSql;
+        }
+
+
+        /// <summary>
+        /// 获取产品型号列表
+        /// </summary>
+        /// <param name="strProdType"></param>
+        /// <returns></returns>
+        public string GetProdTypeSql(string strProdType = "")
+        {
+            string strSql = @"SELECT * FROM ProductModel ";
+            if (strProdType != "")
+            {
+                strSql += string.Format(" where  ModelName='{0}'", strProdType);
+            }
+            strSql += "  order by  ModelName";
+            return strSql;
+        }
+
+
+        /// <summary>
+        /// 获取产品型号
+        /// </summary>
+        /// <param name="strModelType"></param>
+        /// <returns></returns>
+        public string GetProductParaByProdModel(string strModelType)
+        {
+            string strSql = $@"SELECT 
+                        `pb`.`ParaName`,
+                        '{strModelType}' AS `ModelName`,
+                        `pl`.`ParaValueMin`,
+                        `pl`.`ParaValueMax`,
+                        `pl`.`Uint`,
+                        `pb`.`Remark`,
+                        `pl`.`UpdateTime`
+                   FROM 
+                        `Parambase` `pb`
+                   LEFT JOIN 
+                        (SELECT * FROM `Paramlist` WHERE `ModelName` = '{strModelType}') `pl`
+                   ON 
+                        `pb`.`ParaName` = `pl`.`ParaName`
+                   ORDER BY 
+                        `pb`.`fNo` ASC";
+
+            return strSql;
+        }
+
+
+        public string GetPLCConfigBases()
+        {
+            string strSql = string.Format(@"SELECT * FROM `Plcconfigbase` ORDER BY `OrderNum`");
+
+            return strSql;
+        }
+
+
+        public string GetSysAdminSql()
+        {
+            string strSql = string.Format(@"SELECT 
+                                    `LoginId`,
+                                    `LoginName`,
+                                    `LoginPwd`,
+                                    `LoginUid`,
+                                    `LoginLevel`,
+                                    `SystemLog`,
+                                    `CpkData`,
+                                    `HistoryData`,
+                                    `ParamSet`,
+                                    `SystemSet`,
+                                    `UserManage`
+                               FROM 
+                                    `SysAdmin`");
+
+            return strSql;
+        }
+
+        /// <summary>
+        /// 查询历史数据
+        /// </summary>
+        /// <param name="strBarCode"></param>
+        /// <param name="strDate1"></param>
+        /// <param name="strDate2"></param>
+        /// <returns></returns>
+        public string SelectHostData(int type, string strRfid, string strBarCode, string strDate1, string strDate2)
+        {
+            string strSql = "";
+            if (type == 0)
+            {
+                strSql = @"SELECT 
+                            `ChannelNo`,
+                            DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s') AS `TestTime`,
+                            `RFID`,
+                            `BarCode`,
+                            `Result`,
+                            `Remark`,
+                            CASE WHEN `Flag` = 1 THEN 'True' ELSE 'False' END AS `Flag`
+                       FROM 
+                            `AGearEntity`
+                       WHERE 
+                            `TestTime` >= '" + strDate1 + "' AND `TestTime` <= '" + strDate2 + "'";
+
+                if (strRfid != "")
+                {
+                    strSql += " AND `RFID` LIKE '%" + strRfid + "'";
+                }
+                if (strBarCode != "")
+                {
+                    strSql += " AND `BarCode` LIKE '%" + strBarCode + "'";
+                }
+            }
+            else if (type == 1)
+            {
+                strSql = @" SELECT 
+                                `ChannelNo`,
+                                DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s') AS `TestTime`,
+                                `BarCode`,
+                                `CavityLeakageRateSetValue`,
+                                `ProductLeakageRateSetValue`,
+                                `LeakPressureSetValue`,
+                                `CavityLeakageRateActualValue`,
+                                `ProductLeakageRateActualValue`,
+                                `LeakPressureActualValue`,
+                                `PalletNumber`,
+                                `Result`,
+                                `Info`,
+                                `Remark`,
+                                CASE WHEN `Flag` = 1 THEN 'True' ELSE 'False' END AS Flag
+                            FROM `BGearEntity` where `TestTime` >= '" + strDate1 + "' and `TestTime` <= '" + strDate2 + "' ";
+                if (strRfid != "")
+                {
+                    strSql += " AND `RFID` LIKE '%" + strRfid + "'";
+                }
+                if (strBarCode != "")
+                {
+                    strSql += " AND `BarCode` LIKE '%" + strBarCode + "'";
+                }
+            }
+            else if (type == 2)//进站未上传
+            {
+                strSql = @"SELECT 
+                            `ChannelNo`,
+                            DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s') AS `TestTime`,
+                            `RFID`,
+                            `BarCode`,
+                            `Result`,
+                            `Remark`,
+                            CASE WHEN `Flag` = 1 THEN 'True' ELSE 'False' END AS `Flag`
+                       FROM 
+                            `AGearEntity`
+                       WHERE 
+                            `TestTime` >= '" + strDate1 + "' AND `TestTime` <= '" + strDate2 + "'" +
+                       "AND Flag = 2";
+
+                if (strRfid != "")
+                {
+                    strSql += " AND `RFID` LIKE '%" + strRfid + "'";
+                }
+                if (strBarCode != "")
+                {
+                    strSql += " AND `BarCode` LIKE '%" + strBarCode + "'";
+                }
+            }
+            else if (type == 3)//出站未上传
+            {
+                strSql = @" SELECT 
+                                `ChannelNo`,
+                                DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s') AS `TestTime`,
+                                `BarCode`,
+                                `CavityLeakageRateSetValue`,
+                                `ProductLeakageRateSetValue`,
+                                `LeakPressureSetValue`,
+                                `CavityLeakageRateActualValue`,
+                                `ProductLeakageRateActualValue`,
+                                `LeakPressureActualValue`,
+                                `PalletNumber`,
+                                `Result`,
+                                `Info`,
+                                `Remark`,
+                                CASE WHEN `Flag` = 1 THEN 'True' ELSE 'False' END AS Flag
+                            FROM `BGearEntity` WHERE `TestTime` >= '" + strDate1 + "' AND `TestTime` <= '" + strDate2 + "'" +
+                            "AND Flag = 2";
+                if (strRfid != "")
+                {
+                    strSql += " AND `RFID` LIKE '%" + strRfid + "'";
+                }
+                if (strBarCode != "")
+                {
+                    strSql += " AND `BarCode` LIKE '%" + strBarCode + "'";
+                }
+            }
+            else if (type == 4)
+            {
+                strSql = @" SELECT 
+                                `ChannelNo`,
+                                DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s') AS `TestTime`,
+                                `BarCode`,
+                                `CavityLeakageRateSetValue`,
+                                `ProductLeakageRateSetValue`,
+                                `LeakPressureSetValue`,
+                                `CavityLeakageRateActualValue`,
+                                `ProductLeakageRateActualValue`,
+                                `LeakPressureActualValue`,
+                                `PalletNumber`,
+                                `Result`,
+                                `Info`,
+                                `Remark`,
+                                CASE WHEN `Flag1` = 1 THEN 'True' ELSE 'False' END AS Flag
+                            FROM `BGearEntity` where `TestTime` >= '" + strDate1 + "' and `TestTime` <= '" + strDate2 + "' ";
+                if (strRfid != "")
+                {
+                    strSql += " AND `RFID` LIKE '%" + strRfid + "'";
+                }
+                if (strBarCode != "")
+                {
+                    strSql += " AND `BarCode` LIKE '%" + strBarCode + "'";
+                }
+            }
+            else if (type == 5)//出站未上传
+            {
+                strSql = @" SELECT 
+                                `ChannelNo`,
+                                DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s') AS `TestTime`,
+                                `BarCode`,
+                                `CavityLeakageRateSetValue`,
+                                `ProductLeakageRateSetValue`,
+                                `LeakPressureSetValue`,
+                                `CavityLeakageRateActualValue`,
+                                `ProductLeakageRateActualValue`,
+                                `LeakPressureActualValue`,
+                                `PalletNumber`,
+                                `Result`,
+                                `Info`,
+                                `Remark`,
+                                CASE WHEN `Flag1` = 1 THEN 'True' ELSE 'False' END AS Flag
+                            FROM `BGearEntity` WHERE `TestTime` >= '" + strDate1 + "' AND `TestTime` <= '" + strDate2 + "'" +
+                            "AND Flag1 = 2";
+                if (strRfid != "")
+                {
+                    strSql += " AND `RFID` LIKE '%" + strRfid + "'";
+                }
+                if (strBarCode != "")
+                {
+                    strSql += " AND `BarCode` LIKE '%" + strBarCode + "'";
+                }
+            }
+            return strSql;
+        }
+
+
+        /// <summary>
+        /// 查询报警历史数据
+        /// </summary>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <param name="alarmType"></param>
+        /// <returns></returns>
+        public string SelectHostAlarmData(string start, string end, int alarmType)
+        {
+            string strSql = "";
+            switch (alarmType)
+            {
+                case 1:
+                    strSql = @"SELECT 
+                    DATE_FORMAT(`AlarmTime`, '%Y-%m-%d %H:%i:%s') AS `AlarmTime`,
+                    `PLCAdress`,
+                    `AlarmContent`,
+                    `AlarmCount`,
+                    `Class`
+               FROM 
+                    `AlarmCountEntry`
+               WHERE 
+                    `AlarmTime` >= '" + start + "' AND `AlarmTime` <= '" + end + $"' AND `Class` = '{CommonMethods.strClass}'";
+                    break;
+                case 2:
+                    strSql = @"SELECT 
+                    DATE_FORMAT(`AlarmTime`, '%Y-%m-%d %H:%i:%s') AS `AlarmTime`,
+                    `PLCAdress`,
+                    `AlarmContent`,
+                    `AlarmCount`,
+                    `Class`
+               FROM 
+                    `AlarmCountEntry`
+               WHERE 
+                    `AlarmTime` >= '" + start + "' AND `AlarmTime` <= '" + end + $"' AND `Class` = '{CommonMethods.strClass}'";
+                    break;
+                default:
+                case 0:
+                    strSql = @"SELECT 
+                    DATE_FORMAT(`AlarmTime`, '%Y-%m-%d %H:%i:%s') AS `AlarmTime`,
+                    `PLCAdress`,
+                    `AlarmContent`,
+                    `AlarmCount`,
+                    `Class`
+               FROM 
+                    `AlarmCountEntry`
+               WHERE 
+                    `AlarmTime` >= '" + start + "' AND `AlarmTime` <= '" + end + "'";
+                    break;
+            }
+            #region 旧
+            //if (alarmType == "全天")
+            //{
+            //    strSql = @"SELECT 
+            //        DATE_FORMAT(`AlarmTime`, '%Y-%m-%d %H:%i:%s') AS `AlarmTime`,
+            //        `PLCAdress`,
+            //        `AlarmContent`,
+            //        `AlarmCount`,
+            //        `Class`
+            //   FROM 
+            //        `AlarmCountEntry`
+            //   WHERE 
+            //        `AlarmTime` >= '" + start + "' AND `AlarmTime` <= '" + end + "'";
+            //}
+            //else if (alarmType == "白班")
+            //{
+            //    strSql = @"SELECT 
+            //        DATE_FORMAT(`AlarmTime`, '%Y-%m-%d %H:%i:%s') AS `AlarmTime`,
+            //        `PLCAdress`,
+            //        `AlarmContent`,
+            //        `AlarmCount`,
+            //        `Class`
+            //   FROM 
+            //        `AlarmCountEntry`
+            //   WHERE 
+            //        `AlarmTime` >= '" + start + "' AND `AlarmTime` <= '" + end + "' AND `Class` = '白班'";
+            //}
+            //else
+            //{
+            //    strSql = @"SELECT 
+            //        DATE_FORMAT(`AlarmTime`, '%Y-%m-%d %H:%i:%s') AS `AlarmTime`,
+            //        `PLCAdress`,
+            //        `AlarmContent`,
+            //        `AlarmCount`,
+            //        `Class`
+            //   FROM 
+            //        `AlarmCountEntry`
+            //   WHERE 
+            //        `AlarmTime` >= '" + start + "' AND `AlarmTime` <= '" + end + "' AND `Class` = '夜班'";
+            //}
+            #endregion
+            return strSql;
+        }
+
+        /// <summary>
+        /// 按日统计
+        /// </summary>
+        /// <param name="startDateTime"></param>
+        /// <param name="endDateTime"></param>
+        /// <returns></returns>
+        public string GetStaticByDay(string startDateTime, string endDateTime)
+        {
+            string strSql = $@"SELECT 
+                        DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:00:00') AS `Day`,
+                        `ProdIn`,
+                        `ProdOut`,
+                        `Ppm`,
+                        CONCAT(CAST(ROUND(`JiaDL` * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN `ProdIn` > 0 THEN ROUND(COALESCE(`ProdOut`, 0) / COALESCE(`ProdIn`, 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{startDateTime}' AND '{endDateTime}'
+                   GROUP BY 
+                        `TestTime`, `ProdOut`, `ProdIn`, `Ppm`, `JiaDL`
+                   UNION ALL
+                   SELECT 
+                        'Total' AS `Day`,
+                        SUM(`ProdIn`) AS ProdIn,
+                        SUM(`ProdOut`) AS ProdOut,
+                        AVG(`Ppm`) AS Ppm,
+                        CONCAT(CAST(ROUND(AVG(`JiaDL`) * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN SUM(`ProdIn`) > 0 THEN ROUND(COALESCE(SUM(`ProdOut`), 0) / COALESCE(SUM(`ProdIn`), 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{startDateTime}' AND '{endDateTime}'";
+
+            return strSql;
+        }
+
+        /// <summary>
+        /// 按周查询
+        /// </summary>
+        /// <param name="startDateTime"></param>
+        /// <param name="endDateTime"></param>
+        /// <returns></returns>
+        public string GetStaticByWeek(string startDateTime, string endDateTime)
+        {
+            string strSql = $@"SELECT 
+                        DATE_FORMAT(`TestTime`, '%Y-%m') AS `Week`,
+                        SUM(`ProdIn`) AS ProdIn,
+                        SUM(`ProdOut`) AS ProdOut,
+                        AVG(`Ppm`) AS Ppm,
+                        CONCAT(CAST(ROUND(`JiaDL` * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN SUM(`ProdIn`) > 0 THEN ROUND(COALESCE(SUM(`ProdOut`), 0) / COALESCE(SUM(`ProdIn`), 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{startDateTime}' AND '{endDateTime}'
+                   GROUP BY 
+                        DATE_FORMAT(`TestTime`, '%Y-%m'), `JiaDL`
+                   UNION ALL
+                   SELECT 
+                        'Total' AS `Week`,
+                        SUM(`ProdIn`) AS ProdIn,
+                        SUM(`ProdOut`) AS ProdOut,
+                        AVG(`Ppm`) AS Ppm,
+                        CONCAT(CAST(ROUND(AVG(`JiaDL`) * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN SUM(`ProdIn`) > 0 THEN ROUND(COALESCE(SUM(`ProdOut`), 0) / COALESCE(SUM(`ProdIn`), 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{startDateTime}' AND '{endDateTime}'";
+
+            return strSql;
+        }
+
+
+        /// <summary>
+        /// 按月查询
+        /// </summary>
+        /// <param name="startDateTime"></param>
+        /// <param name="endDateTime"></param>
+        /// <returns></returns>
+        public string GetStaticByMonth(string startDateTime, string endDateTime)
+        {
+            string strSql = $@"SELECT 
+                        DATE_FORMAT(`TestTime`, '%Y-%m') AS `Month`,
+                        SUM(`ProdIn`) AS ProdIn,
+                        SUM(`ProdOut`) AS ProdOut,
+                        AVG(`Ppm`) AS Ppm,
+                        CONCAT(CAST(ROUND(`JiaDL` * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN SUM(`ProdIn`) > 0 THEN ROUND(COALESCE(SUM(`ProdOut`), 0) / COALESCE(SUM(`ProdIn`), 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{startDateTime}' AND '{endDateTime}'
+                   GROUP BY 
+                        DATE_FORMAT(`TestTime`, '%Y-%m'), `JiaDL`
+                   UNION ALL
+                   SELECT 
+                        'Total' AS `Month`,
+                        SUM(`ProdIn`) AS ProdIn,
+                        SUM(`ProdOut`) AS ProdOut,
+                        AVG(`Ppm`) AS Ppm,
+                        CONCAT(CAST(ROUND(AVG(`JiaDL`) * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN SUM(`ProdIn`) > 0 THEN ROUND(COALESCE(SUM(`ProdOut`), 0) / COALESCE(SUM(`ProdIn`), 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{startDateTime}' AND '{endDateTime}'";
+
+            return strSql;
+        }
+
+        /// <summary>
+        /// 按班次统计
+        /// </summary>
+        /// <param name="dateTime"></param>
+        /// <param name="shift"></param>
+        /// <param name="changeShiftTime"></param>
+        /// <returns></returns>
+        public string GetStaticByShift(DateTime dateTime, int shift, string changeShiftTime)
+        {
+            string sDateTime1 = string.Empty;
+            string sDateTime2 = string.Empty;
+            if (shift == 0)// 白班
+            {
+                DateTime sTempDateTime = Convert.ToDateTime($"{dateTime.ToString("yyyy-MM-dd")} {changeShiftTime}");
+
+                sDateTime1 = sTempDateTime.AddHours(-12).ToString("yyyy-MM-dd HH:mm:ss");
+                sDateTime2 = sTempDateTime.ToString("yyyy-MM-dd HH:mm:ss");
+            }
+            else
+            {
+                sDateTime1 = $"{dateTime.ToString("yyyy-MM-dd")} {changeShiftTime}";
+                sDateTime2 = Convert.ToDateTime(sDateTime1).AddHours(12).ToString("yyyy-MM-dd HH:mm:ss");
+            }
+
+            string strsql = $@"SELECT 
+                        DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:00:00') AS `TestTime`,
+                        `ProdIn`,
+                        `ProdOut`,
+                        `Ppm`,
+                        CONCAT(CAST(ROUND(`JiaDL` * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN `ProdIn` > 0 THEN ROUND(COALESCE(`ProdOut`, 0) / COALESCE(`ProdIn`, 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{sDateTime1}' AND '{sDateTime2}'
+                   GROUP BY 
+                        `TestTime`, `ProdOut`, `ProdIn`, `Ppm`, `JiaDL`
+                   UNION ALL
+                   SELECT 
+                        'Total' AS `Time`,
+                        SUM(`ProdIn`) AS ProdIn,
+                        SUM(`ProdOut`) AS ProdOut,
+                        AVG(`Ppm`) AS Ppm,
+                        CONCAT(CAST(ROUND(AVG(`JiaDL`) * 100, 1) AS CHAR(10)), '%') AS `JiaDL`,
+                        CONCAT(CAST(
+                            CASE 
+                                WHEN SUM(`ProdIn`) > 0 THEN ROUND(COALESCE(SUM(`ProdOut`), 0) / COALESCE(SUM(`ProdIn`), 0) * 100, 2)
+                                ELSE 0 
+                            END AS CHAR(10)), '%') AS `Prod`
+                   FROM 
+                        `Hourprod`
+                   WHERE 
+                        `TestTime` BETWEEN '{sDateTime1}' AND '{sDateTime2}'";
+
+            return strsql;
+        }
+
+
+        /// <summary>
+        /// 获取最新的数据
+        /// </summary>
+        /// <returns></returns>
+        public string GetStatic(string strDateTime)
+        {
+
+            string strsql = $@" SELECT [FDate]
+                                      ,[FHour]
+                                      ,[ProdIn]
+                                      ,[ProdOut]                                     
+                                      ,[TestTime]
+                                  FROM [dbo].[Hourprod] where FDate='{strDateTime}' order by TestTime desc";
+            return strsql;
+        }
+
+        /// <summary>
+        /// 根据条码获取进站时间最新的一条数据
+        /// </summary>
+        /// <param name="strProdType"></param>
+        /// <returns></returns>
+        public string GetInStationTop1Sql(string barCode)
+        {
+            string strSql = $@"SELECT
+                                    `ChannelNo`,
+                                    DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s'),
+                                    `RFID`,
+                                    `BarCode`,
+                                    `Result`,
+                                    `Remark`,
+                                    `Flag`
+                                FROM 
+                                    `AGearEntity`
+                                WHERE `BarCode` = '{barCode}' ORDER BY `TestTime` DESC
+                                LIMIT 1";
+            return strSql;
+        }
+
+        /// <summary>
+        /// 根据RFID获取进站时间最新的一条数据
+        /// </summary>
+        /// <param name="strProdType"></param>
+        /// <returns></returns>
+        public string GetBarCodeTop1Sql(string rfid)
+        {
+            string strSql = $@"SELECT
+                                    `ChannelNo`,
+                                    DATE_FORMAT(`TestTime`, '%Y-%m-%d %H:%i:%s'),
+                                    `RFID`,
+                                    `BarCode`,
+                                    `Result`,
+                                    `Remark`,
+                                    `Flag`
+                                FROM 
+                                    `AGearEntity`
+                                WHERE `RFID` = '{rfid}' ORDER BY `TestTime` DESC
+                                LIMIT 1";
+            return strSql;
+        }
+
+        /// <summary>
+        /// 获取表头注释
+        /// </summary>
+        /// <returns></returns>
+        public string GetSqlFields(string tableName)
+        {
+            string strSql = $@"SELECT
+                                COLUMN_NAME,
+                                DATA_TYPE,
+                                COLUMN_COMMENT
+                            FROM
+                                INFORMATION_SCHEMA.COLUMNS
+                            WHERE
+                                TABLE_SCHEMA = 'largesquareone' AND TABLE_NAME = '{tableName}'
+                            ORDER BY
+                                ORDINAL_POSITION;";
+            return strSql;
+        }
+
+        /// <summary>
+        /// 根据标志位获取过程数据
+        /// </summary>
+        /// <param name="Flag"></param>
+        /// <returns></returns>
+        public string GetOutFlag1Sql(string Flag1)
+        {
+            string strSql = $@"SELECT
+                                    *
+                                FROM 
+                                    `BGearEntity`
+                                WHERE `Flag1` = '{Flag1}' ";
+            return strSql;
+        }
+
+        /// <summary>
+        /// 使用Rfid批量查询卷芯码
+        /// </summary>
+        /// <param name="listRfid"></param>
+        /// <returns></returns>
+        public string GetRFIDList(string Rfid)
+        {
+            string strSql = $@"SELECT containerCode as RFID,identification AS BarCode   FROM  hbg_cupdataturnover.dataturnover WHERE containerCode ='{Rfid}'ORDER BY `Time` DESC";
+            //string  strSql = $@"SELECT RFID,BarCode  FROM  temprfidtable WHERE RFID ='{Rfid}'ORDER BY `TestTime` DESC LIMIT 1 ";
+
+            return strSql;
+        }
+
+        /// <summary>
+        /// 使用Rfid批量查询卷芯码
+        /// </summary>
+        /// <param name="listRfid"></param>
+        /// <returns></returns>
+        public string DELRFIDList(string Rfid)
+        {
+            string strSql = $@"DELETE  FROM  temprfidtable WHERE RFID ='{Rfid}' ";
+            return strSql;
+        }
+    }
+
+    public class M_DBCtrl
+    {
+        /// <summary>--本机数据库表名
+        /// 
+        /// </summary>
+        //public string machineInSQLTable = "agearentity";
+        public string machineOutSQLTable = "bgearentity";
+
+        private string[] headerTextOut;
+        /// <summary>
+        /// 出站数据库表头
+        /// </summary>
+        public string[] HeaderTextOut
+        {
+            get { return headerTextOut; }
+            set { headerTextOut = value; }
+        }
+
+        /// <summary>查询SQL数据库中的数据,并以string数组列表形式返回
+        /// 
+        /// </summary>
+        /// <param name="strSql"></param>
+        /// <returns>所查询到的数据，null表示不存在</returns>
+        public List<string[]> SQLAllDataSearchToStrArrList(string strSql)
+        {
+            List<string[]> strResArrList = new List<string[]>();
+            List<string> strResList = new List<string>();
+            try
+            {
+                using (DataTable dt = CommonMethods.db.QueryDataTable(strSql))
+                {
+                    if (dt != null)
+                    {
+                        for (int i = 0; i < dt.Rows.Count; i++)
+                        {
+                            for (int j = 0; j < dt.Columns.Count; j++)
+                            {
+                                string resRow = dt.Rows[i][j].ToString();
+                                strResList.Add(resRow);
+                            }
+                            string[] strResArr = strResList.ToArray();
+                            strResList.Clear();
+                            strResArrList.Add(strResArr);
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                return strResArrList = new List<string[]>();
+            }
+            return strResArrList;
+        }
+
+        /// <summary>根据下标在返回的数据库表信息 集合中获取相应数据
+        /// index 0:字段 2:中文注释 1:变量类型int\char等
+        /// </summary>
+        /// <param name="SqlList">liststring[]类型的集合</param>
+        /// <param name="index">string[] 的下标</param>
+        /// <returns></returns>
+        public String[] HeaderTextAssignment(List<string[]> SqlList, int index)
+        {
+            string[] headStringlist = new string[SqlList.Count];
+            //  int i = 0;
+            try
+            {
+                for (int i = 0; i < SqlList.Count; i++)
+                {
+                    headStringlist[i] = SqlList[i][index];
+                }
+            }
+            catch (Exception)
+            {
+            }
+            return headStringlist;
+        }
+    }
+}

JinYuan.VirtualDataLibrary/DelegateLib.cs

@@ -0,0 +1,47 @@
+
+using JinYuan.Models;
+using PLCCommunication;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JinYuan.VirtualDataLibrary
+{
+  
+    public delegate void dgStationFunction(JYResult<byte[]> bArrays, object plcModel);
+
+    /// <summary>
+    /// 显示上料信息
+    /// </summary>
+    /// <param name="Msg"></param>
+    /// <param name="state"></param>
+    //public delegate void dgShowFeeding(List<AGearEntity> list);
+    /// <summary>
+    /// 显示下料信息
+    /// </summary>
+    /// <param name="Msg"></param>
+    /// <param name="state"></param>
+    //public delegate void dgShowBlanking(List<BlankingEntry> list);
+    /// <summary>
+    /// 设备综合效率
+    /// </summary>
+    /// <param name="battery"></param>
+    public delegate void DGShow12HourData(DeviceOEE device12Hour);
+
+    /// <summary>
+    /// 设备综合效率
+    /// </summary>
+    /// <param name="battery"></param>
+    public delegate void DGShowAlarmData(DeviceOEE deviceAlarm);
+
+
+    /// <summary>
+    /// 焊机功率
+    /// </summary> Welding machine power
+    /// <param name="DataList"></param>
+    public delegate void DGShowWeldingPowerData(List<double> DataList);
+
+    
+}

JinYuan.VirtualDataLibrary/JinYuan.VirtualDataLibrary.csproj

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{2AB7E380-7795-448A-933C-0F6A081B5E7E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>JinYuan.VirtualDataLibrary</RootNamespace>
+    <AssemblyName>JinYuan.VirtualDataLibrary</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="PLCCommunication, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\Libs\PLCCommunication.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="CommonMethods.cs" />
+    <Compile Include="DBSQL.cs" />
+    <Compile Include="DelegateLib.cs" />
+    <Compile Include="MesConfig.cs" />
+    <Compile Include="MsgshowTip.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="MsgshowTip.Designer.cs">
+      <DependentUpon>MsgshowTip.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\JinYuan.DAL\JinYuan.DAL.csproj">
+      <Project>{114aa012-29c9-418c-a2d6-3173c5341f51}</Project>
+      <Name>JinYuan.DAL</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\JinYuan.Helper\JinYuan.Helper.csproj">
+      <Project>{258d0ab7-2b4f-4d8f-a3cd-7a8cb4a85360}</Project>
+      <Name>JinYuan.Helper</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\JinYuan.MES\JinYuan.MES.csproj">
+      <Project>{530b6426-08e7-461c-91dc-787f876620fc}</Project>
+      <Name>JinYuan.MES</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\JinYuan.Models\JinYuan.Models.csproj">
+      <Project>{4c0bcb84-5cd7-4846-8363-c4c10d46e391}</Project>
+      <Name>JinYuan.Models</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\PLC\PLC.csproj">
+      <Project>{486aecd0-c2bf-43c5-b7d7-88e565ade4b7}</Project>
+      <Name>PLC</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="MsgshowTip.resx">
+      <DependentUpon>MsgshowTip.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\感叹号提示-块红色.png" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

JinYuan.VirtualDataLibrary/MesConfig.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JinYuan.VirtualDataLibrary
+{
+    public class MesConfig
+    {
+        /// <summary>
+        /// 工厂代码
+        /// </summary>
+        public string siteCode = "";
+        /// <summary>
+        /// 产线编号
+        /// </summary>
+        public string lineCode = "";
+        /// <summary>
+        /// 设备编号
+        /// </summary>
+        public string equipNum = "";
+        /// <summary>
+        /// MES密码
+        /// </summary>
+        public string mesPwd = "";
+        /// <summary>
+        /// MES账户
+        /// </summary>
+        public string mesUserName = "";
+
+        /// <summary>
+        /// 电表编号
+        /// </summary>
+        public List<string> electricMeterNum = new List<string>();
+
+        /// <summary>
+        /// 风速仪个数
+        /// </summary>
+        public int AntiDustAirSpeedCount = 0;
+        /// <summary>
+        /// 风速仪编号
+        /// </summary>
+        public List<string> listAntiDustAirSpeedNum = new List<string>();
+
+        /// <summary>
+        /// 权限
+        /// </summary>
+        public string userLevel = "";
+        /// <summary>
+        /// mes返回权限
+        /// </summary>
+        public string mesUserLevel = "";
+        /// <summary>
+        /// 物料编码
+        /// </summary>
+        public string MaterialCode = "";
+        /// <summary>
+        /// 生产型号
+        /// </summary>
+        public string ModelName = "";
+        /// <summary>
+        /// 是否上传MES
+        /// </summary>
+        public bool isUpMes = false;
+        /// <summary>
+        /// MES接口URL地址中的IP地址
+        /// </summary>
+        public string MESURLAddressIP = "10.100.111.81";
+        /// <summary>
+        /// MES接口URL地址中的端口号
+        /// </summary>
+        public string MESURLAddressPort = "80";
+        /// <summary>
+        /// 是否连接MES
+        /// </summary>
+        public bool isConnected = false;
+        /// <summary>
+        /// 是否刷卡？
+        /// </summary>
+        public bool Isshuaka = false;
+        /// <summary>
+        /// 是否登录成功？
+        /// </summary>
+        public bool IsLoginOK = false;
+        /// <summary>
+        /// 是否登录MES成功？
+        /// </summary>
+        public bool IsLoginMesOK = false;
+        /// <summary>
+        /// 获取MES参数
+        /// </summary>
+        public bool IsMesParam = false;
+        /// <summary>
+        /// MES超时
+        /// </summary>
+        public long MesOutTime = 0;
+        /// <summary>
+        /// 焊接点个数
+        /// </summary>
+        public int weldNum = 0;
+        /// <summary>
+        /// 是否2个电表(此功能仅适用于908-6负极焊接两台设备共用一台敢接机只有一个电表)
+        /// </summary>
+        public bool IsTwoDianBiao = false;
+        /// <summary>
+        /// 电表编号
+        /// </summary>
+        public string ElectricMeterNum = "";
+        /// <summary>
+        /// 除尘风速
+        /// </summary>
+        public decimal antiDustAirSpeed = 0;
+
+        /// <summary>
+        /// 电机旋转速度
+        /// </summary>
+        public decimal dianjiXzSpeed = 0;
+        /// <summary>
+        /// 设备状态上传时间
+        /// </summary>
+        public int EquStatuasTime = 0;
+        /// <summary>
+        /// 获取服务器数据
+        /// </summary>
+        public bool IsGet_Server = true;
+        /// <summary>
+        /// 生成假数据
+        /// </summary>
+        public bool IsDebug = true;
+        /// <summary>
+        /// 卷芯码计数
+        /// </summary>
+        public int CoreCount = 0;
+        /// <summary>
+        /// 钢壳码计数
+        /// </summary>
+        public int SteelshellCount = 0;
+        /// <summary>
+        /// 原材料上料位置
+        /// </summary>
+        public string materialLotCodeLocator = "";
+
+        /// <summary>
+        /// 存储服务器IP地址
+        /// </summary>
+        public string RotueServerIP = "192.168.2.108";
+        /// <summary>
+        /// 员工权限校验
+        /// </summary>
+        public string EmployeeAuthCheck = "http://10.100.111.81/core/api/public/equipment/base/user/permission/verify";
+        /// <summary>
+        /// 原材料投入信息
+        /// </summary>
+        public string MaterialInputInfo = "http://10.100.111.81/core/api/public/raw/material/input/un/first/process";
+        /// <summary>
+        /// 设备参数设定值请求
+        /// </summary>
+        public string DeviceParamRequest = "http://10.100.111.81/core/api/public/param/setting/request";
+        /// <summary>
+        /// 设备参数设定值变更
+        /// </summary>
+        public string DeviceParamChange = "http://10.100.111.81/core/api/public/param/setting/change";
+        /// <summary>
+        /// 产品进站信息（组装）
+        /// </summary>
+        public string ProductInStation = "http://10.100.111.81/core/api/public/batch/in/station/process/currency";
+        /// <summary>
+        /// 产品过程加工参数
+        /// </summary>
+        public string ProductProcessParams = "http://10.100.111.81/core/api/public/product/process/param/new/process";
+        /// <summary>
+        /// 产品结果加工参数
+        /// </summary>
+        public string ProductResultParams = "http://10.100.111.81/core/api/public/product/process/param/new/result";
+        /// <summary>
+        /// 产品出站信息（组装）
+        /// </summary>
+        public string ProductOutStation = "http://10.100.111.81/core/api/public/product/out/station/process/turn";
+        /// <summary>
+        /// 设备报警信息
+        /// </summary>
+        public string DeviceAlarm = "http://10.100.111.81/core/api/public/equipment/alarm/currency";
+        /// <summary>
+        /// 设备运行状态
+        /// </summary>
+        public string DeviceStatus = "http://10.100.111.81/core/api/public/eve/pm/eqm/run/status/operation";
+        /// <summary>
+        /// 能耗数据
+        /// </summary>
+        public string EnergyConsumption = "http://10.100.111.81/core/api/public/eve/pm/energy/consumption/collection/submit";
+        /// <summary>
+        /// 设备风速接口
+        /// </summary>
+        public string Anemometer = "https://iot.eveportal.com:9470/eve_api/ems/iot/upload_device_collect_data";
+
+        /// <summary>
+        /// 进出站一体模式×
+        /// </summary>
+        public string InAndOutStationMesUrl = "http://10.17.96.73/core/api/public/14j/out/station/process/turn-in-out";
+        
+    }
+}

JinYuan.VirtualDataLibrary/MsgshowTip.Designer.cs

@@ -0,0 +1,89 @@
+namespace JinYuan.VirtualDataLibrary
+{
+    partial class MsgshowTip
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            this.pictureBox1 = new System.Windows.Forms.PictureBox();
+            this.label1 = new System.Windows.Forms.Label();
+            this.timer1 = new System.Windows.Forms.Timer(this.components);
+            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
+            this.SuspendLayout();
+            // 
+            // pictureBox1
+            // 
+            this.pictureBox1.Image = global::JinYuan.VirtualDataLibrary.Properties.Resources.感叹号提示_块红色;
+            this.pictureBox1.Location = new System.Drawing.Point(6, 3);
+            this.pictureBox1.Name = "pictureBox1";
+            this.pictureBox1.Size = new System.Drawing.Size(87, 80);
+            this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom;
+            this.pictureBox1.TabIndex = 0;
+            this.pictureBox1.TabStop = false;
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Font = new System.Drawing.Font("微软雅黑", 15.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(134)));
+            this.label1.ForeColor = System.Drawing.Color.Red;
+            this.label1.Location = new System.Drawing.Point(95, 29);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(345, 28);
+            this.label1.TabIndex = 1;
+            this.label1.Text = "与PLC链接断开，请检查通讯线路！";
+            // 
+            // timer1
+            // 
+            this.timer1.Interval = 500;
+            this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
+            // 
+            // MsgshowTip
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.Yellow;
+            this.ClientSize = new System.Drawing.Size(434, 84);
+            this.Controls.Add(this.pictureBox1);
+            this.Controls.Add(this.label1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
+            this.Name = "MsgshowTip";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "MsgshowTip";
+            this.Load += new System.EventHandler(this.MsgshowTip_Load);
+            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.PictureBox pictureBox1;
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.Timer timer1;
+    }
+}

JinYuan.VirtualDataLibrary/MsgshowTip.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace JinYuan.VirtualDataLibrary
+{
+    public partial class MsgshowTip : Form
+    {
+        /// <summary>
+        /// 图标和文本之间的间距（像素）
+        /// </summary>
+        const int IconTextSpacing = 3;
+        /// <summary>
+        /// 显示文字
+        /// </summary>
+        string _tipText;
+        /// <summary>
+        /// 提示图标
+        /// </summary>
+        public Image TipIcon { get; set; }
+
+        /// <summary>
+        /// 提示文本
+        /// </summary>
+        public string TipText
+        {
+            get { return _tipText ?? string.Empty; }
+            set { _tipText = value; }
+        }
+
+        public MsgshowTip(string Msg)
+        {
+            //双缓冲。有必要
+            SetStyle(ControlStyles.UserPaint, true);
+            DoubleBuffered = true;
+            InitializeComponent();
+            this._tipText = Msg;
+        }
+
+        private void MsgshowTip_Load(object sender, EventArgs e)
+        {
+            //ProcessClientSize();
+            ProcessLocation();
+            label1.Text = _tipText;
+            timer1.Enabled = true;
+        }
+
+        /// <summary>
+        /// 根据图标和文字处理窗体尺寸
+        /// </summary>
+        private void ProcessClientSize()
+        {
+            Size size = Size.Empty;
+            if (TipIcon != null)
+            {
+                size += TipIcon.Size;
+            }
+            if (TipText.Length != 0)
+            {
+                if (TipIcon != null)
+                {
+                    size.Width += IconTextSpacing;//图标与文字的间距
+                }
+                var textSize = TextRenderer.MeasureText(TipText, this.Font);
+                size.Width += textSize.Width;
+                if (size.Height < textSize.Height) { size.Height = textSize.Height; }
+            }
+            this.ClientSize = size + Padding.Size;
+        }
+        private int x, y;  //显示的坐标变量
+
+        private void timer1_Tick(object sender, EventArgs e)
+        {
+            this.Close();
+        }
+
+        private void ProcessLocation()
+        {
+
+            #region 弹窗显示在屏幕中间
+            this.y = (Screen.PrimaryScreen.Bounds.Height - 30 - this.Height) / 2;
+            this.x = (Screen.PrimaryScreen.Bounds.Width - 10 - this.Width) / 2;
+            this.Location = new Point(this.x, this.y);
+            #endregion
+
+            #region 弹窗显示在屏幕右下角
+            //this.x = Screen.PrimaryScreen.WorkingArea.Width - this.Width + 15;
+            //this.y = Screen.PrimaryScreen.WorkingArea.Height - this.Height * i - 5 * i;
+            //this.Location = new Point(this.x, this.y);
+            #endregion
+
+            #region 弹窗跟随鼠标位置
+            //var p = BasePoint;
+            //p.X -= Screen.PrimaryScreen.WorkingArea.Width - this.Width - 1000;//Screen.PrimaryScreen.WorkingArea.Width-this.Width / 2;
+
+            ////横向处理。距离屏幕左右两边太近时的处理
+            //int screenWidth;
+            //if (p.X < 10)
+            //{
+            //    p.X = 10;
+            //}
+            //else if (p.X + this.Width > (screenWidth = Screen.PrimaryScreen.Bounds.Width) - 10)
+            //{
+            //    p.X = screenWidth - 10 - this.Width;
+            //}
+
+            ////纵向处理。在鼠标上方显示
+            //p.Y -= this.Height + 20;
+
+            //this.Location = p;
+            #endregion
+        }
+
+    }
+}

JinYuan.VirtualDataLibrary/MsgshowTip.resx

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="timer1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+</root>

JinYuan.VirtualDataLibrary/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("JinYuan.VirtualDataLibrary")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("JinYuan.VirtualDataLibrary")]
+[assembly: AssemblyCopyright("Copyright ©  2023")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("2ab7e380-7795-448a-933c-0f6a081b5e7e")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

JinYuan.VirtualDataLibrary/Properties/Resources.Designer.cs

@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace JinYuan.VirtualDataLibrary.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   一个强类型的资源类，用于查找本地化的字符串等。
+    /// </summary>
+    // 此类是由 StronglyTypedResourceBuilder
+    // 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
+    // 若要添加或移除成员，请编辑 .ResX 文件，然后重新运行 ResGen
+    // (以 /str 作为命令选项)，或重新生成 VS 项目。
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   返回此类使用的缓存的 ResourceManager 实例。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("JinYuan.VirtualDataLibrary.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   重写当前线程的 CurrentUICulture 属性，对
+        ///   使用此强类型资源类的所有资源查找执行重写。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   查找 System.Drawing.Bitmap 类型的本地化资源。
+        /// </summary>
+        internal static System.Drawing.Bitmap 感叹号提示_块红色 {
+            get {
+                object obj = ResourceManager.GetObject("感叹号提示-块红色", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+    }
+}

JinYuan.VirtualDataLibrary/Properties/Resources.resx

@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="感叹号提示-块红色" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\感叹号提示-块红色.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+</root>

JinYuan.VirtualDataLibrary/app.config

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encoding.CodePages" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="MySql.Data" publicKeyToken="c5687fc88969c44d" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.1.0.0" newVersion="9.1.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.IO.Pipelines" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.0.1" newVersion="4.2.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Google.Protobuf" publicKeyToken="a7d26565bac4d604" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-3.23.4.0" newVersion="3.23.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="ZstdSharp" publicKeyToken="8d151af33a4ad5cf" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-0.7.2.0" newVersion="0.7.2.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Configuration.ConfigurationManager" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/JinYuan.DAL.dll.config

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="MySql.Data" publicKeyToken="c5687fc88969c44d" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.1.0.0" newVersion="9.1.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.IO.Pipelines" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Google.Protobuf" publicKeyToken="a7d26565bac4d604" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-3.23.4.0" newVersion="3.23.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="ZstdSharp" publicKeyToken="8d151af33a4ad5cf" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-0.7.2.0" newVersion="0.7.2.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.0.1" newVersion="4.2.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encoding.CodePages" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Configuration.ConfigurationManager" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/JinYuan.Helper.dll.config

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encoding.CodePages" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/JinYuan.MES.dll.config

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encoding.CodePages" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/JinYuan.Models.dll.config

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.4.1" newVersion="4.0.4.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/JinYuan.VirtualDataLibrary.dll.config

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encoding.CodePages" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="MySql.Data" publicKeyToken="c5687fc88969c44d" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.1.0.0" newVersion="9.1.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.IO.Pipelines" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.0.1" newVersion="4.2.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Google.Protobuf" publicKeyToken="a7d26565bac4d604" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-3.23.4.0" newVersion="3.23.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="ZstdSharp" publicKeyToken="8d151af33a4ad5cf" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-0.7.2.0" newVersion="0.7.2.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Configuration.ConfigurationManager" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/K4os.Hash.xxHash.xml

@@ -0,0 +1,245 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>K4os.Hash.xxHash</name>
+    </assembly>
+    <members>
+        <member name="T:K4os.Hash.xxHash.HashAlgorithmAdapter">
+            <summary>
+            Adapter implementing <see cref="T:System.Security.Cryptography.HashAlgorithm"/>
+            </summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.HashAlgorithmAdapter.#ctor(System.Int32,System.Action,System.Action{System.Byte[],System.Int32,System.Int32},System.Func{System.Byte[]})">
+            <summary>
+            Creates new <see cref="T:K4os.Hash.xxHash.HashAlgorithmAdapter"/>. 
+            </summary>
+            <param name="hashSize">Hash size (in bytes)</param>
+            <param name="reset">Reset function.</param>
+            <param name="update">Update function.</param>
+            <param name="digest">Digest function.</param>
+        </member>
+        <member name="P:K4os.Hash.xxHash.HashAlgorithmAdapter.HashSize">
+            <inheritdoc />
+        </member>
+        <member name="P:K4os.Hash.xxHash.HashAlgorithmAdapter.Hash">
+            <inheritdoc />
+        </member>
+        <member name="M:K4os.Hash.xxHash.HashAlgorithmAdapter.HashCore(System.Byte[],System.Int32,System.Int32)">
+            <inheritdoc />
+        </member>
+        <member name="M:K4os.Hash.xxHash.HashAlgorithmAdapter.HashFinal">
+            <inheritdoc />
+        </member>
+        <member name="M:K4os.Hash.xxHash.HashAlgorithmAdapter.Initialize">
+            <inheritdoc />
+        </member>
+        <member name="T:K4os.Hash.xxHash.XXH">
+            <summary>
+            Base class for both <see cref="T:K4os.Hash.xxHash.XXH32"/> and <see cref="T:K4os.Hash.xxHash.XXH64"/>. Do not use directly.
+            </summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH.#ctor">
+            <summary>Protected constructor to prevent instantiation.</summary>
+        </member>
+        <member name="T:K4os.Hash.xxHash.XXH32">
+            <summary>
+            xxHash 32-bit.
+            </summary>
+        </member>
+        <member name="T:K4os.Hash.xxHash.XXH32.State">
+            <summary>Internal state of the algorithm.</summary>
+        </member>
+        <member name="F:K4os.Hash.xxHash.XXH32.EmptyHash">
+            <summary>Hash of empty buffer.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.DigestOf(System.Void*,System.Int32)">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.DigestOf(System.Void*,System.Int32,System.UInt32)">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+            <param name="seed">Seed.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.DigestOf(System.ReadOnlySpan{System.Byte})">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.DigestOf(System.Byte[],System.Int32,System.Int32)">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="offset">Starting offset.</param>
+            <param name="length">Length of buffer.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.#ctor">
+            <summary>Creates xxHash instance.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.#ctor(System.UInt32)">
+            <summary>Creates xxHash instance.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Reset">
+            <summary>Resets hash calculation.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Reset(System.UInt32)">
+            <summary>Resets hash calculation.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Update(System.Void*,System.Int32)">
+            <summary>Updates the hash using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Update(System.Byte*,System.Int32)">
+            <summary>Updates the hash using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Update(System.ReadOnlySpan{System.Byte})">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Update(System.Byte[],System.Int32,System.Int32)">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="offset">Starting offset.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Digest">
+            <summary>Hash so far.</summary>
+            <returns>Hash so far.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.DigestBytes">
+            <summary>Hash so far, as byte array.</summary>
+            <returns>Hash so far.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.AsHashAlgorithm">
+            <summary>Converts this class to <see cref="T:System.Security.Cryptography.HashAlgorithm"/></summary>
+            <returns><see cref="T:System.Security.Cryptography.HashAlgorithm"/></returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Reset(K4os.Hash.xxHash.XXH32.State@,System.UInt32)">
+            <summary>Resets hash calculation.</summary>
+            <param name="state">Hash state.</param>
+            <param name="seed">Hash seed.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Update(K4os.Hash.xxHash.XXH32.State@,System.Void*,System.Int32)">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="state">Hash state.</param>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Update(K4os.Hash.xxHash.XXH32.State@,System.ReadOnlySpan{System.Byte})">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="state">Hash state.</param>
+            <param name="bytes">Buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH32.Digest(K4os.Hash.xxHash.XXH32.State@)">
+            <summary>Hash so far.</summary>
+            <returns>Hash so far.</returns>
+        </member>
+        <member name="T:K4os.Hash.xxHash.XXH64">
+            <summary>
+            xxHash 64-bit.
+            </summary>
+        </member>
+        <member name="T:K4os.Hash.xxHash.XXH64.State">
+            <summary>Internal state of the algorithm.</summary>
+        </member>
+        <member name="F:K4os.Hash.xxHash.XXH64.EmptyHash">
+            <summary>Hash of empty buffer.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.DigestOf(System.Void*,System.Int32)">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.DigestOf(System.Void*,System.Int32,System.UInt64)">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+            <param name="seed">Seed.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.DigestOf(System.ReadOnlySpan{System.Byte})">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.DigestOf(System.Byte[],System.Int32,System.Int32)">
+            <summary>Hash of provided buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="offset">Starting offset.</param>
+            <param name="length">Length of buffer.</param>
+            <returns>Digest.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.#ctor">
+            <summary>Creates xxHash instance.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.#ctor(System.UInt64)">
+            <summary>Creates xxHash instance.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Reset">
+            <summary>Resets hash calculation.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Reset(System.UInt64)">
+            <summary>Resets hash calculation.</summary>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Update(System.Void*,System.Int32)">
+            <summary>Updates the hash using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Update(System.Byte*,System.Int32)">
+            <summary>Updates the hash using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Update(System.ReadOnlySpan{System.Byte})">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Update(System.Byte[],System.Int32,System.Int32)">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="bytes">Buffer.</param>
+            <param name="offset">Starting offset.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Digest">
+            <summary>Hash so far.</summary>
+            <returns>Hash so far.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.DigestBytes">
+            <summary>Hash so far, as byte array.</summary>
+            <returns>Hash so far.</returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.AsHashAlgorithm">
+            <summary>Converts this class to <see cref="T:System.Security.Cryptography.HashAlgorithm"/></summary>
+            <returns><see cref="T:System.Security.Cryptography.HashAlgorithm"/></returns>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Reset(K4os.Hash.xxHash.XXH64.State@,System.UInt64)">
+            <summary>Resets hash calculation.</summary>
+            <param name="state">Hash state.</param>
+            <param name="seed">Hash seed.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Update(K4os.Hash.xxHash.XXH64.State@,System.Void*,System.Int32)">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="state">Hash state.</param>
+            <param name="bytes">Buffer.</param>
+            <param name="length">Length of buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Update(K4os.Hash.xxHash.XXH64.State@,System.ReadOnlySpan{System.Byte})">
+            <summary>Updates the has using given buffer.</summary>
+            <param name="state">Hash state.</param>
+            <param name="bytes">Buffer.</param>
+        </member>
+        <member name="M:K4os.Hash.xxHash.XXH64.Digest(K4os.Hash.xxHash.XXH64.State@)">
+            <summary>Hash so far.</summary>
+            <returns>Hash so far.</returns>
+        </member>
+    </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/Microsoft.Bcl.AsyncInterfaces.xml

@@ -0,0 +1,417 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Microsoft.Bcl.AsyncInterfaces</name>
+    </assembly>
+    <members>
+        <member name="T:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1">
+            <summary>Provides the core logic for implementing a manual-reset <see cref="T:System.Threading.Tasks.Sources.IValueTaskSource"/> or <see cref="T:System.Threading.Tasks.Sources.IValueTaskSource`1"/>.</summary>
+            <typeparam name="TResult"></typeparam>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._continuation">
+            <summary>
+            The callback to invoke when the operation completes if <see cref="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags)"/> was called before the operation completed,
+            or <see cref="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCoreShared.s_sentinel"/> if the operation completed before a callback was supplied,
+            or null if a callback hasn't yet been provided and the operation hasn't yet completed.
+            </summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._continuationState">
+            <summary>State to pass to <see cref="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._continuation"/>.</summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._executionContext">
+            <summary><see cref="T:System.Threading.ExecutionContext"/> to flow to the callback, or null if no flowing is required.</summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._capturedContext">
+            <summary>
+            A "captured" <see cref="T:System.Threading.SynchronizationContext"/> or <see cref="T:System.Threading.Tasks.TaskScheduler"/> with which to invoke the callback,
+            or null if no special context is required.
+            </summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._completed">
+            <summary>Whether the current operation has completed.</summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._result">
+            <summary>The result with which the operation succeeded, or the default value if it hasn't yet completed or failed.</summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._error">
+            <summary>The exception with which the operation failed, or null if it hasn't yet completed or completed successfully.</summary>
+        </member>
+        <member name="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._version">
+            <summary>The current version of this value, used to help prevent misuse.</summary>
+        </member>
+        <member name="P:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.RunContinuationsAsynchronously">
+            <summary>Gets or sets whether to force continuations to run asynchronously.</summary>
+            <remarks>Continuations may run asynchronously if this is false, but they'll never run synchronously if this is true.</remarks>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.Reset">
+            <summary>Resets to prepare for the next operation.</summary>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetResult(`0)">
+            <summary>Completes with a successful result.</summary>
+            <param name="result">The result.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SetException(System.Exception)">
+            <summary>Complets with an error.</summary>
+            <param name="error"></param>
+        </member>
+        <member name="P:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.Version">
+            <summary>Gets the operation version.</summary>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetStatus(System.Int16)">
+            <summary>Gets the status of the operation.</summary>
+            <param name="token">Opaque value that was provided to the <see cref="T:System.Threading.Tasks.ValueTask"/>'s constructor.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.GetResult(System.Int16)">
+            <summary>Gets the result of the operation.</summary>
+            <param name="token">Opaque value that was provided to the <see cref="T:System.Threading.Tasks.ValueTask"/>'s constructor.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.OnCompleted(System.Action{System.Object},System.Object,System.Int16,System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags)">
+            <summary>Schedules the continuation action for this operation.</summary>
+            <param name="continuation">The continuation to invoke when the operation has completed.</param>
+            <param name="state">The state object to pass to <paramref name="continuation"/> when it's invoked.</param>
+            <param name="token">Opaque value that was provided to the <see cref="T:System.Threading.Tasks.ValueTask"/>'s constructor.</param>
+            <param name="flags">The flags describing the behavior of the continuation.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.ValidateToken(System.Int16)">
+            <summary>Ensures that the specified token matches the current version.</summary>
+            <param name="token">The token supplied by <see cref="T:System.Threading.Tasks.ValueTask"/>.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.SignalCompletion">
+            <summary>Signals that the operation has completed.  Invoked after the result or error has been set.</summary>
+        </member>
+        <member name="M:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1.InvokeContinuation">
+            <summary>
+            Invokes the continuation with the appropriate captured context / scheduler.
+            This assumes that if <see cref="F:System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore`1._executionContext"/> is not null we're already
+            running within that <see cref="T:System.Threading.ExecutionContext"/>.
+            </summary>
+        </member>
+        <member name="T:System.Threading.Tasks.TaskAsyncEnumerableExtensions">
+            <summary>Provides a set of static methods for configuring <see cref="T:System.Threading.Tasks.Task"/>-related behaviors on asynchronous enumerables and disposables.</summary>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait(System.IAsyncDisposable,System.Boolean)">
+            <summary>Configures how awaits on the tasks returned from an async disposable will be performed.</summary>
+            <param name="source">The source async disposable.</param>
+            <param name="continueOnCapturedContext">Whether to capture and marshal back to the current context.</param>
+            <returns>The configured async disposable.</returns>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.ConfigureAwait``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Boolean)">
+            <summary>Configures how awaits on the tasks returned from an async iteration will be performed.</summary>
+            <typeparam name="T">The type of the objects being iterated.</typeparam>
+            <param name="source">The source enumerable being iterated.</param>
+            <param name="continueOnCapturedContext">Whether to capture and marshal back to the current context.</param>
+            <returns>The configured enumerable.</returns>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.WithCancellation``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken)">
+            <summary>Sets the <see cref="T:System.Threading.CancellationToken"/> to be passed to <see cref="M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken)"/> when iterating.</summary>
+            <typeparam name="T">The type of the objects being iterated.</typeparam>
+            <param name="source">The source enumerable being iterated.</param>
+            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> to use.</param>
+            <returns>The configured enumerable.</returns>
+        </member>
+        <member name="T:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder">
+            <summary>Represents a builder for asynchronous iterators.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Create">
+            <summary>Creates an instance of the <see cref="T:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder"/> struct.</summary>
+            <returns>The initialized instance.</returns>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.MoveNext``1(``0@)">
+            <summary>Invokes <see cref="M:System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext"/> on the state machine while guarding the <see cref="T:System.Threading.ExecutionContext"/>.</summary>
+            <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+            <param name="stateMachine">The state machine instance, passed by reference.</param>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitOnCompleted``2(``0@,``1@)">
+            <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes.</summary>
+            <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+            <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+            <param name="awaiter">The awaiter.</param>
+            <param name="stateMachine">The state machine.</param>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitUnsafeOnCompleted``2(``0@,``1@)">
+            <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes.</summary>
+            <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+            <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+            <param name="awaiter">The awaiter.</param>
+            <param name="stateMachine">The state machine.</param>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete">
+            <summary>Marks iteration as being completed, whether successfully or otherwise.</summary>
+        </member>
+        <member name="P:System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.ObjectIdForDebugger">
+            <summary>Gets an object that may be used to uniquely identify this builder to the debugger.</summary>
+        </member>
+        <member name="T:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute">
+            <summary>Indicates whether a method is an asynchronous iterator.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute.#ctor(System.Type)">
+            <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute"/> class.</summary>
+            <param name="stateMachineType">The type object for the underlying state machine type that's used to implement a state machine method.</param>
+        </member>
+        <member name="T:System.Runtime.CompilerServices.ConfiguredAsyncDisposable">
+            <summary>Provides a type that can be used to configure how awaits on an <see cref="T:System.IAsyncDisposable"/> are performed.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.ConfiguredAsyncDisposable.DisposeAsync">
+            <summary>Asynchronously releases the unmanaged resources used by the <see cref="T:System.Runtime.CompilerServices.ConfiguredAsyncDisposable" />.</summary>
+            <returns>A task that represents the asynchronous dispose operation.</returns>
+        </member>
+        <member name="T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1">
+            <summary>Provides an awaitable async enumerable that enables cancelable iteration and configured awaits.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.ConfigureAwait(System.Boolean)">
+            <summary>Configures how awaits on the tasks returned from an async iteration will be performed.</summary>
+            <param name="continueOnCapturedContext">Whether to capture and marshal back to the current context.</param>
+            <returns>The configured enumerable.</returns>
+            <remarks>This will replace any previous value set by <see cref="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.ConfigureAwait(System.Boolean)"/> for this iteration.</remarks>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.WithCancellation(System.Threading.CancellationToken)">
+            <summary>Sets the <see cref="T:System.Threading.CancellationToken"/> to be passed to <see cref="M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken)"/> when iterating.</summary>
+            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> to use.</param>
+            <returns>The configured enumerable.</returns>
+            <remarks>This will replace any previous <see cref="T:System.Threading.CancellationToken"/> set by <see cref="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.WithCancellation(System.Threading.CancellationToken)"/> for this iteration.</remarks>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.GetAsyncEnumerator">
+            <summary>Returns an enumerator that iterates asynchronously through collections that enables cancelable iteration and configured awaits.</summary>
+            <returns>An enumerator for the <see cref="T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1" /> class.</returns>
+        </member>
+        <member name="T:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator">
+            <summary>Provides an awaitable async enumerator that enables cancelable iteration and configured awaits.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.MoveNextAsync">
+            <summary>Advances the enumerator asynchronously to the next element of the collection.</summary>
+            <returns>
+            A <see cref="T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1"/> that will complete with a result of <c>true</c>
+            if the enumerator was successfully advanced to the next element, or <c>false</c> if the enumerator has
+            passed the end of the collection.
+            </returns>
+        </member>
+        <member name="P:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.Current">
+            <summary>Gets the element in the collection at the current position of the enumerator.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.Enumerator.DisposeAsync">
+            <summary>
+            Performs application-defined tasks associated with freeing, releasing, or
+            resetting unmanaged resources asynchronously.
+            </summary>
+        </member>
+        <member name="T:System.Runtime.CompilerServices.EnumeratorCancellationAttribute">
+            <summary>Allows users of async-enumerable methods to mark the parameter that should receive the cancellation token value from <see cref="M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken)" />.</summary>
+        </member>
+        <member name="M:System.Runtime.CompilerServices.EnumeratorCancellationAttribute.#ctor">
+            <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.EnumeratorCancellationAttribute" /> class.</summary>
+        </member>
+        <member name="T:System.Runtime.InteropServices.LibraryImportAttribute">
+            <summary>
+            Attribute used to indicate a source generator should create a function for marshalling
+            arguments instead of relying on the runtime to generate an equivalent marshalling function at run-time.
+            </summary>
+            <remarks>
+            This attribute is meaningless if the source generator associated with it is not enabled.
+            The current built-in source generator only supports C# and only supplies an implementation when
+            applied to static, partial, non-generic methods.
+            </remarks>
+        </member>
+        <member name="M:System.Runtime.InteropServices.LibraryImportAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.LibraryImportAttribute"/>.
+            </summary>
+            <param name="libraryName">Name of the library containing the import.</param>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.LibraryName">
+            <summary>
+            Gets the name of the library containing the import.
+            </summary>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.EntryPoint">
+            <summary>
+            Gets or sets the name of the entry point to be called.
+            </summary>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshalling">
+            <summary>
+            Gets or sets how to marshal string arguments to the method.
+            </summary>
+            <remarks>
+            If this field is set to a value other than <see cref="F:System.Runtime.InteropServices.StringMarshalling.Custom" />,
+            <see cref="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshallingCustomType" /> must not be specified.
+            </remarks>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshallingCustomType">
+            <summary>
+            Gets or sets the <see cref="T:System.Type"/> used to control how string arguments to the method are marshalled.
+            </summary>
+            <remarks>
+            If this field is specified, <see cref="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshalling" /> must not be specified
+            or must be set to <see cref="F:System.Runtime.InteropServices.StringMarshalling.Custom" />.
+            </remarks>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.SetLastError">
+            <summary>
+            Gets or sets whether the callee sets an error (SetLastError on Windows or errno
+            on other platforms) before returning from the attributed method.
+            </summary>
+        </member>
+        <member name="T:System.Runtime.InteropServices.StringMarshalling">
+            <summary>
+            Specifies how strings should be marshalled for generated p/invokes
+            </summary>
+        </member>
+        <member name="F:System.Runtime.InteropServices.StringMarshalling.Custom">
+            <summary>
+            Indicates the user is supplying a specific marshaller in <see cref="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshallingCustomType"/>.
+            </summary>
+        </member>
+        <member name="F:System.Runtime.InteropServices.StringMarshalling.Utf8">
+            <summary>
+            Use the platform-provided UTF-8 marshaller.
+            </summary>
+        </member>
+        <member name="F:System.Runtime.InteropServices.StringMarshalling.Utf16">
+            <summary>
+            Use the platform-provided UTF-16 marshaller.
+            </summary>
+        </member>
+        <member name="T:System.Collections.Generic.IAsyncEnumerable`1">
+            <summary>Exposes an enumerator that provides asynchronous iteration over values of a specified type.</summary>
+            <typeparam name="T">The type of values to enumerate.</typeparam>
+        </member>
+        <member name="M:System.Collections.Generic.IAsyncEnumerable`1.GetAsyncEnumerator(System.Threading.CancellationToken)">
+            <summary>Returns an enumerator that iterates asynchronously through the collection.</summary>
+            <param name="cancellationToken">A <see cref="T:System.Threading.CancellationToken"/> that may be used to cancel the asynchronous iteration.</param>
+            <returns>An enumerator that can be used to iterate asynchronously through the collection.</returns>
+        </member>
+        <member name="T:System.Collections.Generic.IAsyncEnumerator`1">
+            <summary>Supports a simple asynchronous iteration over a generic collection.</summary>
+            <typeparam name="T">The type of objects to enumerate.</typeparam>
+        </member>
+        <member name="M:System.Collections.Generic.IAsyncEnumerator`1.MoveNextAsync">
+            <summary>Advances the enumerator asynchronously to the next element of the collection.</summary>
+            <returns>
+            A <see cref="T:System.Threading.Tasks.ValueTask`1"/> that will complete with a result of <c>true</c> if the enumerator
+            was successfully advanced to the next element, or <c>false</c> if the enumerator has passed the end
+            of the collection.
+            </returns>
+        </member>
+        <member name="P:System.Collections.Generic.IAsyncEnumerator`1.Current">
+            <summary>Gets the element in the collection at the current position of the enumerator.</summary>
+        </member>
+        <member name="T:System.IAsyncDisposable">
+            <summary>Provides a mechanism for releasing unmanaged resources asynchronously.</summary>
+        </member>
+        <member name="M:System.IAsyncDisposable.DisposeAsync">
+            <summary>
+            Performs application-defined tasks associated with freeing, releasing, or
+            resetting unmanaged resources asynchronously.
+            </summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.AllowNullAttribute">
+            <summary>Specifies that null is allowed as an input even if the corresponding type disallows it.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.DisallowNullAttribute">
+            <summary>Specifies that null is disallowed as an input even if the corresponding type allows it.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MaybeNullAttribute">
+            <summary>Specifies that an output may be null even if the corresponding type disallows it.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.NotNullAttribute">
+            <summary>Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute">
+            <summary>Specifies that when a method returns <see cref="P:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.#ctor(System.Boolean)">
+            <summary>Initializes the attribute with the specified return value condition.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated parameter may be null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.ReturnValue">
+            <summary>Gets the return value condition.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute">
+            <summary>Specifies that when a method returns <see cref="P:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.#ctor(System.Boolean)">
+            <summary>Initializes the attribute with the specified return value condition.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated parameter will not be null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.ReturnValue">
+            <summary>Gets the return value condition.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute">
+            <summary>Specifies that the output will be non-null if the named parameter is non-null.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.#ctor(System.String)">
+            <summary>Initializes the attribute with the associated parameter name.</summary>
+            <param name="parameterName">
+            The associated parameter name.  The output will be non-null if the argument to the parameter specified is non-null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.ParameterName">
+            <summary>Gets the associated parameter name.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute">
+            <summary>Applied to a method that will never return under any circumstance.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute">
+            <summary>Specifies that the method will not return if the associated Boolean parameter is passed the specified value.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.#ctor(System.Boolean)">
+            <summary>Initializes the attribute with the specified parameter value.</summary>
+            <param name="parameterValue">
+            The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
+            the associated parameter matches this value.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.ParameterValue">
+            <summary>Gets the condition parameter value.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute">
+            <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String)">
+            <summary>Initializes the attribute with a field or property member.</summary>
+            <param name="member">
+            The field or property member that is promised to be not-null.
+            </param>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String[])">
+            <summary>Initializes the attribute with the list of field and property members.</summary>
+            <param name="members">
+            The list of field and property members that are promised to be not-null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.Members">
+            <summary>Gets field or property member names.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute">
+            <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String)">
+            <summary>Initializes the attribute with the specified return value condition and a field or property member.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated field or property member will not be null.
+            </param>
+            <param name="member">
+            The field or property member that is promised to be not-null.
+            </param>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String[])">
+            <summary>Initializes the attribute with the specified return value condition and list of field and property members.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated field and property members will not be null.
+            </param>
+            <param name="members">
+            The list of field and property members that are promised to be not-null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.ReturnValue">
+            <summary>Gets the return value condition.</summary>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.Members">
+            <summary>Gets field or property member names.</summary>
+        </member>
+    </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/Microsoft.Bcl.HashCode.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Microsoft.Bcl.HashCode</name>
+    </assembly>
+    <members>
+        <member name="M:System.Numerics.BitOperations.RotateLeft(System.UInt32,System.Int32)">
+            <summary>
+            Rotates the specified value left by the specified number of bits.
+            Similar in behavior to the x86 instruction ROL.
+            </summary>
+            <param name="value">The value to rotate.</param>
+            <param name="offset">The number of bits to rotate by.
+            Any value outside the range [0..31] is treated as congruent mod 32.</param>
+            <returns>The rotated value.</returns>
+        </member>
+        <member name="M:System.Numerics.BitOperations.RotateLeft(System.UInt64,System.Int32)">
+            <summary>
+            Rotates the specified value left by the specified number of bits.
+            Similar in behavior to the x86 instruction ROL.
+            </summary>
+            <param name="value">The value to rotate.</param>
+            <param name="offset">The number of bits to rotate by.
+            Any value outside the range [0..63] is treated as congruent mod 64.</param>
+            <returns>The rotated value.</returns>
+        </member>
+        <member name="P:System.SR.HashCode_EqualityNotSupported">
+            <summary>HashCode is a mutable struct and should not be compared with other HashCodes.</summary>
+        </member>
+        <member name="P:System.SR.HashCode_HashCodeNotSupported">
+            <summary>HashCode is a mutable struct and should not be compared with other HashCodes. Use ToHashCode to retrieve the computed hash code.</summary>
+        </member>
+    </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/PLC.dll.config

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encoding.CodePages" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-13.0.0.0" newVersion="13.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" /></startup></configuration>

JinYuan.VirtualDataLibrary/bin/Debug/System.Buffers.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?><doc>
+  <assembly>
+    <name>System.Buffers</name>
+  </assembly>
+  <members>
+    <member name="T:System.Buffers.ArrayPool`1">
+      <summary>Provides a resource pool that enables reusing instances of type <see cref="T[]"></see>.</summary>
+      <typeparam name="T">The type of the objects that are in the resource pool.</typeparam>
+    </member>
+    <member name="M:System.Buffers.ArrayPool`1.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:System.Buffers.ArrayPool`1"></see> class.</summary>
+    </member>
+    <member name="M:System.Buffers.ArrayPool`1.Create">
+      <summary>Creates a new instance of the <see cref="T:System.Buffers.ArrayPool`1"></see> class.</summary>
+      <returns>A new instance of the <see cref="System.Buffers.ArrayPool`1"></see> class.</returns>
+    </member>
+    <member name="M:System.Buffers.ArrayPool`1.Create(System.Int32,System.Int32)">
+      <summary>Creates a new instance of the <see cref="T:System.Buffers.ArrayPool`1"></see> class using the specifed configuration.</summary>
+      <param name="maxArrayLength">The maximum length of an array instance that may be stored in the pool.</param>
+      <param name="maxArraysPerBucket">The maximum number of array instances that may be stored in each bucket in the pool. The pool groups arrays of similar lengths into buckets for faster access.</param>
+      <returns>A new instance of the <see cref="System.Buffers.ArrayPool`1"></see> class with the specified configuration.</returns>
+    </member>
+    <member name="M:System.Buffers.ArrayPool`1.Rent(System.Int32)">
+      <summary>Retrieves a buffer that is at least the requested length.</summary>
+      <param name="minimumLength">The minimum length of the array.</param>
+      <returns>An array of type <see cref="T[]"></see> that is at least <paramref name="minimumLength">minimumLength</paramref> in length.</returns>
+    </member>
+    <member name="M:System.Buffers.ArrayPool`1.Return(`0[],System.Boolean)">
+      <summary>Returns an array to the pool that was previously obtained using the <see cref="M:System.Buffers.ArrayPool`1.Rent(System.Int32)"></see> method on the same <see cref="T:System.Buffers.ArrayPool`1"></see> instance.</summary>
+      <param name="array">A buffer to return to the pool that was previously obtained using the <see cref="M:System.Buffers.ArrayPool`1.Rent(System.Int32)"></see> method.</param>
+      <param name="clearArray">Indicates whether the contents of the buffer should be cleared before reuse. If <paramref name="clearArray">clearArray</paramref> is set to true, and if the pool will store the buffer to enable subsequent reuse, the <see cref="M:System.Buffers.ArrayPool`1.Return(`0[],System.Boolean)"></see> method will clear the <paramref name="array">array</paramref> of its contents so that a subsequent caller using the <see cref="M:System.Buffers.ArrayPool`1.Rent(System.Int32)"></see> method will not see the content of the previous caller. If <paramref name="clearArray">clearArray</paramref> is set to false or if the pool will release the buffer, the array&amp;#39;s contents are left unchanged.</param>
+    </member>
+    <member name="P:System.Buffers.ArrayPool`1.Shared">
+      <summary>Gets a shared <see cref="T:System.Buffers.ArrayPool`1"></see> instance.</summary>
+      <returns>A shared <see cref="System.Buffers.ArrayPool`1"></see> instance.</returns>
+    </member>
+  </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/System.IO.Pipelines.xml

@@ -0,0 +1,848 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>System.IO.Pipelines</name>
+    </assembly>
+    <members>
+        <member name="T:System.Threading.Tasks.TaskToApm">
+            <summary>
+            Provides support for efficiently using Tasks to implement the APM (Begin/End) pattern.
+            </summary>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.Begin(System.Threading.Tasks.Task,System.AsyncCallback,System.Object)">
+            <summary>
+            Marshals the Task as an IAsyncResult, using the supplied callback and state
+            to implement the APM pattern.
+            </summary>
+            <param name="task">The Task to be marshaled.</param>
+            <param name="callback">The callback to be invoked upon completion.</param>
+            <param name="state">The state to be stored in the IAsyncResult.</param>
+            <returns>An IAsyncResult to represent the task's asynchronous operation.</returns>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.End(System.IAsyncResult)">
+            <summary>Processes an IAsyncResult returned by Begin.</summary>
+            <param name="asyncResult">The IAsyncResult to unwrap.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.End``1(System.IAsyncResult)">
+            <summary>Processes an IAsyncResult returned by Begin.</summary>
+            <param name="asyncResult">The IAsyncResult to unwrap.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.GetTask(System.IAsyncResult)">
+            <summary>Gets the task represented by the IAsyncResult.</summary>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.ThrowArgumentException(System.IAsyncResult)">
+            <summary>Throws an argument exception for the invalid <paramref name="asyncResult"/>.</summary>
+        </member>
+        <member name="T:System.Threading.Tasks.TaskToApm.TaskAsyncResult">
+            <summary>Provides a simple IAsyncResult that wraps a Task.</summary>
+            <remarks>
+            We could use the Task as the IAsyncResult if the Task's AsyncState is the same as the object state,
+            but that's very rare, in particular in a situation where someone cares about allocation, and always
+            using TaskAsyncResult simplifies things and enables additional optimizations.
+            </remarks>
+        </member>
+        <member name="F:System.Threading.Tasks.TaskToApm.TaskAsyncResult._task">
+            <summary>The wrapped Task.</summary>
+        </member>
+        <member name="F:System.Threading.Tasks.TaskToApm.TaskAsyncResult._callback">
+            <summary>Callback to invoke when the wrapped task completes.</summary>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.TaskAsyncResult.#ctor(System.Threading.Tasks.Task,System.Object,System.AsyncCallback)">
+            <summary>Initializes the IAsyncResult with the Task to wrap and the associated object state.</summary>
+            <param name="task">The Task to wrap.</param>
+            <param name="state">The new AsyncState value.</param>
+            <param name="callback">Callback to invoke when the wrapped task completes.</param>
+        </member>
+        <member name="M:System.Threading.Tasks.TaskToApm.TaskAsyncResult.InvokeCallback">
+            <summary>Invokes the callback.</summary>
+        </member>
+        <member name="P:System.Threading.Tasks.TaskToApm.TaskAsyncResult.AsyncState">
+            <summary>Gets a user-defined object that qualifies or contains information about an asynchronous operation.</summary>
+        </member>
+        <member name="P:System.Threading.Tasks.TaskToApm.TaskAsyncResult.CompletedSynchronously">
+            <summary>Gets a value that indicates whether the asynchronous operation completed synchronously.</summary>
+            <remarks>This is set lazily based on whether the <see cref="F:System.Threading.Tasks.TaskToApm.TaskAsyncResult._task"/> has completed by the time this object is created.</remarks>
+        </member>
+        <member name="P:System.Threading.Tasks.TaskToApm.TaskAsyncResult.IsCompleted">
+            <summary>Gets a value that indicates whether the asynchronous operation has completed.</summary>
+        </member>
+        <member name="P:System.Threading.Tasks.TaskToApm.TaskAsyncResult.AsyncWaitHandle">
+            <summary>Gets a <see cref="T:System.Threading.WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary>
+        </member>
+        <member name="P:System.IO.Pipelines.BufferSegment.End">
+            <summary>
+            The End represents the offset into AvailableMemory where the range of "active" bytes ends. At the point when the block is leased
+            the End is guaranteed to be equal to Start. The value of Start may be assigned anywhere between 0 and
+            Buffer.Length, and must be equal to or less than End.
+            </summary>
+        </member>
+        <member name="P:System.IO.Pipelines.BufferSegment.NextSegment">
+            <summary>
+            Reference to the next block of data when the overall "active" bytes spans multiple blocks. At the point when the block is
+            leased Next is guaranteed to be null. Start, End, and Next are used together in order to create a linked-list of discontiguous
+            working memory. The "active" memory is grown when bytes are copied in, End is increased, and Next is assigned. The "active"
+            memory is shrunk when bytes are consumed, Start is increased, and blocks are returned to the pool.
+            </summary>
+        </member>
+        <member name="T:System.IO.Pipelines.FlushResult">
+            <summary>Result returned by <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> call.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.FlushResult.#ctor(System.Boolean,System.Boolean)">
+            <summary>Initializes a new instance of <see cref="T:System.IO.Pipelines.FlushResult" /> struct setting the <see cref="P:System.IO.Pipelines.FlushResult.IsCanceled" /> and <see cref="P:System.IO.Pipelines.FlushResult.IsCompleted" /> flags.</summary>
+            <param name="isCanceled"><see langword="true" /> to indicate the current <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> operation that produced this <see cref="T:System.IO.Pipelines.FlushResult" /> was canceled by <see cref="M:System.IO.Pipelines.PipeWriter.CancelPendingFlush" />; otherwise, <see langword="false" />.</param>
+            <param name="isCompleted"><see langword="true" /> to indicate the reader is no longer reading data written to the <see cref="T:System.IO.Pipelines.PipeWriter" />.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.FlushResult.IsCanceled">
+            <summary>Gets a value that indicates whether the current <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> operation was canceled by <see cref="M:System.IO.Pipelines.PipeWriter.CancelPendingFlush" />.</summary>
+            <value><see langword="true" /> if the current <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> operation was canceled by <see cref="M:System.IO.Pipelines.PipeWriter.CancelPendingFlush" />; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.FlushResult.IsCompleted">
+            <summary>Gets a value that indicates the reader is no longer reading data written to the <see cref="T:System.IO.Pipelines.PipeWriter" />.</summary>
+            <value><see langword="true" /> if the reader is no longer reading data written to the <see cref="T:System.IO.Pipelines.PipeWriter" />; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="T:System.IO.Pipelines.IDuplexPipe">
+            <summary>Defines a class that provides a duplex pipe from which data can be read from and written to.</summary>
+        </member>
+        <member name="P:System.IO.Pipelines.IDuplexPipe.Input">
+            <summary>Gets the <see cref="T:System.IO.Pipelines.PipeReader" /> half of the duplex pipe.</summary>
+        </member>
+        <member name="P:System.IO.Pipelines.IDuplexPipe.Output">
+            <summary>Gets the <see cref="T:System.IO.Pipelines.PipeWriter" /> half of the duplex pipe.</summary>
+        </member>
+        <member name="T:System.IO.Pipelines.BufferSegmentStack.SegmentAsValueType">
+            <summary>
+            A simple struct we wrap reference types inside when storing in arrays to
+            bypass the CLR's covariant checks when writing to arrays.
+            </summary>
+            <remarks>
+            We use <see cref="T:System.IO.Pipelines.BufferSegmentStack.SegmentAsValueType"/> as a wrapper to avoid paying the cost of covariant checks whenever
+            the underlying array that the <see cref="T:System.IO.Pipelines.BufferSegmentStack"/> class uses is written to.
+            We've recognized this as a perf win in ETL traces for these stack frames:
+            clr!JIT_Stelem_Ref
+              clr!ArrayStoreCheck
+                clr!ObjIsInstanceOf
+            </remarks>
+        </member>
+        <member name="T:System.IO.Pipelines.Pipe">
+            <summary>The default <see cref="T:System.IO.Pipelines.PipeWriter" /> and <see cref="T:System.IO.Pipelines.PipeReader" /> implementation.</summary>
+            <summary>The default <see cref="T:System.IO.Pipelines.PipeWriter" /> and <see cref="T:System.IO.Pipelines.PipeReader" /> implementation.</summary>
+            <summary>The default <see cref="T:System.IO.Pipelines.PipeWriter" /> and <see cref="T:System.IO.Pipelines.PipeReader" /> implementation.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.Pipe.#ctor">
+            <summary>Initializes a new instance of the <see cref="T:System.IO.Pipelines.Pipe" /> class using <see cref="P:System.IO.Pipelines.PipeOptions.Default" /> as options.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.Pipe.#ctor(System.IO.Pipelines.PipeOptions)">
+            <summary>Initializes a new instance of the <see cref="T:System.IO.Pipelines.Pipe" /> class with the specified options.</summary>
+            <param name="options">The set of options for this pipe.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.Pipe.Reader">
+            <summary>Gets the <see cref="T:System.IO.Pipelines.PipeReader" /> for this pipe.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeReader" /> instance for this pipe.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.Pipe.Writer">
+            <summary>Gets the <see cref="T:System.IO.Pipelines.PipeWriter" /> for this pipe.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeWriter" /> instance for this pipe.</value>
+        </member>
+        <member name="M:System.IO.Pipelines.Pipe.Reset">
+            <summary>Resets the pipe.</summary>
+        </member>
+        <member name="T:System.IO.Pipelines.PipeOptions">
+            <summary>Represents a set of <see cref="T:System.IO.Pipelines.Pipe" /> options.</summary>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.Default">
+            <summary>Gets the default instance of <see cref="T:System.IO.Pipelines.PipeOptions" />.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeOptions" /> object initialized with default parameters.</value>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeOptions.#ctor(System.Buffers.MemoryPool{System.Byte},System.IO.Pipelines.PipeScheduler,System.IO.Pipelines.PipeScheduler,System.Int64,System.Int64,System.Int32,System.Boolean)">
+            <summary>Initializes a new instance of the <see cref="T:System.IO.Pipelines.PipeOptions" /> class with the specified parameters.</summary>
+            <param name="pool">The pool of memory blocks to be used for buffer management.</param>
+            <param name="readerScheduler">The <see cref="T:System.IO.Pipelines.PipeScheduler" /> to be used to execute <see cref="T:System.IO.Pipelines.PipeReader" /> callbacks and async continuations.</param>
+            <param name="writerScheduler">The <see cref="T:System.IO.Pipelines.PipeScheduler" /> used to execute <see cref="T:System.IO.Pipelines.PipeWriter" /> callbacks and async continuations.</param>
+            <param name="pauseWriterThreshold">The number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> before <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> starts blocking. A value of zero prevents <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> from ever blocking, effectively making the number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> unlimited.</param>
+            <param name="resumeWriterThreshold">The number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> when <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> stops blocking.</param>
+            <param name="minimumSegmentSize">The minimum size of the segment requested from <paramref name="pool" />.</param>
+            <param name="useSynchronizationContext"><see langword="true" /> if asynchronous continuations should be executed on the <see cref="T:System.Threading.SynchronizationContext" /> they were captured on; <see langword="false" /> otherwise. This takes precedence over the schedulers specified in <see cref="P:System.IO.Pipelines.PipeOptions.ReaderScheduler" /> and <see cref="P:System.IO.Pipelines.PipeOptions.WriterScheduler" />.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.UseSynchronizationContext">
+            <summary>Gets a value that determines if asynchronous callbacks and continuations should be executed on the <see cref="T:System.Threading.SynchronizationContext" /> they were captured on. This takes precedence over the schedulers specified in <see cref="P:System.IO.Pipelines.PipeOptions.ReaderScheduler" /> and <see cref="P:System.IO.Pipelines.PipeOptions.WriterScheduler" />.</summary>
+            <value><see langword="true" /> if asynchronous callbacks and continuations should be executed on the <see cref="T:System.Threading.SynchronizationContext" /> they were captured on; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.PauseWriterThreshold">
+            <summary>Gets the number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> when <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> starts blocking.</summary>
+            <value>The number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> when <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> starts blocking.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.ResumeWriterThreshold">
+            <summary>Gets the number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> when <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> stops blocking.</summary>
+            <value>The number of bytes in the <see cref="T:System.IO.Pipelines.Pipe" /> when <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> stops blocking.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.MinimumSegmentSize">
+            <summary>Gets the minimum size of the segment requested from the <see cref="P:System.IO.Pipelines.PipeOptions.Pool" />.</summary>
+            <value>The minimum size of the segment requested from the <see cref="P:System.IO.Pipelines.PipeOptions.Pool" />.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.WriterScheduler">
+            <summary>Gets the <see cref="T:System.IO.Pipelines.PipeScheduler" /> used to execute <see cref="T:System.IO.Pipelines.PipeWriter" /> callbacks and async continuations.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeScheduler" /> object used to execute <see cref="T:System.IO.Pipelines.PipeWriter" /> callbacks and async continuations.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.ReaderScheduler">
+            <summary>Gets the <see cref="T:System.IO.Pipelines.PipeScheduler" /> used to execute <see cref="T:System.IO.Pipelines.PipeReader" /> callbacks and async continuations.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeScheduler" /> that is used to execute <see cref="T:System.IO.Pipelines.PipeReader" /> callbacks and async continuations.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.Pool">
+            <summary>Gets the <see cref="T:System.Buffers.MemoryPool`1" /> object used for buffer management.</summary>
+            <value>A pool of memory blocks used for buffer management.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.IsDefaultSharedMemoryPool">
+            <summary>
+            Returns true if Pool is <see cref="T:System.Buffers.MemoryPool`1"/>.Shared
+            </summary>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.InitialSegmentPoolSize">
+            <summary>
+            The initialize size of the segment pool
+            </summary>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeOptions.MaxSegmentPoolSize">
+            <summary>
+            The maximum number of segments to pool
+            </summary>
+        </member>
+        <member name="T:System.IO.Pipelines.PipeReader">
+            <summary>Defines a class that provides access to a read side of pipe.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.TryRead(System.IO.Pipelines.ReadResult@)">
+             <summary>Attempts to synchronously read data from the <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+             <param name="result">When this method returns <see langword="true" />, this value is set to a <see cref="T:System.IO.Pipelines.ReadResult" /> instance that represents the result of the read call; otherwise, this value is set to <see langword="default" />.</param>
+             <returns><see langword="true" /> if data was available, or if the call was canceled or the writer was completed; otherwise, <see langword="false" />.</returns>
+             <remarks><format type="text/markdown"><![CDATA[
+             If the pipe returns <see langword="false" />, there is no need to call <see cref="System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)" />.
+             [!IMPORTANT]
+             The `System.IO.Pipelines.PipeReader` implementation returned by `System.IO.Pipelines.PipeReader.Create(System.IO.Stream, System.IO.Pipelines.StreamPipeReaderOptions?)`
+             will not read new data from the backing `System.IO.Stream` when `System.IO.Pipelines.PipeReader.TryRead(out System.IO.Pipelines.ReadResult)` is called.
+            
+             `System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)` must be called to read new data from the backing `System.IO.Stream`.
+             Any unconsumed data from a previous asynchronous read will be available to `System.IO.Pipelines.PipeReader.TryRead(out System.IO.Pipelines.ReadResult)`.
+             ]]></format></remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)">
+            <summary>Asynchronously reads a sequence of bytes from the current <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see langword="default" />.</param>
+            <returns>A <see cref="T:System.Threading.Tasks.ValueTask`1" /> representing the asynchronous read operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.ReadAtLeastAsync(System.Int32,System.Threading.CancellationToken)">
+            <summary>Asynchronously reads a sequence of bytes from the current <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+            <param name="minimumSize">The minimum length that needs to be buffered in order to for the call to return.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see langword="default" />.</param>
+            <returns>A <see cref="T:System.Threading.Tasks.ValueTask`1" /> representing the asynchronous read operation.</returns>
+            <remarks>
+                <para>
+                The call returns if the <see cref="T:System.IO.Pipelines.PipeReader" /> has read the minimumLength specified, or is cancelled or completed.
+                </para>
+                <para>
+                Passing a value of 0 for <paramref name="minimumSize" /> will return a <see cref="T:System.Threading.Tasks.ValueTask`1" /> that will not complete until
+                further data is available. You should instead call <see cref="M:System.IO.Pipelines.PipeReader.TryRead(System.IO.Pipelines.ReadResult@)" /> to avoid a blocking call.
+                </para>
+                <para>
+                Subsequent calls to <see cref="M:System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)" /> should
+                examine at least <paramref name="minimumSize" /> bytes in order to avoid an <see cref="T:System.InvalidOperationException" />.
+                </para>
+            </remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.ReadAtLeastAsyncCore(System.Int32,System.Threading.CancellationToken)">
+            <summary>Asynchronously reads a sequence of bytes from the current <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+            <param name="minimumSize">The minimum length that needs to be buffered in order to for the call to return.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see langword="default" />.</param>
+            <returns>A <see cref="T:System.Threading.Tasks.ValueTask`1" /> representing the asynchronous read operation.</returns>
+            <remarks>The call returns if the <see cref="T:System.IO.Pipelines.PipeReader" /> has read the minimumLength specified, or is cancelled or completed.</remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition)">
+            <summary>Moves forward the pipeline's read cursor to after the consumed data, marking the data as processed.</summary>
+            <param name="consumed">Marks the extent of the data that has been successfully processed.</param>
+            <remarks>The memory for the consumed data will be released and no longer available.
+            The <see cref="P:System.IO.Pipelines.ReadResult.Buffer" /> previously returned from <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> must not be accessed after this call.
+            This is equivalent to calling <see cref="M:System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)" /> with identical examined and consumed positions.
+            The examined data communicates to the pipeline when it should signal more data is available.
+            Because the consumed parameter doubles as the examined parameter, the consumed parameter should be greater than or equal to the examined position in the previous call to `AdvanceTo`. Otherwise, an <see cref="T:System.InvalidOperationException" /> is thrown.</remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)">
+            <summary>Moves forward the pipeline's read cursor to after the consumed data, marking the data as processed, read and examined.</summary>
+            <param name="consumed">Marks the extent of the data that has been successfully processed.</param>
+            <param name="examined">Marks the extent of the data that has been read and examined.</param>
+            <remarks>The memory for the consumed data will be released and no longer available.
+            The <see cref="P:System.IO.Pipelines.ReadResult.Buffer" /> previously returned from <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> must not be accessed after this call.
+            The examined data communicates to the pipeline when it should signal more data is available.
+            The examined parameter should be greater than or equal to the examined position in the previous call to `AdvanceTo`. Otherwise, an <see cref="T:System.InvalidOperationException" /> is thrown.</remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.AsStream(System.Boolean)">
+            <summary>Returns a <see cref="T:System.IO.Stream" /> representation of the <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+            <param name="leaveOpen">An optional flag that indicates whether disposing the returned <see cref="T:System.IO.Stream" /> leaves <see cref="T:System.IO.Pipelines.PipeReader" /> open (<see langword="true" />) or completes <see cref="T:System.IO.Pipelines.PipeReader" /> (<see langword="false" />).</param>
+            <returns>A stream that represents the <see cref="T:System.IO.Pipelines.PipeReader" />.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.CancelPendingRead">
+            <summary>Cancels the pending <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> operation without causing it to throw and without completing the <see cref="T:System.IO.Pipelines.PipeReader" />. If there is no pending operation, this cancels the next operation.</summary>
+            <remarks>The canceled <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> operation returns a <see cref="T:System.IO.Pipelines.ReadResult" /> where <see cref="P:System.IO.Pipelines.ReadResult.IsCanceled" /> is <see langword="true" />.</remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.Complete(System.Exception)">
+            <summary>Signals to the producer that the consumer is done reading.</summary>
+            <param name="exception">Optional <see cref="T:System.Exception" /> indicating a failure that's causing the pipeline to complete.</param>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.CompleteAsync(System.Exception)">
+            <summary>Marks the current pipe reader instance as being complete, meaning no more data will be read from it.</summary>
+            <param name="exception">An optional exception that indicates the failure that caused the reader to complete.</param>
+            <returns>A value task that represents the asynchronous complete operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.OnWriterCompleted(System.Action{System.Exception,System.Object},System.Object)">
+            <summary>Registers a callback that executes when the <see cref="T:System.IO.Pipelines.PipeWriter" /> side of the pipe is completed.</summary>
+            <param name="callback">The callback to register.</param>
+            <param name="state">The state object to pass to <paramref name="callback" /> when it's invoked.</param>
+            <remarks><format type="text/markdown"><![CDATA[
+            > [!IMPORTANT]
+            > `OnWriterCompleted` may not be invoked on all implementations of <xref:System.IO.Pipelines.PipeWriter>. This method will be removed in a future release.
+            ]]></format></remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.Create(System.IO.Stream,System.IO.Pipelines.StreamPipeReaderOptions)">
+            <summary>Creates a <see cref="T:System.IO.Pipelines.PipeReader" /> wrapping the specified <see cref="T:System.IO.Stream" />.</summary>
+            <param name="stream">The stream that the pipe reader will wrap.</param>
+            <param name="readerOptions">The options to configure the pipe reader.</param>
+            <returns>A <see cref="T:System.IO.Pipelines.PipeReader" /> that wraps the <see cref="T:System.IO.Stream" />.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.Create(System.Buffers.ReadOnlySequence{System.Byte})">
+            <summary>
+            Creates a <see cref="T:System.IO.Pipelines.PipeReader"/> wrapping the specified <see cref="T:System.Buffers.ReadOnlySequence`1"/>.
+            </summary>
+            <param name="sequence">The sequence.</param>
+            <returns>A <see cref="T:System.IO.Pipelines.PipeReader"/> that wraps the <see cref="T:System.Buffers.ReadOnlySequence`1"/>.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.CopyToAsync(System.IO.Pipelines.PipeWriter,System.Threading.CancellationToken)">
+            <summary>Asynchronously reads the bytes from the <see cref="T:System.IO.Pipelines.PipeReader" /> and writes them to the specified <see cref="T:System.IO.Pipelines.PipeWriter" />, using a specified buffer size and cancellation token.</summary>
+            <param name="destination">The pipe writer to which the contents of the current stream will be copied.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+            <returns>A task that represents the asynchronous copy operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeReader.CopyToAsync(System.IO.Stream,System.Threading.CancellationToken)">
+            <summary>Asynchronously reads the bytes from the <see cref="T:System.IO.Pipelines.PipeReader" /> and writes them to the specified stream, using a specified cancellation token.</summary>
+            <param name="destination">The stream to which the contents of the current stream will be copied.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+            <returns>A task that represents the asynchronous copy operation.</returns>
+        </member>
+        <member name="T:System.IO.Pipelines.PipeScheduler">
+            <summary>Abstraction for running <see cref="T:System.IO.Pipelines.PipeReader" /> and <see cref="T:System.IO.Pipelines.PipeWriter" /> callbacks and continuations.</summary>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeScheduler.ThreadPool">
+            <summary>The <see cref="T:System.IO.Pipelines.PipeScheduler" /> implementation that queues callbacks to the thread pool.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeScheduler" /> instance that queues callbacks to the thread pool.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeScheduler.Inline">
+            <summary>The <see cref="T:System.IO.Pipelines.PipeScheduler" /> implementation that runs callbacks inline.</summary>
+            <value>A <see cref="T:System.IO.Pipelines.PipeScheduler" /> instance that runs callbacks inline.</value>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeScheduler.Schedule(System.Action{System.Object},System.Object)">
+            <summary>Requests <paramref name="action" /> to be run on scheduler with <paramref name="state" /> being passed in.</summary>
+            <param name="action">The single-parameter action delegate to schedule.</param>
+            <param name="state">The parameter to pass to the <paramref name="action" /> delegate.</param>
+        </member>
+        <member name="T:System.IO.Pipelines.PipeWriter">
+            <summary>Defines a class that provides a pipeline to which data can be written.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.Complete(System.Exception)">
+            <summary>Marks the <see cref="T:System.IO.Pipelines.PipeWriter" /> as being complete, meaning no more items will be written to it.</summary>
+            <param name="exception">Optional <see cref="T:System.Exception" /> indicating a failure that's causing the pipeline to complete.</param>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.CompleteAsync(System.Exception)">
+            <summary>Marks the current pipe writer instance as being complete, meaning no more data will be written to it.</summary>
+            <param name="exception">An optional exception that indicates the failure that caused the pipeline to complete.</param>
+            <returns>A value task that represents the asynchronous complete operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.CancelPendingFlush">
+            <summary>Cancels the pending <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> or <see cref="M:System.IO.Pipelines.PipeWriter.WriteAsync(System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)" /> operation without causing the operation to throw and without completing the <see cref="T:System.IO.Pipelines.PipeWriter" />. If there is no pending operation, this cancels the next operation.</summary>
+            <remarks>The canceled <see cref="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> or <see cref="M:System.IO.Pipelines.PipeWriter.WriteAsync(System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)" /> operation returns a <see cref="T:System.IO.Pipelines.FlushResult" /> where <see cref="P:System.IO.Pipelines.FlushResult.IsCanceled" /> is <see langword="true" />.</remarks>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeWriter.CanGetUnflushedBytes">
+            <summary>Gets a value that indicates whether the current <see cref="T:System.IO.Pipelines.PipeWriter" /> supports reporting the count of unflushed bytes.</summary>
+            <value><see langword="true" />If a class derived from <see cref="T:System.IO.Pipelines.PipeWriter" /> does not support getting the unflushed bytes, calls to <see cref="P:System.IO.Pipelines.PipeWriter.UnflushedBytes" /> throw <see cref="T:System.NotImplementedException" />.</value>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.OnReaderCompleted(System.Action{System.Exception,System.Object},System.Object)">
+            <summary>Registers a callback that executes when the <see cref="T:System.IO.Pipelines.PipeReader" /> side of the pipe is completed.</summary>
+            <param name="callback">The callback to register.</param>
+            <param name="state">The state object to pass to <paramref name="callback" /> when it's invoked.</param>
+            <remarks><format type="text/markdown"><![CDATA[
+            > [!IMPORTANT]
+            > `OnReaderCompleted` may not be invoked on all implementations of <xref:System.IO.Pipelines.PipeWriter>. This method will be removed in a future release.
+            ]]></format></remarks>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)">
+            <summary>Makes bytes written available to <see cref="T:System.IO.Pipelines.PipeReader" /> and runs <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> continuation.</summary>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+            <returns>A task that represents and wraps the asynchronous flush operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.Advance(System.Int32)">
+            <summary>Notifies the <see cref="T:System.IO.Pipelines.PipeWriter" /> that <paramref name="bytes" /> bytes were written to the output <see cref="T:System.Span`1" /> or <see cref="T:System.Memory`1" />. You must request a new buffer after calling <see cref="M:System.IO.Pipelines.PipeWriter.Advance(System.Int32)" /> to continue writing more data; you cannot write to a previously acquired buffer.</summary>
+            <param name="bytes">The number of bytes written to the <see cref="T:System.Span`1" /> or <see cref="T:System.Memory`1" />.</param>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.GetMemory(System.Int32)">
+            <summary>Returns a <see cref="T:System.Memory`1" /> to write to that is at least the requested size, as specified by the <paramref name="sizeHint" /> parameter.</summary>
+            <param name="sizeHint">The minimum length of the returned <see cref="T:System.Memory`1" />. If 0, a non-empty memory buffer of arbitrary size is returned.</param>
+            <returns>A memory buffer of at least <paramref name="sizeHint" /> bytes. If <paramref name="sizeHint" /> is 0, returns a non-empty buffer of arbitrary size.</returns>
+            <remarks>There is no guarantee that successive calls will return the same buffer or the same-sized buffer.
+            This method never returns <see cref="P:System.Memory`1.Empty" />, but it throws an <see cref="T:System.OutOfMemoryException" /> if the requested buffer size is not available.
+            You must request a new buffer after calling <see cref="M:System.IO.Pipelines.PipeWriter.Advance(System.Int32)" /> to continue writing more data; you cannot write to a previously acquired buffer.</remarks>
+            <exception cref="T:System.OutOfMemoryException">The requested buffer size is not available.</exception>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.GetSpan(System.Int32)">
+            <summary>Returns a <see cref="T:System.Span`1" /> to write to that is at least the requested size, as specified by the <paramref name="sizeHint" /> parameter.</summary>
+            <param name="sizeHint">The minimum length of the returned <see cref="T:System.Span`1" />. If 0, a non-empty buffer of arbitrary size is returned.</param>
+            <returns>A buffer of at least <paramref name="sizeHint" /> bytes. If <paramref name="sizeHint" /> is 0, returns a non-empty buffer of arbitrary size.</returns>
+            <remarks>There is no guarantee that successive calls will return the same buffer or the same-sized buffer.
+            This method never returns <see cref="P:System.Span`1.Empty" />, but it throws an <see cref="T:System.OutOfMemoryException" /> if the requested buffer size is not available.
+            You must request a new buffer after calling <see cref="M:System.IO.Pipelines.PipeWriter.Advance(System.Int32)" /> to continue writing more data; you cannot write to a previously acquired buffer.</remarks>
+            <exception cref="T:System.OutOfMemoryException">The requested buffer size is not available.</exception>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.AsStream(System.Boolean)">
+            <summary>Returns a <see cref="T:System.IO.Stream" /> representation of the <see cref="T:System.IO.Pipelines.PipeWriter" />.</summary>
+            <param name="leaveOpen">An optional flag that indicates whether disposing the returned <see cref="T:System.IO.Stream" /> leaves <see cref="T:System.IO.Pipelines.PipeReader" /> open (<see langword="true" />) or completes <see cref="T:System.IO.Pipelines.PipeReader" /> (<see langword="false" />).</param>
+            <returns>A stream that represents the <see cref="T:System.IO.Pipelines.PipeWriter" />.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.Create(System.IO.Stream,System.IO.Pipelines.StreamPipeWriterOptions)">
+            <summary>Creates a <see cref="T:System.IO.Pipelines.PipeWriter" /> wrapping the specified <see cref="T:System.IO.Stream" />.</summary>
+            <param name="stream">The stream that the pipe writer will wrap.</param>
+            <param name="writerOptions">The options to configure the pipe writer.</param>
+            <returns>A <see cref="T:System.IO.Pipelines.PipeWriter" /> that wraps the <see cref="T:System.IO.Stream" />.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.WriteAsync(System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)">
+            <summary>Writes the specified byte memory range to the pipe and makes data accessible to the <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+            <param name="source">The read-only byte memory region to write.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+            <returns>A task that represents the asynchronous write operation, and wraps the flush asynchronous operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.PipeWriter.CopyFromAsync(System.IO.Stream,System.Threading.CancellationToken)">
+            <summary>Asynchronously reads the bytes from the specified stream and writes them to the <see cref="T:System.IO.Pipelines.PipeWriter" />.</summary>
+            <param name="source">The stream from which the contents will be copied.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+            <returns>A task that represents the asynchronous copy operation.</returns>
+        </member>
+        <member name="P:System.IO.Pipelines.PipeWriter.UnflushedBytes">
+            <summary>
+            When overridden in a derived class, gets the count of unflushed bytes within the current writer.
+            </summary>
+            <exception cref="T:System.NotImplementedException">The <see cref="T:System.IO.Pipelines.PipeWriter"/> does not support getting the unflushed byte count.</exception>
+        </member>
+        <member name="T:System.IO.Pipelines.ReadResult">
+            <summary>Represents the result of a <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> call.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.ReadResult.#ctor(System.Buffers.ReadOnlySequence{System.Byte},System.Boolean,System.Boolean)">
+            <summary>Creates a new instance of <see cref="T:System.IO.Pipelines.ReadResult" /> setting <see cref="P:System.IO.Pipelines.ReadResult.IsCanceled" /> and <see cref="P:System.IO.Pipelines.ReadResult.IsCompleted" /> flags.</summary>
+            <param name="buffer">The read-only sequence containing the bytes of data that were read in the <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> call.</param>
+            <param name="isCanceled">A flag that indicates if the <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> operation that produced this <see cref="T:System.IO.Pipelines.ReadResult" /> was canceled by <see cref="M:System.IO.Pipelines.PipeReader.CancelPendingRead" />.</param>
+            <param name="isCompleted">A flag that indicates whether the end of the data stream has been reached.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.ReadResult.Buffer">
+            <summary>Gets the <see cref="T:System.Buffers.ReadOnlySequence`1" /> that was read.</summary>
+            <value>A read-only sequence containing the bytes of data that were read in the <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> call.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.ReadResult.IsCanceled">
+            <summary>Gets a value that indicates whether the current <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> operation was canceled by <see cref="M:System.IO.Pipelines.PipeReader.CancelPendingRead" />.</summary>
+            <value><see langword="true" /> if the <see cref="M:System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)" /> operation that produced this <see cref="T:System.IO.Pipelines.ReadResult" /> was canceled by <see cref="M:System.IO.Pipelines.PipeReader.CancelPendingRead" />; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.ReadResult.IsCompleted">
+            <summary>Gets a value that indicates whether the end of the data stream has been reached.</summary>
+            <value><see langword="true" /> if the end of the data stream has been reached; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="M:System.IO.Pipelines.SequencePipeReader.AdvanceTo(System.SequencePosition)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.SequencePipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.SequencePipeReader.CancelPendingRead">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.SequencePipeReader.Complete(System.Exception)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.SequencePipeReader.ReadAsync(System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.SequencePipeReader.TryRead(System.IO.Pipelines.ReadResult@)">
+            <inheritdoc />
+        </member>
+        <member name="T:System.IO.Pipelines.StreamPipeExtensions">
+            <summary>Provides extension methods for <see cref="T:System.IO.Stream" /> that support read and write operations directly into pipes.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeExtensions.CopyToAsync(System.IO.Stream,System.IO.Pipelines.PipeWriter,System.Threading.CancellationToken)">
+            <summary>Asynchronously reads the bytes from the <see cref="T:System.IO.Stream" /> and writes them to the specified <see cref="T:System.IO.Pipelines.PipeWriter" />, using a cancellation token.</summary>
+            <param name="source">The stream from which the contents of the current stream will be copied.</param>
+            <param name="destination">The writer to which the contents of the source stream will be copied.</param>
+            <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+            <returns>A task that represents the asynchronous copy operation.</returns>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.#ctor(System.IO.Stream,System.IO.Pipelines.StreamPipeReaderOptions)">
+            <summary>
+            Creates a new StreamPipeReader.
+            </summary>
+            <param name="readingStream">The stream to read from.</param>
+            <param name="options">The options to use.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReader.InnerStream">
+            <summary>
+            Gets the inner stream that is being read from.
+            </summary>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.AdvanceTo(System.SequencePosition)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.CancelPendingRead">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.Complete(System.Exception)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.ReadAsync(System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.CopyToAsync(System.IO.Pipelines.PipeWriter,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReader.CopyToAsync(System.IO.Stream,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="T:System.IO.Pipelines.StreamPipeReaderOptions">
+            <summary>Represents a set of options for controlling the creation of the <see cref="T:System.IO.Pipelines.PipeReader" />.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReaderOptions.#ctor(System.Buffers.MemoryPool{System.Byte},System.Int32,System.Int32,System.Boolean)">
+            <summary>Initializes a <see cref="T:System.IO.Pipelines.StreamPipeReaderOptions" /> instance, optionally specifying a memory pool, a minimum buffer size, a minimum read size, and whether the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeReader" /> completes.</summary>
+            <param name="pool">The memory pool to use when allocating memory. The default value is <see langword="null" />.</param>
+            <param name="bufferSize">The minimum buffer size to use when renting memory from the <paramref name="pool" />. The default value is 4096.</param>
+            <param name="minimumReadSize">The threshold of remaining bytes in the buffer before a new buffer is allocated. The default value is 1024.</param>
+            <param name="leaveOpen"><see langword="true" /> to leave the underlying stream open after the <see cref="T:System.IO.Pipelines.PipeReader" /> completes; <see langword="false" /> to close it. The default is <see langword="false" />.</param>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeReaderOptions.#ctor(System.Buffers.MemoryPool{System.Byte},System.Int32,System.Int32,System.Boolean,System.Boolean)">
+            <summary>Initializes a <see cref="T:System.IO.Pipelines.StreamPipeReaderOptions" /> instance, optionally specifying a memory pool, a minimum buffer size, a minimum read size, and whether the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeReader" /> completes.</summary>
+            <param name="pool">The memory pool to use when allocating memory. The default value is <see langword="null" />.</param>
+            <param name="bufferSize">The minimum buffer size to use when renting memory from the <paramref name="pool" />. The default value is 4096.</param>
+            <param name="minimumReadSize">The threshold of remaining bytes in the buffer before a new buffer is allocated. The default value is 1024.</param>
+            <param name="leaveOpen"><see langword="true" /> to leave the underlying stream open after the <see cref="T:System.IO.Pipelines.PipeReader" /> completes; <see langword="false" /> to close it. The default is <see langword="false" />.</param>
+            <param name="useZeroByteReads"><see langword="true" /> if reads with an empty buffer should be issued to the underlying stream before allocating memory; otherwise, <see langword="false" />.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.BufferSize">
+            <summary>Gets the minimum buffer size to use when renting memory from the <see cref="P:System.IO.Pipelines.StreamPipeReaderOptions.Pool" />.</summary>
+            <value>The buffer size.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.MaxBufferSize">
+            <summary>Gets the maximum buffer size to use when renting memory from the <see cref="P:System.IO.Pipelines.StreamPipeReaderOptions.Pool" />.</summary>
+            <value>The maximum buffer size.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.MinimumReadSize">
+            <summary>Gets the threshold of remaining bytes in the buffer before a new buffer is allocated.</summary>
+            <value>The minimum read size.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.Pool">
+            <summary>Gets the <see cref="T:System.Buffers.MemoryPool`1" /> to use when allocating memory.</summary>
+            <value>A memory pool instance.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.LeaveOpen">
+            <summary>Gets the value that indicates if the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeReader" /> completes.</summary>
+            <value><see langword="true" /> if the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeReader" /> completes; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.UseZeroByteReads">
+            <summary>Gets the value that indicates if reads with an empty buffer should be issued to the underlying stream, in order to wait for data to arrive before allocating memory.</summary>
+            <value><see langword="true" /> if reads with an empty buffer should be issued to the underlying stream before allocating memory; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeReaderOptions.IsDefaultSharedMemoryPool">
+            <summary>
+            Returns true if Pool is <see cref="T:System.Buffers.MemoryPool`1"/>.Shared
+            </summary>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeWriter.InnerStream">
+            <summary>
+            Gets the inner stream that is being written to.
+            </summary>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriter.Advance(System.Int32)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriter.GetMemory(System.Int32)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriter.GetSpan(System.Int32)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriter.CancelPendingFlush">
+            <inheritdoc />
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeWriter.CanGetUnflushedBytes">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriter.Complete(System.Exception)">
+            <inheritdoc />
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriter.FlushAsync(System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeWriter.UnflushedBytes">
+            <inheritdoc />
+        </member>
+        <member name="T:System.IO.Pipelines.StreamPipeWriterOptions">
+            <summary>Represents a set of options for controlling the creation of the <see cref="T:System.IO.Pipelines.PipeWriter" />.</summary>
+        </member>
+        <member name="M:System.IO.Pipelines.StreamPipeWriterOptions.#ctor(System.Buffers.MemoryPool{System.Byte},System.Int32,System.Boolean)">
+            <summary>Initializes a <see cref="T:System.IO.Pipelines.StreamPipeWriterOptions" /> instance, optionally specifying a memory pool, a minimum buffer size, and whether the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeWriter" /> completes.</summary>
+            <param name="pool">The memory pool to use when allocating memory. The default value is <see langword="null" />.</param>
+            <param name="minimumBufferSize">The minimum buffer size to use when renting memory from the <paramref name="pool" />. The default value is 4096.</param>
+            <param name="leaveOpen"><see langword="true" /> to leave the underlying stream open after the <see cref="T:System.IO.Pipelines.PipeWriter" /> completes; <see langword="false" /> to close it. The default is <see langword="false" />.</param>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeWriterOptions.MinimumBufferSize">
+            <summary>Gets the minimum buffer size to use when renting memory from the <see cref="P:System.IO.Pipelines.StreamPipeWriterOptions.Pool" />.</summary>
+            <value>An integer representing the minimum buffer size.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeWriterOptions.Pool">
+            <summary>Gets the <see cref="T:System.Buffers.MemoryPool`1" /> to use when allocating memory.</summary>
+            <value>A memory pool instance.</value>
+        </member>
+        <member name="P:System.IO.Pipelines.StreamPipeWriterOptions.LeaveOpen">
+            <summary>Gets the value that indicates if the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeWriter" /> completes.</summary>
+            <value><see langword="true" /> if the underlying stream should be left open after the <see cref="T:System.IO.Pipelines.PipeWriter" /> completes; otherwise, <see langword="false" />.</value>
+        </member>
+        <member name="T:System.IO.StreamHelpers">
+            <summary>Provides methods to help in the implementation of Stream-derived types.</summary>
+        </member>
+        <member name="M:System.IO.StreamHelpers.ValidateCopyToArgs(System.IO.Stream,System.IO.Stream,System.Int32)">
+            <summary>Validate the arguments to CopyTo, as would Stream.CopyTo.</summary>
+        </member>
+        <member name="P:System.SR.AdvanceToInvalidCursor">
+            <summary>The PipeReader has already advanced past the provided position.</summary>
+        </member>
+        <member name="P:System.SR.ArgumentOutOfRange_NeedPosNum">
+            <summary>Positive number required.</summary>
+        </member>
+        <member name="P:System.SR.ConcurrentOperationsNotSupported">
+            <summary>Concurrent reads or writes are not supported.</summary>
+        </member>
+        <member name="P:System.SR.FlushCanceledOnPipeWriter">
+            <summary>Flush was canceled on underlying PipeWriter.</summary>
+        </member>
+        <member name="P:System.SR.GetResultBeforeCompleted">
+            <summary>Can't GetResult unless awaiter is completed.</summary>
+        </member>
+        <member name="P:System.SR.InvalidExaminedOrConsumedPosition">
+            <summary>The examined position must be greater than or equal to the consumed position.</summary>
+        </member>
+        <member name="P:System.SR.InvalidExaminedPosition">
+            <summary>The examined position cannot be less than the previously examined position.</summary>
+        </member>
+        <member name="P:System.SR.InvalidZeroByteRead">
+            <summary>The PipeReader returned 0 bytes when the ReadResult was not completed or canceled.</summary>
+        </member>
+        <member name="P:System.SR.ObjectDisposed_StreamClosed">
+            <summary>Cannot access a closed stream.</summary>
+        </member>
+        <member name="P:System.SR.NoReadingOperationToComplete">
+            <summary>No reading operation to complete.</summary>
+        </member>
+        <member name="P:System.SR.NotSupported_UnreadableStream">
+            <summary>Stream does not support reading.</summary>
+        </member>
+        <member name="P:System.SR.NotSupported_UnwritableStream">
+            <summary>Stream does not support writing.</summary>
+        </member>
+        <member name="P:System.SR.ReadCanceledOnPipeReader">
+            <summary>Read was canceled on underlying PipeReader.</summary>
+        </member>
+        <member name="P:System.SR.ReaderAndWriterHasToBeCompleted">
+            <summary>Both reader and writer has to be completed to be able to reset the pipe.</summary>
+        </member>
+        <member name="P:System.SR.ReadingAfterCompleted">
+            <summary>Reading is not allowed after reader was completed.</summary>
+        </member>
+        <member name="P:System.SR.ReadingIsInProgress">
+            <summary>Reading is already in progress.</summary>
+        </member>
+        <member name="P:System.SR.WritingAfterCompleted">
+            <summary>Writing is not allowed after writer was completed.</summary>
+        </member>
+        <member name="P:System.SR.UnflushedBytesNotSupported">
+            <summary>UnflushedBytes is not supported.</summary>
+        </member>
+        <member name="T:System.Runtime.InteropServices.LibraryImportAttribute">
+            <summary>
+            Attribute used to indicate a source generator should create a function for marshalling
+            arguments instead of relying on the runtime to generate an equivalent marshalling function at run-time.
+            </summary>
+            <remarks>
+            This attribute is meaningless if the source generator associated with it is not enabled.
+            The current built-in source generator only supports C# and only supplies an implementation when
+            applied to static, partial, non-generic methods.
+            </remarks>
+        </member>
+        <member name="M:System.Runtime.InteropServices.LibraryImportAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.LibraryImportAttribute"/>.
+            </summary>
+            <param name="libraryName">Name of the library containing the import.</param>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.LibraryName">
+            <summary>
+            Gets the name of the library containing the import.
+            </summary>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.EntryPoint">
+            <summary>
+            Gets or sets the name of the entry point to be called.
+            </summary>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshalling">
+            <summary>
+            Gets or sets how to marshal string arguments to the method.
+            </summary>
+            <remarks>
+            If this field is set to a value other than <see cref="F:System.Runtime.InteropServices.StringMarshalling.Custom" />,
+            <see cref="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshallingCustomType" /> must not be specified.
+            </remarks>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshallingCustomType">
+            <summary>
+            Gets or sets the <see cref="T:System.Type"/> used to control how string arguments to the method are marshalled.
+            </summary>
+            <remarks>
+            If this field is specified, <see cref="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshalling" /> must not be specified
+            or must be set to <see cref="F:System.Runtime.InteropServices.StringMarshalling.Custom" />.
+            </remarks>
+        </member>
+        <member name="P:System.Runtime.InteropServices.LibraryImportAttribute.SetLastError">
+            <summary>
+            Gets or sets whether the callee sets an error (SetLastError on Windows or errno
+            on other platforms) before returning from the attributed method.
+            </summary>
+        </member>
+        <member name="T:System.Runtime.InteropServices.StringMarshalling">
+            <summary>
+            Specifies how strings should be marshalled for generated p/invokes
+            </summary>
+        </member>
+        <member name="F:System.Runtime.InteropServices.StringMarshalling.Custom">
+            <summary>
+            Indicates the user is suppling a specific marshaller in <see cref="P:System.Runtime.InteropServices.LibraryImportAttribute.StringMarshallingCustomType"/>.
+            </summary>
+        </member>
+        <member name="F:System.Runtime.InteropServices.StringMarshalling.Utf8">
+            <summary>
+            Use the platform-provided UTF-8 marshaller.
+            </summary>
+        </member>
+        <member name="F:System.Runtime.InteropServices.StringMarshalling.Utf16">
+            <summary>
+            Use the platform-provided UTF-16 marshaller.
+            </summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.AllowNullAttribute">
+            <summary>Specifies that null is allowed as an input even if the corresponding type disallows it.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.DisallowNullAttribute">
+            <summary>Specifies that null is disallowed as an input even if the corresponding type allows it.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MaybeNullAttribute">
+            <summary>Specifies that an output may be null even if the corresponding type disallows it.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.NotNullAttribute">
+            <summary>Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute">
+            <summary>Specifies that when a method returns <see cref="P:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.#ctor(System.Boolean)">
+            <summary>Initializes the attribute with the specified return value condition.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated parameter may be null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute.ReturnValue">
+            <summary>Gets the return value condition.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute">
+            <summary>Specifies that when a method returns <see cref="P:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.#ctor(System.Boolean)">
+            <summary>Initializes the attribute with the specified return value condition.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated parameter will not be null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute.ReturnValue">
+            <summary>Gets the return value condition.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute">
+            <summary>Specifies that the output will be non-null if the named parameter is non-null.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.#ctor(System.String)">
+            <summary>Initializes the attribute with the associated parameter name.</summary>
+            <param name="parameterName">
+            The associated parameter name.  The output will be non-null if the argument to the parameter specified is non-null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute.ParameterName">
+            <summary>Gets the associated parameter name.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute">
+            <summary>Applied to a method that will never return under any circumstance.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute">
+            <summary>Specifies that the method will not return if the associated Boolean parameter is passed the specified value.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.#ctor(System.Boolean)">
+            <summary>Initializes the attribute with the specified parameter value.</summary>
+            <param name="parameterValue">
+            The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
+            the associated parameter matches this value.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute.ParameterValue">
+            <summary>Gets the condition parameter value.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute">
+            <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String)">
+            <summary>Initializes the attribute with a field or property member.</summary>
+            <param name="member">
+            The field or property member that is promised to be not-null.
+            </param>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.#ctor(System.String[])">
+            <summary>Initializes the attribute with the list of field and property members.</summary>
+            <param name="members">
+            The list of field and property members that are promised to be not-null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute.Members">
+            <summary>Gets field or property member names.</summary>
+        </member>
+        <member name="T:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute">
+            <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.</summary>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String)">
+            <summary>Initializes the attribute with the specified return value condition and a field or property member.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated parameter will not be null.
+            </param>
+            <param name="member">
+            The field or property member that is promised to be not-null.
+            </param>
+        </member>
+        <member name="M:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.#ctor(System.Boolean,System.String[])">
+            <summary>Initializes the attribute with the specified return value condition and list of field and property members.</summary>
+            <param name="returnValue">
+            The return value condition. If the method returns this value, the associated parameter will not be null.
+            </param>
+            <param name="members">
+            The list of field and property members that are promised to be not-null.
+            </param>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.ReturnValue">
+            <summary>Gets the return value condition.</summary>
+        </member>
+        <member name="P:System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute.Members">
+            <summary>Gets field or property member names.</summary>
+        </member>
+    </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/System.Memory.xml

@@ -0,0 +1,355 @@
+<?xml version="1.0" encoding="utf-8"?><doc>
+  <assembly>
+    <name>System.Memory</name>
+  </assembly>
+  <members>
+    <member name="T:System.Span`1">
+      <typeparam name="T"></typeparam>
+    </member>
+    <member name="M:System.Span`1.#ctor(`0[])">
+      <param name="array"></param>
+    </member>
+    <member name="M:System.Span`1.#ctor(System.Void*,System.Int32)">
+      <param name="pointer"></param>
+      <param name="length"></param>
+    </member>
+    <member name="M:System.Span`1.#ctor(`0[],System.Int32)">
+      <param name="array"></param>
+      <param name="start"></param>
+    </member>
+    <member name="M:System.Span`1.#ctor(`0[],System.Int32,System.Int32)">
+      <param name="array"></param>
+      <param name="start"></param>
+      <param name="length"></param>
+    </member>
+    <member name="M:System.Span`1.Clear">
+      
+    </member>
+    <member name="M:System.Span`1.CopyTo(System.Span{`0})">
+      <param name="destination"></param>
+    </member>
+    <member name="M:System.Span`1.DangerousCreate(System.Object,`0@,System.Int32)">
+      <param name="obj"></param>
+      <param name="objectData"></param>
+      <param name="length"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.DangerousGetPinnableReference">
+      <returns></returns>
+    </member>
+    <member name="P:System.Span`1.Empty">
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.Equals(System.Object)">
+      <param name="obj"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.Fill(`0)">
+      <param name="value"></param>
+    </member>
+    <member name="M:System.Span`1.GetHashCode">
+      <returns></returns>
+    </member>
+    <member name="P:System.Span`1.IsEmpty">
+      <returns></returns>
+    </member>
+    <member name="P:System.Span`1.Item(System.Int32)">
+      <param name="index"></param>
+      <returns></returns>
+    </member>
+    <member name="P:System.Span`1.Length">
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.op_Equality(System.Span{`0},System.Span{`0})">
+      <param name="left"></param>
+      <param name="right"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.op_Implicit(System.ArraySegment{T})~System.Span{T}">
+      <param name="arraySegment"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.op_Implicit(System.Span{T})~System.ReadOnlySpan{T}">
+      <param name="span"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.op_Implicit(T[])~System.Span{T}">
+      <param name="array"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.op_Inequality(System.Span{`0},System.Span{`0})">
+      <param name="left"></param>
+      <param name="right"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.Slice(System.Int32)">
+      <param name="start"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.Slice(System.Int32,System.Int32)">
+      <param name="start"></param>
+      <param name="length"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.ToArray">
+      <returns></returns>
+    </member>
+    <member name="M:System.Span`1.TryCopyTo(System.Span{`0})">
+      <param name="destination"></param>
+      <returns></returns>
+    </member>
+    <member name="T:System.SpanExtensions">
+      
+    </member>
+    <member name="M:System.SpanExtensions.AsBytes``1(System.ReadOnlySpan{``0})">
+      <param name="source"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.AsBytes``1(System.Span{``0})">
+      <param name="source"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.AsSpan(System.String)">
+      <param name="text"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.AsSpan``1(System.ArraySegment{``0})">
+      <param name="arraySegment"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.AsSpan``1(``0[])">
+      <param name="array"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.CopyTo``1(``0[],System.Span{``0})">
+      <param name="array"></param>
+      <param name="destination"></param>
+      <typeparam name="T"></typeparam>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf(System.Span{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf(System.Span{System.Byte},System.Byte)">
+      <param name="span"></param>
+      <param name="value"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf(System.ReadOnlySpan{System.Byte},System.Byte)">
+      <param name="span"></param>
+      <param name="value"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf``1(System.ReadOnlySpan{``0},System.ReadOnlySpan{``0})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf``1(System.ReadOnlySpan{``0},``0)">
+      <param name="span"></param>
+      <param name="value"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf``1(System.Span{``0},System.ReadOnlySpan{``0})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOf``1(System.Span{``0},``0)">
+      <param name="span"></param>
+      <param name="value"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOfAny(System.ReadOnlySpan{System.Byte},System.Byte,System.Byte,System.Byte)">
+      <param name="span"></param>
+      <param name="value0"></param>
+      <param name="value1"></param>
+      <param name="value2"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOfAny(System.Span{System.Byte},System.Byte,System.Byte,System.Byte)">
+      <param name="span"></param>
+      <param name="value0"></param>
+      <param name="value1"></param>
+      <param name="value2"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOfAny(System.Span{System.Byte},System.Byte,System.Byte)">
+      <param name="span"></param>
+      <param name="value0"></param>
+      <param name="value1"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOfAny(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="span"></param>
+      <param name="values"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOfAny(System.Span{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="span"></param>
+      <param name="values"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.IndexOfAny(System.ReadOnlySpan{System.Byte},System.Byte,System.Byte)">
+      <param name="span"></param>
+      <param name="value0"></param>
+      <param name="value1"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.NonPortableCast``2(System.ReadOnlySpan{``0})">
+      <param name="source"></param>
+      <typeparam name="TFrom"></typeparam>
+      <typeparam name="TTo"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.NonPortableCast``2(System.Span{``0})">
+      <param name="source"></param>
+      <typeparam name="TFrom"></typeparam>
+      <typeparam name="TTo"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.SequenceEqual(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="first"></param>
+      <param name="second"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.SequenceEqual(System.Span{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="first"></param>
+      <param name="second"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.SequenceEqual``1(System.ReadOnlySpan{``0},System.ReadOnlySpan{``0})">
+      <param name="first"></param>
+      <param name="second"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.SequenceEqual``1(System.Span{``0},System.ReadOnlySpan{``0})">
+      <param name="first"></param>
+      <param name="second"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.StartsWith(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.StartsWith(System.Span{System.Byte},System.ReadOnlySpan{System.Byte})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.StartsWith``1(System.ReadOnlySpan{``0},System.ReadOnlySpan{``0})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="M:System.SpanExtensions.StartsWith``1(System.Span{``0},System.ReadOnlySpan{``0})">
+      <param name="span"></param>
+      <param name="value"></param>
+      <typeparam name="T"></typeparam>
+      <returns></returns>
+    </member>
+    <member name="T:System.ReadOnlySpan`1">
+      <typeparam name="T"></typeparam>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.#ctor(`0[])">
+      <param name="array"></param>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.#ctor(System.Void*,System.Int32)">
+      <param name="pointer"></param>
+      <param name="length"></param>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.#ctor(`0[],System.Int32)">
+      <param name="array"></param>
+      <param name="start"></param>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.#ctor(`0[],System.Int32,System.Int32)">
+      <param name="array"></param>
+      <param name="start"></param>
+      <param name="length"></param>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.CopyTo(System.Span{`0})">
+      <param name="destination"></param>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.DangerousCreate(System.Object,`0@,System.Int32)">
+      <param name="obj"></param>
+      <param name="objectData"></param>
+      <param name="length"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.DangerousGetPinnableReference">
+      <returns></returns>
+    </member>
+    <member name="P:System.ReadOnlySpan`1.Empty">
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.Equals(System.Object)">
+      <param name="obj"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.GetHashCode">
+      <returns></returns>
+    </member>
+    <member name="P:System.ReadOnlySpan`1.IsEmpty">
+      <returns></returns>
+    </member>
+    <member name="P:System.ReadOnlySpan`1.Item(System.Int32)">
+      <param name="index"></param>
+      <returns></returns>
+    </member>
+    <member name="P:System.ReadOnlySpan`1.Length">
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.op_Equality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0})">
+      <param name="left"></param>
+      <param name="right"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.op_Implicit(System.ArraySegment{T})~System.ReadOnlySpan{T}">
+      <param name="arraySegment"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.op_Implicit(T[])~System.ReadOnlySpan{T}">
+      <param name="array"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.op_Inequality(System.ReadOnlySpan{`0},System.ReadOnlySpan{`0})">
+      <param name="left"></param>
+      <param name="right"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.Slice(System.Int32)">
+      <param name="start"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.Slice(System.Int32,System.Int32)">
+      <param name="start"></param>
+      <param name="length"></param>
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.ToArray">
+      <returns></returns>
+    </member>
+    <member name="M:System.ReadOnlySpan`1.TryCopyTo(System.Span{`0})">
+      <param name="destination"></param>
+      <returns></returns>
+    </member>
+  </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/System.Runtime.CompilerServices.Unsafe.xml

@@ -0,0 +1,291 @@
+<?xml version="1.0" encoding="utf-8"?>
+<doc>
+  <assembly>
+    <name>System.Runtime.CompilerServices.Unsafe</name>
+  </assembly>
+  <members>
+    <member name="T:System.Runtime.CompilerServices.Unsafe">
+      <summary>Contains generic, low-level functionality for manipulating pointers.</summary>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.Int32)">
+      <summary>Adds an element offset to the given reference.</summary>
+      <param name="source">The reference to add the offset to.</param>
+      <param name="elementOffset">The offset to add.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the addition of offset to pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.IntPtr)">
+      <summary>Adds an element offset to the given reference.</summary>
+      <param name="source">The reference to add the offset to.</param>
+      <param name="elementOffset">The offset to add.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the addition of offset to pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Add``1(``0@,System.UIntPtr)">
+      <summary>Adds an element offset to the given reference.</summary>
+      <param name="source">The reference to add the offset to.</param>
+      <param name="elementOffset">The offset to add.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the addition of offset to pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Add``1(System.Void*,System.Int32)">
+      <summary>Adds an element offset to the given void pointer.</summary>
+      <param name="source">The void pointer to add the offset to.</param>
+      <param name="elementOffset">The offset to add.</param>
+      <typeparam name="T">The type of void pointer.</typeparam>
+      <returns>A new void pointer that reflects the addition of offset to the specified pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.IntPtr)">
+      <summary>Adds a byte offset to the given reference.</summary>
+      <param name="source">The reference to add the offset to.</param>
+      <param name="byteOffset">The offset to add.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the addition of byte offset to pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.AddByteOffset``1(``0@,System.UIntPtr)">
+      <summary>Adds a byte offset to the given reference.</summary>
+      <param name="source">The reference to add the offset to.</param>
+      <param name="byteOffset">The offset to add.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the addition of byte offset to pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.AreSame``1(``0@,``0@)">
+      <summary>Determines whether the specified references point to the same location.</summary>
+      <param name="left">The first reference to compare.</param>
+      <param name="right">The second reference to compare.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>
+        <see langword="true" /> if <paramref name="left" /> and <paramref name="right" /> point to the same location; otherwise, <see langword="false" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.As``1(System.Object)">
+      <summary>Casts the given object to the specified type.</summary>
+      <param name="o">The object to cast.</param>
+      <typeparam name="T">The type which the object will be cast to.</typeparam>
+      <returns>The original object, casted to the given type.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.As``2(``0@)">
+      <summary>Reinterprets the given reference as a reference to a value of type <typeparamref name="TTo" />.</summary>
+      <param name="source">The reference to reinterpret.</param>
+      <typeparam name="TFrom">The type of reference to reinterpret.</typeparam>
+      <typeparam name="TTo">The desired type of the reference.</typeparam>
+      <returns>A reference to a value of type <typeparamref name="TTo" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.AsPointer``1(``0@)">
+      <summary>Returns a pointer to the given by-ref parameter.</summary>
+      <param name="value">The object whose pointer is obtained.</param>
+      <typeparam name="T">The type of object.</typeparam>
+      <returns>A pointer to the given value.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.AsRef``1(``0@)">
+      <summary>Reinterprets the given read-only reference as a reference.</summary>
+      <param name="source">The read-only reference to reinterpret.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A reference to a value of type <typeparamref name="T" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.AsRef``1(System.Void*)">
+      <summary>Reinterprets the given location as a reference to a value of type <typeparamref name="T" />.</summary>
+      <param name="source">The location of the value to reference.</param>
+      <typeparam name="T">The type of the interpreted location.</typeparam>
+      <returns>A reference to a value of type <typeparamref name="T" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.ByteOffset``1(``0@,``0@)">
+      <summary>Determines the byte offset from origin to target from the given references.</summary>
+      <param name="origin">The reference to origin.</param>
+      <param name="target">The reference to target.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>Byte offset from origin to target i.e. <paramref name="target" /> - <paramref name="origin" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Copy``1(``0@,System.Void*)">
+      <summary>Copies a value of type <typeparamref name="T" /> to the given location.</summary>
+      <param name="destination">The location to copy to.</param>
+      <param name="source">A pointer to the value to copy.</param>
+      <typeparam name="T">The type of value to copy.</typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Copy``1(System.Void*,``0@)">
+      <summary>Copies a value of type <typeparamref name="T" /> to the given location.</summary>
+      <param name="destination">The location to copy to.</param>
+      <param name="source">A reference to the value to copy.</param>
+      <typeparam name="T">The type of value to copy.</typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Byte@,System.Byte@,System.UInt32)">
+      <summary>Copies bytes from the source address to the destination address.</summary>
+      <param name="destination">The destination address to copy to.</param>
+      <param name="source">The source address to copy from.</param>
+      <param name="byteCount">The number of bytes to copy.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.CopyBlock(System.Void*,System.Void*,System.UInt32)">
+      <summary>Copies bytes from the source address to the destination address.</summary>
+      <param name="destination">The destination address to copy to.</param>
+      <param name="source">The source address to copy from.</param>
+      <param name="byteCount">The number of bytes to copy.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Byte@,System.Byte@,System.UInt32)">
+      <summary>Copies bytes from the source address to the destination address without assuming architecture dependent alignment of the addresses.</summary>
+      <param name="destination">The destination address to copy to.</param>
+      <param name="source">The source address to copy from.</param>
+      <param name="byteCount">The number of bytes to copy.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.CopyBlockUnaligned(System.Void*,System.Void*,System.UInt32)">
+      <summary>Copies bytes from the source address to the destination address without assuming architecture dependent alignment of the addresses.</summary>
+      <param name="destination">The destination address to copy to.</param>
+      <param name="source">The source address to copy from.</param>
+      <param name="byteCount">The number of bytes to copy.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.InitBlock(System.Byte@,System.Byte,System.UInt32)">
+      <summary>Initializes a block of memory at the given location with a given initial value.</summary>
+      <param name="startAddress">The address of the start of the memory block to initialize.</param>
+      <param name="value">The value to initialize the block to.</param>
+      <param name="byteCount">The number of bytes to initialize.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.InitBlock(System.Void*,System.Byte,System.UInt32)">
+      <summary>Initializes a block of memory at the given location with a given initial value.</summary>
+      <param name="startAddress">The address of the start of the memory block to initialize.</param>
+      <param name="value">The value to initialize the block to.</param>
+      <param name="byteCount">The number of bytes to initialize.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Byte@,System.Byte,System.UInt32)">
+      <summary>Initializes a block of memory at the given location with a given initial value without assuming architecture dependent alignment of the address.</summary>
+      <param name="startAddress">The address of the start of the memory block to initialize.</param>
+      <param name="value">The value to initialize the block to.</param>
+      <param name="byteCount">The number of bytes to initialize.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.InitBlockUnaligned(System.Void*,System.Byte,System.UInt32)">
+      <summary>Initializes a block of memory at the given location with a given initial value without assuming architecture dependent alignment of the address.</summary>
+      <param name="startAddress">The address of the start of the memory block to initialize.</param>
+      <param name="value">The value to initialize the block to.</param>
+      <param name="byteCount">The number of bytes to initialize.</param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.IsAddressGreaterThan``1(``0@,``0@)">
+      <summary>Returns a value that indicates whether a specified reference is greater than another specified reference.</summary>
+      <param name="left">The first value to compare.</param>
+      <param name="right">The second value to compare.</param>
+      <typeparam name="T">The type of the reference.</typeparam>
+      <returns>
+        <see langword="true" /> if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, <see langword="false" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.IsAddressLessThan``1(``0@,``0@)">
+      <summary>Returns a value that indicates whether a specified reference is less than another specified reference.</summary>
+      <param name="left">The first value to compare.</param>
+      <param name="right">The second value to compare.</param>
+      <typeparam name="T">The type of the reference.</typeparam>
+      <returns>
+        <see langword="true" /> if <paramref name="left" /> is less than <paramref name="right" />; otherwise, <see langword="false" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@)">
+      <summary>Determines if a given reference to a value of type <typeparamref name="T" /> is a null reference.</summary>
+      <param name="source">The reference to check.</param>
+      <typeparam name="T">The type of the reference.</typeparam>
+      <returns>
+        <see langword="true" /> if <paramref name="source" /> is a null reference; otherwise, <see langword="false" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.NullRef``1">
+      <summary>Returns a reference to a value of type <typeparamref name="T" /> that is a null reference.</summary>
+      <typeparam name="T">The type of the reference.</typeparam>
+      <returns>A reference to a value of type <typeparamref name="T" /> that is a null reference.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Read``1(System.Void*)">
+      <summary>Reads a value of type <typeparamref name="T" /> from the given location.</summary>
+      <param name="source">The location to read from.</param>
+      <typeparam name="T">The type to read.</typeparam>
+      <returns>An object of type <typeparamref name="T" /> read from the given location.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Byte@)">
+      <summary>Reads a value of type <typeparamref name="T" /> from the given location without assuming architecture dependent alignment of the addresses.</summary>
+      <param name="source">The location to read from.</param>
+      <typeparam name="T">The type to read.</typeparam>
+      <returns>An object of type <typeparamref name="T" /> read from the given location.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.ReadUnaligned``1(System.Void*)">
+      <summary>Reads a value of type <typeparamref name="T" /> from the given location without assuming architecture dependent alignment of the addresses.</summary>
+      <param name="source">The location to read from.</param>
+      <typeparam name="T">The type to read.</typeparam>
+      <returns>An object of type <typeparamref name="T" /> read from the given location.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.SizeOf``1">
+      <summary>Returns the size of an object of the given type parameter.</summary>
+      <typeparam name="T">The type of object whose size is retrieved.</typeparam>
+      <returns>The size of an object of type <typeparamref name="T" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.SkipInit``1(``0@)">
+      <summary>Bypasses definite assignment rules for a given value.</summary>
+      <param name="value">The uninitialized object.</param>
+      <typeparam name="T">The type of the uninitialized object.</typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.Int32)">
+      <summary>Subtracts an element offset from the given reference.</summary>
+      <param name="source">The reference to subtract the offset from.</param>
+      <param name="elementOffset">The offset to subtract.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the subtraction of offset from pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.IntPtr)">
+      <summary>Subtracts an element offset from the given reference.</summary>
+      <param name="source">The reference to subtract the offset from.</param>
+      <param name="elementOffset">The offset to subtract.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the subtraction of offset from pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Subtract``1(``0@,System.UIntPtr)">
+      <summary>Subtracts an element offset from the given reference.</summary>
+      <param name="source">The reference to subtract the offset from.</param>
+      <param name="elementOffset">The offset to subtract.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the subraction of offset from pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Subtract``1(System.Void*,System.Int32)">
+      <summary>Subtracts an element offset from the given void pointer.</summary>
+      <param name="source">The void pointer to subtract the offset from.</param>
+      <param name="elementOffset">The offset to subtract.</param>
+      <typeparam name="T">The type of the void pointer.</typeparam>
+      <returns>A new void pointer that reflects the subtraction of offset from the specified pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.IntPtr)">
+      <summary>Subtracts a byte offset from the given reference.</summary>
+      <param name="source">The reference to subtract the offset from.</param>
+      <param name="byteOffset">The offset to subtract.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the subtraction of byte offset from pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.SubtractByteOffset``1(``0@,System.UIntPtr)">
+      <summary>Subtracts a byte offset from the given reference.</summary>
+      <param name="source">The reference to subtract the offset from.</param>
+      <param name="byteOffset">The offset to subtract.</param>
+      <typeparam name="T">The type of reference.</typeparam>
+      <returns>A new reference that reflects the subraction of byte offset from pointer.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Unbox``1(System.Object)">
+      <summary>Returns a <see langword="mutable ref" /> to a boxed value.</summary>
+      <param name="box">The value to unbox.</param>
+      <typeparam name="T">The type to be unboxed.</typeparam>
+      <exception cref="T:System.NullReferenceException">
+        <paramref name="box" /> is <see langword="null" />, and <typeparamref name="T" /> is a non-nullable value type.</exception>
+      <exception cref="T:System.InvalidCastException">
+        <paramref name="box" /> is not a boxed value type.
+         
+-or-
+
+<paramref name="box" /> is not a boxed <typeparamref name="T" />.</exception>
+      <exception cref="T:System.TypeLoadException">
+        <typeparamref name="T" /> cannot be found.</exception>
+      <returns>A <see langword="mutable ref" /> to the boxed value <paramref name="box" />.</returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.Write``1(System.Void*,``0)">
+      <summary>Writes a value of type <typeparamref name="T" /> to the given location.</summary>
+      <param name="destination">The location to write to.</param>
+      <param name="value">The value to write.</param>
+      <typeparam name="T">The type of value to write.</typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Byte@,``0)">
+      <summary>Writes a value of type <typeparamref name="T" /> to the given location without assuming architecture dependent alignment of the addresses.</summary>
+      <param name="destination">The location to write to.</param>
+      <param name="value">The value to write.</param>
+      <typeparam name="T">The type of value to write.</typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.Unsafe.WriteUnaligned``1(System.Void*,``0)">
+      <summary>Writes a value of type <typeparamref name="T" /> to the given location without assuming architecture dependent alignment of the addresses.</summary>
+      <param name="destination">The location to write to.</param>
+      <param name="value">The value to write.</param>
+      <typeparam name="T">The type of value to write.</typeparam>
+    </member>
+  </members>
+</doc>

JinYuan.VirtualDataLibrary/bin/Debug/System.Threading.Tasks.Extensions.xml

@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="utf-8"?><doc>
+  <assembly>
+    <name>System.Threading.Tasks.Extensions</name>
+  </assembly>
+  <members>
+    <member name="T:System.Runtime.CompilerServices.ValueTaskAwaiter`1">
+      <typeparam name="TResult"></typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.GetResult">
+      <returns></returns>
+    </member>
+    <member name="P:System.Runtime.CompilerServices.ValueTaskAwaiter`1.IsCompleted">
+      <returns></returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.OnCompleted(System.Action)">
+      <param name="continuation"></param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ValueTaskAwaiter`1.UnsafeOnCompleted(System.Action)">
+      <param name="continuation"></param>
+    </member>
+    <member name="T:System.Threading.Tasks.ValueTask`1">
+      <summary>Provides a value type that wraps a <see cref="Task{TResult}"></see> and a <typeparamref name="TResult">TResult</typeparamref>, only one of which is used.</summary>
+      <typeparam name="TResult">The result.</typeparam>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.#ctor(System.Threading.Tasks.Task{`0})">
+      <summary>Initializes a new instance of the <see cref="ValueTask{TResult}"></see> class using the supplied task that represents the operation.</summary>
+      <param name="task">The task.</param>
+      <exception cref="T:System.ArgumentNullException">The <paramref name="task">task</paramref> argument is null.</exception>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.#ctor(`0)">
+      <summary>Initializes a new instance of the <see cref="ValueTask{TResult}"></see> class using the supplied result of a successful operation.</summary>
+      <param name="result">The result.</param>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.AsTask">
+      <summary>Retrieves a <see cref="Task{TResult}"></see> object that represents this <see cref="ValueTask{TResult}"></see>.</summary>
+      <returns>The <see cref="Task{TResult}"></see> object that is wrapped in this <see cref="ValueTask{TResult}"></see> if one exists, or a new <see cref="Task{TResult}"></see> object that represents the result.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.ConfigureAwait(System.Boolean)">
+      <summary>Configures an awaiter for this value.</summary>
+      <param name="continueOnCapturedContext">true to attempt to marshal the continuation back to the captured context; otherwise, false.</param>
+      <returns>The configured awaiter.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.CreateAsyncMethodBuilder">
+      <summary>Creates a method builder for use with an async method.</summary>
+      <returns>The created builder.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.Equals(System.Object)">
+      <summary>Determines whether the specified object is equal to the current object.</summary>
+      <param name="obj">The object to compare with the current object.</param>
+      <returns>true if the specified object is equal to the current object; otherwise, false.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.Equals(System.Threading.Tasks.ValueTask{`0})">
+      <summary>Determines whether the specified <see cref="ValueTask{TResult}"></see> object is equal to the current <see cref="ValueTask{TResult}"></see> object.</summary>
+      <param name="other">The object to compare with the current object.</param>
+      <returns>true if the specified object is equal to the current object; otherwise, false.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.GetAwaiter">
+      <summary>Creates an awaiter for this value.</summary>
+      <returns>The awaiter.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.GetHashCode">
+      <summary>Returns the hash code for this instance.</summary>
+      <returns>The hash code for the current object.</returns>
+    </member>
+    <member name="P:System.Threading.Tasks.ValueTask`1.IsCanceled">
+      <summary>Gets a value that indicates whether this object represents a canceled operation.</summary>
+      <returns>true if this object represents a canceled operation; otherwise, false.</returns>
+    </member>
+    <member name="P:System.Threading.Tasks.ValueTask`1.IsCompleted">
+      <summary>Gets a value that indicates whether this object represents a completed operation.</summary>
+      <returns>true if this object represents a completed operation; otherwise, false.</returns>
+    </member>
+    <member name="P:System.Threading.Tasks.ValueTask`1.IsCompletedSuccessfully">
+      <summary>Gets a value that indicates whether this object represents a successfully completed operation.</summary>
+      <returns>true if this object represents a successfully completed operation; otherwise, false.</returns>
+    </member>
+    <member name="P:System.Threading.Tasks.ValueTask`1.IsFaulted">
+      <summary>Gets a value that indicates whether this object represents a failed operation.</summary>
+      <returns>true if this object represents a failed operation; otherwise, false.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.op_Equality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0})">
+      <summary>Compares two values for equality.</summary>
+      <param name="left">The first value to compare.</param>
+      <param name="right">The second value to compare.</param>
+      <returns>true if the two <see cref="ValueTask{TResult}"></see> values are equal; otherwise, false.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.op_Inequality(System.Threading.Tasks.ValueTask{`0},System.Threading.Tasks.ValueTask{`0})">
+      <summary>Determines whether two <see cref="ValueTask{TResult}"></see> values are unequal.</summary>
+      <param name="left">The first value to compare.</param>
+      <param name="right">The seconed value to compare.</param>
+      <returns>true if the two <see cref="ValueTask{TResult}"></see> values are not equal; otherwise, false.</returns>
+    </member>
+    <member name="P:System.Threading.Tasks.ValueTask`1.Result">
+      <summary>Gets the result.</summary>
+      <returns>The result.</returns>
+    </member>
+    <member name="M:System.Threading.Tasks.ValueTask`1.ToString">
+      <summary>Returns a string that represents the current object.</summary>
+      <returns>A string that represents the current object.</returns>
+    </member>
+    <member name="T:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute">
+      
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.#ctor(System.Type)">
+      <param name="builderType"></param>
+    </member>
+    <member name="P:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute.BuilderType">
+      <returns></returns>
+    </member>
+    <member name="T:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1">
+      <typeparam name="TResult"></typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitOnCompleted``2(``0@,``1@)">
+      <param name="awaiter"></param>
+      <param name="stateMachine"></param>
+      <typeparam name="TAwaiter"></typeparam>
+      <typeparam name="TStateMachine"></typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.AwaitUnsafeOnCompleted``2(``0@,``1@)">
+      <param name="awaiter"></param>
+      <param name="stateMachine"></param>
+      <typeparam name="TAwaiter"></typeparam>
+      <typeparam name="TStateMachine"></typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Create">
+      <returns></returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetException(System.Exception)">
+      <param name="exception"></param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetResult(`0)">
+      <param name="result"></param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine)">
+      <param name="stateMachine"></param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Start``1(``0@)">
+      <param name="stateMachine"></param>
+      <typeparam name="TStateMachine"></typeparam>
+    </member>
+    <member name="P:System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1.Task">
+      <returns></returns>
+    </member>
+    <member name="T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter">
+      <typeparam name="TResult"></typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.GetResult">
+      <returns></returns>
+    </member>
+    <member name="P:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.IsCompleted">
+      <returns></returns>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.OnCompleted(System.Action)">
+      <param name="continuation"></param>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.ConfiguredValueTaskAwaiter.UnsafeOnCompleted(System.Action)">
+      <param name="continuation"></param>
+    </member>
+    <member name="T:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1">
+      <typeparam name="TResult"></typeparam>
+    </member>
+    <member name="M:System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1.GetAwaiter">
+      <returns></returns>
+    </member>
+  </members>
+</doc>

JinYuan.VirtualDataLibrary/obj/Debug/.NETFramework,Version=v4.7.2.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]

JinYuan.VirtualDataLibrary/obj/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]

JinYuan.VirtualDataLibrary/obj/Debug/JinYuan.VirtualDataLibrary.csproj.CoreCompileInputs.cache

@@ -0,0 +1 @@
+0ce95ace31f676c640f1808649ef81cdf790ae91e671d402861a0915547bc0c6