FieldInfo.GetValue(Object) Método

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Source:

FieldInfo.cs

Cuando se reemplaza en una clase derivada, devuelve el valor de un campo compatible con un objeto concreto.

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á.

Devoluciones

Object

Objeto que contiene el valor del campo reflejado por esta instancia.

Excepciones

TargetException

El campo no es estático y obj es null.

Nota: En .NET para aplicaciones de la Tienda Windows o la biblioteca de clases portable, detecte Exception en su lugar.

NotSupportedException

Un campo está marcado como literal, pero el campo no tiene uno de los tipos literales aceptados.

FieldAccessException

El autor de la llamada no tiene permiso para acceder a este campo.

Nota: En .NET para aplicaciones de la Tienda Windows o la Biblioteca de clases portable, detecte la excepción de clase base, MemberAccessException, en su lugar.

ArgumentException

La clase de obj no declara ni hereda el método.

Ejemplos

En el ejemplo siguiente se usa el GetValue método para recuperar el valor de un campo estático. Tenga en cuenta que el valor del obj argumento es 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 de FieldInfo objetos que representa los campos del FieldsClass tipo y, a continuación, se llama GetValue a para mostrar el valor de cada campo para el fieldsInst objeto .

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. En el caso de los campos no estáticos, obj debe ser una instancia de una clase que herede o declare el campo. Tenga en cuenta que el tipo de valor devuelto de GetValue es Object. Por ejemplo, si el campo contiene un valor primitivo booleano, se devuelve una instancia de Object con el valor booleano adecuado. Antes de devolver el valor, GetValue comprueba si el usuario tiene permiso de acceso.

Nota:

Las restricciones de acceso se omiten para el código de plena confianza. Es decir, se puede tener acceso a constructores privados, métodos, campos y propiedades e invocarse a través de la reflexión siempre que el código sea de plena confianza.

Nota

A partir de .NET Framework 2.0 Service Pack 1, este método se puede usar para acceder a miembros no públicos si se ha concedido ReflectionPermission al autor de la llamada con la ReflectionPermissionFlag.RestrictedMemberAccess marca y si el conjunto de concesión de los miembros no públicos está restringido al conjunto de concesión del autor de la llamada o a un subconjunto de ellos. (Consulte Consideraciones de seguridad para la reflexión).

Para usar esta funcionalidad, la aplicación debe tener como destino .NET Framework 3.5 o posterior.

Consulte también

• Object