Attribute..::.Equals Method

This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.

[ This article is for Windows Phone 8 developers. If you’re developing for Windows 10, see the latest documentation. ]

Returns a value that indicates whether this instance is equal to a specified object.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

Public Overrides Function Equals ( _
    obj As Object _
) As Boolean
public override bool Equals(
    Object obj
)

Parameters

  • obj
    Type: System..::.Object
    An Object to compare with this instance or nullNothingnullptra null reference (Nothing in Visual Basic).

Return Value

Type: System..::.Boolean
true if obj equals the type and value of this instance; otherwise, false.

Examples

The following code example defines two custom parameter Attribute classes, then creates several objects of each class and shows the use of the Equals method to compare them.

' Example for the Attribute.Equals( Object ) method.
Imports System.Reflection

' Define a custom parameter attribute that takes a single message argument.
<AttributeUsage(AttributeTargets.Parameter)> _
Public Class ArgumentUsageAttribute
   Inherits Attribute

   ' This is the attribute constructor.
   Public Sub New(ByVal UsageMsg As String)
      Me.usageMsg = UsageMsg
   End Sub ' New

   ' usageMsg is storage for the attribute message.
   Protected usageMsg As String

   ' Override ToString() to append the message to what the base generates.
   Public Overrides Function ToString() As String
      Return MyBase.ToString() + ":" + usageMsg
   End Function ' ToString
End Class ' ArgumentUsageAttribute

' Define a custom parameter attribute that generates a GUID for each instance.
<AttributeUsage(AttributeTargets.Parameter)> _
Public Class ArgumentIDAttribute
   Inherits Attribute

   ' This is the attribute constructor, which generates the GUID.
   Public Sub New()
      Me.GUIDinstance = Guid.NewGuid()
   End Sub ' New

   ' instanceGUID is storage for the generated GUID.
   Protected GUIDinstance As Guid

   ' Override ToString() to append the GUID to what the base generates.
   Public Overrides Function ToString() As String
      Return MyBase.ToString() + "." + GUIDinstance.ToString()
   End Function ' ToString
End Class ' ArgumentIDAttribute

Public Class TestClass

   ' Assign an ArgumentID attribute to each parameter.
   ' Assign an ArgumentUsage attribute to each parameter.
   Public Sub TestMethod( _
       <ArgumentID(), ArgumentUsage("Must pass an array here.")> ByVal _
       strArray() As String, _
       <ArgumentID(), ArgumentUsage("Can pass param list or array here.")> ByVal _
       ParamArray strList() As String)
   End Sub ' TestMethod
End Class ' TestClass

Module Example

   ' Create Attribute objects and compare them.
   Sub CompareAttributes(ByVal outputBlock As System.Windows.Controls.TextBlock)

      ' Get the class type, and then get the MethodInfo object 
      ' for TestMethod to access its metadata.
      Dim clsType As Type = GetType(TestClass)
      Dim mInfo As MethodInfo = clsType.GetMethod("TestMethod")

      ' There will be two elements in pInfoArray, one for each parameter.
      Dim pInfoArray As ParameterInfo() = mInfo.GetParameters()
      If Not (pInfoArray Is Nothing) Then

         ' Create an instance of the argument usage attribute on strArray.
         Dim arrayUsageAttr1 As ArgumentUsageAttribute = _
             Attribute.GetCustomAttribute(pInfoArray(0), _
                 GetType(ArgumentUsageAttribute))

         ' Create another instance of the argument usage attribute 
         ' on strArray.
         Dim arrayUsageAttr2 As ArgumentUsageAttribute = _
             Attribute.GetCustomAttribute(pInfoArray(0), _
                 GetType(ArgumentUsageAttribute))

         ' Create an instance of the argument usage attribute on strList.
         Dim listUsageAttr As ArgumentUsageAttribute = _
             Attribute.GetCustomAttribute(pInfoArray(1), _
                 GetType(ArgumentUsageAttribute))

         ' Create an instance of the argument ID attribute on strArray.
         Dim arrayIDAttr1 As ArgumentIDAttribute = _
             Attribute.GetCustomAttribute(pInfoArray(0), _
                 GetType(ArgumentIDAttribute))

         ' Create another instance of the argument ID attribute on strArray.
         Dim arrayIDAttr2 As ArgumentIDAttribute = _
             Attribute.GetCustomAttribute(pInfoArray(0), _
                 GetType(ArgumentIDAttribute))

         ' Create an instance of the argument ID attribute on strList.
         Dim listIDAttr As ArgumentIDAttribute = _
             Attribute.GetCustomAttribute(pInfoArray(1), _
                 GetType(ArgumentIDAttribute))

         ' Compare various pairs of attributes for equality.
         outputBlock.Text &= vbCrLf & "Compare a usage attribute instance " & _
             "to another instance of the same attribute:" & vbCrLf
         outputBlock.Text &= String.Format("   ""{0}"" = " & vbCrLf & "   ""{1}"" ? {2}", _
             arrayUsageAttr1.ToString(), arrayUsageAttr2.ToString(), _
             arrayUsageAttr1.Equals(arrayUsageAttr2)) & vbCrLf

         outputBlock.Text &= String.Format(vbCrLf & _
             "Compare a usage attribute to another usage attribute:") & vbCrLf
         outputBlock.Text &= String.Format("   ""{0}"" = " & vbCrLf & "   ""{1}"" ? {2}", _
             arrayUsageAttr1.ToString(), listUsageAttr.ToString(), _
             arrayUsageAttr1.Equals(listUsageAttr)) & vbCrLf

         outputBlock.Text &= String.Format(vbCrLf & "Compare an ID attribute instance " & _
             "to another instance of the same attribute:") & vbCrLf
         outputBlock.Text &= String.Format("   ""{0}"" = " & vbCrLf & "   ""{1}"" ? {2}", _
             arrayIDAttr1.ToString(), arrayIDAttr2.ToString(), _
             arrayIDAttr1.Equals(arrayIDAttr2)) & vbCrLf

         outputBlock.Text &= String.Format(vbCrLf & _
             "Compare an ID attribute to another ID attribute:") & vbCrLf
         outputBlock.Text &= String.Format("   ""{0}"" = " & vbCrLf & "   ""{1}"" ? {2}", _
             arrayIDAttr1.ToString(), listIDAttr.ToString(), _
             arrayIDAttr1.Equals(listIDAttr)) & vbCrLf
      Else
         outputBlock.Text &= String.Format("The parameters information could " & _
             "not be retrieved for method {0}.", mInfo.Name) & vbCrLf
      End If
   End Sub 

   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      outputBlock.Text &= "This example of Attribute.Equals( Object ) " & _
          "generates the following output." & vbCrLf

      CompareAttributes(outputBlock)

   End Sub 
End Module 
' This example of Attribute.Equals( Object ) generates the following output.
' 
' Compare a usage attribute instance to another instance of the same attribute:
'    "NDP_UE_VB.ArgumentUsageAttribute:Must pass an array here." =
'    "NDP_UE_VB.ArgumentUsageAttribute:Must pass an array here." ? True
' 
' Compare a usage attribute to another usage attribute:
'    "NDP_UE_VB.ArgumentUsageAttribute:Must pass an array here." =
'    "NDP_UE_VB.ArgumentUsageAttribute:Can pass param list or array here." ? False
' 
' Compare an ID attribute instance to another instance of the same attribute:
'    "NDP_UE_VB.ArgumentIDAttribute.aa2c2346-ca87-40d6-afb7-5e3bc1637351" =
'    "NDP_UE_VB.ArgumentIDAttribute.4192c26c-9a7b-4a74-97fc-6c3dfbc2cdfe" ? False
' 
' Compare an ID attribute to another ID attribute:
'    "NDP_UE_VB.ArgumentIDAttribute.aa2c2346-ca87-40d6-afb7-5e3bc1637351" =
'    "NDP_UE_VB.ArgumentIDAttribute.237a7337-15f1-469b-a5ce-7503def917b2" ? False
// Example for the Attribute.Equals( object ) method.
using System;
using System.Reflection;

// Define a custom parameter attribute that takes a single message argument.
[AttributeUsage(AttributeTargets.Parameter)]
public class ArgumentUsageAttribute : Attribute
{
    // This is the attribute constructor.
    public ArgumentUsageAttribute(string UsageMsg)
    {
        this.usageMsg = UsageMsg;
    }

    // usageMsg is storage for the attribute message.
    protected string usageMsg;

    // Override ToString() to append the message to what the base generates.
    public override string ToString()
    {
        return base.ToString() + ":" + usageMsg;
    }
}

// Define a custom parameter attribute that generates
// a GUID for each instance.
[AttributeUsage(AttributeTargets.Parameter)]
public class ArgumentIDAttribute : Attribute
{
    // This is the attribute constructor, which generates the GUID.
    public ArgumentIDAttribute()
    {
        this.instanceGUID = Guid.NewGuid();
    }

    // instanceGUID is storage for the generated GUID.
    protected Guid instanceGUID;

    // Override ToString() to append the GUID to what the base generates.
    public override string ToString()
    {
        return base.ToString() + "." + instanceGUID.ToString();
    }
}

public class TestClass
{
    // Assign an ArgumentID attribute to each parameter.
    // Assign an ArgumentUsage attribute to each parameter.
    public void TestMethod(
        [ArgumentID]
        [ArgumentUsage("Must pass an array here.")]
        String[] strArray,
        [ArgumentID]
        [ArgumentUsage("Can pass param list or array here.")]
        params String[] strList)
    { }
}

class Example
{
    // Create Attribute objects and compare them.
    public static void Demo(System.Windows.Controls.TextBlock outputBlock)
    {
        outputBlock.Text += "This example of Attribute.Equals( object ) " +
            "generates the following output." + "\n";

        // Get the class type, and then get the MethodInfo object
        // for TestMethod to access its metadata.
        Type clsType = typeof(TestClass);
        MethodInfo mInfo = clsType.GetMethod("TestMethod");

        // There will be two elements in pInfoArray, one for each parameter.
        ParameterInfo[] pInfoArray = mInfo.GetParameters();
        if (pInfoArray != null)
        {
            // Create an instance of the argument usage attribute on strArray.
            ArgumentUsageAttribute arrayUsageAttr1 = (ArgumentUsageAttribute)
                Attribute.GetCustomAttribute(pInfoArray[0],
                    typeof(ArgumentUsageAttribute));

            // Create another instance of the argument usage attribute
            // on strArray.
            ArgumentUsageAttribute arrayUsageAttr2 = (ArgumentUsageAttribute)
                Attribute.GetCustomAttribute(pInfoArray[0],
                    typeof(ArgumentUsageAttribute));

            // Create an instance of the argument usage attribute on strList.
            ArgumentUsageAttribute listUsageAttr = (ArgumentUsageAttribute)
                Attribute.GetCustomAttribute(pInfoArray[1],
                    typeof(ArgumentUsageAttribute));

            // Create an instance of the argument ID attribute on strArray.
            ArgumentIDAttribute arrayIDAttr1 = (ArgumentIDAttribute)
                Attribute.GetCustomAttribute(pInfoArray[0],
                    typeof(ArgumentIDAttribute));

            // Create another instance of the argument ID attribute on strArray.
            ArgumentIDAttribute arrayIDAttr2 = (ArgumentIDAttribute)
                Attribute.GetCustomAttribute(pInfoArray[0],
                    typeof(ArgumentIDAttribute));

            // Create an instance of the argument ID attribute on strList.
            ArgumentIDAttribute listIDAttr = (ArgumentIDAttribute)
                Attribute.GetCustomAttribute(pInfoArray[1],
                    typeof(ArgumentIDAttribute));

            // Compare various pairs of attributes for equality.
            outputBlock.Text += "\nCompare a usage attribute instance to " +
                "another instance of the same attribute:" + "\n";
            outputBlock.Text += String.Format("   \"{0}\" == \n   \"{1}\" ? {2}",
                arrayUsageAttr1.ToString(), arrayUsageAttr2.ToString(),
                arrayUsageAttr1.Equals(arrayUsageAttr2)) + "\n";

            outputBlock.Text += String.Format("\nCompare a usage attribute to " +
                "another usage attribute:") + "\n";
            outputBlock.Text += String.Format("   \"{0}\" == \n   \"{1}\" ? {2}",
                arrayUsageAttr1.ToString(), listUsageAttr.ToString(),
                arrayUsageAttr1.Equals(listUsageAttr)) + "\n";

            outputBlock.Text += String.Format("\nCompare an ID attribute instance to " +
                "another instance of the same attribute:") + "\n";
            outputBlock.Text += String.Format("   \"{0}\" == \n   \"{1}\" ? {2}",
                arrayIDAttr1.ToString(), arrayIDAttr2.ToString(),
                arrayIDAttr1.Equals(arrayIDAttr2)) + "\n";

            outputBlock.Text += "\nCompare an ID attribute to another ID attribute:" + "\n";
            outputBlock.Text += String.Format("   \"{0}\" == \n   \"{1}\" ? {2}",
                arrayIDAttr1.ToString(), listIDAttr.ToString(),
                arrayIDAttr1.Equals(listIDAttr)) + "\n";
        }
        else
            outputBlock.Text += String.Format("The parameters information could " +
                "not be retrieved for method {0}.", mInfo.Name) + "\n";
    }
}

/*
This example of Attribute.Equals( object ) generates the following output.

Compare a usage attribute instance to another instance of the same attribute:
   "ArgumentUsageAttribute:Must pass an array here." ==
   "ArgumentUsageAttribute:Must pass an array here." ? True

Compare a usage attribute to another usage attribute:
   "ArgumentUsageAttribute:Must pass an array here." ==
   "ArgumentUsageAttribute:Can pass param list or array here." ? False

Compare an ID attribute instance to another instance of the same attribute:
   "ArgumentIDAttribute.06abf046-0c38-47ac-b215-09e1daa7f37d" ==
   "ArgumentIDAttribute.cea23c39-f14b-4e95-bee2-9f661d8cd64b" ? False

Compare an ID attribute to another ID attribute:
   "ArgumentIDAttribute.06abf046-0c38-47ac-b215-09e1daa7f37d" ==
   "ArgumentIDAttribute.bdeb6f3e-18aa-410b-bef6-9788956b008c" ? False
*/

Version Information

Windows Phone OS

Supported in: 8.1, 8.0, 7.1, 7.0

Platforms

Windows Phone

See Also

Reference

Attribute Class

System Namespace