comment faire pour itérer sur les propriétés internes en c#

public class TestClass
{
        public string property1 { get; set; }
        public string property2 { get; set; }

        internal string property3 { get; set; }
        internal string property4 { get; set; }
        internal string property5 { get; set; }
}

Je peux parcourir les propriétés à l'aide de la boucle suivante, mais il ne montre que des propriétés publiques. J'ai besoin de toutes les propriétés.

foreach (PropertyInfo property in typeof(TestClass).GetProperties())
{
    //do something
}
InformationsquelleAutor GaneshT | 2011-09-27
  1. 57

    Vous devez indiquer que vous n'avez pas seulement besoin de les propriétés publiques, à l'aide de la surcharge accepter BindingFlags:

    foreach (PropertyInfo property in typeof(TestClass)
             .GetProperties(BindingFlags.Instance | 
                            BindingFlags.NonPublic |
                            BindingFlags.Public))
{
    //do something
}

    Ajouter BindingFlags.Static si vous souhaitez inclure des propriétés statiques.

    Le sans paramètre surcharge retourne uniquement des propriétés publiques.

    • Donner Non publiques et de l'Instance va se cacher prop 1 et prop 2, vous devez à la fois, Non publiques | Public pour toutes les propriétés
    • de toute façon pour sélectionner seulement protégés ou interne?
    • Pas avec la liaison des drapeaux, des que je suis au courant. Juste de filtrer par la suite.
    InformationsquelleAutor Jon Skeet
  2. 10

    Vous avez besoin de changer la BindingFlags sur votre appel à Type.GetProperties

    Essayer:

    var instanceProperties = typeof(TestClass).GetProperties(
    BindingFlags.Public |
    BindingFlags.NonPublic | 
    BindingFlags.Instance
);
foreach(var instanceProperty in instanceProperties) {
    //a little something something for the instanceProperty
}
    • ouais, j'ai dû ajouter BindingFlags.Public
    InformationsquelleAutor jason
  3. 5

    Selon MSDN, privé, interne et ne sont pas comptabilisés dans la Réflexion de l'API.

    À identifier une méthode interne à l'aide de la Réflexion, de l'utilisation de la IsAssembly
    de la propriété. Pour identifier un protégé de l'intérieur de la méthode, l'utilisation de la
    IsFamilyOrAssembly.

    Si Vous êtes à la rédaction de certaines unités de test, Vous voudrez peut-être jeter un oeil à InternalsVisibleTo attribut. Elle permet de préciser que l'assemblée peut voir les propriétés internes.

    Et enfin, avez-Vous vraiment besoin d'avoir des propriétés internes...

    • ouais je le fais, c'est de la wcf service de la classe, je veux que le client de remplir certaines propriétés avant de les envoyer au serveur, et le reste des propriétés à remplir sur le service.
    InformationsquelleAutor Filip Popović
  4. 3

    par préciser ce bindingflags dans GetProperties:

    foreach (PropertyInfo property in typeof(TestClass).GetProperties(
      BindingFlags.Instance|
      BindingFlags.Public|
      BindingFlags.NonPublic))
    InformationsquelleAutor MatteKarla
  5. 3

    Utilisation BindingFlags

    foreach (PropertyInfo property in typeof(TestClass)
        .GetProperties(
            BindingFlags.Public |
            BindingFlags.NonPublic |
            BindingFlags.Instance))
{
    //do something
}
    InformationsquelleAutor amit_g
  6. 0

    Vous obtenez les propriétés internes d'un type en interrogeant l'Confidentielles propriétés puis en filtrant les méthodes Get de ces par des "IsAssembly".

    interne"protégés" propriétés ont leurs accesseurs marqué comme "IsFamilyOrAssembly", "protégés" propriétés "IsFamily", et
    "privé" propriétés marquées avec "IsPrivate":

        public class TestClass
{
public string Property1 { get; set; }
private string Property2 { get; set; }
public string Property9 { get; set; }
private string Property10 { get; set; }
protected internal string Property3 { get; set; }
protected string Property4 { get; set; }
internal string Property5 { get; set; }
protected internal int Property6 { get; set; }
protected int Property7 { get; set; }
internal int Property8 { get; set; }
internal static void ShowPropertyAccessScope(Type t)
{
foreach (var prop in t.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
Console.WriteLine("{0,-28} {1,15}", "Public property:", prop.Name);
}
var nonPublic = t.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var prop in nonPublic.Where(p => p.GetGetMethod(true)?.IsAssembly == true))
{
Console.WriteLine("{0,-28} {1,15}", "Internal property:", prop.Name);
}
foreach (var prop in nonPublic.Where(p => p.GetGetMethod(true)?.IsFamilyOrAssembly == true))
{
Console.WriteLine("{0,-28} {1,15}", "Internal protected property:", prop.Name);
}
foreach (var prop in nonPublic.Where(p => p.GetGetMethod(true)?.IsFamily == true))
{
Console.WriteLine("{0,-28} {1,15}", "Protected property:", prop.Name);
}
foreach (var prop in nonPublic.Where(p => p.GetGetMethod(true)?.IsPrivate == true))
{
Console.WriteLine("{0,-28} {1,15}", "Private property:", prop.Name);
}
}
static void Main() 
{
ShowPropertyAccessScope(typeof(TestClass));
}
}
    InformationsquelleAutor lidqy