Vind 'n private veld met Refleksie?

Question

Gegewe hierdie klas

class Foo
{
    // Want to find _bar with reflection
    [SomeAttribute]
    private string _bar;

    public string BigBar
    {
        get { return this._bar; }
    }
}

Ek wil die private item _bar dat ek sal merk met 'n kenmerk vind. Is dit moontlik?

Ek het dit gedoen met eiendomme waar ek gekyk het vir 'n kenmerk, maar nooit 'n private lid veld.

Wat is die bindende vlae wat ek nodig het om te stel die private velde kry?

Answer 1

Gebruik BindingFlags.NonPublic en BindingFlags.Instance vlae

FieldInfo[] fields = myType.GetFields(
                         BindingFlags.NonPublic | 
                         BindingFlags.Instance);

Answer 2

Jy kan dit doen net soos met 'n eiendom:

FieldInfo fi = typeof(Foo).GetField("_bar", BindingFlags.NonPublic | BindingFlags.Instance);
if (fi.GetCustomAttributes(typeof(SomeAttribute)) != null)
    ...

Answer 3

Kry waarde met behulp van Refleksie private veranderlike se:

var _barVariable = typeof(Foo).GetField("_bar", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(objectForFooClass);

Stel waarde vir private veranderlike met behulp Refleksie:

typeof(Foo).GetField("_bar", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(objectForFoocClass, "newValue");

Waar objectForFooClass is 'n nie nul byvoorbeeld vir die tipe klas Foo.

Answer 4

Een ding wat jy nodig het om bewus te wees van wanneer besin oor private lede is dat indien jou aansoek hardloop in medium trust (soos byvoorbeeld wanneer jy loop op 'n gedeelde hosting omgewing), dit sal nie hulle vind -. die opsie BindingFlags.NonPublic sal eenvoudig geïgnoreer word

Answer 5

typeof(MyType).GetField("fieldName", BindingFlags.NonPublic | BindingFlags.Instance)

Answer 6

Nice Syntax Met Uitbreiding Metode

Jy kan toegang tot enige private gebied van 'n arbitrêre tipe met kode soos volg:

Foo foo = new Foo();
string c = foo.GetFieldValue<string>("_bar");

Vir wat jy nodig het om 'n verlenging metode wat die werk vir jou doen definieer:

public static class ReflectionExtensions {
    public static T GetFieldValue<T>(this object obj, string name) {
        // Set the flags so that private and public fields from instances will be found
        var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
        var field = obj.GetType().GetField(name, bindingFlags);
        return (T)field?.GetValue(obj);
    }
}

Answer 7

Ek gebruik hierdie metode persoonlik

if (typeof(Foo).GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Any(c => c.GetCustomAttributes(typeof(SomeAttribute), false).Any()))
{ 
    // do stuff
}

Answer 8

Ja, maar jy sal nodig hê om jou Binding vlae ingestel om te soek na private velde (indien u op soek na die lid buite die klas byvoorbeeld).

Die bindende vlag wat jy nodig het is: System.Reflection.BindingFlags.NonPublic

Answer 9

Hier is 'n paar uitbreiding metodes vir eenvoudige get en stel private velde en eienskappe (eienskappe met setter):

gebruik byvoorbeeld:

    public class Foo
    {
        private int Bar = 5;
    }

    var targetObject = new Foo();
    var barValue = targetObject.GetMemberValue("Bar");//Result is 5
    targetObject.SetMemberValue("Bar", 10);//Sets Bar to 10

Kode:

    /// <summary>
    /// Extensions methos for using reflection to get / set member values
    /// </summary>
    public static class ReflectionExtensions
    {
        /// <summary>
        /// Gets the public or private member using reflection.
        /// </summary>
        /// <param name="obj">The source target.</param>
        /// <param name="memberName">Name of the field or property.</param>
        /// <returns>the value of member</returns>
        public static object GetMemberValue(this object obj, string memberName)
        {
            var memInf = GetMemberInfo(obj, memberName);

            if (memInf == null)
                throw new System.Exception("memberName");

            if (memInf is System.Reflection.PropertyInfo)
                return memInf.As<System.Reflection.PropertyInfo>().GetValue(obj, null);

            if (memInf is System.Reflection.FieldInfo)
                return memInf.As<System.Reflection.FieldInfo>().GetValue(obj);

            throw new System.Exception();
        }

        /// <summary>
        /// Gets the public or private member using reflection.
        /// </summary>
        /// <param name="obj">The target object.</param>
        /// <param name="memberName">Name of the field or property.</param>
        /// <returns>Old Value</returns>
        public static object SetMemberValue(this object obj, string memberName, object newValue)
        {
            var memInf = GetMemberInfo(obj, memberName);


            if (memInf == null)
                throw new System.Exception("memberName");

            var oldValue = obj.GetMemberValue(memberName);

            if (memInf is System.Reflection.PropertyInfo)
                memInf.As<System.Reflection.PropertyInfo>().SetValue(obj, newValue, null);
            else if (memInf is System.Reflection.FieldInfo)
                memInf.As<System.Reflection.FieldInfo>().SetValue(obj, newValue);
            else
                throw new System.Exception();

            return oldValue;
        }

        /// <summary>
        /// Gets the member info
        /// </summary>
        /// <param name="obj">source object</param>
        /// <param name="memberName">name of member</param>
        /// <returns>instanse of MemberInfo corresponsing to member</returns>
        private static System.Reflection.MemberInfo GetMemberInfo(object obj, string memberName)
        {
            var prps = new System.Collections.Generic.List<System.Reflection.PropertyInfo>();

            prps.Add(obj.GetType().GetProperty(memberName,
                                               System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance |
                                               System.Reflection.BindingFlags.FlattenHierarchy));
            prps = System.Linq.Enumerable.ToList(System.Linq.Enumerable.Where( prps,i => !ReferenceEquals(i, null)));
            if (prps.Count != 0)
                return prps[0];

            var flds = new System.Collections.Generic.List<System.Reflection.FieldInfo>();

            flds.Add(obj.GetType().GetField(memberName,
                                            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance |
                                            System.Reflection.BindingFlags.FlattenHierarchy));

            //to add more types of properties

            flds = System.Linq.Enumerable.ToList(System.Linq.Enumerable.Where(flds, i => !ReferenceEquals(i, null)));

            if (flds.Count != 0)
                return flds[0];

            return null;
        }

        [System.Diagnostics.DebuggerHidden]
        private static T As<T>(this object obj)
        {
            return (T)obj;
        }
    }

Answer 10

Ek het afgekom op hierdie, terwyl die soek vir hierdie op Google so ek besef ek stamp 'n ou post. Maar die GetCustomAttributes vereis twee params.

typeof(Foo).GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.Where(x => x.GetCustomAttributes(typeof(SomeAttribute), false).Length > 0);

Die tweede parameter bepaal of jy wil die erfenis hiërargie soek