Comment faire une boucle à travers toutes les propriétés d'une classe?

J'ai une classe.

Public Class Foo
    Private _Name As String
    Public Property Name() As String
        Get
            Return _Name
        End Get
        Set(ByVal value As String)
            _Name = value
        End Set
    End Property

    Private _Age As String
    Public Property Age() As String
        Get
            Return _Age
        End Get
        Set(ByVal value As String)
            _Age = value
        End Set
    End Property

    Private _ContactNumber As String
    Public Property ContactNumber() As String
        Get
            Return _ContactNumber
        End Get
        Set(ByVal value As String)
            _ContactNumber = value
        End Set
    End Property


End Class

Je veux faire une boucle par les propriétés de la classe ci-dessus.
par exemple;

Public Sub DisplayAll(ByVal Someobject As Foo)
    For Each _Property As something In Someobject.Properties
        Console.WriteLine(_Property.Name & "=" & _Property.value)
    Next
End Sub

InformationsquelleAutor Sachin Chavan | 2009-02-10

287

Utiliser La Réflexion:
```
Type type = obj.GetType();
PropertyInfo[] properties = type.GetProperties();

foreach (PropertyInfo property in properties)
{
    Console.WriteLine("Name: " + property.Name + ", Value: " + property.GetValue(obj, null));
}
```
Edit: Vous pouvez également spécifier un BindingFlags de la valeur à type.GetProperties():
```
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
PropertyInfo[] properties = type.GetProperties(flags);
```
Qui va limiter le retour de propriétés publiques des propriétés d'une instance (à l'exclusion des propriétés statiques, les propriétés protégées, etc).

Vous n'avez pas besoin de spécifier BindingFlags.GetProperty, vous l'utiliser lors de l'appel de type.InvokeMember() pour obtenir la valeur d'une propriété.
- Btw, ne devrait pas y avoir de liaison des drapeaux pour que GetProperties? Comme BindingFlags.Public | BindingFlags.GetProperty ou quelque chose?
- vous avez raison 🙂 On pourrait utiliser une BindingFlags, mais ils sont facultatifs. Vous voulez probablement Public | Instance.
- Astuce: Si vous avez affaire à des champs statiques, puis il suffit de passer la valeur null ici: de la propriété.GetValue(null);
InformationsquelleAutor Brannon
39

Noter que si l'objet dont vous parlez a une propriété personnalisée modèle (comme les DataRowView etc pour DataTable), alors vous devez utiliser TypeDescriptor; la bonne nouvelle, c'est que cela fonctionne toujours très bien pour des classes régulières (et peut-être même beaucoup plus rapide que la réflexion):
```
foreach(PropertyDescriptor prop in TypeDescriptor.GetProperties(obj)) {
    Console.WriteLine("{0} = {1}", prop.Name, prop.GetValue(obj));
}
```
Cela fournit également un accès facile à des choses comme TypeConverter pour la mise en forme:
```
    string fmt = prop.Converter.ConvertToString(prop.GetValue(obj));
```
InformationsquelleAutor Marc Gravell

VB version de C# donnée par Brannon:

Public Sub DisplayAll(ByVal Someobject As Foo)
    Dim _type As Type = Someobject.GetType()
    Dim properties() As PropertyInfo = _type.GetProperties()  'line 3
    For Each _property As PropertyInfo In properties
        Console.WriteLine("Name: " + _property.Name + ", Value: " + _property.GetValue(Someobject, Nothing))
    Next
End Sub

À l'aide de la Liaison des drapeaux, au lieu de la ligne no.3

    Dim flags As BindingFlags = BindingFlags.Public Or BindingFlags.Instance
    Dim properties() As PropertyInfo = _type.GetProperties(flags)

Merci, ça m'aurait pris trop de temps pour convertir VB 🙂
vous pouvez toujours utiliser un convertisseur automatique, il y en a beaucoup dans le web 🙂
Oui, mais pas tous aussi bon que le codage à la main. Un remarquable est telerik convertisseur de code
Voici comment Telerik aurait converti: gist.github.com/shmup/3f5abd617a525416fee7

InformationsquelleAutor Sachin Chavan

Réflexion est assez "lourd"

Peut-être essayer cette solution:
//C#

if (item is IEnumerable) {
    foreach (object o in item as IEnumerable) {
            //do function
    }
} else {
    foreach (System.Reflection.PropertyInfo p in obj.GetType().GetProperties())      {
        if (p.CanRead) {
            Console.WriteLine("{0}: {1}", p.Name, p.GetValue(obj,  null)); //possible function
        }
    }
}

'VB.Net

  If TypeOf item Is IEnumerable Then

    For Each o As Object In TryCast(item, IEnumerable)
               'Do Function
     Next
  Else
    For Each p As System.Reflection.PropertyInfo In obj.GetType().GetProperties()
         If p.CanRead Then
               Console.WriteLine("{0}: {1}", p.Name, p.GetValue(obj, Nothing))  'possible function
          End If
      Next
  End If

Réflexion ralentit +/- 1000 x la vitesse d'un appel de méthode, illustrée en Les Performances des Choses de tous les jours

InformationsquelleAutor NicoJuicy

private void ResetAllProperties()
    {
        Type type = this.GetType();
        PropertyInfo[] properties = (from c in type.GetProperties()
                                     where c.Name.StartsWith("Doc")
                                     select c).ToArray();
        foreach (PropertyInfo item in properties)
        {
            if (item.PropertyType.FullName == "System.String")
                item.SetValue(this, "", null);
        }
    }

J'ai utilisé le bloc de code ci-dessus pour réinitialiser toutes les propriétés de chaîne dans mon web objet de contrôle utilisateur qui sont les noms qui commencent par "Doc".

InformationsquelleAutor Jack

Voici une autre façon de faire, à l'aide d'une LINQ lambda:

C#:

SomeObject.GetType().GetProperties().ToList().ForEach(x => Console.WriteLine($"{x.Name} = {x.GetValue(SomeObject, null)}"));

VB.NET:

SomeObject.GetType.GetProperties.ToList.ForEach(Sub(x) Console.WriteLine($"{x.Name} = {x.GetValue(SomeObject, Nothing)}"))

InformationsquelleAutor 01F0

1

C'est comment je le fais.
```
foreach (var fi in typeof(CustomRoles).GetFields())
{
    var propertyName = fi.Name;
}
```
- Utilisation GetProperties() au lieu de GetFields() si l'objet/classe contient des propriétés au lieu de champs.
InformationsquelleAutor Chris Go

Vous devez vous connecter pour publier un commentaire.