C# BuiltInType类代码示例

 /// <summary>
 /// Initializes a new instance of the <see cref="UATypeInfo"/> class.
 /// </summary>
 /// <param name="builtInType">Type of the built in.</param>
 /// <param name="valueRank">The value rank.</param>
 /// <param name="arrayDimensions">The array dimensions.</param>
 /// <exception cref="System.ArgumentOutOfRangeException">$for {nameof(valueRank)} == {valueRank} {nameof(ArrayDimensions)} must be provided.</exception>
 public UATypeInfo(BuiltInType builtInType, int valueRank, int[] arrayDimensions)
 {
     if ((valueRank == 0 || valueRank > 1) && (arrayDimensions == null || arrayDimensions.Length == 0))
     throw new ArgumentOutOfRangeException(nameof(valueRank), $"for {nameof(valueRank)} == {valueRank} {nameof(ArrayDimensions)} must be provided.");
       m_builtInType = builtInType;
       m_valueRank = valueRank;
       m_ArrayDimensionsField = (arrayDimensions == null || arrayDimensions.Length == 0) ? null : (int[])arrayDimensions.Clone();
 }

        /// <summary>
        /// Prompts the user to edit an array value.
        /// </summary>
        public Array ShowDialog(Array value, BuiltInType dataType, bool readOnly, string caption)
        {
            if (caption != null)
            {
                this.Text = caption;
            }

            // detect the data type.
            if (dataType == BuiltInType.Null)
            {
                dataType = TypeInfo.Construct(value).BuiltInType;
            }

            m_dataType = dataType;
            ArrayDV.AllowUserToAddRows = !readOnly;
            ArrayDV.AllowUserToDeleteRows = !readOnly;
            ArrayDV.RowHeadersVisible = !readOnly;
            m_dataset.Tables[0].Clear();

            if (value != null)
            {
                for (int ii = 0; ii < value.Length; ii++)
                {
                    DataRow row = m_dataset.Tables[0].NewRow();
                    row[0] = new Variant(value.GetValue(ii)).ToString();
                    row[1] = ii;
                    m_dataset.Tables[0].Rows.Add(row);
                }
            }

            m_dataset.AcceptChanges();

            if (ShowDialog() != DialogResult.OK)
            {
                return null;
            }

            m_dataset.AcceptChanges();

            if (!readOnly)
            {
                value = TypeInfo.CreateArray(dataType, m_dataset.Tables[0].Rows.Count);

                for (int ii = 0; ii < m_dataset.Tables[0].DefaultView.Count; ii++)
                {
                    string oldValue = m_dataset.Tables[0].DefaultView[ii].Row[0] as string;
                    object newValue = TypeInfo.Cast(oldValue, m_dataType);
                    value.SetValue(newValue, ii);
                }
            }

            return value;
        }

 /// <summary>
 /// Helper method that creates the consumer binding. 
 /// </summary>
 /// <param name="variableName">Name of the variable.</param>
 /// <returns>IConsumerBinding.</returns>
 /// <exception cref="System.ArgumentOutOfRangeException">variableName</exception>
 public IConsumerBinding GetConsumerBinding(string variableName, BuiltInType encoding)
 {
     UATypeInfo _uaTypeInfo = new UATypeInfo(encoding);
       if (variableName == "Value1")
       {
     Value1 = new ConsumerBindingMonitoredValue<string>(_uaTypeInfo);
     return Value1;
       }
       else if (variableName == "Value2")
       {
     Value2 = new ConsumerBindingMonitoredValue<double>(_uaTypeInfo);
     return Value2;
       }
       throw new ArgumentOutOfRangeException("variableName");
 }

        public Variant? ShowDialog(Variant value, BuiltInType builtInType)
        {
            if (value != Variant.Null)
            {
                ValueTB.Text = value.ToString();
            }
            
            if (ShowDialog() != DialogResult.OK)
            {
                return null;
            }

            if (String.IsNullOrEmpty(ValueTB.Text))
            {
                return Variant.Null;
            }

            return new Variant(TypeInfo.Cast(ValueTB.Text, builtInType));
        }

        /// <summary>
        /// Changes the data type.
        /// </summary>
        public void SetType(BuiltInType builtInType)
        {
            if (!CanChangeType)
            {
                return;
            }
            
            AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;

            TypeInfo currentType = info.TypeInfo;
            object currentValue = info.Value;

            try
            {
                EndEdit();
                currentValue = info.Value;
            }
            catch (Exception)
            {
                currentValue = TypeInfo.GetDefaultValue(currentType.BuiltInType);
            }

            if (info.Value is Variant)
            {
                Variant variant = (Variant)info.Value;
                currentValue = variant.Value;

                if (currentValue != null)
                {
                    currentType = variant.TypeInfo;

                    if (currentType == null)
                    {
                        currentType = TypeInfo.Construct(currentValue);
                    }
                }
            }
            
            TypeInfo targetType = new TypeInfo(builtInType, currentType.ValueRank);
            object newValue  = Convert(currentValue, currentType, targetType, true);

            NavigationMENU.Items.RemoveAt(NavigationMENU.Items.Count - 1);

            info.TypeInfo = targetType;
            info.Value = newValue;
            ShowValueNoNotify(info);
        }

        /// <summary>
        /// Converts a value to a Double
        /// </summary>
        private static object ToDouble(object value, BuiltInType sourceType)
        {            
            // check for array conversions.
            Array array = value as Array;

            if (array != null)
            {
                double[] output = new double[array.Length];

                for (int ii = 0; ii < array.Length; ii++)
                {
                    output[ii] = (double)Cast(array.GetValue(ii), BuiltInType.Double);
                }

                return output;
            }
            
            // handle for supported conversions.
            switch (sourceType)
            {
                case BuiltInType.Double:
                {
                    return (double)value; 
                }
                    
                case BuiltInType.Boolean: return Convert.ToDouble((bool)value);
                case BuiltInType.SByte:   return Convert.ToDouble((sbyte)value);
                case BuiltInType.Byte:    return Convert.ToDouble((byte)value);
                case BuiltInType.Int16:   return Convert.ToDouble((short)value);
                case BuiltInType.UInt16:  return Convert.ToDouble((ushort)value);
                case BuiltInType.Int32:   return Convert.ToDouble((int)value);
                case BuiltInType.UInt32:  return Convert.ToDouble((uint)value);
                case BuiltInType.Int64:   return Convert.ToDouble((long)value);
                case BuiltInType.UInt64:  return Convert.ToDouble((ulong)value);
                case BuiltInType.Float:   return Convert.ToDouble((float)value);

                case BuiltInType.String:
                {
                    return XmlConvert.ToDouble((string)value); 
                }
            }
            
            // conversion not supported.
            return DBNull.Value;
        }        

 private DataItemState CreateAnalogItemVariable(NodeState parent, string path, string name, BuiltInType dataType, int valueRank, object initialValues, Range customRange)
 {
     return CreateAnalogItemVariable(parent, path, name, (uint)dataType, valueRank, initialValues, customRange);
 }

        /// <summary>
        /// Creates a new variable type.
        /// </summary>
        private BaseVariableTypeState CreateVariableType(NodeState parent, IDictionary<NodeId, IList<IReference>> externalReferences, string path, string name, BuiltInType dataType, int valueRank)
        {
            BaseDataVariableTypeState type = new BaseDataVariableTypeState();

            type.SymbolicName = name;
            type.SuperTypeId = VariableTypeIds.BaseDataVariableType;
            type.NodeId = new NodeId(path, NamespaceIndex);
            type.BrowseName = new QualifiedName(name, NamespaceIndex);
            type.DisplayName = type.BrowseName.Name;
            type.WriteMask = AttributeWriteMask.None;
            type.UserWriteMask = AttributeWriteMask.None;
            type.IsAbstract = false;
            type.DataType = (uint)dataType;
            type.ValueRank = valueRank;
            type.Value = null;

            IList<IReference> references = null;

            if (!externalReferences.TryGetValue(VariableTypeIds.BaseDataVariableType, out references))
            {
                externalReferences[VariableTypeIds.BaseDataVariableType] = references = new List<IReference>();
            }

            references.Add(new NodeStateReference(ReferenceTypes.HasSubtype, false, type.NodeId));

            if (parent != null)
            {
                parent.AddReference(ReferenceTypes.Organizes, false, type.NodeId);
                type.AddReference(ReferenceTypes.Organizes, true, parent.NodeId);
            }

            AddPredefinedNode(SystemContext, type);
            return type;
        }

        /// <summary>
        /// Returns the data type precedence for the value.
        /// </summary>
        private static int GetDataTypePrecedence(BuiltInType type)
        {           
            switch (type)
            {
                case BuiltInType.Double:         { return 18; }
                case BuiltInType.Float:          { return 17; }
                case BuiltInType.Int64:          { return 16; }
                case BuiltInType.UInt64:         { return 15; }
                case BuiltInType.Int32:          { return 14; }
                case BuiltInType.UInt32:         { return 13; }
                case BuiltInType.StatusCode:     { return 12; }
                case BuiltInType.Int16:          { return 11; }
                case BuiltInType.UInt16:         { return 10; }
                case BuiltInType.SByte:          { return 9;  }
                case BuiltInType.Byte:           { return 8;  }
                case BuiltInType.Boolean:        { return 7;  }
                case BuiltInType.Guid:           { return 6;  }
                case BuiltInType.String:         { return 5;  }
                case BuiltInType.ExpandedNodeId: { return 4;  }
                case BuiltInType.NodeId:         { return 3;  }
                case BuiltInType.LocalizedText:  { return 2;  }
                case BuiltInType.QualifiedName:  { return 1;  }
            }

            return 0;
        }

        /// <summary>
        /// Checks if the datatype id is a built-in type.
        /// </summary>
        private bool IsBuiltInType(ExpandedNodeId nodeId, out BuiltInType builtinType)
        {
            builtinType = BuiltInType.Null;

            if (nodeId.IsAbsolute || nodeId.NamespaceIndex != 0 || nodeId.IdType != IdType.Numeric)
            {
                return false;
            }

            uint id = (uint)nodeId.Identifier;

            if (id > 0 && id <= DataTypes.BaseDataType)
            {
                builtinType = (BuiltInType)(int)id;
                return true;
            }

            switch (id)
            {
                case DataTypes.Enumeration: { builtinType = BuiltInType.Int32;  break; }
                case DataTypes.Number:      { builtinType = BuiltInType.Double; break; }
                case DataTypes.Integer:     { builtinType = BuiltInType.Int64;  break; }
                case DataTypes.UInteger:    { builtinType = BuiltInType.UInt64; break; }

                default:
                {
                    return false;
                }
            }

            return true;
        }

        /// <summary>
        /// Converts a value to a ExpandedNodeId
        /// </summary>
        private static object ToExpandedNodeId(object value, BuiltInType sourceType)
        {            
            // check for array conversions.
            Array array = value as Array;

            if (array != null)
            {
                ExpandedNodeId[] output = new ExpandedNodeId[array.Length];

                for (int ii = 0; ii < array.Length; ii++)
                {
                    output[ii] = (ExpandedNodeId)Cast(array.GetValue(ii), BuiltInType.ExpandedNodeId);
                }

                return output;
            }
            
            // handle for supported conversions.
            switch (sourceType)
            {
                case BuiltInType.ExpandedNodeId:
                {
                    return (ExpandedNodeId)value; 
                }

                case BuiltInType.NodeId:
                {
                    return (ExpandedNodeId)(NodeId)value; 
                }

                case BuiltInType.String:
                {
                    return ExpandedNodeId.Parse((string)value);
                }
            }
            
            // conversion not supported.
            return null;
        }

 /// <summary>
 /// Creates a new variable.
 /// </summary>
 private BaseDataVariableState CreateVariable(NodeState parent, string path, string name, BuiltInType dataType, int valueRank)
 {
     return CreateVariable(parent, path, name, (uint)dataType, valueRank);
 }

        private Variant ReadVariantArrayBody(string fieldName, BuiltInType type)
        {
            switch (type)
            {
                case BuiltInType.Boolean: { return new Variant(ReadBooleanArray(fieldName), TypeInfo.Arrays.Boolean); }
                case BuiltInType.SByte: { return new Variant(ReadSByteArray(fieldName), TypeInfo.Arrays.SByte); }
                case BuiltInType.Byte: { return new Variant(ReadByteArray(fieldName), TypeInfo.Arrays.Byte); }
                case BuiltInType.Int16: { return new Variant(ReadInt16Array(fieldName), TypeInfo.Arrays.Int16); }
                case BuiltInType.UInt16: { return new Variant(ReadUInt16Array(fieldName), TypeInfo.Arrays.UInt16); }
                case BuiltInType.Int32: { return new Variant(ReadInt32Array(fieldName), TypeInfo.Arrays.Int32); }
                case BuiltInType.UInt32: { return new Variant(ReadUInt32Array(fieldName), TypeInfo.Arrays.UInt32); }
                case BuiltInType.Int64: { return new Variant(ReadInt64Array(fieldName), TypeInfo.Arrays.Int64); }
                case BuiltInType.UInt64: { return new Variant(ReadUInt64Array(fieldName), TypeInfo.Arrays.UInt64); }
                case BuiltInType.Float: { return new Variant(ReadFloatArray(fieldName), TypeInfo.Arrays.Float); }
                case BuiltInType.Double: { return new Variant(ReadDoubleArray(fieldName), TypeInfo.Arrays.Double); }
                case BuiltInType.String: { return new Variant(ReadStringArray(fieldName), TypeInfo.Arrays.String); }
                case BuiltInType.ByteString: { return new Variant(ReadByteStringArray(fieldName), TypeInfo.Arrays.ByteString); }
                case BuiltInType.DateTime: { return new Variant(ReadDateTimeArray(fieldName), TypeInfo.Arrays.DateTime); }
                case BuiltInType.Guid: { return new Variant(ReadGuidArray(fieldName), TypeInfo.Arrays.Guid); }
                case BuiltInType.NodeId: { return new Variant(ReadNodeIdArray(fieldName), TypeInfo.Arrays.NodeId); }
                case BuiltInType.ExpandedNodeId: { return new Variant(ReadExpandedNodeIdArray(fieldName), TypeInfo.Arrays.ExpandedNodeId); }
                case BuiltInType.QualifiedName: { return new Variant(ReadQualifiedNameArray(fieldName), TypeInfo.Arrays.QualifiedName); }
                case BuiltInType.LocalizedText: { return new Variant(ReadLocalizedTextArray(fieldName), TypeInfo.Arrays.LocalizedText); }
                case BuiltInType.StatusCode: { return new Variant(ReadStatusCodeArray(fieldName), TypeInfo.Arrays.StatusCode); }
                case BuiltInType.XmlElement: { return new Variant(ReadXmlElementArray(fieldName), TypeInfo.Arrays.XmlElement); }
                case BuiltInType.ExtensionObject: { return new Variant(ReadExtensionObjectArray(fieldName), TypeInfo.Arrays.ExtensionObject); }
                case BuiltInType.Variant: { return new Variant(ReadVariantArray(fieldName), TypeInfo.Arrays.Variant); }
            }

            return Variant.Null;
        }

        /// <summary>
        /// Converts a value to a DateTime
        /// </summary>
        private static object ToDateTime(object value, BuiltInType sourceType)
        {            
            // check for array conversions.
            Array array = value as Array;

            if (array != null)
            {
                DateTime[] output = new DateTime[array.Length];

                for (int ii = 0; ii < array.Length; ii++)
                {
                    output[ii] = (DateTime)Cast(array.GetValue(ii), BuiltInType.DateTime);
                }

                return output;
            }
            
            // handle for supported conversions.
            switch (sourceType)
            {
                case BuiltInType.DateTime:
                {
                    return (DateTime)value; 
                }

                case BuiltInType.String:
                {
                    return XmlConvert.ToDateTimeOffset((string) value); 
                }
            }
            
            // conversion not supported.
            return null;
        }

        /// <summary>
        /// Converts a value to a QualifiedName
        /// </summary>
        private static object ToQualifiedName(object value, BuiltInType sourceType)
        {            
            // check for array conversions.
            Array array = value as Array;

            if (array != null)
            {
                QualifiedName[] output = new QualifiedName[array.Length];

                for (int ii = 0; ii < array.Length; ii++)
                {
                    output[ii] = (QualifiedName)Cast(array.GetValue(ii), BuiltInType.QualifiedName);
                }

                return output;
            }
            
            // handle for supported conversions.
            switch (sourceType)
            {
                case BuiltInType.QualifiedName:
                {
                    return (QualifiedName)value; 
                }

                case BuiltInType.String:
                {
                    return QualifiedName.Parse((string)value);
                }
            }
            
            // conversion not supported.
            return null;
        }