Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

Type.GetProperty-Methode (String, Type[])

Sucht die angegebene öffentliche Eigenschaft, deren Parameter den angegebenen Argumenttypen entsprechen.

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

public PropertyInfo GetProperty (
	string name,
	Type[] types
)
public final PropertyInfo GetProperty (
	String name, 
	Type[] types
)
public final function GetProperty (
	name : String, 
	types : Type[]
) : PropertyInfo

Parameter

name

Der String, der den Namen der abzurufenden öffentlichen Eigenschaft enthält.

types

Ein Array von Type-Objekten, die Anzahl, Reihenfolge und Typ der Parameter der abzurufenden indizierten Eigenschaft darstellen.

– oder –

Ein leeres Array vom Type-Typ, d. h. Type[] types = new Type[0], zum Abrufen einer nicht indizierten Eigenschaft.

Rückgabewert

Ein PropertyInfo-Objekt, das die öffentliche Eigenschaft darstellt, deren Parameter den angegebenen Argumenttypen entsprechen, sofern gefunden, andernfalls NULL (Nothing in Visual Basic).
AusnahmetypBedingung

AmbiguousMatchException

Es wurde mehr als eine Eigenschaft mit dem angegebenen Namen gefunden, die den angegebenen Argumenttypen entspricht.

ArgumentNullException

name ist NULL (Nothing in Visual Basic).

– oder –

types ist NULL (Nothing in Visual Basic).

– oder –

Eines der Elemente in types ist NULL (Nothing in Visual Basic).

ArgumentException

types ist mehrdimensional.

Bei der Suche nach name wird die Groß- und Kleinschreibung berücksichtigt. Die Suche schließt öffentliche statische Eigenschaften und öffentliche Instanzeigenschaften ein.

Diese Methode gibt NULL (Nothing in Visual Basic) zurück, wenn der angeforderte Typ nicht öffentlich ist und der Aufrufer keine ReflectionPermission zum Reflektieren nicht öffentlicher Objekte außerhalb der aktuellen Assembly besitzt.

Wenn der aktuelle T:System.Type einen konstruierten generischen Typ darstellt, gibt diese Methode die PropertyInfo zurück, wobei die Typparameter durch die entsprechenden Typargumente ersetzt wurden.

Wenn der aktuelle Type einen Typparameter einer generischen Typ- oder Methodendefinition darstellt, durchsucht diese Methode die Eigenschaften der Klasseneinschränkung.

Im folgenden Beispiel werden das Type-Objekt einer benutzerdefinierten Klasse und die Eigenschaft dieser Klasse abgerufen sowie der Eigenschaftenname und -typ angezeigt, die durch die an GetProperty übergebenen Argumente angegeben wurden.


using System;
using System.Reflection;
class MyClass1
{         
    private int [,] myArray = {{1,2},{3,4}}; 
    // Declare an indexer.
    public int this [int i,int j]   
    {
        get 
        {
            return myArray[i,j];
        }
        set 
        {
            myArray[i,j] = value;
        }
    }
}
public class MyTypeClass
{
    public static void Main(string[] args)
    {
        try
        { 
            // Get the Type object.
            Type myType=typeof(MyClass1);       
            Type[] myTypeArr = new Type[2];
            // Create an instance of a Type array.
            myTypeArr.SetValue(typeof(int),0);            
            myTypeArr.SetValue(typeof(int),1);
            // Get the PropertyInfo object for the indexed property Item, which has two integer parameters. 
            PropertyInfo myPropInfo = myType.GetProperty("Item", myTypeArr);
            // Display the property.
            Console.WriteLine("The {0} property exists in MyClass1.", myPropInfo.ToString());
        }           
        catch(NullReferenceException e)
        {
            Console.WriteLine("An exception occurred.");
            Console.WriteLine("Source : {0}" , e.Source);
            Console.WriteLine("Message : {0}" , e.Message);
        }
    }
}

import System.*;
import System.Reflection.*;

class MyClass1
{
    private int myArray[,] =  {{1, 2}, {3, 4}};
    // Declare an indexer.
    /** @property 
     */
    public int get_Item(int i, int j)
    {
        return myArray[i, j];
    } //Item

    /** @property 
     */
    public void set_Item(int i, int j, int value)
    {
        myArray[i, j] = value;
    } //Item
} //MyClass1

public class MyTypeClass
{
    public static void main(String[] args)
    {
        try {
            // Get the Type object.
            Type myType = MyClass1.class.ToType();
            Type myTypeArr[] = new Type[2];
            // Create an instance of a Type array.
            myTypeArr.SetValue(int.class.ToType(), 0);
            myTypeArr.SetValue(int.class.ToType(), 1);
            // Get the PropertyInfo object for the indexed property Item,
            // which has two integer parameters. 
            PropertyInfo myPropInfo = myType.GetProperty("Item", myTypeArr);
            // Display the property.
            Console.WriteLine("The {0} property exists in MyClass1.",
                myPropInfo.ToString());
        }
        catch (NullReferenceException e) {
            Console.WriteLine("An exception occurred.");
            Console.WriteLine("Source : {0}", e.get_Source());
            Console.WriteLine("Message : {0}", e.get_Message());
        }
    } //main
} //MyTypeClass

Intern wird diese Eigenschaft in den Metadaten als "Item" bezeichnet. Damit die PropertyInfo richtig zurückgegeben wird, muss daher bei jedem Versuch, die PropertyInfo unter Verwendung der Reflektion abzurufen, dieser interne Name angegeben werden.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, 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.

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
© 2013 Microsoft. Alle Rechte vorbehalten.