C# Variant.ToString方法代码示例

        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>
        /// Gets the display text for the specified attribute.
        /// </summary>
        /// <param name="session">The currently active session.</param>
        /// <param name="attributeId">The id of the attribute.</param>
        /// <param name="value">The value of the attribute.</param>
        /// <returns>The attribute formatted as a string.</returns>
        public static string GetAttributeDisplayText(Session session, uint attributeId, Variant value)
        {
            if (value == Variant.Null)
            {
                return String.Empty;
            }

            switch (attributeId)
            {
                case Attributes.AccessLevel:
                case Attributes.UserAccessLevel:
                {
                    byte? field = value.Value as byte?;
                    
                    if (field != null)
                    {
                        return GetAccessLevelDisplayText(field.Value);
                    }

                    break;
                }

                case Attributes.EventNotifier:
                {
                    byte? field = value.Value as byte?;

                    if (field != null)
                    {
                        return GetEventNotifierDisplayText(field.Value);
                    }

                    break;
                }

                case Attributes.DataType:
                {
                    return session.NodeCache.GetDisplayText(value.Value as NodeId);
                }

                case Attributes.ValueRank:
                {
                    int? field = value.Value as int?;

                    if (field != null)
                    {
                        return GetValueRankDisplayText(field.Value);
                    }

                    break;
                }

                case Attributes.NodeClass:
                {
                    int? field = value.Value as int?;

                    if (field != null)
                    {
                        return ((NodeClass)field.Value).ToString();
                    }

                    break;
                }

                case Attributes.NodeId:
                {
                    NodeId field = value.Value as NodeId;

                    if (!NodeId.IsNull(field))
                    {
                        return field.ToString();
                    }

                    return "Null";
                }
            }

            // check for byte strings.
            if (value.Value is byte[])
            {
                return Utils.ToHexString(value.Value as byte[]);
            }

            // use default format.
            return value.ToString();            
        }

        /// <summary>
        /// Sets the value shown in the control.
        /// </summary>
        private void SetValue(Variant value)
        {
            BuiltInType targetType = BuiltInType.Null;
            int valueRank = ValueRanks.Scalar;

            if (value.TypeInfo != null && value.TypeInfo.BuiltInType != BuiltInType.Null)
            {
                targetType = value.TypeInfo.BuiltInType;
                valueRank = value.TypeInfo.ValueRank;
            }

            DataTypeCB.SelectedItem = targetType;
            ValueRankCB.SelectedItem = (ValueRankOptions)valueRank;

            if (value.Value == null)
            {
                ValueTB.Text = String.Empty;
                return;
            }

            // check for arrays.
            if (valueRank != ValueRanks.Scalar)
            {
                ValueTB.Text = value.ToString();
                ValueTB.ReadOnly = true;
                return;
            }

            // cast the value to the requested data type.
            ValueTB.Text = (string)TypeInfo.Cast(value.Value, value.TypeInfo, BuiltInType.String);
            ValueTB.ReadOnly = false;
        }

        private void OkBTN_Click(object sender, EventArgs e)
        {
            try
            {
                #region Task #B4 - Call a Method
                List<object> inputArguments = new List<object>();

                TutorialModel.CalibrationDataType d = new TutorialModel.CalibrationDataType();
                d.Period = 10;
                d.Offset = 20;
                inputArguments.Add(new Variant(new ExtensionObject(d)));
             
                /*
             byte[] buffer1 = BitConverter.GetBytes((double)1);
             byte[] buffer2 = BitConverter.GetBytes((double)2);

             ExtensionObject ex = new ExtensionObject();
             ex.TypeId = new ExpandedNodeId(238, "http://somecompany.com/TutorialModel");
             ex.Body = Utils.Append(buffer1, buffer2);

             inputArguments.Add(new Variant(ex));
             
             for (int ii = 0; ii < m_firstOutputArgument; ii++)
             {
                 Variant value = (Variant)ArgumentsLV.Items[ii].Tag;
                 inputArguments.Add(value.Value);
             }
             */

                IList<object> outputArguments = m_session.Call(m_objectId, m_methodId, inputArguments.ToArray());

                for (int ii = m_firstOutputArgument; ii-m_firstOutputArgument < outputArguments.Count && ii < ArgumentsLV.Items.Count; ii++)
                {
                    Variant value = new Variant(outputArguments[ii-m_firstOutputArgument]);
                    ArgumentsLV.Items[ii].SubItems[2].Text = value.ToString();
                }

                MessageBox.Show("Call succeeded.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                #endregion
            }
            catch (Exception exception)
            {
                ClientUtils.HandleException(this.Text, exception);
            }
        }

        /// <summary>
        /// Updates the list control.
        /// </summary>
        private void UpdateList(Session session, Argument[] arguments, string browseName)
        {
            for (int ii = 0; ii < arguments.Length; ii++)
            {
                Argument argument = arguments[ii];
                Variant defaultValue = new Variant(TypeInfo.GetDefaultValue(argument.DataType, argument.ValueRank));

                ListViewItem item = new ListViewItem(arguments[ii].Name);

                if (browseName == BrowseNames.InputArguments)
                {
                    item.SubItems.Add("IN");
                    m_firstOutputArgument++;
                }
                else
                {
                    item.SubItems.Add("OUT");
                }

                string dataType = session.NodeCache.GetDisplayText(arguments[ii].DataType);

                if (arguments[ii].ValueRank >= 0)
                {
                    dataType += "[]";
                }

                item.SubItems.Add(defaultValue.ToString());
                item.SubItems.Add(dataType);
                item.SubItems.Add(Utils.Format("{0}", arguments[ii].Description));
                item.Tag = defaultValue;

                ArgumentsLV.Items.Add(item);
            }
        }