C# Session.FetchTypeTree方法代码示例

        /// <summary>
        /// Called when a session is created with a server.
        /// </summary>
        private void OnSessionCreated(Session session)
        {
            string commonAppDataPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
            string configFileName = Utils.Format(@"{0}\OPC Foundation\ComPseudoServers\{1}.internal.xml", commonAppDataPath, m_clsid);

            lock (m_lock)
            {
                try
                {
                    m_session = null;
                    m_Subscription = null;
                    m_AreaNodes.Clear();

                    m_session = session;

                    // load the config file.
                    if (File.Exists(configFileName))
                    {
                        XmlSerializer ser = new XmlSerializer(typeof(Configuration));
                        TextReader reader = new StreamReader(configFileName);
                        m_configFile = (Configuration)ser.Deserialize(reader);
                        reader.Close();

                        // set the ActualDataType property
                        for (int ii = 0; ii < m_configFile.Attributes.Length - 1; ii++)
                        {
                            NodeId nodeid = new NodeId(m_configFile.Attributes[ii].strDataTypeNodeId);
                            m_configFile.Attributes[ii].ActualDataType = DataTypes.GetSystemType(nodeid, EncodeableFactory.GlobalFactory);
                        }
                    }
                    else
                    {
                        InitConfigInfo(configFileName);
                    }

                    // Obtain the current server table, generate index mapping tables (client->server, server->client)
                    // and update the client side namespace table if necessary due to server changes
                    GenerateNamespaceIndexMappings(m_clsid);

                    // The client side namespace table may have been updated if the server namespace table
                    // has changed therefore save the updated client table.
                    SaveConfigInfo(configFileName);
                    
                    // fetch type tree.
                    m_session.FetchTypeTree(Opc.Ua.ObjectTypeIds.BaseEventType);
                    m_session.FetchTypeTree(Opc.Ua.ReferenceTypeIds.References);
                    
                    //Create UA Event Subscription if none configured in the registry
                    m_Subscription = new Opc.Ua.Client.Subscription(m_session.DefaultSubscription);
                    m_Subscription.PublishingEnabled = true;
                    m_Subscription.PublishingInterval = m_configFile.ProxySubscriptionSettings.PublishingInterval;
                    m_Subscription.KeepAliveCount = m_configFile.ProxySubscriptionSettings.KeepAliveCount;
                    m_Subscription.LifetimeCount = m_configFile.ProxySubscriptionSettings.LifetimeCount;
                    m_Subscription.Priority = m_configFile.ProxySubscriptionSettings.Priority;
                    m_Subscription.MaxNotificationsPerPublish = m_configFile.ProxySubscriptionSettings.MaxNotificationsPerPublish;

                    m_session.AddSubscription(m_Subscription);
                    m_Subscription.Create();
                    m_KeepAliveInterval = (int)(m_Subscription.CurrentPublishingInterval * m_Subscription.CurrentKeepAliveCount);

                    // Add Server object as the only monitored item to this subscription

                    NodeId nodeId_Server = new NodeId(Opc.Ua.Objects.Server);

                    MonitoredItem monitoredItem = CreateMonitoredItemForEvents(nodeId_Server);
                    m_Subscription.AddItem(monitoredItem);
                    m_Subscription.ApplyChanges();

                    AreaNode areaNode = new AreaNode();
                    areaNode.AreaName = "/";
                    ++areaNode.RefCount;
                    areaNode.MonitoredItem = monitoredItem;
                    m_notifiers.Add(monitoredItem.ClientHandle, areaNode);
                    m_AreaNodes.Add("/", areaNode);

                    m_Subscription.Session.Call(
                        Opc.Ua.ObjectTypes.ConditionType,
                        Methods.ConditionType_ConditionRefresh,
                        m_Subscription.Id);
                }
                catch (Exception e)
                {
                    Utils.Trace(e, "Initializing server after create.");
                    throw ComUtils.CreateComException(e);
                }
            }
        }

        /// <summary>
        /// Creates a new session.
        /// </summary>
        private Session CreateSession(Guid clsid)
        {
            // lookup the cached configuration information.
            ConfiguredEndpoint endpoint = null;
            bool previouslyConnected = true;

            if (!m_verifiedEndpoints.TryGetValue(clsid, out endpoint))
            {
                endpoint = LoadConfiguredEndpoint(clsid);

                if (endpoint != null)
                {
                    Utils.Trace("Loaded endpoint with URL: {0}", endpoint.EndpointUrl);
                    previouslyConnected = false;
                }
            } 
            
            if (endpoint == null)
            { 
                endpoint = m_endpointCache.Create(DefaultServerUrl);
            }
            
            // Initialize the client configuration.
            // Fetch the current configuration information by connecting to the server's discovery endpoint.
            // This method assumes that the discovery endpoint can be constructed by appending "/discovery" to the URL.
            if (endpoint.UpdateBeforeConnect && !previouslyConnected)
            {
                endpoint.UpdateFromServer(BindingFactory.Default);
                Utils.Trace("Updated endpoint from server: {0}", endpoint.EndpointUrl);
            }

            // Need to specify that the server is trusted by the client application.
            if (!previouslyConnected)
            {
                m_configuration.SecurityConfiguration.AddTrustedPeer(endpoint.Description.ServerCertificate);
            }

            // Set the session keep alive to 600 seconds.
            m_configuration.ClientConfiguration.DefaultSessionTimeout = 600000;

            ServiceMessageContext messageContext = m_configuration.CreateMessageContext();

            // Initialize the channel which will be created with the server.
            ITransportChannel channel = SessionChannel.Create(
                m_configuration,
                endpoint.Description,
                endpoint.Configuration,
                m_configuration.SecurityConfiguration.ApplicationCertificate.Find(true),
                messageContext);

              // Wrap the channel with the session object.
            Session session = new Session(channel, m_configuration, endpoint, null);
            session.ReturnDiagnostics = DiagnosticsMasks.SymbolicId;
            
            // The user login credentials must be provided when opening a session.
            IUserIdentity identity = null;

            if (endpoint.UserIdentity != null)
            {
                identity = new Opc.Ua.UserIdentity(endpoint.UserIdentity);
            }

            // Create the session. This actually connects to the server.
            session.Open("COM Client Session", identity);
        
            // need to fetch the references in order use the node cache.
            session.FetchTypeTree(ReferenceTypeIds.References);

            // save the updated information.
            if (!previouslyConnected)
            {
                try
                {
                    SaveConfiguredEndpoint(clsid, endpoint);
                }
                catch (Exception e)
                {
                    Utils.Trace(e, "Could not save SaveConfiguredEndpoint in registry."); 
                }

                m_verifiedEndpoints.Add(clsid, endpoint);
            }
            
            return session;
        }