Why is my Type.GetFields(BindingFlags.Instance|BindingFlags.Public) not working?
My code can see the non-public members, but not the public ones. Why?
FieldInfo[] publicFieldInfos =
t.GetFields(BindingFlags.Instance | BindingFlags.Public);
is returning nothing.
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).
The MSDN example works with the 2 flags (BindingFlags.Instance | BindingFlags.Public)
but my mini inheritance example below does not.
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 && attributes.Length > 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.NewLin开发者_如何学编程e);
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;
}
}
EDIT
Here is my code after I took the advice given here:
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 && attributes.Length > 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;
}
}
Maybe because you're using GetFields
and the class doesn't have any public fields: properties and fields are two different things.
Try using the GetProperties
method instead of GetFields
.
Generally you're not going to find any non-public fields. Assuming your typical class is structured something like this:
public class MyClass {
private int myField;
public int MyProperty {
get { return myField; }
}
}
Notice the field (myField
) is private whereas the property (MyProperty
) is public.
So to find fields, you'll probably get the most mileage out of:
// note: fields -> generally non-public
Type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
Whereas for properties the reverse is true: you're likely to get the most mileage out of:
// note: properties -> generally public
Type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
Obviously, if you want to find all (public and non-public) members of a particular kind (field/property), you're going to have to use:
Type.GetFields( // (or GetProperties)
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
)
精彩评论