C# IDebugReference2类代码示例

        public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo) {
            pPropertyInfo[0] = new DEBUG_PROPERTY_INFO();

            if (dwFields.HasFlag(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB)) {
                pPropertyInfo[0].dwAttrib = enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_ERROR;
                pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB;
            }

            if (dwFields.HasFlag(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE)) {
                pPropertyInfo[0].bstrValue = _errorText;
                pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE;
            }

            return VSConstants.S_OK;
        }

        public int GetPropertyInfo(uint dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
        {
            if (pPropertyInfo.Length > 0)
            {
                Expression debugExpr = vs.Debugger.GetExpression(_expression, true, 1000);

                pPropertyInfo[0].dwAttrib = (long)Constants.DBG_ATTRIB_ACCESS_ALL;
                pPropertyInfo[0].dwAttrib |= (long)Constants.DBG_ATTRIB_TYPE_VOLATILE;
                pPropertyInfo[0].dwAttrib |= (long) Constants.DBG_ATTRIB_STORAGE_REGISTER;

                pPropertyInfo[0].dwFields = dwFields;

                if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME) != 0)
                {
                    pPropertyInfo[0].bstrFullName = _expression;
                }

                if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME) != 0)
                {
                    pPropertyInfo[0].bstrName = debugExpr.Name;
                }

                if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE) != 0)
                {
                    pPropertyInfo[0].bstrType = debugExpr.Type;
                }

                if ((dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE) != 0
                    || (dwFields & (uint)enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_RAW) != 0)
                {
                    pPropertyInfo[0].bstrValue = debugExpr.Value;
                }
            }
            return VSConstants.S_OK;
        }

 //  Return an IDebugReference2 for this property. An IDebugReference2 can be thought of as a type and an address.
 public int GetReference(out IDebugReference2 ppReference) {
     ppReference = null;
     return VSConstants.E_NOTIMPL;
 }

 /// <summary>
 /// Sets the value of the property from the value of a given reference. (http://msdn.microsoft.com/en-ca/library/bb145613.aspx)
 /// The debugger will call this when the user tries to edit the property's values. As the sample has set the read-only flag on 
 /// its properties, this should not be called.
 /// Not implemented.  
 /// </summary>
 /// <param name="rgpArgs"> An array of arguments to pass to the managed code property setter. If the property setter does not 
 /// take arguments or if this IDebugProperty2 object does not refer to such a property setter, rgpArgs should be a null value. 
 /// This parameter is typically a null value. </param>
 /// <param name="dwArgCount"> The number of arguments in the rgpArgs array. </param>
 /// <param name="pValue"> A reference, in the form of an IDebugReference2 object, to the value to use to set this property. </param>
 /// <param name="dwTimeout"> How long to take to set the value, in milliseconds. A typical value is INFINITE. This affects 
 /// the length of time that any possible evaluation can take. </param>
 /// <returns> Not implemented. </returns>
 public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
 {
     throw new Exception("The method or operation is not implemented.");
 }

 // The debugger will call this when the user tries to edit the property's values
 // the sample has set the read-only flag on its properties, so this should not be called.
 public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
 {
     throw new NotImplementedException();
 }

 public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
 {
     pPropertyInfo[0] = ConstructErrorPropertyInfo(dwFields, _name, _message, this);
     rgpArgs = null;
     return Constants.S_OK;
 }

 public int GetReference(out IDebugReference2 ppReference)
 {
     ppReference = null;
     return AD7Constants.E_GETREFERENCE_NO_REFERENCE;
 }

 int IDebugProperty3.SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout) {
     return IDebugProperty2.SetValueAsReference(rgpArgs, dwArgCount, pValue, dwTimeout);
 }

 public int SetValueAsReference(IDebugReference2[] rgpArgs, uint dwArgCount, IDebugReference2 pValue, uint dwTimeout)
 {
     return AD7Constants.E_SETVALUEASREFERENCE_NOTSUPPORTED;
 }

            public int GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_PROPERTY_INFO[] pPropertyInfo)
            {
                if (pPropertyInfo == null)
                    throw new ArgumentNullException("pPropertyInfo");
                if (pPropertyInfo.Length == 0)
                    throw new ArgumentException();

                bool getFullName = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME) != 0;
                bool getName = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME) != 0;
                bool getType = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE) != 0;
                bool getValue = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE) != 0;
                bool getAttributes = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB) != 0;
                bool getProperty = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP) != 0;

                bool useAutoExpandValue = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_AUTOEXPAND) != 0;
                bool noFormatting = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_RAW) != 0;
                bool noToString = (dwFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_NO_TOSTRING) != 0;

                if (getFullName)
                {
                    if (ErrorHandler.Succeeded(_stackFrame.GetName(out pPropertyInfo[0].bstrFullName)))
                        pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME;
                }

                if (getName)
                {
                    if (ErrorHandler.Succeeded(_stackFrame.GetName(out pPropertyInfo[0].bstrName)))
                        pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME;
                }

                if (getType)
                {
                    pPropertyInfo[0].bstrType = string.Empty;
                    pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE;
                }

                if (getValue)
                {
                    // value??
                }

                if (getAttributes)
                {
                    pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE;
                    pPropertyInfo[0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY;
                    pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB;
                }

                if (getProperty)
                {
                    pPropertyInfo[0].pProperty = this;
                    pPropertyInfo[0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_PROP;
                }

                return VSConstants.S_OK;
            }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public override int GetPropertyInfo (enum_DEBUGPROP_INFO_FLAGS requestedFields, uint radix, uint timeout, IDebugReference2 [] debugReferenceArray, uint argumentCount, DEBUG_PROPERTY_INFO [] propertyInfoArray)
    {
      // 
      // Fills in a DEBUG_PROPERTY_INFO structure that describes a property.
      // 

      LoggingUtils.PrintFunction ();

      try
      {
        LoggingUtils.RequireOk (base.GetPropertyInfo (requestedFields, radix, timeout, debugReferenceArray, argumentCount, propertyInfoArray));

#if false
        if ((m_gdbVariable != null) && (requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME) != 0)
        {
          propertyInfoArray [0].bstrFullName = m_gdbVariable.Name;

          propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_FULLNAME;
        }
#endif

        if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME) != 0)
        {
          if (m_gdbVariable != null)
          {
            propertyInfoArray [0].bstrName = m_gdbVariable.Expression;

            propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_NAME;
          }
        }

        if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE) != 0)
        {
          if (m_gdbVariable != null)
          {
            propertyInfoArray [0].bstrType = m_gdbVariable.Type;

            propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE;
          }
        }

        if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE) != 0)
        {
#if false
          if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_AUTOEXPAND) != 0)
          {
          }

          if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_RAW) != 0)
          {
          }

          if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE_NO_TOSTRING) != 0)
          {
          }
#endif
          if (m_gdbVariable != null)
          {
            propertyInfoArray [0].bstrValue = m_gdbVariable.Value;

            propertyInfoArray [0].dwFields |= enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_VALUE;
          }
        }

        if ((requestedFields & enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ATTRIB) != 0)
        {
          if (m_gdbVariable != null)
          {
            if (m_gdbVariable.HasChildren)
            {
              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_OBJ_IS_EXPANDABLE;
            }

            if (m_gdbVariable.Expression.StartsWith ("$")) // Register. '$r0'
            {
              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_STORAGE_REGISTER;

              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_DATA;

              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_NONE;
            }
            else if (string.IsNullOrEmpty (m_gdbVariable.Type))
            {
              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_PROPERTY;
            }
            else if (m_gdbVariable.Value.Equals ("{...}"))
            {
              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_PROPERTY;

              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_CLASS;
            }
            else if (m_gdbVariable.Type.Contains ("(")) // Function, i.e: 'bool (void)'
            {
              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_METHOD;

              propertyInfoArray [0].dwAttrib |= enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_VALUE_READONLY;
//.........这里部分代码省略.........

 public int GetReferenceInfo(enum_DEBUGREF_INFO_FLAGS dwFields, uint dwRadix, uint dwTimeout, IDebugReference2[] rgpArgs, uint dwArgCount, DEBUG_REFERENCE_INFO[] pReferenceInfo)
 {
     throw new NotImplementedException();
 }

 public int GetParent(out IDebugReference2 ppParent)
 {
     throw new NotImplementedException();
 }

 public int GetDerivedMostReference(out IDebugReference2 ppDerivedMost)
 {
     throw new NotImplementedException();
 }

 public int Compare(enum_REFERENCE_COMPARE dwCompare, IDebugReference2 pReference)
 {
     throw new NotImplementedException();
 }