FlagsAttribute 클래스

정의

열거형을 비트 필드 즉, 플래그 집합으로 처리할 수 있음을 나타냅니다.Indicates that an enumeration can be treated as a bit field; that is, a set of flags.

public ref class FlagsAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)]
public class FlagsAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)]
[System.Serializable]
public class FlagsAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class FlagsAttribute : Attribute
[<System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)>]
type FlagsAttribute = class
    inherit Attribute
[<System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)>]
[<System.Serializable>]
type FlagsAttribute = class
    inherit Attribute
[<System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type FlagsAttribute = class
    inherit Attribute
Public Class FlagsAttribute
Inherits Attribute
상속
FlagsAttribute
특성

예제

다음 예제에서는 특성을 사용 하는 방법을 보여 FlagsAttribute 주고 ToString 선언에서를 사용 하는 방법에 미치는 영향을 보여 줍니다 FlagsAttribute Enum .The following example illustrates the use of the FlagsAttribute attribute and shows the effect on the ToString method of using FlagsAttribute on an Enum declaration.

using namespace System;

// Define an Enum without FlagsAttribute.
public enum class SingleHue : short
{
   None = 0,
   Black = 1,
   Red = 2,
   Green = 4,
   Blue = 8
};

// Define an Enum with FlagsAttribute.
[Flags]
enum class MultiHue : short
{
   None = 0,
   Black = 1,
   Red = 2,
   Green = 4,
   Blue = 8
};

int main()
{
   // Display all possible combinations of values.
   Console::WriteLine(
        "All possible combinations of values without FlagsAttribute:");
   for (int val = 0; val <= 16; val++)
      Console::WriteLine("{0,3} - {1:G}", val, (SingleHue)val);
      
   Console::WriteLine(
        "\nAll possible combinations of values with FlagsAttribute:");
   
   // Display all combinations of values, and invalid values.
   for (int val = 0; val <= 16; val++ )
      Console::WriteLine("{0,3} - {1:G}", val, (MultiHue)val);
}
// The example displays the following output:
//       All possible combinations of values without FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - 3
//         4 - Green
//         5 - 5
//         6 - 6
//         7 - 7
//         8 - Blue
//         9 - 9
//        10 - 10
//        11 - 11
//        12 - 12
//        13 - 13
//        14 - 14
//        15 - 15
//        16 - 16
//       
//       All possible combinations of values with FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - Black, Red
//         4 - Green
//         5 - Black, Green
//         6 - Red, Green
//         7 - Black, Red, Green
//         8 - Blue
//         9 - Black, Blue
//        10 - Red, Blue
//        11 - Black, Red, Blue
//        12 - Green, Blue
//        13 - Black, Green, Blue
//        14 - Red, Green, Blue
//        15 - Black, Red, Green, Blue
//        16 - 16
using System;

class Example
{
   // Define an Enum without FlagsAttribute.
   enum SingleHue : short
   {
      None = 0,
      Black = 1,
      Red = 2,
      Green = 4,
      Blue = 8
   };

   // Define an Enum with FlagsAttribute.
   [Flags]
   enum MultiHue : short
   {
      None = 0,
      Black = 1,
      Red = 2,
      Green = 4,
      Blue = 8
   };

   static void Main( )
   {
      // Display all possible combinations of values.
      Console.WriteLine(
           "All possible combinations of values without FlagsAttribute:");
      for(int val = 0; val <= 16; val++ )
         Console.WriteLine( "{0,3} - {1:G}", val, (SingleHue)val);

      // Display all combinations of values, and invalid values.
      Console.WriteLine(
           "\nAll possible combinations of values with FlagsAttribute:");
      for( int val = 0; val <= 16; val++ )
         Console.WriteLine( "{0,3} - {1:G}", val, (MultiHue)val);
   }
}
// The example displays the following output:
//       All possible combinations of values without FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - 3
//         4 - Green
//         5 - 5
//         6 - 6
//         7 - 7
//         8 - Blue
//         9 - 9
//        10 - 10
//        11 - 11
//        12 - 12
//        13 - 13
//        14 - 14
//        15 - 15
//        16 - 16
//
//       All possible combinations of values with FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - Black, Red
//         4 - Green
//         5 - Black, Green
//         6 - Red, Green
//         7 - Black, Red, Green
//         8 - Blue
//         9 - Black, Blue
//        10 - Red, Blue
//        11 - Black, Red, Blue
//        12 - Green, Blue
//        13 - Black, Green, Blue
//        14 - Red, Green, Blue
//        15 - Black, Red, Green, Blue
//        16 - 16
Module Example
   ' Define an Enum without FlagsAttribute.
   Enum SingleHue As Short
      None = 0
      Black = 1
      Red = 2
      Green = 4
      Blue = 8
   End Enum

   ' Define an Enum with FlagsAttribute.
   <Flags()> 
   Enum MultiHue As Short
      None = 0
      Black = 1
      Red = 2
      Green = 4
      Blue = 8
   End Enum

   Sub Main()
      ' Display all possible combinations of values.
      Console.WriteLine(
           "All possible combinations of values without FlagsAttribute:")
      For val As Integer = 0 To 16
         Console.WriteLine("{0,3} - {1:G}", val, CType(val, SingleHue))
     Next 
     Console.WriteLine()
     
     ' Display all combinations of values, and invalid values.
     Console.WriteLine( 
          "All possible combinations of values with FlagsAttribute:")
     For val As Integer = 0 To 16
        Console.WriteLine( "{0,3} - {1:G}", val, CType(val, MultiHue))
     Next 
   End Sub 
End Module 
' The example displays the following output:
'       All possible combinations of values without FlagsAttribute:
'         0 - None
'         1 - Black
'         2 - Red
'         3 - 3
'         4 - Green
'         5 - 5
'         6 - 6
'         7 - 7
'         8 - Blue
'         9 - 9
'        10 - 10
'        11 - 11
'        12 - 12
'        13 - 13
'        14 - 14
'        15 - 15
'        16 - 16
'       
'       All possible combinations of values with FlagsAttribute:
'         0 - None
'         1 - Black
'         2 - Red
'         3 - Black, Red
'         4 - Green
'         5 - Black, Green
'         6 - Red, Green
'         7 - Black, Red, Green
'         8 - Blue
'         9 - Black, Blue
'        10 - Red, Blue
'        11 - Black, Red, Blue
'        12 - Green, Blue
'        13 - Black, Green, Blue
'        14 - Red, Green, Blue
'        15 - Black, Red, Green, Blue
'        16 - 16

앞의 예제에서는 두 가지 색 관련 열거형 인 및를 정의 합니다 SingleHue MultiHue .The preceding example defines two color-related enumerations, SingleHue and MultiHue. 후자에는 특성이 있지만 이전에는 FlagsAttribute 그렇지 않습니다.The latter has the FlagsAttribute attribute; the former does not. 이 예제에서는 열거형 형식의 내부 값을 나타내지 않는 정수를 포함 하 여 정수 범위가 열거형 형식 및 해당 문자열 표현으로 캐스팅 되는 동작의 차이점을 보여 줍니다.The example shows the difference in behavior when a range of integers, including integers that do not represent underlying values of the enumeration type, are cast to the enumeration type and their string representations displayed. 예를 들어 3 SingleHue 은 멤버의 기본 값이 아니라 3을 값으로 나타낼 수 있지만 특성을 사용 하면 값이 3 임을 나타낼 수 SingleHue FlagsAttribute MultiHue Black, Red 있습니다.For example, note that 3 cannot be represented as a SingleHue value because 3 is not the underlying value of any SingleHue member, whereas the FlagsAttribute attribute makes it possible to represent 3 as a MultiHue value of Black, Red.

다음 예제에서는 특성을 사용 하 여 다른 열거형을 정의 FlagsAttribute 하 고 비트 논리 및 같음 연산자를 사용 하 여 열거형 값에 하나 이상의 비트 필드가 설정 되어 있는지 여부를 확인 하는 방법을 보여 줍니다.The following example defines another enumeration with the FlagsAttribute attribute and shows how to use bitwise logical and equality operators to determine whether one or more bit fields are set in an enumeration value. 메서드를 사용 하 여 Enum.HasFlag 이 작업을 수행할 수도 있지만이 예제에는 표시 되지 않습니다.You can also use the Enum.HasFlag method to do that, but that is not shown in this example.

using namespace System;

[Flags]
enum class PhoneService
{
   None = 0,
   LandLine = 1,
   Cell = 2,
   Fax = 4,
   Internet = 8,
   Other = 16
};

void main()
{
   // Define three variables representing the types of phone service
   // in three households.
   PhoneService household1 = PhoneService::LandLine | PhoneService::Cell |
                             PhoneService::Internet;
   PhoneService household2 = PhoneService::None;
   PhoneService household3 = PhoneService::Cell | PhoneService::Internet;

   // Store the variables in an array for ease of access.
   array<PhoneService>^ households = { household1, household2, household3 };

   // Which households have no service?
   for (int ctr = 0; ctr < households->Length; ctr++)
      Console::WriteLine("Household {0} has phone service: {1}",
                         ctr + 1,
                         households[ctr] == PhoneService::None ?
                             "No" : "Yes");
   Console::WriteLine();

   // Which households have cell phone service?
   for (int ctr = 0; ctr < households->Length; ctr++)
      Console::WriteLine("Household {0} has cell phone service: {1}",
                         ctr + 1,
                         (households[ctr] & PhoneService::Cell) == PhoneService::Cell ?
                            "Yes" : "No");
   Console::WriteLine();

   // Which households have cell phones and land lines?
   PhoneService cellAndLand = PhoneService::Cell | PhoneService::LandLine;
   for (int ctr = 0; ctr < households->Length; ctr++)
      Console::WriteLine("Household {0} has cell and land line service: {1}",
                         ctr + 1,
                         (households[ctr] & cellAndLand) == cellAndLand ?
                            "Yes" : "No");
   Console::WriteLine();

   // List all types of service of each household?//
   for (int ctr = 0; ctr < households->Length; ctr++)
      Console::WriteLine("Household {0} has: {1:G}",
                         ctr + 1, households[ctr]);
   Console::WriteLine();
}
// The example displays the following output:
//    Household 1 has phone service: Yes
//    Household 2 has phone service: No
//    Household 3 has phone service: Yes
//
//    Household 1 has cell phone service: Yes
//    Household 2 has cell phone service: No
//    Household 3 has cell phone service: Yes
//
//    Household 1 has cell and land line service: Yes
//    Household 2 has cell and land line service: No
//    Household 3 has cell and land line service: No
//
//    Household 1 has: LandLine, Cell, Internet
//    Household 2 has: None
//    Household 3 has: Cell, Internet
using System;

[Flags]
public enum PhoneService
{
   None = 0,
   LandLine = 1,
   Cell = 2,
   Fax = 4,
   Internet = 8,
   Other = 16
}

public class Example
{
   public static void Main()
   {
      // Define three variables representing the types of phone service
      // in three households.
      var household1 = PhoneService.LandLine | PhoneService.Cell |
                       PhoneService.Internet;
      var household2 = PhoneService.None;
      var household3 = PhoneService.Cell | PhoneService.Internet;

      // Store the variables in an array for ease of access.
      PhoneService[] households = { household1, household2, household3 };

      // Which households have no service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           households[ctr] == PhoneService.None ?
                               "No" : "Yes");
      Console.WriteLine();

      // Which households have cell phone service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           (households[ctr] & PhoneService.Cell) == PhoneService.Cell ?
                              "Yes" : "No");
      Console.WriteLine();

      // Which households have cell phones and land lines?
      var cellAndLand = PhoneService.Cell | PhoneService.LandLine;
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           (households[ctr] & cellAndLand) == cellAndLand ?
                              "Yes" : "No");
      Console.WriteLine();

      // List all types of service of each household?//
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households[ctr]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Household 1 has phone service: Yes
//    Household 2 has phone service: No
//    Household 3 has phone service: Yes
//
//    Household 1 has cell phone service: Yes
//    Household 2 has cell phone service: No
//    Household 3 has cell phone service: Yes
//
//    Household 1 has cell and land line service: Yes
//    Household 2 has cell and land line service: No
//    Household 3 has cell and land line service: No
//
//    Household 1 has: LandLine, Cell, Internet
//    Household 2 has: None
//    Household 3 has: Cell, Internet
<Flags()>
Public Enum PhoneService As Integer
   None = 0
   LandLine = 1
   Cell = 2
   Fax = 4
   Internet = 8
   Other = 16
End Enum

Module Example
   Public Sub Main()
      ' Define three variables representing the types of phone service
      ' in three households.
      Dim household1 As PhoneService = PhoneService.LandLine Or
                                       PhoneService.Cell Or
                                       PhoneService.Internet
      Dim household2 As PhoneService = PhoneService.None
      Dim household3 As PhoneService = PhoneService.Cell Or
                                       PhoneService.Internet

      ' Store the variables in an array for ease of access.
      Dim households() As PhoneService = { household1, household2,
                                           household3 }

      ' Which households have no service?
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           If(households(ctr) = PhoneService.None,
                              "No", "Yes"))
      Next
      Console.WriteLine()
      
      ' Which households have cell phone service?
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           If((households(ctr) And PhoneService.Cell) = PhoneService.Cell,
                              "Yes", "No"))
      Next
      Console.WriteLine()
      
      ' Which households have cell phones and land lines?
      Dim cellAndLand As PhoneService = PhoneService.Cell Or PhoneService.LandLine
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           If((households(ctr) And cellAndLand) = cellAndLand,
                              "Yes", "No"))
      Next
      Console.WriteLine()
      
      ' List all types of service of each household?'
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households(ctr))
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Household 1 has phone service: Yes
'    Household 2 has phone service: No
'    Household 3 has phone service: Yes
'
'    Household 1 has cell phone service: Yes
'    Household 2 has cell phone service: No
'    Household 3 has cell phone service: Yes
'
'    Household 1 has cell and land line service: Yes
'    Household 2 has cell and land line service: No
'    Household 3 has cell and land line service: No
'
'    Household 1 has: LandLine, Cell, Internet
'    Household 2 has: None
'    Household 3 has: Cell, Internet

설명

비트 필드는 일반적으로 조합에서 발생할 수 있는 요소 목록에 사용 되는 반면, 열거형 상수는 일반적으로 함께 사용할 수 없는 요소의 목록에 사용 됩니다.Bit fields are generally used for lists of elements that might occur in combination, whereas enumeration constants are generally used for lists of mutually exclusive elements. 따라서 비트 필드는 명명 되지 않은 값을 생성 하기 위해 비트 OR 작업과 결합 되도록 설계 되었지만 열거 된 상수는 그렇지 않습니다.Therefore, bit fields are designed to be combined with a bitwise OR operation to generate unnamed values, whereas enumerated constants are not. 언어는 열거 상수와 비교할 때 비트 필드를 사용 하는 데 따라 다릅니다.Languages vary in their use of bit fields compared to enumeration constants.

FlagsAttribute 특성Attributes of the FlagsAttribute

AttributeUsageAttribute 는이 클래스에 적용 되 고, 해당 속성은를 Inherited 지정 false 합니다.AttributeUsageAttribute is applied to this class, and its Inherited property specifies false. 이 특성은 열거형에만 적용할 수 있습니다.This attribute can only be applied to enumerations.

FlagsAttribute 및 열거형에 대 한 지침Guidelines for FlagsAttribute and Enum

  • FlagsAttribute숫자 값에 대해 비트 연산 (and, or, EXCLUSIVE 또는)을 수행 하는 경우에만 열거형에 대해 사용자 지정 특성을 사용 합니다.Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

  • 2의 거듭제곱, 즉 1, 2, 4, 8 등의 열거 상수를 정의 합니다.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. 즉, 결합 된 열거 상수의 개별 플래그가 겹치지 않습니다.This means the individual flags in combined enumeration constants do not overlap.

  • 일반적으로 사용 되는 플래그 조합에 대해 열거 된 상수를 만드는 것이 좋습니다.Consider creating an enumerated constant for commonly used flag combinations. 예를 들어 열거 된 상수 및를 포함 하는 파일 i/o 작업에 사용 되는 열거형이 있는 경우 및 플래그를 결합 하는 Read = 1 Write = 2 열거 상수를 만드는 것이 좋습니다 ReadWrite = Read OR Write Read Write .For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. 또한 플래그를 조합 하는 데 사용 되는 비트 OR 연산은 간단한 작업에 반드시 필요한 것은 아닙니다.In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

  • 많은 플래그 위치를 1로 설정 하 여 코드를 혼동 하 고 코딩 오류를 발생 시킬 수 있으므로 음수를 플래그 열거 상수로 정의 하는 경우 주의 해야 합니다.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • 숫자 값에 플래그가 설정 되었는지 여부를 테스트 하는 편리한 방법은 숫자 값과 플래그 열거 상수 간에 비트 AND 연산을 수행 하는 것입니다 .이 상수는 숫자 값의 모든 비트를 플래그에 해당 하지 않는 0으로 설정 하 고 해당 작업의 결과가 플래그 열거 상수와 같은지 여부를 테스트 합니다.A convenient way to test whether a flag is set in a numeric value is to perform a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, then test whether the result of that operation is equal to the flag enumerated constant.

  • None값이 0 인 플래그 열거 상수의 이름으로 사용 합니다.Use None as the name of the flag enumerated constant whose value is zero. None결과는 항상 0 이므로 비트 and 연산에서 열거형 상수를 사용 하 여 플래그를 테스트할 수 없습니다.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. 그러나 숫자 값과 열거 된 상수 간에 비트를 비교 하지 않고 논리를 수행 None 하 여 숫자 값의 비트가 설정 되어 있는지 여부를 확인할 수 있습니다.However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set.

    플래그 열거 대신 값 열거를 만드는 경우에도 열거 상수를 만드는 것이 좋습니다 None .If you create a value enumeration instead of a flags enumeration, it is still worthwhile to create a None enumerated constant. 그 이유는 기본적으로 열거형에 사용 되는 메모리가 공용 언어 런타임에서 0으로 초기화 되기 때문입니다.The reason is that by default the memory used for the enumeration is initialized to zero by the common language runtime. 따라서 값이 0 인 상수를 정의 하지 않으면 열거형이 만들어질 때 잘못 된 값이 포함 됩니다.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

    애플리케이션을 나타내는 필요한 명확한 기본 사례를 경우에 값이 기본값을 나타내는 0 인 열거형된 상수를 사용 하는 것이 좋습니다.If there is an obvious default case your application needs to represent, consider using an enumerated constant whose value is zero to represent the default. 기본 사례가 없는 경우 값이 0 인 열거 된 상수를 사용 하는 것이 좋습니다 .이는 다른 열거 상수로 표현 되지 않는 사례를 의미 합니다.If there is no default case, consider using an enumerated constant whose value is zero that means the case that is not represented by any of the other enumerated constants.

  • 열거형 자체의 상태를 미러링 하기 위해 열거형 값만 정의 하지 마십시오.Do not define an enumeration value solely to mirror the state of the enumeration itself. 예를 들어 단순히 열거형의 끝을 표시 하는 열거형 상수를 정의 하지 마십시오.For example, do not define an enumerated constant that merely marks the end of the enumeration. 열거형의 마지막 값을 확인 해야 하는 경우 해당 값을 명시적으로 확인 합니다.If you need to determine the last value of the enumeration, check for that value explicitly. 또한 범위 내에 있는 모든 값이 유효 하면 첫 번째 및 마지막 열거 상수에 대해 범위 검사를 수행할 수 있습니다.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

  • 나중에 사용 하도록 예약 된 열거 상수는 지정 하지 마세요.Do not specify enumerated constants that are reserved for future use.

  • 열거형 상수를 값으로 사용 하는 메서드 또는 속성을 정의 하는 경우 값의 유효성을 검사 하는 것이 좋습니다.When you define a method or property that takes an enumerated constant as a value, consider validating the value. 그 이유는 숫자 값이 열거형에 정의 되지 않은 경우에도 숫자 값을 열거형 형식으로 캐스팅할 수 있기 때문입니다.The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.

생성자

FlagsAttribute()

FlagsAttribute 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the FlagsAttribute class.

속성

TypeId

파생 클래스에서 구현된 경우 이 Attribute에 대한 고유 식별자를 가져옵니다.When implemented in a derived class, gets a unique identifier for this Attribute.

(다음에서 상속됨 Attribute)

메서드

Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether this instance is equal to a specified object.

(다음에서 상속됨 Attribute)
GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.Returns the hash code for this instance.

(다음에서 상속됨 Attribute)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
IsDefaultAttribute()

파생 클래스에서 재정의된 경우 이 인스턴스 값이 파생 클래스에 대한 기본값인지 여부를 표시합니다.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(다음에서 상속됨 Attribute)
Match(Object)

파생 클래스에서 재정의된 경우 이 인스턴스가 지정된 개체와 같은지 여부를 나타내는 값을 반환합니다.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(다음에서 상속됨 Attribute)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)

명시적 인터페이스 구현

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can be used to get the type information for an interface.

(다음에서 상속됨 Attribute)
_Attribute.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 Attribute)

적용 대상