MethodAttributes Énumération

Définition

Espace de noms:

System.Reflection

Assembly:

System.Runtime.dll

Spécifie les indicateurs des attributs de méthode. Ces indicateurs sont définis dans le fichier corhdr.h.

Cette énumération prend en charge une combinaison au niveau du bit de ses valeurs membres.

public enum class MethodAttributes

[System.Flags]
public enum MethodAttributes

[<System.Flags>]
type MethodAttributes = 

Public Enum MethodAttributes

Héritage

Object

ValueType

Enum

MethodAttributes

Attributs

FlagsAttribute

Champs

Abstract	1024	Indique que la classe ne fournit pas d'implémentation pour cette méthode.
Assembly	3	Indique que la méthode est accessible à n'importe quelle classe de cet assembly.
CheckAccessOnOverride	512	Indique que la méthode ne peut être substituée que lorsqu'elle est également accessible.
FamANDAssem	2	Indique que la méthode est accessible aux membres de ce type et à ses types dérivés de cet assembly uniquement.
Family	4	Indique que la méthode est accessible aux membres de cette classe et à ses classes dérivées uniquement.
FamORAssem	5	Indique que la méthode est accessible aux classes dérivées, quel que soit leur emplacement, ainsi qu'à toutes les classes de l'assembly.
Final	32	Indique que la méthode ne peut pas être substituée.
HasSecurity	16384	Indique qu'une sécurité est associée à la méthode. Indicateur réservé pour une utilisation au moment de l'exécution uniquement.
HideBySig	128	Indique que la méthode est masquée-par-nom-et-signature ; sinon, elle est masquée-par-nom uniquement.
MemberAccessMask	7	Récupère les informations d'accessibilité.
NewSlot	256	Indique que la méthode obtient toujours un nouvel emplacement vtable.
PinvokeImpl	8192	Indique que l'implémentation de la méthode est transmise via PInvoke (Platform Invocation Services).
Private	1	Indique que la méthode est uniquement accessible à la classe en cours.
PrivateScope	0	Indique que la méthode ne peut pas être référencée.
Public	6	Indique que la méthode est accessible à tout objet pour lequel cet objet figure dans la portée.
RequireSecObject	32768	Indique que la méthode appelle une autre méthode contenant du code de sécurité. Indicateur réservé pour une utilisation au moment de l'exécution uniquement.
ReservedMask	53248	Indique un indicateur réservé pour une utilisation au moment de l'exécution uniquement.
ReuseSlot	0	Indique que la méthode va réutiliser un emplacement vtable existant. Il s'agit du comportement par défaut.
RTSpecialName	4096	Indique que le Common Language Runtime vérifie l'encodage des noms.
SpecialName	2048	Indique qu'il s'agit d'une méthode spéciale. Le nom de la méthode décrit sa spécificité.
Static	16	Indique que la méthode est définie sur le type ; sinon, elle est définie par instance.
UnmanagedExport	8	Indique que la méthode managée est exportée par thunk vers du code non managé.
Virtual	64	Indique qu'il s'agit d'une méthode virtuelle.
VtableLayoutMask	256	Récupère les attributs vtable.

Exemples

L’exemple suivant affiche les attributs de la méthode spécifiée.

using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::InteropServices;

public ref class AttributesSample
{
public:
   void Mymethod( int int1m, [Out]interior_ptr<String^> str2m, interior_ptr<String^> str3m )
   {
       *str2m = "in Mymethod";
   }
};

void PrintAttributes( Type^ attribType, int iAttribValue )
{
   if (  !attribType->IsEnum )
   {
      Console::WriteLine( "This type is not an enum." );
      return;
   }

   array<FieldInfo^>^fields = attribType->GetFields( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Static) );
   for ( int i = 0; i < fields->Length; i++ )
   {
      int fieldvalue = safe_cast<Int32>(fields[ i ]->GetValue( nullptr ));
      if ( (fieldvalue & iAttribValue) == fieldvalue )
      {
         Console::WriteLine( fields[ i ]->Name );
      }
   }
}

int main()
{
   Console::WriteLine( "Reflection.MethodBase.Attributes Sample" );

   // Get the type of the chosen class.
   Type^ MyType = Type::GetType( "AttributesSample" );

   // Get the method Mymethod on the type.
   MethodBase^ Mymethodbase = MyType->GetMethod( "Mymethod" );

   // Display the method name and signature.
   Console::WriteLine( "Mymethodbase = {0}", Mymethodbase );

   // Get the MethodAttribute enumerated value.
   MethodAttributes Myattributes = Mymethodbase->Attributes;

   // Display the flags that are set.
   PrintAttributes( System::Reflection::MethodAttributes::typeid, (int)Myattributes );
   return 0;
}

using System;
using System.Reflection;

class AttributesSample
{
    public void Mymethod (int int1m, out string str2m, ref string str3m)
    {
        str2m = "in Mymethod";
    }

    public static int Main(string[] args)
    {
        Console.WriteLine ("Reflection.MethodBase.Attributes Sample");

        // Get the type of the chosen class.
        Type MyType = Type.GetType("AttributesSample");

        // Get the method Mymethod on the type.
        MethodBase Mymethodbase = MyType.GetMethod("Mymethod");

        // Display the method name and signature.
        Console.WriteLine("Mymethodbase = " + Mymethodbase);

        // Get the MethodAttribute enumerated value.
        MethodAttributes Myattributes = Mymethodbase.Attributes;

        // Display the flags that are set.
        PrintAttributes(typeof(System.Reflection.MethodAttributes), (int) Myattributes);
        return 0;
    }

    public static void PrintAttributes(Type attribType, int iAttribValue)
    {
        if (!attribType.IsEnum) {Console.WriteLine("This type is not an enum."); return;}

        FieldInfo[] fields = attribType.GetFields(BindingFlags.Public | BindingFlags.Static);
        for (int i = 0; i < fields.Length; i++)
        {
            int fieldvalue = (int)fields[i].GetValue(null);
            if ((fieldvalue & iAttribValue) == fieldvalue)
            {
                Console.WriteLine(fields[i].Name);
            }
        }
    }
}

Imports System.Reflection

Class AttributesSample

    Public Sub Mymethod(ByVal int1m As Integer, ByRef str2m As String, ByRef str3m As String)
        str2m = "in Mymethod"
    End Sub


    Public Shared Function Main(ByVal args() As String) As Integer
        Console.WriteLine("Reflection.MethodBase.Attributes Sample")

        ' Get the type of a chosen class.
        Dim MyType As Type = Type.GetType("AttributesSample")

        ' Get the method Mymethod on the type.
        Dim Mymethodbase As MethodBase = MyType.GetMethod("Mymethod")

        ' Display the method name and signature.
        Console.WriteLine("Mymethodbase = {0}", Mymethodbase)

        ' Get the MethodAttribute enumerated value.
        Dim Myattributes As MethodAttributes = Mymethodbase.Attributes

        ' Display the flags that are set.
        PrintAttributes(GetType(System.Reflection.MethodAttributes), CInt(Myattributes))
        Return 0
    End Function 'Main

    Public Shared Sub PrintAttributes(ByVal attribType As Type, ByVal iAttribValue As Integer)
        If Not attribType.IsEnum Then
            Console.WriteLine("This type is not an enum.")
            Return
        End If
        Dim fields As FieldInfo() = attribType.GetFields((BindingFlags.Public Or BindingFlags.Static))
        Dim i As Integer
        For i = 0 To fields.Length - 1
            Dim fieldvalue As Integer = CType(fields(i).GetValue(Nothing), Int32)
            If (fieldvalue And iAttribValue) = fieldvalue Then
                Console.WriteLine(fields(i).Name)
            End If
        Next i
    End Sub
End Class