using System;
using System.Collections.Generic;
using System.Text;
using Opc;
using Opc.Da;
using OpcCom;
using System.Threading;
using System.Data;
using DBFactory;
using CommonLib;
namespace OPCClient
{
    public static class CCommonOPCClient
    {
        public static object lockob = new object();
        public static event CUpdateDBEventHandler UpdateDB;
        public static void OnUpdateDB(object sender,CUpdateDBChangeEventArgs e)
        {
            if (UpdateDB != null)
            {
                UpdateDB(sender, e);
            }
        }
        public static DBOperator dbo = new DBOperator();
        //20110726
        private static Dictionary<string, int> _connectCount = new Dictionary<string, int>(); //private static int _connectCount = 0;
        //20110726
        public static Dictionary<string, int> ConnectCount
        {
            get { return CCommonOPCClient._connectCount; }
            set { CCommonOPCClient._connectCount = value; }
        }
        //public static int ConnectCount
        //{
        //    get { return CCommonOPCClient._connectCount; }
        //    set {
        //        if (value == 0)
        //        {
        //            _opcError = "";
        //        }
        //        CCommonOPCClient._connectCount = value; 
        //    }
        //}

        private static int[] _plcStates=null ;

        public static int[] PlcStates
        {
            get { return CCommonOPCClient._plcStates; }
            //set { CCommonOPCClient._plcStates = value; }
        }
        
        /// <summary>
        /// 20110309订阅的组内标签数据变化事件
        /// </summary>
        /// <param name="subscriptionHandle">客户端句柄</param>
        /// <param name="requestHandle">请求句柄</param>
        /// <param name="values">标签值数组</param>
        public static void OnDataChange(object subscriptionHandle, object requestHandle, ItemValueResult[] values)
        {
            lock (lockob)
            {
                //根据subscriptionHandle对应设备索引，依据设备种类（不同类型设备通讯数据帧不同）
                //分别处理：完成，报警，光电开关，PLC发起的请求
                int deviceindex = 0;
                try
                {
                    if (subscriptionHandle.ToString().IndexOf("split") >= 0)
                    {
                        deviceindex = System.Convert.ToInt32(subscriptionHandle.ToString().Substring(5));
                        if (values[0].Quality != Quality.Good) return;
                        Array arr = (Array)values[0].Value;
                        byte[] GDKG = null;

                        GDKG = new byte[arr.GetLength(0)];
                        Array.Copy(arr, GDKG, arr.GetLength(0));
                        //object lockthis = new object();
                        //lock (UpdateDB)
                        {
                            CUpdateDBChangeEventArgs udbe = new CUpdateDBChangeEventArgs(deviceindex, GDKG, null);
                            OnUpdateDB("OPCClient.CCommonOPCClient.OnDataChange", udbe);
                        }

                    }
                    else
                    {

                        deviceindex = System.Convert.ToInt32(subscriptionHandle);
                        Array arr = (Array)values[0].Value;
                        byte[] itemnamevalue = new byte[arr.GetLength(0)];
                        Array.Copy(arr, itemnamevalue, arr.GetLength(0));
                        int head = 0;
                        head = itemnamevalue[0];//读写标志
                        //if (head != 1) return;
                        //object lockthis = new object();
                        //lock (UpdateDB)
                        {
                            CUpdateDBChangeEventArgs udbe = new CUpdateDBChangeEventArgs(deviceindex, null, itemnamevalue);
                            OnUpdateDB("OPCClient.CCommonOPCClient.OnDataChange", udbe);
                        }
                    }
                    //电气PLC的有物字节单独建组（按照S7Connection），高端不需要



                }
                catch (Exception ex)
                {//20120420
                    _opcError = string.Format("OPC服务器订阅事件异常：{0},{1}", ex.Message, ex.StackTrace);
                    CUpdateDBChangeEventArgs udbe = new CUpdateDBChangeEventArgs(deviceindex, null, null);
                    OnUpdateDB("OPCClient.CCommonOPCClient.OnDataChange", udbe);


                }
            }
        }

        

        //WriteComplete回调
        public static void OnWriteComplete(object requestHandle, Opc.IdentifiedResult[] values)
        {
            /*Console.WriteLine("发生异步写name:{0},value:{1}", values[0].ItemName, values[0].GetType());
            if ((int)requestHandle == 2)
                Console.WriteLine("事件信号句柄为{0}", requestHandle);*/
        }

        static private string _PLCconnectionID = "S7:[S7 connection_1]";
        /// <summary>
        /// 建立PLC连接的ID，例如："S7:[S7 connection_1]"
        /// 或者"S7:[@LOCALSERVER]"
        /// </summary>
        public static string PlcConnectionID
        {
            get { return CCommonOPCClient._PLCconnectionID; }
            set { CCommonOPCClient._PLCconnectionID = value; }
        }
        static private string _opcError;
        static private bool _IfConnectOPCServer=false ;
        static private string _hostname;
        /// <summary>
        /// OPC Server的机器名称或者IP地址
        /// </summary>
        public static string Hostname
        {
            get { return CCommonOPCClient._hostname; }
            set { CCommonOPCClient._hostname = value; }
        }
        static private string _progID;
        /// <summary>
        /// OPC Server的程序标识，例如：OPC.SimaticNET
        /// </summary>
        public static string ProgID
        {
            get { return CCommonOPCClient._progID; }
            set { CCommonOPCClient._progID = value; }
        }
        public static string OpcError
        {
            get { return CCommonOPCClient._opcError; }
            set { CCommonOPCClient._opcError = value; }
        }
        static private Opc.Da.Server m_server = null;//定义数据存取服务器
        static private Opc.Server[] servers;
        static private Opc.Da.Subscription subscription = null;//定义组对象（订阅者）
        static private Opc.Da.SubscriptionState state = null;//定义组（订阅者）状态，相当于OPC规范中组的参数
        static private Opc.Da.Subscription _readSubscription = null;//定义组对象（订阅者）
        //static private Opc.Da.SubscriptionState _readstate = null;//定义组（订阅者）状态，相当于OPC规范中组的参数
        static private Opc.Da.Subscription _writeSubscription = null;//定义组对象（订阅者）
        static private Opc.Da.SubscriptionState _writestate = null;//定义组（订阅者）状态，相当于OPC规范中组的参数
        static private Opc.Da.Subscription _tempSubscription = null;//定义组对象（订阅者）
        static private Opc.Da.SubscriptionState _tempstate = null;//定义组（订阅者）状态，相当于OPC规范中组的参数
        static private Opc.IDiscovery m_discovery = new OpcCom.ServerEnumerator();//定义枚举基于COM服务器的接口，用来搜索所有的此类服务器。
        /// <summary>
        /// 《设备索引，对应设备订阅》
        /// </summary>
        public static SubscriptionCollection  SubscriptionGroup = new SubscriptionCollection();//定义组对象集合（订阅者集合）//20110309
        //public static System.Collections.Hashtable SubscriptionG = new System.Collections.Hashtable();
        //static Model.MDevice devinfo;//20110309
        /// <summary>
        /// 20110309每个设备创建一个订阅和DataChange事件
        /// </summary>
        public static void CreateSubscriptionGroup()
        {
            if (_IfConnectOPCServer == false)
            {
                _hostname = CommonClassLib.AppSettings.GetValue("HostName");
                _progID = CommonClassLib.AppSettings.GetValue("OPCProgID");
                if (ConnectOPCServer(_hostname, _progID) == false) return ;
            }
            //SELECT F_DeviceIndex, F_DBW2Address, F_DBWGetLength, F_S7Connection,F_SplitByte FROM T_Base_Device where f_devicekindindex<>28 and  F_DBW2Address >=0 and F_DBWGetLength>0 order by F_DeviceIndex asc
            DataView dv = dbo.ExceSQL("SELECT F_ReadSubscription, F_DeviceIndex, F_DBW2Address, F_DBWGetLength, F_S7Connection, F_SplitByte FROM T_Base_Device WHERE (F_ReadSubscription IS NOT NULL) AND (F_ReadSubscription =F_DeviceIndex) ORDER BY F_ReadSubscription").Tables[0].DefaultView;
            if (dv.Count > 0)
            {
                if (dv.Count < SubscriptionGroup.Count) return;
            }
            DataView dvx; 
            for (int i = 0; i < dv.Count; i++)
            {
                //string dt = DateTime.Now.Minute.ToString() + "-" + DateTime.Now.Second.ToString() + "-" + DateTime.Now.Millisecond.ToString();
                dvx = dbo.ExceSQL(string.Format("SELECT (MAX(F_DBW2Address) + F_DBWGetLength) as maxdbw2 FROM T_Base_Device WHERE (F_ReadSubscription = {0})  AND (F_DeviceKindIndex <> 33) GROUP BY F_DBWGetLength ORDER BY maxdbw2 DESC", dv[i]["F_ReadSubscription"])).Tables[0].DefaultView;
                if (dvx.Count > 0)
                {

                    //设定设备订阅状态
                    _tempstate = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                    _tempstate.Name = dv[i]["F_ReadSubscription"].ToString();//组名
                    
                    _tempstate.ServerHandle = null;//服务器给该组分配的句柄。
                    _tempstate.ClientHandle = dv[i]["F_ReadSubscription"].ToString();//客户端给该组分配的句柄。
                    _tempstate.Active = true;//激活该组。
                    _tempstate.UpdateRate = 500;//刷新频率为500毫秒。
                    _tempstate.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                    _tempstate.Locale = null;//不设置地区值。
                    //添加设备订阅
                    _tempSubscription = (Opc.Da.Subscription)m_server.CreateSubscription(_tempstate);//创建设备订阅
                    //添加事件

                    
                    //添加标签
                    ////定义读item列表
                    Item[] items = new Item[1];//定义数据项，即item//20111110

                    int ii = 0;//20111110数据区
                    items[ii] = new Item();//创建一个项Item对象。
                    items[ii].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[ii].ItemPath = null; //该数据项在服务器中的路径。
                    items[ii].ItemName = dv[i]["F_S7Connection"].ToString() +
                        Model.CGeneralFunction.DBGet + ",byte" +
                        dv[i]["F_DBW2Address"].ToString() + "," +
                        (System.Convert.ToInt32(System.Convert.ToInt32(dvx[0]["maxdbw2"]) - System.Convert.ToInt32(dv[i]["F_DBW2Address"]))).ToString(); //该数据项在服务器中的名字。
                    
                    //添加读Item
                    ItemResult[] irs = _tempSubscription.AddItems(items);
                    _tempSubscription.DataChanged += new Opc.Da.DataChangedEventHandler(OnDataChange);
                    if (SubscriptionGroup.Contains(_tempSubscription) == false)
                    {
                        SubscriptionGroup.Add(_tempSubscription);
                    }
                    
                }
            }
            dv = dbo.ExceSQL("SELECT F_ReadSubscription, F_DeviceIndex, F_DBW2Address, F_DBWGetLength, F_S7Connection, F_SplitByte FROM T_Base_Device WHERE (F_ReadSubscription IS NOT NULL) AND (F_DeviceKindIndex=33)  ORDER BY F_ReadSubscription").Tables[0].DefaultView;
            
            for (int i = 0; i < dv.Count; i++)
            {
                //设定设备订阅状态
                _tempstate = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                _tempstate.Name = "split" + dv[i]["F_ReadSubscription"].ToString();//组名
                _tempstate.ServerHandle = null;//服务器给该组分配的句柄。
                _tempstate.ClientHandle ="split"+ dv[i]["F_ReadSubscription"].ToString();//客户端给该组分配的句柄。
                _tempstate.Active = true;//激活该组。
                _tempstate.UpdateRate = 500;//刷新频率为500毫秒。
                _tempstate.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                _tempstate.Locale = null;//不设置地区值。
                //添加设备订阅
                _tempSubscription = (Opc.Da.Subscription)m_server.CreateSubscription(_tempstate);//创建设备订阅
                //添加标签
                ////定义读item列表
                Item[] items = new Item[1];//定义数据项，即item//20111110

                int ii = 0;//20111110数据区
                items[ii] = new Item();//创建一个项Item对象。
                items[ii].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                items[ii].ItemPath = null; //该数据项在服务器中的路径。
                items[ii].ItemName = dv[i]["F_S7Connection"].ToString() +
                    Model.CGeneralFunction.DBGet + ",byte" +
                    dv[i]["F_DBW2Address"].ToString() + "," +
                    (System.Convert.ToInt32(dv[i]["F_DBWGetLength"])).ToString(); //该数据项在服务器中的名字。

                //添加读Item
                ItemResult[] irs = _tempSubscription.AddItems(items);
                //添加事件
                _tempSubscription.DataChanged += new Opc.Da.DataChangedEventHandler(OnDataChange);
                if (SubscriptionGroup.Contains(_tempSubscription) == false)
                {
                    SubscriptionGroup.Add(_tempSubscription);
                }
            }
        }
        /// <summary>
        /// 获取主机的所有OPC服务器的标识名称数组
        /// </summary>
        /// <param name="hostname">主机名称</param>
        /// <returns></returns>
        public static List<string> GetOpcServers(string hostname)
        {
            try
            {
                ConnectData cd = new ConnectData(new System.Net.NetworkCredential(CommonClassLib.AppSettings.GetValue("OPCUsername"),
                    CommonClassLib.AppSettings.GetValue("OPCPassword")));//20120510
                
                servers = m_discovery.GetAvailableServers(Specification.COM_DA_20, hostname, cd);//20120510
                //daver表示数据存取规范版本，Specification.COMDA_20等于2.0版本。
                //host为计算机名，null表示不需要任何网络安全认证。
                if (servers != null)
                {
                    List<string> ser =new List<string>();;
                    foreach (Opc.Da.Server server in servers)
                    {
                        ser.Add(server.Name);
                    }
                    return ser;
                }
                return null;
            }
            catch (Exception ex)
            {
                _opcError = "获取OPC服务器时：" + ex.Message;
                return null;
            }
        }
        /// <summary>
        /// 连接指定主机的OPC服务器
        /// </summary>
        /// <param name="hostname">主机名称</param>
        /// <param name="ProgID">OPC服务器程序标识例如："OPC.SimaticNET"</param>
        /// <returns></returns>
        public static bool ConnectOPCServer(string hostname, string ProgID)
        {
            try
            {
                
                GetOpcServers(hostname);
                if (ProgID.Contains(hostname) == false && hostname!="127.0.0.1")//20120510
                {
                    ProgID = hostname + "." + ProgID;
                }
                foreach (Opc.Da.Server server in servers)
                {
                    //server即为需要连接的OPC数据存取服务器。
                    if (String.Compare(server.Name,  ProgID, true) == 0)//为true忽略大小写
                    {
                        m_server = server;//建立连接。
                        break;
                        
                    }
                }
                //连接服务器
                if (m_server != null)//非空连接服务器
                {
                    m_server.Connect();
                    _IfConnectOPCServer = true;
                    CreateItemGroup();
                    return true;
                }
                else
                {
                    _IfConnectOPCServer = false;
                    return false;
                }
                
            }
            catch (Exception ex)
            {
                _opcError ="连接OPC数据存取服务器时："+ ex.Message;
                _IfConnectOPCServer = false;
                return false;
            }
            
        }
        /// <summary>
        /// 创建OPC组（订阅者），定义组内变量名称
        /// </summary>
        /// <param name="groupname">OPC组（订阅者）名称</param>
        /// <param name="itemnames">指定组内所有变量名称,数组的值举例"S7:[S7 connection_1]DB1,INT1"</param>
        /// <returns></returns>
        public static Opc.Da.Subscription CreateItemGroup(string groupname, string[] itemnames)
        {
            string[] itemName ;
            //定义item列表
            Item[] items;
            ItemResult[] irs;
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }
                //设定组状态
                state = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                state.Name = groupname;//组名
                state.ServerHandle = null;//服务器给该组分配的句柄。
                state.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
                state.Active = true;//激活该组。
                state.UpdateRate = 50;//刷新频率为100毫秒。
                state.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                state.Locale = null;//不设置地区值。


                //添加组
                subscription = (Opc.Da.Subscription)m_server.CreateSubscription(state);//创建组

                //定义Item列表
                //对应类型为:{Byte,Byte,Char,Short,String,Word,Boolean}
                itemName = itemnames;//{ "S7:[S7 connection_1]DB1,INT1", "S7:[@LOCALSERVER]DB1,INT20", "S7:[@LOCALSERVER]DB1,INT30", "S7:[@LOCALSERVER]DB1,INT50" };

                //定义item列表
                items = new Item[itemName.Length];//定义数据项，即item
                int i;
                for (i = 0; i < items.Length; i++)//item初始化赋值
                {
                    items[i] = new Item();//创建一个项Item对象。
                    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[i].ItemPath = null; //该数据项在服务器中的路径。
                    items[i].ItemName = itemName[i]; //该数据项在服务器中的名字。
                }

                //添加Item
                irs = subscription.AddItems(items);
                return subscription;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "创建OPC组时：" + ex.Message;
                return null;
            }
            finally
            {
                itemName=null;
                //定义item列表
                items=null;
                irs=null;
            }
        }
        /// <summary>
        /// 创建OPC组（订阅者），不定义组内变量名称
        /// </summary>
        /// <param name="groupname">OPC组（订阅者）名称</param>
        /// <returns></returns>
        public static Opc.Da.Subscription CreateItemGroup(string groupname)
        {
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }
                //设定组状态
                state = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                state.Name = groupname;//组名
                state.ServerHandle = null;//服务器给该组分配的句柄。
                state.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
                state.Active = true;//激活该组。
                state.UpdateRate = 50;//刷新频率为100毫秒。
                state.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                state.Locale = null;//不设置地区值。


                //添加组
                subscription = (Opc.Da.Subscription)m_server.CreateSubscription(state);//创建组

                
                return subscription;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "创建OPC组时：" + ex.Message;
                return null;
            }
        }
        /// <summary>
        /// 创建几个默认组：read和write、临时读写组tempGroup
        /// </summary>
        /// <returns></returns>
        public static void  CreateItemGroup()
        {
            try
            {
                //if (_IfConnectOPCServer == false)
                //{
                //    if (ConnectOPCServer(_hostname, _progID) == false) return ;
                //}
                #region 建立读全部标签组
                //20110216
                
                ////设定读取组状态
                //_readstate = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                //_readstate.Name = "readopc";//组名
                //_readstate.ServerHandle = null;//服务器给该组分配的句柄。
                //_readstate.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
                //_readstate.Active = true;//激活该组。
                //_readstate.UpdateRate = 50;//刷新频率为100毫秒。
                //_readstate.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                //_readstate.Locale = null;//不设置地区值。
                ////添加读组
                //_readSubscription = (Opc.Da.Subscription)m_server.CreateSubscription(_readstate);//创建读取组
                //20110216
                //string[] itemName;
                //DataView dv = dbo.ExceSQL("SELECT F_S7Connection,F_DBW2Address,F_DBWGetLength  FROM T_Base_Device WHERE (F_DeviceKindIndex = 28)").Tables[0].DefaultView;
                //if (dv.Count > 0)
                //{
                //    itemName=new string[dv.Count];
                //    for(int i=0;i<dv.Count;i++)
                //    {
                //        itemName[i] = dv[i]["F_S7Connection"] + Model.CGeneralFunction.DBGet + ",byte"
                //            + dv[i]["F_DBW2Address"].ToString() + "," + ((int)dv[i]["F_DBWGetLength"]).ToString();
                //    }
                //    //{ "S7:[S7 connection_1]DB1,INT1", "S7:[@LOCALSERVER]DB1,INT20", "S7:[@LOCALSERVER]DB1,INT30", "S7:[@LOCALSERVER]DB1,INT50" };
                //}
                //else
                //{
                //    return ;
                //}
                ////定义读item列表
                //Item[] items = new Item[itemName.Length];//定义数据项，即item
                //int i;
                //for (i = 0; i < items.Length; i++)//item初始化赋值
                //{
                //    items[i] = new Item();//创建一个项Item对象。
                //    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                //    items[i].ItemPath = null; //该数据项在服务器中的路径。
                //    items[i].ItemName =  itemName[i]; //该数据项在服务器中的名字。
                //}

                ////添加读Item
                //ItemResult[] irs = _readSubscription.AddItems(items);
                //_plcStates = new int[System.Convert.ToInt32( devinfo28.Dbw2Getlength)];
                //_readSubscription.DataChanged += new Opc.Da.DataChangedEventHandler(OnDataChange);
                #endregion

                //设定写组状态
                _writestate = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                _writestate.Name = "writeopc";//组名
                _writestate.ServerHandle = null;//服务器给该组分配的句柄。
                _writestate.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
                _writestate.Active = true;//激活该组。
                _writestate.UpdateRate = 50;//刷新频率为100毫秒。
                _writestate.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                _writestate.Locale = null;//不设置地区值。
                //添加写入组
                _writeSubscription = (Opc.Da.Subscription)m_server.CreateSubscription(_writestate);//创建写入组
                
                //设定临时读组状态
                _tempstate = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                _tempstate.Name = "opctemp";//组名
                _tempstate.ServerHandle = null;//服务器给该组分配的句柄。
                _tempstate.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
                _tempstate.Active = true;//激活该组。
                _tempstate.UpdateRate = 50;//刷新频率为100毫秒。
                _tempstate.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                _tempstate.Locale = null;//不设置地区值。
                //添加写入组
                _tempSubscription = (Opc.Da.Subscription)m_server.CreateSubscription(_tempstate);//创建写入组
                
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "创建OPC组时：" + ex.Message;
                return ;
            }
        }
        /// <summary>
        /// 创建OPC组（订阅者），定义组内变量名称
        /// </summary>
        /// <param name="plcConnectionID">组态软件中定义的每个PLC连接的标识</param>
        /// <param name="groupname">OPC组（订阅者）名称</param>
        /// <param name="itemnames">指定组内所有变量名称,数组的值举例"DB1,INT1"</param>
        /// <returns></returns>
        public static Opc.Da.Subscription CreateItemGroup(string plcConnectionID,string groupname, string[] itemnames)
        {
            string[] itemName;
            //定义item列表
            Item[] items;
            ItemResult[] irs;
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }
                //设定组状态
                state = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
                state.Name = groupname;//组名
                state.ServerHandle = null;//服务器给该组分配的句柄。
                state.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
                state.Active = true;//激活该组。
                state.UpdateRate = 50;//刷新频率为100毫秒。
                state.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
                state.Locale = null;//不设置地区值。


                //添加组
                subscription = (Opc.Da.Subscription)m_server.CreateSubscription(state);//创建组

                //定义Item列表
                //对应类型为:{Byte,Byte,Char,Short,String,Word,Boolean}
                itemName = itemnames;//{ "S7:[S7 connection_1]DB1,INT1", "S7:[@LOCALSERVER]DB1,INT20", "S7:[@LOCALSERVER]DB1,INT30", "S7:[@LOCALSERVER]DB1,INT50" };

                //定义item列表
                items = new Item[itemName.Length];//定义数据项，即item
                int i;
                for (i = 0; i < items.Length; i++)//item初始化赋值
                {
                    items[i] = new Item();//创建一个项Item对象。
                    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[i].ItemPath = null; //该数据项在服务器中的路径。
                    items[i].ItemName = plcConnectionID + itemName[i]; //该数据项在服务器中的名字。
                }

                //添加Item
                irs = subscription.AddItems(items);
                return subscription;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "创建OPC组时：" + ex.Message;
                return null;
            }
            finally
            {
                itemName=null;
                //定义item列表
                items=null;
                irs=null;
            }
        }
        
        /// <summary>
        /// 同步读取全部OPC组内变量的值，List《变量名+ ":" +变量值》
       /// </summary>
       /// <param name="subscription">OPC组名称</param>
       /// <returns></returns>
        public static List<string> SyncReadAllItems(Opc.Da.Subscription subscription)
        {
            ItemValueResult[] values;
            List<string> itemnamevalue;
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }
                itemnamevalue = new List<string>();
                //注册回调事件
                //subscription.DataChanged += new Opc.Da.DataChangedEventHandler(OnDataChange);

                //以下测试同步读
                //以下读整个组
                values = subscription.Read(subscription.Items);
                foreach (ItemValueResult value in values)
                {
                    itemnamevalue.Add(value.ItemName + ":" + value.Value);
                    
                }
                //subscription.RemoveItems(subscription.Items);
                //subscription.Dispose();
                return itemnamevalue;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "同步读数据时：" + ex.Message;
                return null;
            }
            finally
            {
                values=null;
                itemnamevalue=null;
            }
        }

        /// <summary>
        /// 读取指定S7Connection所有DB1对应标签数组的数据，返回值：“标签值”组成的数组
        /// </summary>
        /// <param name="S7Connection">OPC连接</param>
        /// <returns></returns>
        public static byte[] SyncReadAllItems(string S7Connection)
        {//20110216
            ItemValueResult[] values;
            byte[] itemnamevalue;
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }
                if (_readSubscription.Items != null)
                {
                    _readSubscription.RemoveItems(_readSubscription.Items);
                }
                string[] itemName= new string[1];
                DataView dv = dbo.ExceSQL("SELECT F_DBW2Address,F_DBWGetLength  FROM T_Base_Device WHERE (F_DeviceKindIndex = 28 and F_S7Connection='"+S7Connection+"')").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    
                    itemName[0] = S7Connection + Model.CGeneralFunction.DBGet + ",byte"+ dv[0]["F_DBW2Address"].ToString() + "," + (System.Convert.ToInt32( dv[0]["F_DBWGetLength"])).ToString();
                    //20110726
                }
                else
                {
                    return null ;
                }
                
                //定义读item列表
                Item[] items = new Item[itemName.Length];//定义数据项，即item
                int i;
                for (i = 0; i < items.Length; i++)//item初始化赋值
                {
                    items[i] = new Item();//创建一个项Item对象。
                    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[i].ItemPath = null; //该数据项在服务器中的路径。
                    items[i].ItemName = itemName[i]; //该数据项在服务器中的名字。
                }

                //添加读Item
                
                ItemResult[] irs = _readSubscription.AddItems(items);
                //_plcStates = new int[System.Convert.ToInt32(devinfo28.Dbw2Getlength)];
                //_readSubscription.DataChanged += new Opc.Da.DataChangedEventHandler(OnDataChange);
                if (ConnectCount.ContainsKey(S7Connection) == false)//20110726
                {
                    ConnectCount.Add(S7Connection, 0);
                }
                if (ConnectCount[S7Connection] > 1)//20110726
                {

                    _opcError = "同步数据时：OPC Server没连接到PLC，并且超过重复连接次数!请先关闭命令开关，检查通讯线路，确认后重新打开命令开关！";
                    return null;
                }
                values = _readSubscription.Read(_readSubscription.Items);
                if (values.Length <= 0)
                {
                    ConnectCount[S7Connection]++;//20110726
                    _opcError = "同步读数据时：OPC Server没连接到PLC!";
                    return null;
                }
                if (values[0].Quality == Quality.Bad)
                {
                    ConnectCount[S7Connection]++;//20110726
                    _opcError = "同步读数据时：OPC Server没连接到PLC!";
                    return null;
                }
                
                Array arr = (Array)values[0].Value;
                itemnamevalue = new byte[arr.GetLength(0)];
                Array.Copy(arr, itemnamevalue, arr.GetLength(0));
                _readSubscription.RemoveItems(_readSubscription.Items);
                //subscription.Dispose();
                return itemnamevalue;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "同步读数据时：" + ex.Message;
                return null;
            }
            finally
            {
                itemnamevalue = null;
                values = null;
            }
        }

        /// <summary>
        /// 读取指定标签名称的数据
        /// </summary>
        /// <param name="itemname">标签名称</param>
        /// <returns></returns>
        public static string SyncReadItemValue(string itemname)
        {
            string[] items = new string[1] { itemname };
            Subscription subs = CreateItemGroup(_PLCconnectionID, Guid.NewGuid().ToString(), items);
            string itemnamevalue = "";
            ItemValueResult[] values = subs.Read(subs.Items);
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }

                if (values.Length > 0)
                {
                    if (values[0].Value != null)
                    {
                        itemnamevalue = values[0].Value.ToString();
                    }
                }
                subs.RemoveItems(subs.Items);
                subs.Dispose();
                return itemnamevalue;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "同步读数据时：" + ex.Message;
                return null;
            }
            finally
            {
                items = null;
                subs = null;
                itemnamevalue = null;
                values = null;
            }
        }

        //20100221
        #region 延吉同步读、写OPC

        /// <summary>
        /// 延吉读取整个_readSubscription组的内容
        /// </summary>
        /// <returns></returns>
        //public static byte[] SyncReadAllItems()
        //{
        //    ItemValueResult[] values;
        //    byte[] itemnamevalue;
        //    try
        //    {
        //        if (_IfConnectOPCServer == false)
        //        {
        //            if (ConnectOPCServer(_hostname, _progID) == false) return null;
        //        }
        //        //List<string> itemnamevalue = new List<string>();
        //        //注册回调事件
        //        //subscription.DataChanged += new Opc.Da.DataChangedEventHandler(OnDataChange);

        //        //以下测试同步读
        //        //以下读整个组
        //        if (ConnectCount > 1)
        //        {
        //            _opcError = "同步数据时：OPC Server没连接到PLC，并且超过重复连接次数!请先关闭命令开关，检查通讯线路，确认后重新打开命令开关！";
        //            return null;
        //        }
        //        values = _readSubscription.Read(_readSubscription.Items);
        //        if (values.Length <= 0)
        //        {
        //            _opcError = "同步读数据时：OPC Server没连接到PLC!";
        //            return null;
        //        }
        //        if (values[0].Quality == Quality.Bad)
        //        {
        //            ConnectCount++;
        //            _opcError = "同步读数据时：OPC Server没连接到PLC!";
        //            return null;
        //        }
        //        Array arr = (Array)values[0].Value;
        //        itemnamevalue = new byte[arr.GetLength(0)];
        //        Array.Copy(arr, itemnamevalue, arr.GetLength(0));
        //        //subscription.RemoveItems(subscription.Items);
        //        //subscription.Dispose();
        //        return itemnamevalue;
        //    }
        //    catch (Exception ex)
        //    {
        //        //if ((m_server == null) || (m_server.IsConnected == false))
        //        //{
        //        _IfConnectOPCServer = false;
        //        //}
        //        _opcError = "同步读数据时：" + ex.Message;
        //        return null;
        //    }
        //    finally
        //    {
        //        itemnamevalue = null;
        //        values = null;
        //    }
        //}
        /// <summary>
        /// 延吉向指定OPC标签组写入数据（_writeSubscription组）
        /// </summary>
        /// <param name="itemnames"></param>
        /// <param name="itemvalue"></param>
        /// <returns></returns>
        public static bool SyncWriteAllItemValue(string[] itemnames, string[] itemvalue)
        {
            Item[] items;
            ItemValue[] itemvalues;
            IdentifiedResult[] ir;
            try
            {
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return false;
                }
                if (ConnectCount.ContainsKey(_PLCconnectionID) == false)//20110726
                {
                    ConnectCount.Add(_PLCconnectionID, 0);
                }
                if (ConnectCount[_PLCconnectionID] > 1)//20110726
                {
                    ConnectCount[_PLCconnectionID]++;//20110726
                    _opcError = "同步数据时：OPC Server没连接到PLC，并且超过重复连接次数!请先关闭命令开关，检查通讯线路，确认后重新打开命令开关！";
                    return false;
                }
                //定义item列表
                items = new Item[itemnames.Length];//定义数据项，即item
                int i;
                for (i = 0; i < items.Length; i++)//item初始化赋值
                {
                    items[i] = new Item();//创建一个项Item对象。
                    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[i].ItemPath = null; //该数据项在服务器中的路径。
                    items[i].ItemName = _PLCconnectionID + itemnames[i]; //该数据项在服务器中的名字。
                }
                _writeSubscription.AddItems(items);
                itemvalues = new ItemValue[_writeSubscription.Items.Length];
                for (int ii = 0; ii < _writeSubscription.Items.Length; ii++)
                {
                    itemvalues[ii] = new ItemValue((ItemIdentifier)_writeSubscription.Items[ii]);
                    itemvalues[ii].Value = itemvalue[ii];
                }

                ir = _writeSubscription.Write(itemvalues);

                _writeSubscription.RemoveItems(_writeSubscription.Items);
                //_writeSubscription.Dispose();
                //GC.Collect();
                return true;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "同步写数据时：" + ex.Message;
                return false;
            }
            finally
            {
                items=null;
                itemvalues=null;
                ir=null;
            }
        }

        public static bool SyncWriteAllItemValue(StringBuilder[] itemnames, StringBuilder[] itemvalue)
        {
            Item[] items;
            ItemValue[] itemvalues;
            IdentifiedResult[] ir;
            try
            {

                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return false;
                }
                if (ConnectCount.ContainsKey(_PLCconnectionID) == false)//20110726
                {
                    ConnectCount.Add(_PLCconnectionID, 0);
                }
                if (ConnectCount[_PLCconnectionID] > 1)//20110726
                {
                    ConnectCount[_PLCconnectionID]++;//20110726
                    //_opcError = "同步数据时：OPC Server没连接到PLC:"+_PLCconnectionID.ToString()+"，人工确认后进行【设备初始化】";
                    return false;
                }
                //定义item列表
                items = new Item[itemnames.Length];//定义数据项，即item
                int i;
                for (i = 0; i < items.Length; i++)//item初始化赋值
                {
                    items[i] = new Item();//创建一个项Item对象。
                    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[i].ItemPath = null; //该数据项在服务器中的路径。
                    items[i].ItemName = _PLCconnectionID + itemnames[i].ToString(); //该数据项在服务器中的名字。
                }
                _writeSubscription.AddItems(items);
                itemvalues = new ItemValue[_writeSubscription.Items.Length];
                for (int ii = 0; ii < _writeSubscription.Items.Length; ii++)
                {
                    itemvalues[ii] = new ItemValue((ItemIdentifier)_writeSubscription.Items[ii]);
                    itemvalues[ii].Value = itemvalue[ii].ToString();
                }

                ir = _writeSubscription.Write(itemvalues);
                
                _writeSubscription.RemoveItems(_writeSubscription.Items);
                if (ir.Length == 0)
                {
                    ConnectCount[_PLCconnectionID]++;//20120405
                    _opcError = "同步写数据时：OPC Server没连接到PLC："+_PLCconnectionID.ToString();
                    return false;
                }
                else
                {
                    if (ir[0].ResultID !=ResultID.S_OK)
                    {
                        ConnectCount[_PLCconnectionID]++;//20120405
                        _opcError = "同步写数据时：OPC Server没连接到PLC："+_PLCconnectionID.ToString();
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                //_writeSubscription.Dispose();
                //GC.Collect();
                
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "同步写数据时：" + ex.Message;
                return false;
            }
            finally
            {
                items = null;
                itemvalues = null;
                ir = null;
            }
        }
        /// <summary>
        /// 延吉读取指定OPC标签组数据（_tempSubscription组）
        /// </summary>
        /// <param name="itemnames"></param>
        /// <returns></returns>
        public static object[] SyncReadItemValues(string[] itemnames)
        {
            Item[] items;
            ItemResult[] irs;
            ItemValueResult[] values;
            object[] itemnamevalue;
            try
            {
                string ss; string ss1;
                ss = DateTime.Now.Second.ToString() + "-" + DateTime.Now.Millisecond.ToString();
                if (_IfConnectOPCServer == false)
                {
                    if (ConnectOPCServer(_hostname, _progID) == false) return null;
                }
                //定义item列表
                items = new Item[itemnames.Length];//定义数据项，即item
                int i;
                for (i = 0; i < items.Length; i++)//item初始化赋值
                {
                    items[i] = new Item();//创建一个项Item对象。
                    items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
                    items[i].ItemPath = null; //该数据项在服务器中的路径。
                    items[i].ItemName = _PLCconnectionID + itemnames[i]; //该数据项在服务器中的名字。
                }
                irs = _tempSubscription.AddItems(items);

                values = _tempSubscription.Read(_tempSubscription.Items);
                if (values[0].Quality == Quality.Bad)
                {
                    _opcError = "同步读数据时：OPC Server没连接到PLC!";
                    return null;
                }
                itemnamevalue = new object[values.Length];
                int k = 0;
                foreach (ItemValueResult value in values)
                {
                    itemnamevalue[k] = value.Value;
                    k++;
                }
                //Array.Copy(values.[0].Value, itemnamevalue, values.Length);
                _tempSubscription.RemoveItems(_tempSubscription.Items);
                //_tempSubscription.Dispose();
                //GC.Collect();
                ss1 = DateTime.Now.Second.ToString() + "-" + DateTime.Now.Millisecond.ToString();
                return itemnamevalue;
            }
            catch (Exception ex)
            {
                //if ((m_server == null) || (m_server.IsConnected == false))
                //{
                _IfConnectOPCServer = false;
                //}
                _opcError = "同步读数据时：" + ex.Message;
                return null;
            }
            finally
            {
                items=null ;
                irs=null ;
                values=null ;
                itemnamevalue=null ;
            }
        }
        #endregion


        //20100221
        //#region 延吉同步写、异步读OPC
        //static byte[] AsyncReadAllItemNameValue= new byte[(int)devinfo28.Dbw2Getlength];
        //static bool AsyncReadOK=false ;
        ///// <summary>
        ///// 延吉异步读取整个_readSubscription组的内容
        ///// </summary>
        ///// <returns></returns>
        //public static void AsyncReadAllItems()
        //{
            
        //    try
        //    {
        //        if (_IfConnectOPCServer == false)
        //        {
        //            if (ConnectOPCServer(_hostname, _progID) == false) return ;
        //        }
                
        //        IRequest quest=null ;
        //        _readSubscription.Read(_readSubscription.Items, Guid.NewGuid().ToString(), OnReadComplete,out quest);
                
        //    }
        //    catch (Exception ex)
        //    {
        //        //if ((m_server == null) || (m_server.IsConnected == false))
        //        //{
        //        _IfConnectOPCServer = false;
        //        //}
        //        _opcError = "异步读数据时：" + ex.Message;
        //        AsyncReadOK = false;
        //        return ;
        //    }
        //    finally
        //    {
                
        //    }
        //}
        ///// <summary>
        ///// 延吉向指定OPC标签组同步写入数据（_writeSubscription组）
        ///// </summary>
        ///// <param name="itemnames"></param>
        ///// <param name="itemvalue"></param>
        ///// <returns></returns>
        //public static bool SyncWriteGroupItemValue(string[] itemnames, string[] itemvalue)
        //{
        //    Item[] items;
        //    ItemValue[] itemvalues;
        //    IdentifiedResult[] ir;
        //    try
        //    {
        //        if (AsyncReadOK == false) return false;
        //        if (_IfConnectOPCServer == false)
        //        {
        //            if (ConnectOPCServer(_hostname, _progID) == false) return false;
        //        }
        //        //定义item列表
        //        items = new Item[itemnames.Length];//定义数据项，即item
        //        int i;
        //        for (i = 0; i < items.Length; i++)//item初始化赋值
        //        {
        //            items[i] = new Item();//创建一个项Item对象。
        //            items[i].ClientHandle = Guid.NewGuid().ToString();//客户端给该数据项分配的句柄。
        //            items[i].ItemPath = null; //该数据项在服务器中的路径。
        //            items[i].ItemName = _PLCconnectionID + itemnames[i]; //该数据项在服务器中的名字。
        //        }
        //        _writeSubscription.AddItems(items);
        //        itemvalues = new ItemValue[_writeSubscription.Items.Length];
        //        for (int ii = 0; ii < _writeSubscription.Items.Length; ii++)
        //        {
        //            itemvalues[ii] = new ItemValue((ItemIdentifier)_writeSubscription.Items[ii]);
        //            itemvalues[ii].Value = itemvalue[ii];
        //        }

        //        ir = _writeSubscription.Write(itemvalues);

        //        _writeSubscription.RemoveItems(_writeSubscription.Items);
        //        //_writeSubscription.Dispose();
        //        GC.Collect();
        //        return true;
        //    }
        //    catch (Exception ex)
        //    {
        //        //if ((m_server == null) || (m_server.IsConnected == false))
        //        //{
        //        _IfConnectOPCServer = false;
        //        //}
        //        _opcError = "同步写数据时：" + ex.Message;
        //        return false;
        //    }
        //    finally
        //    {
        //        items = null;
        //        itemvalues = null;
        //        ir = null;
        //    }
        //}
        ////ReadComplete回调
        //public static void OnReadComplete(object requestHandle, Opc.Da.ItemValueResult[] values)
        //{
        //    /*Console.WriteLine("发生异步读name:{0},value:{1}", values[0].ItemName, values[0].Value);
        //    if ((int)requestHandle == 1)
        //        Console.WriteLine("事件信号句柄为{0}", requestHandle);*/
        //    //不区分请求句柄了，直接接收OPC数据
        //    try
        //    {
        //        if (values.Length <= 0)
        //        {
        //            _opcError = "异步读数据时：OPC Server没连接到PLC!";
        //            AsyncReadOK = false;
        //            return ;
        //        }
        //        if (values[0].Quality == Quality.Bad)
        //        {
        //            _opcError = "异步读数据时：OPC Server没连接到PLC!";
        //            AsyncReadOK = false;
        //            return ;
        //        }


        //        Array.Copy((Array)values[0].Value, AsyncReadAllItemNameValue, AsyncReadAllItemNameValue.GetLength(0));// (int)devinfo28.Dbw2Getlength
        //        AsyncReadOK = true;
        //    }
        //    catch (Exception ex)
        //    {
        //        _opcError = "异步读数据时："+ex.Message ;
        //        AsyncReadOK = false;
        //        return;
        //    }
        //    finally
        //    {
        //        values = null;
        //    }
        //}
        //#endregion



        /// <summary>
        /// 获得设备类型索引
        /// </summary>
        /// <param name="devIdx">设备索引</param>
        /// <returns>设备类型索引</returns>
        static int GetDeviceKindIdx(int devIdx)
        {
            System.Object lockThis = new System.Object();
            lock (lockThis)
            {
                try
                {

                    DataView dv= dbo.ExceSQL(string.Format("SELECT F_DeviceKindIndex FROM T_Base_Device WHERE F_DeviceIndex={0}", devIdx)).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        return System.Convert.ToInt32(dv[0]["F_DeviceKindIndex"]);
                    }
                    else
                        return 0;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }
        public static void DisConnectOPCServer()
        {
            if (m_server== null) return;
            if (m_server.IsConnected == false ) return;

            
            foreach (Subscription sub in SubscriptionGroup)
            {
                try
                {
                    m_server.CancelSubscription(sub);//m_server前文已说明，通知服务器要求删除组。     
                }
                catch
                {

                }
                sub.Dispose();//强制.NET资源回收站回收该subscription的所有资源。
            }
            if (_readSubscription != null)
            {
                m_server.CancelSubscription(_readSubscription);//m_server前文已说明，通知服务器要求删除组。        
                _readSubscription.Dispose();//强制.NET资源回收站回收该subscription的所有资源。
            }
            
            if (_writeSubscription != null)
            {
                m_server.CancelSubscription(_writeSubscription);//m_server前文已说明，通知服务器要求删除组。        
                _writeSubscription.Dispose();//强制.NET资源回收站回收该subscription的所有资源。
            }
            m_server.Disconnect();//
        }
        public static void  CreateReadSubscription()
        {
            if (_IfConnectOPCServer == false)
            {
                if (ConnectOPCServer(_hostname, _progID) == false) return;
            }
            #region 建立读全部标签组
            Opc.Da.SubscriptionState _readstate = null;//定义组（订阅者）状态，相当于OPC规范中组的参数
            //设定读取组状态
            _readstate = new Opc.Da.SubscriptionState();//组（订阅者）状态，相当于OPC规范中组的参数
            _readstate.Name = "readopc";//组名
            _readstate.ServerHandle = null;//服务器给该组分配的句柄。
            _readstate.ClientHandle = Guid.NewGuid().ToString();//客户端给该组分配的句柄。
            _readstate.Active = true;//激活该组。
            _readstate.UpdateRate = 50;//刷新频率为100毫秒。
            _readstate.Deadband = 0;// 死区值，设为0时，服务器端该组内任何数据变化都通知组。
            _readstate.Locale = null;//不设置地区值。
            //添加读组
            _readSubscription = (Opc.Da.Subscription)m_server.CreateSubscription(_readstate);//创建读取组
           
            #endregion
        }
    }
}