FieldInfo.GetValue(Object) FieldInfo.GetValue(Object) FieldInfo.GetValue(Object) FieldInfo.GetValue(Object) Method

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 Object Object 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 la 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 un tableau de FieldInfo objets qui représentent les champs de la FieldsClass type, puis appelle la GetValue pour afficher la valeur de chaque champ pour le 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 de GetValue est Object.Note that the return type of GetValue is Object. Par exemple, si le champ contient une valeur booléenne primitifs valeur, une instance de Object avec la valeur booléenne appropriée la valeur 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 a l’autorisation d’accès.Before returning the value, GetValue checks to see if the user has access permission.

Notes

Restrictions d’accès sont ignorées pour le code totalement approuvé.Access restrictions are ignored for fully trusted code. Autrement dit, les propriétés, méthodes, champs et constructeurs privés sont accessibles et peuvent être appelées via la réflexion chaque fois que le code est entièrement fiable.That is, private constructors, methods, fields, and properties can be accessed and invoked through reflection whenever the code is fully trusted.

Notes

En commençant par le .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, cette méthode peut être utilisée pour accéder aux membres non publics si l’appelant a été accordé ReflectionPermission avec la ReflectionPermissionFlag.RestrictedMemberAccess indicateur et si le jeu d’autorisations des membres non publics est limité à l’appelant accorder ensemble ou un sous-ensemble son.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 de 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
Lorsqu’elle est appelée à liaison tardive via des mécanismes tels que InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).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