FieldInfo.GetValue(Object) Método

Definición

Cuando se reemplaza en una clase derivada, devuelve el valor de un campo compatible con un objeto concreto.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

Parámetros

obj
Object

Objeto cuyo valor de campo se devolverá.The object whose field value will be returned.

Devoluciones

Objeto que contiene el valor del campo reflejado por esta instancia.An object containing the value of the field reflected by this instance.

Implementaciones

Excepciones

En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, capture Exception en su lugar.In the .NET for Windows Store apps or the Portable Class Library, catch Exception instead.

El campo no es estático y obj es null.The field is non-static and obj is null.

Un campo está marcado como literal, pero el campo no tiene uno de los tipos literales aceptados.A field is marked literal, but the field does not have one of the accepted literal types.

En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, capture en su lugar la excepción de clase base, MemberAccessException.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, MemberAccessException, instead.

El autor de la llamada no tiene permiso para acceder a este campo.The caller does not have permission to access this field.

La clase de obj no declara ni hereda el método.The method is neither declared nor inherited by the class of obj.

Ejemplos

En el ejemplo siguiente se GetValue usa el método para recuperar el valor de un campo estático.The following example uses the GetValue method to retrieve the value of a static field. Tenga en cuenta que el valor obj del argumento nulles.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

En el ejemplo siguiente se recupera una matriz FieldInfo de objetos que representa los campos FieldsClass del tipo y, a continuación, se llama fieldsInst a para mostrar el valor de cada campo del objeto. GetValueThe 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'

Comentarios

Si el campo es estático, obj se omite.If the field is static, obj is ignored. En el caso de los campos obj no estáticos, debe ser una instancia de una clase que herede o declare el campo.For non-static fields, obj should be an instance of a class that inherits or declares the field. Tenga en cuenta que el tipo GetValue de Objectvalor devuelto de es.Note that the return type of GetValue is Object. Por ejemplo, si el campo contiene un valor primitivo booleano, se devuelve una Object instancia de con el valor booleano adecuado.For example, if the field holds a Boolean primitive value, an instance of Object with the appropriate Boolean value is returned. Antes de devolver el valor GetValue , comprueba para ver si el usuario tiene permiso de acceso.Before returning the value, GetValue checks to see if the user has access permission.

Nota

Las restricciones de acceso se omiten para el código de plena confianza.Access restrictions are ignored for fully trusted code. Es decir, se puede tener acceso a los constructores, métodos, campos y propiedades privados y se pueden invocar mediante reflexión siempre que el código sea de plena confianza.That is, private constructors, methods, fields, and properties can be accessed and invoked through reflection whenever the code is fully trusted.

Nota

A partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , este método se puede utilizar para tener acceso a los miembros no públicos si el llamador se ha concedido con la marca y si el conjunto de permisos de los miembros no públicos está restringido al conjunto de permisos del llamador o a un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1subconjunto. mismo.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. (Consulte consideraciones de seguridad para la reflexión).(See Security Considerations for Reflection.)

Para utilizar esta funcionalidad, la aplicación debe utilizar .NET Framework 3,5.NET Framework 3.5 o posterior como destino.To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Seguridad

ReflectionPermission
Cuando se invoca enlazado en tiempo de ejecución mediante InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])mecanismos como.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumeración asociada: MemberAccess.Associated enumeration: MemberAccess.

Se aplica a

Consulte también: