Opc.Ua.Com.Client.HdaParsedNodeId.Parse C# (CSharp) Méthode

        public static new HdaParsedNodeId Parse(NodeId nodeId)
        {
            // can only parse non-null string node identifiers.
            if (NodeId.IsNull(nodeId))
            {
                return null;
            }

            string identifier = nodeId.Identifier as string;

            if (String.IsNullOrEmpty(identifier))
            {
                return null;
            }

            HdaParsedNodeId parsedNodeId = new HdaParsedNodeId();
            parsedNodeId.NamespaceIndex = nodeId.NamespaceIndex;

            int start = 0;

            // extract the type of identifier.
            parsedNodeId.RootType = (int)ExtractNumber(identifier, ref start);

            if (start >= identifier.Length || identifier[start] != ':')
            {
                return null;
            }

            // extract any component path.
            StringBuilder buffer = new StringBuilder();

            int index = start+1;

            parsedNodeId.RootId = ExtractAndUnescapeString(identifier, ref index, '&', '?');

            // extract any component.
            int end = index+1;
            parsedNodeId.ComponentPath = null;

            // extract the component path.
            if (end < identifier.Length)
            {
                parsedNodeId.ComponentPath = identifier.Substring(end);
            }

            // extract the category and condition name.
            start = 0;
            identifier = parsedNodeId.RootId;

            switch (parsedNodeId.RootType)
            {
                case HdaModelUtils.HdaAggregate:
                {
                    parsedNodeId.AggregateId = ExtractNumber(identifier, ref start);

                    if (start < identifier.Length)
                    {
                        return null;
                    }

                    break;
                }
            }

            // extract the attribute id.
            if (!String.IsNullOrEmpty(parsedNodeId.ComponentPath))
            {
                start = 0;
                identifier = parsedNodeId.ComponentPath;

                switch (parsedNodeId.RootType)
                {
                    case HdaModelUtils.HdaItemAttribute:
                    {
                        parsedNodeId.AttributeId = ExtractNumber(identifier, ref start);

                        if (start < identifier.Length)
                        {
                            return null;
                        }

                        break;
                    }
                }
            }

            return parsedNodeId;
        }

        /// <summary>
        /// Converts a UA Aggregate ID to a HDA aggregate ID
        /// </summary>
        /// <param name="nodeId">The node id.</param>
        /// <param name="namespaceIndex">Index of the namespace.</param>
        /// <returns></returns>
        public static uint HdaAggregateToUaAggregate(NodeId nodeId, ushort namespaceIndex)
        {
            // check for valid node.
            if (nodeId == null)
            {
                return(0);
            }

            // check for built in aggregate.
            uint aggregateId = ComUtils.GetHdaAggregateId(nodeId);

            if (aggregateId != 0)
            {
                return(aggregateId);
            }

            // parse the node id.
            HdaParsedNodeId parsedNodeId = HdaParsedNodeId.Parse(nodeId);

            if (parsedNodeId == null || namespaceIndex != parsedNodeId.NamespaceIndex || parsedNodeId.RootType != HdaModelUtils.HdaAggregate)
            {
                return(0);
            }

            return(parsedNodeId.AggregateId);
        }