FieldInfo.GetValue(Object) Méthode

Définition

En cas de substitution dans une classe dérivée, retourne la valeur d’un champ pris en charge par un objet donné.When overridden in a derived class, returns the value of a field supported by a given object.

public:
 abstract System::Object ^ GetValue(System::Object ^ obj);
public abstract object GetValue (object obj);
abstract member GetValue : obj -> obj
Public MustOverride Function GetValue (obj As Object) As Object

Paramètres

obj
Object

Objet dont la valeur de champ sera retournée.The object whose field value will be returned.

Retours

Objet contenant la valeur du champ réfléchi par cette instance.An object containing the value of the field reflected by this instance.

Implémente

Exceptions

Dans .NET pour les applications du Windows Store ou la Bibliothèque de classes portable, interceptez Exception à la place.In the .NET for Windows Store apps or the Portable Class Library, catch Exception instead.

Le champ est non static et obj est null.The field is non-static and obj is null.

Un champ est marqué comme littéral, mais il n’a pas l’un des types littéraux acceptés.A field is marked literal, but the field does not have one of the accepted literal types.

Dans .NET pour les applications du Windows Store ou la Bibliothèque de classes portable, interceptez l’exception de la classe de base, MemberAccessException, à la place.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, MemberAccessException, instead.

L’appelant n’est pas autorisé à accéder à ce champ.The caller does not have permission to access this field.

La méthode n’est ni déclarée, ni héritée par la classe de obj.The method is neither declared nor inherited by the class of obj.

Exemples

L’exemple suivant utilise la GetValue méthode pour récupérer la valeur d’un champ statique.The following example uses the GetValue method to retrieve the value of a static field. Notez que la valeur de l' obj argument est null.Note that the value of the obj argument is null.

using namespace System;
using namespace System::Reflection;

ref class Example
{
  public:
     static String^ val = "test";
};

int main()
{
   FieldInfo^ fld = Example::typeid->GetField( "val" );
   Console::WriteLine(fld->GetValue(nullptr) );
   Example::val = "hi";
   Console::WriteLine(fld->GetValue(nullptr) );
}
// The example displays the following output:
//     test
//     hi
using System;
using System.Reflection;

class Example
{
    public static String val = "test";
    
    public static void Main()
    {
        FieldInfo fld = typeof(Example).GetField("val");
        Console.WriteLine(fld.GetValue(null));
        val = "hi";
        Console.WriteLine(fld.GetValue(null));
    }
}
// The example displays the following output:
//     test
//     hi
Imports System.Reflection

Class Example
    Public Shared val As String = "test"
    
    Public Shared Sub Main()
        Dim fld As FieldInfo = GetType(Example).GetField("val")
        Console.WriteLine(fld.GetValue(Nothing))
        val = "hi"
        Console.WriteLine(fld.GetValue(Nothing))
    End Sub 
End Class 
' The example displays the following output:
'     test
'     hi

L’exemple suivant récupère FieldInfo un tableau d’objets qui représente les champs FieldsClass du type GetValue , puis appelle pour afficher la valeur de chaque champ pour l' fieldsInst objet.The following example retrieves an array of FieldInfo objects that represents the fields of the FieldsClass type, and then calls the GetValue to display the value of each field for the fieldsInst object.

using namespace System;
using namespace System::Reflection;

public ref class FieldsClass
{
  public:
     String^ fieldA;
     String^ fieldB;

     FieldsClass()
     {
        fieldA = "A public field";
        fieldB = "Another public field";
     }
};

int main()
{
   FieldsClass^ fieldsInst = gcnew FieldsClass;
   
   // Get the type of FieldsClass.
   Type^ fieldsType = FieldsClass::typeid;

   // Get the FieldInfo of FieldsClass.
   array<FieldInfo^>^ fields = fieldsType->GetFields(static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance));

   // Display the values of the fields.
   Console::WriteLine("Displaying the values of the fields of {0}:", fieldsType);
   for (int i = 0; i < fields->Length; i++)
   {
      Console::WriteLine("   {0}:\t'{1}'", 
                         fields[i]->Name, fields[i]->GetValue(fieldsInst));
   }
}
// The example displays the following output:
//     Displaying the values of the fields of FieldsClass:
//        fieldA:      'A public field'
//        fieldB:      'Another public field'
using System;
using System.Reflection;

public class FieldsClass
{
    public string fieldA;
    public string fieldB;
     
    public FieldsClass()
    {
        fieldA = "A public field";
        fieldB = "Another public field";
    }
}

public class Example
{
    public static void Main()
    {
        FieldsClass fieldsInst = new FieldsClass();
        // Get the type of FieldsClass.
        Type fieldsType = typeof(FieldsClass);

        // Get an array of FieldInfo objects.
        FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public 
            | BindingFlags.Instance);
        // Display the values of the fields.
        Console.WriteLine("Displaying the values of the fields of {0}:",
            fieldsType);
        for(int i = 0; i < fields.Length; i++)
        {
            Console.WriteLine("   {0}:\t'{1}'",
                fields[i].Name, fields[i].GetValue(fieldsInst));
        }
    }
}
// The example displays the following output:
//     Displaying the values of the fields of FieldsClass:
//        fieldA:      'A public field'
//        fieldB:      'Another public field'
Imports System.Reflection

Public Class FieldsClass
    Public fieldA As String
    Public fieldB As String

    Public Sub New()
        fieldA = "A public field"
        fieldB = "Another public field"
    End Sub 
End Class 

Public Module Example
    Public Sub Main()
        Dim fieldsInst As New FieldsClass()
        ' Get the type of FieldsClass.
        Dim fieldsType As Type = GetType(FieldsClass)

        ' Get an array of FieldInfo objects.
        Dim fields As FieldInfo() = fieldsType.GetFields(BindingFlags.Public Or BindingFlags.Instance)
        ' Display the values of the fields.
        Console.WriteLine("Displaying the values of the fields of {0}:", fieldsType)
        For i As Integer = 0 To fields.Length - 1
            Console.WriteLine("   {0}:{2}'{1}'",
                fields(i).Name, fields(i).GetValue(fieldsInst), vbTab)
        Next 
    End Sub 
End Module
' The example displays the following output:
'     Displaying the values of the fields of FieldsClass:
'        fieldA:      'A public field'
'        fieldB:      'Another public field'

Remarques

Si le champ est statique, obj est ignoré.If the field is static, obj is ignored. Pour les champs non statiques obj , doit être une instance d’une classe qui hérite ou déclare le champ.For non-static fields, obj should be an instance of a class that inherits or declares the field. Notez que le type de retour GetValue de Objectest.Note that the return type of GetValue is Object. Par exemple, si le champ contient une valeur primitive booléenne, une instance de Object avec la valeur booléenne appropriée est retournée.For example, if the field holds a Boolean primitive value, an instance of Object with the appropriate Boolean value is returned. Avant de retourner la valeur GetValue , vérifie si l’utilisateur dispose de l’autorisation d’accès.Before returning the value, GetValue checks to see if the user has access permission.

Notes

Les restrictions d’accès sont ignorées pour le code d’un niveau de confiance totale.Access restrictions are ignored for fully trusted code. Autrement dit, les constructeurs, les méthodes, les champs et les propriétés privés sont accessibles et appelés via la réflexion chaque fois que le code est d’un niveau de confiance suffisant.That is, private constructors, methods, fields, and properties can be accessed and invoked through reflection whenever the code is fully trusted.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux membres non publics si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des membres non publics est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public members if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public members is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

S’applique à

Voir aussi