PropertyGetAt Method (ActiveX/CSP)

Get the name and value of a property at the specified index in the property list.

Supported platforms: Windows only

Namespace: AcStMgr

Assembly: AcStMgr.tlb

Signature

VB.NET:

object.PropertyGetAt(index, szName, value)

C#:

object.PropertyGetAt(index, ref szName, ref value);

object

Type: AcStError, AcStFix object

The object this method applies to.

index

Access: Input-only

Type: Long

The index of the property to get from the property list.

szName

Access: Input/Output

Type: String

The name of the property in the property list.

value

Access: Input/Output

Type: Variant

The value of the property in the property list.

Return Value (RetVal)

No return value.

Remarks

No additional remarks.

Release Information

Releases: AutoCAD 2004 and later

• AcStMgr.tlb - AutoCAD 2004 and later

Examples

VB.NET:

Public Sub GetPropertyDiffs(ByVal pError As AcStError, _
                            ByVal pFix As AcStFix, _
                            ByRef pPropNames As Object, _
                            ByRef pErrorValues As Object, _
                            ByRef pFixValues As Object, _
                            ByRef pFixableStatuses As Object) _
                            Implements IAcStPlugin2.GetPropertyDiffs

    If IsNothing(pError) = False And IsNothing(pFix) = False Then

        ' Define the arrays that will hold the property values to compare
        Dim sPropNames(0) As String
        Dim sErrorValues(0) As String
        Dim sFixValues(0) As String
        Dim bFixableStatuses(0) As Boolean

        Dim sPropName As String = ""
        Dim vErrorVal As Object = Nothing
        Dim vFixVal As Object = Nothing
        Dim i As Integer, nPropCnt As Integer = 0

        ' Iterate the properties of the error object
        For i = 0 To pError.PropertyCount - 1
            ' Get a property name and value from the error
            pError.PropertyGetAt(i, sPropName, vErrorVal)
            m_sPropName = sPropName

            Try
                ' Retrieve the corresponding property value for the fix object
                pFix.PropertyValueGet(sPropName, vFixVal)

                ' Compare the value of the error and fix objects
                If (vErrorVal.CompareTo(vFixVal) <> 0) Then
                    ' Resize the arrays and add the new values
                    ReDim Preserve sPropNames(nPropCnt + 1)
                    ReDim Preserve sErrorValues(nPropCnt + 1)
                    ReDim Preserve sFixValues(nPropCnt + 1)
                    ReDim Preserve bFixableStatuses(nPropCnt + 1)

                    ' Store the property names and values in arrays
                    sPropNames(nPropCnt) = sPropName
                    sErrorValues(nPropCnt) = vErrorVal.ToString
                    sFixValues(nPropCnt) = vFixVal.ToString
                    bFixableStatuses(nPropCnt) = True

                    ' Increment the property counter
                    nPropCnt = nPropCnt + 1
                End If
            Catch
                ' Catch and handle the error as needed
            End Try
        Next

        ' Return the arrays
        pPropNames = sPropNames
        pErrorValues = sErrorValues
        pFixValues = sFixValues
        pFixableStatuses = bFixableStatuses

        ' Clear the local arrays
        Erase sPropNames
        Erase sErrorValues
        Erase sFixValues
        Erase bFixableStatuses

        ' Increment the number of fixes
        m_FixCnt = m_FixCnt + 1
    End If
End Sub

C#:

public void GetPropertyDiffs(AcStError pError, AcStFix pFix, ref object pPropNames, 
                             ref object pErrorValues, ref object pFixValues, ref object pFixableStatuses)
{
    if ((pError == null) == false & (pFix == null) == false)
    {
        // Define the arrays that will hold the property values to compare
        string[] sPropNames = new string[0];
        string[] sErrorValues = new string[0];
        string[] sFixValues = new string[0];
        bool[] bFixableStatuses = new bool[0];

        string sPropName = "";
        object vErrorVal = null;
        object vFixVal = null;
        int nPropCnt = 0;

        // Iterate the properties of the error object
        for (int i = 0; i <= pError.PropertyCount - 1; i++)
        {
            // Get a property name and value from the error
            pError.PropertyGetAt(i, ref sPropName, ref vErrorVal);
            m_sPropName = sPropName;

            try
            {
                // Retrieve the corresponding property value for the fix object
                pFix.PropertyValueGet(sPropName, ref vFixVal);

                // Compare the value of the error and fix objects
                if ((vErrorVal.Equals(vFixVal) == false))
                {
                    // Resize the arrays and add the new values
                    Array.Resize<string>(ref sPropNames, nPropCnt + 1);
                    Array.Resize<string>(ref sErrorValues, nPropCnt + 1);
                    Array.Resize<string>(ref sFixValues, nPropCnt + 1);
                    Array.Resize<bool>(ref bFixableStatuses, nPropCnt + 1);

                    // Store the property names and values in arrays
                    sPropNames[nPropCnt] = sPropName;
                    sErrorValues[nPropCnt] = vErrorVal.ToString();
                    sFixValues[nPropCnt] = vFixVal.ToString();
                    bFixableStatuses[nPropCnt] = true;

                    // Increment the property counter
                    nPropCnt = nPropCnt + 1;
                }
            }
            catch
            {
                // Catch and handle the error as needed
            }
        }

        // Return the arrays
        pPropNames = sPropNames;
        pErrorValues = sErrorValues;
        pFixValues = sFixValues;
        pFixableStatuses = bFixableStatuses;

        // Clear the local arrays
        sPropNames = null;
        sErrorValues = null;
        sFixValues = null;
        bFixableStatuses = null;

        // Increment the number of fixes
        m_FixCnt = m_FixCnt + 1;
    }
}