title: Why is my Type.GetFields(BindingFlags.Instance|BindingFlags.Public) not working?
body: <p>My code can see the non-public members, but not the public ones. Why?</p>
  
  <pre><code>FieldInfo[] publicFieldInfos =
      t.GetFields(BindingFlags.Instance | BindingFlags.Public);
  </code></pre>
  
  <p>is returning nothing.</p>
  
  <p>Note: I'm trying to get at the properties on the abstract class as well as 
  the concrete class. (And read the attributes as well).</p>
  
  <p>The MSDN example works with the 2 flags <code>(BindingFlags.Instance | BindingFlags.Public)</code> but my mini inheritance example below does not.</p>
  
  <pre><code>private void RunTest1()
  {
      try
      {
          textBox1.Text = string.Empty;
  
          Type t = typeof(MyInheritedClass);
  
          //Look at the BindingFlags *** NonPublic ***
  
          int fieldCount = 0;
  
          while (null != t)
          {
              fieldCount += t.GetFields(BindingFlags.Instance |
              BindingFlags.NonPublic).Length;
  
              FieldInfo[] nonPublicFieldInfos = t.GetFields(BindingFlags.Instance |
              BindingFlags.NonPublic);
  
              foreach (FieldInfo field in nonPublicFieldInfos)
              {
                  if (null != field)
                  {
                      Console.WriteLine(field.Name);
                  }
              }
  
              t = t.BaseType;
          }
  
          Console.WriteLine("\n\r------------------\n\r");
  
          //Look at the BindingFlags *** Public ***
  
          t = typeof(MyInheritedClass);
  
          FieldInfo[] publicFieldInfos = t.GetFields(BindingFlags.Instance |
          BindingFlags.Public);
  
          foreach (FieldInfo field in publicFieldInfos)
          {
              if (null != field)
              {
                  Console.WriteLine(field.Name);
  
                  object[] attributes = field.GetCustomAttributes(t, true);
  
                  if (attributes != null &amp;&amp; attributes.Length &gt; 0)
                  {
                      foreach (Attribute att in attributes)
                      {
                          Console.WriteLine(att.GetType().Name);
                      }
                  }
              }
          }
      }
      catch (Exception ex)
      {
          ReportException(ex);
      }
  }
  
  private void ReportException(Exception ex)
  {
      Exception innerException = ex;
  
      while (innerException != null)
      {
          Console.WriteLine(innerException.Message + System.Environment.NewLine +
          innerException.StackTrace + System.Environment.NewLine +
          System.Environment.NewLine);
  
          innerException = innerException.InnerException;
      }
  }
  
  public abstract class MySuperType
  {
      public MySuperType(string st)
      {
          this.STString = st;
      }
  
      public string STString
      {
          get;
          set;
      }
  
      public abstract string MyAbstractString { get; set; }
  }
  
  public class MyInheritedClass : MySuperType
  {
      public MyInheritedClass(string ic)
          : base(ic)
      {
          this.ICString = ic;
      }
  
      [Description("This is an important property"), Category("HowImportant")]
      public string ICString
      {
          get;
          set;
      }
  
      private string _oldSchoolPropertyString = string.Empty;
  
      public string OldSchoolPropertyString
      {
          get { return _oldSchoolPropertyString; }
          set { _oldSchoolPropertyString = value; }
      }
  
      [Description("This is a not so importarnt property"),
      Category("HowImportant")]
      public override string MyAbstractString
      {
          get;
          set;
      }
  }
  </code></pre>
  
  <p>EDIT </p>
  
  <p>Here is my code after I took the advice given here:</p>
  
  <pre><code>private void RunTest1()
  {
      try
      {
  
          textBox1.Text = string.Empty;
  
          Type t = typeof(MyInheritedClass);
  
  
          //Look at the BindingFlags *** NonPublic ***
          int fieldCount = 0;
          while (null != t)
          {
              fieldCount += t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Length;
  
              PropertyInfo[] nonPublicFieldInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic);
              foreach (PropertyInfo field in nonPublicFieldInfos)
              {
                  if (null != field)
                  {
                      Console.WriteLine(field.Name);
  
                  }
              }
  
              t = t.BaseType;
  
          }
  
  
  
          Console.WriteLine("\n\r------------------\n\r");
  
  
  
          //Look at the BindingFlags *** Public ***
          t = typeof(MyInheritedClass);
          PropertyInfo[] publicFieldInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public);
  
          foreach (PropertyInfo field in publicFieldInfos)
          {
              if (null != field)
              {
                  Console.WriteLine(field.Name);
                  textBox1.Text += field.Name + System.Environment.NewLine;
                  DescriptionAttribute[] attributes = (DescriptionAttribute[])field.GetCustomAttributes(typeof(DescriptionAttribute), false);             
  
                  if (attributes != null &amp;&amp; attributes.Length &gt; 0)
                  {
                      foreach (Attribute att in attributes)
                      {
                          Console.WriteLine(att.GetType().Name);
  
                      }
                  }
              }
          }
      }
      catch (Exception ex)
      {
          ReportException(ex);
      }
  
  }
  
  private void ReportException(Exception ex)
  {
  
  
  
      Exception innerException = ex;
      while (innerException != null)
      {
          Console.WriteLine(innerException.Message + System.Environment.NewLine + innerException.StackTrace + System.Environment.NewLine + System.Environment.NewLine);
  
      }
  
  }
  
  
  public abstract class MySuperType
  {
      public MySuperType(string st)
      {
          this.STString = st;
      }
      public string STString
      {
          get;
          set;
      }
  
      public abstract string MyAbstractString {get;set;}
  
  }
  
  public class MyInheritedClass : MySuperType
  {
      public MyInheritedClass(string ic)
          : base(ic)
      {
          this.ICString = ic;
      }
  
      [Description("This is an important property"),Category("HowImportant")]
      public string ICString
      {
          get;
          set;
      }
  
  
      private string _oldSchoolPropertyString = string.Empty;
      public string OldSchoolPropertyString
      {
          get { return _oldSchoolPropertyString; }
          set { _oldSchoolPropertyString = value; }
      }
  
  
      [Description("This is a not so importarnt property"), Category("HowImportant")]
      public override string MyAbstractString
      {
          get; set;
      }
  
  
  }
  </code></pre>