FieldInfo.GetValue(Object) Metodo

Definizione

In caso di override in una classe derivata, restituisce il valore di un campo supportato da un determinato oggetto.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

Parametri

obj
Object

Oggetto di cui verrà restituito il valore del campo.The object whose field value will be returned.

Restituisce

Oggetto contenente il valore del campo riflesso da questa istanza.An object containing the value of the field reflected by this instance.

Implementazioni

Eccezioni

In .NET per app di Windows Store o nella libreria di classi portabile rilevare invece l'eccezione Exception.In the .NET for Windows Store apps or the Portable Class Library, catch Exception instead.

Il campo non è statico e obj è null.The field is non-static and obj is null.

Un campo viene contrassegnato come valore letterale, ma non contiene uno dei tipi letterali accettati.A field is marked literal, but the field does not have one of the accepted literal types.

In .NET per app di Windows Store o nella libreria di classi portabile rilevare invece l'eccezione della classe di base, MemberAccessException.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, MemberAccessException, instead.

Il chiamante non ha l'autorizzazione necessaria per accedere a questo campo.The caller does not have permission to access this field.

Il metodo non viene dichiarato né ereditato dalla classe di obj.The method is neither declared nor inherited by the class of obj.

Esempi

Nell'esempio seguente viene usato GetValue il metodo per recuperare il valore di un campo statico.The following example uses the GetValue method to retrieve the value of a static field. Si noti che il valore dell' obj argomento è 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

Nell'esempio seguente viene recuperata una FieldInfo matrice di oggetti che rappresenta i campi FieldsClass del tipo GetValue , quindi viene chiamato per visualizzare il valore di ogni campo per l' fieldsInst oggetto.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'

Commenti

Se il campo è statico, obj viene ignorato.If the field is static, obj is ignored. Per i campi non statici, obj deve essere un'istanza di una classe che eredita o dichiara il campo.For non-static fields, obj should be an instance of a class that inherits or declares the field. Si noti che il tipo restituito GetValue di Objectè.Note that the return type of GetValue is Object. Se, ad esempio, il campo include un valore primitivo booleano, Object viene restituita un'istanza di con il valore booleano appropriato.For example, if the field holds a Boolean primitive value, an instance of Object with the appropriate Boolean value is returned. Prima di restituire il valore GetValue , verifica se l'utente dispone delle autorizzazioni di accesso.Before returning the value, GetValue checks to see if the user has access permission.

Nota

Le restrizioni di accesso vengono ignorate per il codice completamente attendibile.Access restrictions are ignored for fully trusted code. Ovvero, i costruttori privati, i metodi, i campi e le proprietà possono essere accessibili e richiamati tramite reflection ogni volta che il codice è completamente attendibile.That is, private constructors, methods, fields, and properties can be accessed and invoked through reflection whenever the code is fully trusted.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a membri non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei membri non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Si applica a

Vedi anche