다음을 통해 공유


Attribute.Match(Object) 메서드

정의

파생 클래스에서 재정의된 경우 이 인스턴스가 지정된 개체와 같은지 여부를 나타내는 값을 반환합니다.

public:
 virtual bool Match(System::Object ^ obj);
public virtual bool Match (object? obj);
public virtual bool Match (object obj);
abstract member Match : obj -> bool
override this.Match : obj -> bool
Public Overridable Function Match (obj As Object) As Boolean

매개 변수

obj
Object

Object의 이 인스턴스와 비교할 Attribute입니다.

반환

Boolean

이 인스턴스가 obj와 같으면 true이고, 그렇지 않으면 false입니다.

설명

이 메서드는 다른 메서드 Attribute 가 다른 메서드와 같은지 여부를 결정합니다. 기본 구현은 두 특성이 동일한 Equals형식이고 필드 값이 같은지 여부를 결정하는 것과 동일합니다.

일반적으로 이 Equals 메서드는 참조 또는 값 같음에 대한 표준 테스트를 수행하기 위한 것입니다. 두 특성 인스턴스가 Match 형식이 동일하고 값이 동일한 조건 이외의 일부 조건을 기반으로 하는 같음의 사용자 지정 비교를 수행하려는 경우 메서드를 재정의할 수 있습니다. 예를 들어 다음 시나리오에서 Match 특성을 비교하도록 메서드를 재정의할 수 있습니다.

  • 특성에는 비트 필드가 포함되며, 특정 비트가 설정된 경우 두 특성 인스턴스가 같은 것으로 간주됩니다. 예를 들어 NumericDisplay 특성에는 클라이언트가 지원하는 숫자 형식(예: 이진, 8진수, 10진수 및 16진수)을 나타내는 비트 필드가 포함될 수 있습니다. 재정의된 Match 메서드는 동일한 숫자 형식을 지원하는 경우 두 인스턴스를 동일하게 간주할 수 있습니다.

  • 특성에는 동일한 종류의 정보를 포함하는 여러 필드가 포함되거나 값이 순서에 관계없이 있을 수 있는 배열이 포함됩니다. 예를 들어 특성에는 작성자 Author 이름에 대한 여러 필드가 포함될 수 있습니다. 재정의된 Match 메서드는 각 필드가 해당 필드와 같은지 여부에 관계없이 동일한 작성자가 있는 경우 두 인스턴스를 동일하게 간주할 수 있습니다.

다음 예제에서는 특성 값에 대한 사용자 지정 비교 메서드를 만드는 데 사용하는 Match 방법을 보여 줍니다. 내부적으로 List<String> 작성자 AuthorsAttribute 이름을 저장하는 항목을 정의하는 경우 이름은 목록에서 임의의 순서로 발생할 수 있으므로 목록에서의 위치에 관계없이 작성자 이름을 비교하는 메서드를 재정 Match 의합니다. Equals 값 같음 테스트를 수행하는 메서드는 메서드와 Match 다른 결과를 반환합니다.

using System;
using System.Collections.Generic;
using System.Reflection;

// A custom attribute to allow multiple authors per method.
[AttributeUsage(AttributeTargets.Method)]
public class AuthorsAttribute : Attribute
{
   protected List<string> _authors;

    public AuthorsAttribute(params string[] names)
   {
      _authors = new List<string>(names);
    }

   public List<string> Authors
   {
       get { return _authors; }
   }

    // Determine if the object is a match to this one.
    public override bool Match(object obj)
   {
      // Return false if obj is null or not an AuthorsAttribute.
      AuthorsAttribute authors2 = obj as AuthorsAttribute;
      if (authors2 == null) return false;

        // Return true if obj and this instance are the same object reference.
      if (Object.ReferenceEquals(this, authors2))
         return true;

      // Return false if obj and this instance have different numbers of authors
      if (_authors.Count != authors2._authors.Count)
         return false;

      bool matches = false;
      foreach (var author in _authors)
      {
         for (int ctr = 0; ctr < authors2._authors.Count; ctr++)
         {
            if (author == authors2._authors[ctr])
            {
               matches = true;
               break;
            }
            if (ctr == authors2._authors.Count)
            {
               matches = false;
            }
         }
      }
      return matches;
   }

   public override string ToString()
   {
      string retval = "";
      for (int ctr = 0; ctr < _authors.Count; ctr++)
      {
         retval += $"{_authors[ctr]}{(ctr < _authors.Count - 1 ? ", " : String.Empty)}";
      }
      if (retval.Trim().Length == 0)
      {
         return "<unknown>";
      }
      return retval;
   }
}

// Add some authors to methods of a class.
public class TestClass {
    [Authors("Leo Tolstoy", "John Milton")]
    public void Method1()
    {}

    [Authors("Anonymous")]
    public void Method2()
    {}

    [Authors("Leo Tolstoy", "John Milton", "Nathaniel Hawthorne")]
    public void Method3()
    {}

    [Authors("John Milton", "Leo Tolstoy")]
    public void Method4()
    {}
}

class Example
{
    static void Main()
   {
        // Get the type for TestClass to access its metadata.
        Type clsType = typeof(TestClass);

        // Iterate through each method of the class.
      AuthorsAttribute authors = null;
        foreach(var method in clsType.GetMethods())
      {
            // Check each method for the Authors attribute.
            AuthorsAttribute authAttr = (AuthorsAttribute)  Attribute.GetCustomAttribute(method,
                                         typeof(AuthorsAttribute));
            if (authAttr != null)
         {
            // Display the authors.
                Console.WriteLine($"{clsType.Name}.{method.Name} was authored by {authAttr}.");

            // Select Method1's authors as the basis for comparison.
            if (method.Name == "Method1")
            {
                   authors = authAttr;
               Console.WriteLine();
               continue;
            }

            // Compare first authors with the authors of this method.
            if (authors.Match(authAttr))
            {
                    Console.WriteLine("TestClass.Method1 was also authored by the same team.");
            }

            // Perform an equality comparison of the two attributes.
            Console.WriteLine($"{authors} {(authors.Equals(authAttr) ? "=" : "<>")} {authAttr}");
            Console.WriteLine();
            }
        }
    }
}
// The example displays the following output:
//       TestClass.Method1 was authored by Leo Tolstoy, John Milton.
//
//       TestClass.Method2 was authored by Anonymous.
//       Leo Tolstoy, John Milton <> Anonymous
//
//       TestClass.Method3 was authored by Leo Tolstoy, John Milton, Nathaniel Hawthorne.
//       Leo Tolstoy, John Milton <> Leo Tolstoy, John Milton, Nathaniel Hawthorne
//
//       TestClass.Method4 was authored by John Milton, Leo Tolstoy.
//       TestClass.Method1 was also authored by the same team.
//       Leo Tolstoy, John Milton <> John Milton, Leo Tolstoy
open System

// A custom attribute to allow multiple authors per method.
[<AttributeUsage(AttributeTargets.Method); AllowNullLiteral>]
type AuthorsAttribute([<ParamArray>] names: string []) =
    inherit Attribute()

    member val Authors = ResizeArray names

    // Determine if the object is a match to this one.
    override this.Match(obj) =
        match obj with 
        | :? AuthorsAttribute as authors2 ->
            // Return true if obj and this instance are the same object reference.
            if Object.ReferenceEquals(this, authors2) then true
            // Return false if obj and this instance have different numbers of authors
            elif this.Authors.Count <> authors2.Authors.Count then false 
            else
                let authors1 = this.Authors |> set
                let authors2 = this.Authors |> set
                authors1 = authors2
        | _ ->
            // Return false if obj is null or not an AuthorsAttribute.
            false

    override this.ToString() =
        let retval = String.Join(", ", this.Authors)
        if retval.Trim().Length = 0 then 
            "<unknown>" 
        else 
            retval

// Add some authors to methods of a class.
type TestClass() =
    [<Authors("Leo Tolstoy", "John Milton")>]
    member _.Method1() = ()

    [<Authors "Anonymous">]
    member _.Method2() = ()

    [<Authors("Leo Tolstoy", "John Milton", "Nathaniel Hawthorne")>]
    member _.Method3() = ()

    [<Authors("John Milton", "Leo Tolstoy")>]
    member _.Method4() = ()

// Get the type for TestClass to access its metadata.
let clsType = typeof<TestClass>

// Iterate through each method of the class.

let mutable authors = null
for method in clsType.GetMethods() do
    // Check each method for the Authors attribute.
    let authAttr = 
        Attribute.GetCustomAttribute(method, typeof<AuthorsAttribute>)
        :?> AuthorsAttribute

    if authAttr <> null then
        // Display the authors.
        printfn $"{clsType.Name}.{method.Name} was authored by {authAttr}."

        // Select Method1's authors as the basis for comparison.
        if method.Name = "Method1" then
            authors <- authAttr
            printfn ""

        else
            // Compare first authors with the authors of this method.
            if authors.Match authAttr then
                printfn "TestClass.Method1 was also authored by the same team."

            // Perform an equality comparison of the two attributes.
            printfn $"""{authors} {if authors.Equals(authAttr) then "=" else "<>"} {authAttr}"""
            printfn ""

// The example displays the following output:
//       TestClass.Method1 was authored by Leo Tolstoy, John Milton.
//
//       TestClass.Method2 was authored by Anonymous.
//       Leo Tolstoy, John Milton <> Anonymous
//
//       TestClass.Method3 was authored by Leo Tolstoy, John Milton, Nathaniel Hawthorne.
//       Leo Tolstoy, John Milton <> Leo Tolstoy, John Milton, Nathaniel Hawthorne
//
//       TestClass.Method4 was authored by John Milton, Leo Tolstoy.
//       TestClass.Method1 was also authored by the same team.
//       Leo Tolstoy, John Milton <> John Milton, Leo Tolstoy
Imports System.Collections.Generic
Imports System.Reflection
                                                               
' A custom attribute to allow multiple authors per method.
<AttributeUsage(AttributeTargets.Method)> _
Public Class AuthorsAttribute : Inherits Attribute 
   Protected _authors As List(Of String)

    Public Sub New(paramarray names As String()) 
      _authors = New List(Of string)(names)
    End Sub

   Public ReadOnly Property Authors As List(Of String) 
       Get 
         Return _authors
      End Get   
   End Property

    ' Determine if the object is a match to this one.
    Public Overrides Function Match(obj As Object) As Boolean 
      ' Return false if obj is null or not an AuthorsAttribute.
      Dim authors2 As AuthorsAttribute = DirectCast(obj, AuthorsAttribute)
      If authors2 Is Nothing Then Return False
      
        ' Return true if obj and this instance are the same object reference.
      If Object.ReferenceEquals(Me, authors2) Then Return True

      ' Return false if obj and this instance have different numbers of authors
      If _authors.Count <> authors2._authors.Count Then Return False
         
      Dim matches As Boolean = False
      For Each author in _authors 
         For ctr As Integer = 0 To authors2._authors.Count - 1
            If author = authors2._authors(ctr) Then
               matches = True
               Exit For
            End If
            If ctr = authors2._authors.Count Then matches = False
         Next
      Next
      Return matches
   End Function

   Public Overrides Function ToString() As String
      Dim retval As String = ""
      For ctr As Integer = 0 To _authors.Count -1
         retval += $"{_authors(ctr)}{If(ctr < _authors.Count - 1, ", ", String.Empty)}"
      Next
      If retval.Trim().Length = 0 Then Return "<unknown>"

      Return retval
   End Function
End Class

' Add some authors to methods of a class.
Public Class TestClass 
    <Authors("Leo Tolstoy", "John Milton")>
    Public sub Method1()
    End sub

    <Authors("Anonymous")>
    Public Sub Method2()
    End Sub

    <Authors("Leo Tolstoy", "John Milton", "Nathaniel Hawthorne")>
    Public Sub Method3()
    End Sub

    <Authors("John Milton", "Leo Tolstoy")>
    Public Sub Method4()
    End Sub
End Class

Public Module Example 
    Public Sub Main() 
        ' Get the type for TestClass to access its metadata.
        Dim clsType As Type = GetType(TestClass)

        ' Iterate through each method of the class.
      Dim authors As AuthorsAttribute = Nothing
        For Each method In clsType.GetMethods() 
            ' Check each method for the Authors attribute.
            Dim authAttr As AuthorsAttribute = DirectCast(Attribute.GetCustomAttribute(method, 
                                         GetType(AuthorsAttribute)), AuthorsAttribute)
            If authAttr IsNot Nothing Then 
            ' Display the authors.
                Console.WriteLine($"{clsType.Name}.{method.Name} was authored by {authAttr}.")

            ' Select Method1's authors as the basis for comparison.
            If method.Name = "Method1" Then
                   authors = authAttr
               Console.WriteLine()
               Continue For
            End If
         
            ' Compare first authors with the authors of this method.
            If authors.Match(authAttr) Then
                    Console.WriteLine("TestClass.Method1 was also authored by the same team.")
            End If

            ' Perform an equality comparison of the two attributes.
            Console.WriteLine($"{authors} {If(authors.Equals(authAttr), "=", "<>")} {authAttr}")
            Console.WriteLine()
            End If
      Next
   End Sub
End Module
' The example displays the following output:
//       TestClass.Method1 was authored by Leo Tolstoy, John Milton.
//       
//       TestClass.Method2 was authored by Anonymous.
//       Leo Tolstoy, John Milton <> Anonymous
//       
//       TestClass.Method3 was authored by Leo Tolstoy, John Milton, Nathaniel Hawthorne.
//       Leo Tolstoy, John Milton <> Leo Tolstoy, John Milton, Nathaniel Hawthorne
//       
//       TestClass.Method4 was authored by John Milton, Leo Tolstoy.
//       TestClass.Method1 was also authored by the same team.
//       Leo Tolstoy, John Milton <> John Milton, Leo Tolstoy

적용 대상