FieldInfo.GetValue-Methode

Gibt den Wert eines Felds zurück, das durch ein angegebenes Objekt unterstützt wird, wenn es in einer abgeleiteten Klasse überschrieben wird.

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public MustOverride Function GetValue ( _
    obj As Object _
) As Object
'Usage
Dim instance As FieldInfo
Dim obj As Object
Dim returnValue As Object

returnValue = instance.GetValue(obj)

public abstract Object GetValue (
    Object obj
)

public:
virtual Object^ GetValue (
    Object^ obj
) abstract

public abstract Object GetValue (
    Object obj
)

public abstract function GetValue (
    obj : Object
) : Object

Parameter

• obj
  Das Objekt, dessen Feldwert zurückgegeben wird.

Rückgabewert

Ein Objekt mit dem Wert des Felds, das von dieser Instanz reflektiert wird.

Ausnahmen

Ausnahmetyp	Bedingung
TargetException	Das Feld ist nicht statisch, und obj ist NULL (Nothing in Visual Basic).
NotSupportedException	Ein Feld ist als literal markiert, aber das Feld weist keine der akzeptierten literalen Typen auf.
FieldAccessException	Der Aufrufer besitzt keine Zugriffsberechtigungen für dieses Feld.
ArgumentException	Die Methode ist weder deklariert noch von der Klasse von obj geerbt.

Hinweise

Bei einem statischen Feld wird obj ignoriert. Bei nicht statischen Feldern sollte obj eine Instanz einer Klasse sein, die das Feld erbt oder deklariert. Beachten Sie, dass GetValue den Rückgabetyp Object hat. Wenn das Feld beispielsweise einen einfachen booleschen Wert enthält, wird eine Instanz von Object mit dem entsprechenden booleschen Wert zurückgegeben. Vor dem Zurückgeben des Werts werden die Zugriffsberechtigung des Benutzers durch GetValue überprüft.

Hinweis

Zugriffsbeschränkungen werden bei vollständig vertrauenswürdigem Code ignoriert. Daher ist das Zugreifen auf und das Aufrufen von privaten Konstruktoren, Methoden, Feldern und Eigenschaften bei vollständig vertrauenswürdigem Code über Reflektion möglich.

Beispiel

' The following example demonstrates getting
' a field value directly, without having an object,
' by defining it as a static field.
Imports System
Imports System.Reflection

Class [MyClass]
    Public Shared val As [String] = "test"
    Public Shared Sub Main()
        Dim myf As FieldInfo = GetType([MyClass]).GetField("val")
        Console.WriteLine(myf.GetValue(Nothing))
        val = "hi"
        Console.WriteLine(myf.GetValue(Nothing))
    End Sub 'Main
End Class '[MyClass]

// The following example demonstrates getting
// a field value directly, without having an object,
// by defining it as a static field.

using System;
using System.Reflection;

class MyClass
{
    public static String val = "test";
    public static void Main()
    {
        FieldInfo myf = typeof(MyClass).GetField("val");
        Console.WriteLine(myf.GetValue(null));
        val = "hi";
        Console.WriteLine(myf.GetValue(null));
    }
}

// The following example demonstrates getting
// a field value directly, without having an object,
// by defining it as a static field.
using namespace System;
using namespace System::Reflection;

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

int main()
{
   FieldInfo^ myf = MyClass::typeid->GetField( "val" );
   Console::WriteLine( myf->GetValue( nullptr ) );
   MyClass::val = "hi";
   Console::WriteLine( myf->GetValue( nullptr ) );
}

// The following example demonstrates getting
// a field value directly, without having an object,
// by defining it as a static field.
import System.*;
import System.Reflection.*;

class MyClass
{
    public static String val = "test";

    public static void main(String[] args)
    {
        FieldInfo myf = MyClass.class.ToType().GetField("val");
        Console.WriteLine(myf.GetValue(null));
        val = "hi";
        Console.WriteLine(myf.GetValue(null));
    } //main
} //MyClass

Im folgenden Beispiel werden die Felder von MyClass abgerufen und die Feldwerte angezeigt.

Imports System
Imports System.Reflection
Imports Microsoft.VisualBasic

Public Class MyClass1
    Public myFieldA As String
    Public myFieldB As String

    Public Sub New()
        myFieldA = "A public field"
        myFieldB = "Another public field"
    End Sub 'New
End Class 'MyClass1

Public Class FieldInfo_GetValue

    Public Shared Sub Main()
        Dim myInstance As New MyClass1()
        ' Get the type of MyClass1.
        Dim myType As Type = GetType(MyClass1)
        Try
            ' Get the FieldInfo of MyClass1.
            Dim myFields As FieldInfo() = myType.GetFields((BindingFlags.Public Or BindingFlags.Instance))
            ' Display the values of the fields.
            Console.WriteLine(ControlChars.NewLine & "Displaying the values of the fields of {0}." & ControlChars.NewLine, myType.ToString())
            Dim i As Integer
            For i = 0 To myFields.Length - 1
                Console.WriteLine("The value of the field {0} is: {1}", myFields(i).Name, myFields(i).GetValue(myInstance))
            Next i
        Catch e As FieldAccessException
            Console.WriteLine("FieldAccessException : {0}", e.Message.ToString())
        Catch e As TargetException
            Console.WriteLine("TargetException : {0}", e.Message.ToString())
        Catch e As ExecutionEngineException
            Console.WriteLine("ExecutionEngineException : {0}", e.Message.ToString())
        Catch e As MemberAccessException
            Console.WriteLine("MemberAccessException : {0}", e.Message.ToString())
        Catch e As Exception
            Console.WriteLine("Exception : {0}", e.Message.ToString())
        End Try
    End Sub 'Main
End Class 'FieldInfo_GetValue

using System;
using System.Reflection;

public class MyClass
{
    public string myFieldA;
    public string myFieldB; 
    public MyClass()
    {
        myFieldA = "A public field";
        myFieldB = "Another public field";
    }
}

public class FieldInfo_GetValue
{
    public static void Main()
    {
        MyClass myInstance = new MyClass();
        // Get the type of MyClass.
        Type myType = typeof(MyClass);
        try
        {
            // Get the FieldInfo of MyClass.
            FieldInfo[] myFields = myType.GetFields(BindingFlags.Public 
                | BindingFlags.Instance);
            // Display the values of the fields.
            Console.WriteLine("\nDisplaying the values of the fields of {0}.\n",
                myType);
            for(int i = 0; i < myFields.Length; i++)
            {
                Console.WriteLine("The value of {0} is: {1}",
                    myFields[i].Name, myFields[i].GetValue(myInstance));
            }
        }  
        catch(FieldAccessException e)
        {
            Console.WriteLine("FieldAccessException : {0}", e.Message);
        }
        catch(TargetException e)
        {
            Console.WriteLine("TargetException : {0}", e.Message);
        }
        catch(ExecutionEngineException e)
        {
            Console.WriteLine("ExecutionEngineException : {0}", e.Message);
        }
        catch(MemberAccessException e)
        {
            Console.WriteLine("MemberAccessException : {0}", e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception : {0}", e.Message);
        }
    }
}

using namespace System;
using namespace System::Reflection;

public ref class MyClass
{
public:
   String^ myFieldA;
   String^ myFieldB;
   MyClass()
   {
      myFieldA = "A public field";
      myFieldB = "Another public field";
   }
};

int main()
{
   MyClass^ myInstance = gcnew MyClass;
   
   // Get the type of MyClass.
   Type^ myType = MyClass::typeid;
   try
   {
      // Get the FieldInfo of MyClass.
      array<FieldInfo^>^myFields = myType->GetFields( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance) );

      // Display the values of the fields.
      Console::WriteLine( "\nDisplaying the values of the fields of {0}.\n", myType );
      for ( int i = 0; i < myFields->Length; i++ )
      {
         Console::WriteLine( "The value of {0} is: {1}", myFields[ i ]->Name, myFields[ i ]->GetValue( myInstance ) );

      }
   }
   catch ( FieldAccessException^ e ) 
   {
      Console::WriteLine( "FieldAccessException : {0}", e->Message );
   }
   catch ( TargetException^ e ) 
   {
      Console::WriteLine( "TargetException : {0}", e->Message );
   }
   catch ( ExecutionEngineException^ e ) 
   {
      Console::WriteLine( "ExecutionEngineException : {0}", e->Message );
   }
   catch ( MemberAccessException^ e ) 
   {
      Console::WriteLine( "MemberAccessException : {0}", e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception : {0}", e->Message );
   }
}

.NET Framework-Sicherheit

• ReflectionPermission  beim Laden mit später Bindung durch Mechanismen wie Type.InvokeMember. Zugeordnete Enumeration: ReflectionPermissionFlag.MemberAccess.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

FieldInfo-Klasse
FieldInfo-Member
System.Reflection-Namespace
Object