开发者

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
)
0

上一篇:

下一篇:

精彩评论

暂无评论...
验证码 换一张
取 消

最新问答

问答排行榜