// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+using System.Collections.Generic;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
internal struct MonoPropertyInfo {
public Type parent;
+ public Type declaring_type;
public String name;
public MethodInfo get_method;
public MethodInfo set_method;
[MethodImplAttribute (MethodImplOptions.InternalCall)]
internal static extern Type[] GetTypeModifiers (MonoProperty prop, bool optional);
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ internal static extern object get_default_value (MonoProperty prop);
}
[Flags]
}
-#if NET_2_0
internal delegate object GetterAdapter (object _this);
internal delegate R Getter<T,R> (T _this);
-#endif
[Serializable]
internal class MonoProperty : PropertyInfo, ISerializable {
internal IntPtr prop;
MonoPropertyInfo info;
PInfo cached;
-#if NET_2_0
GetterAdapter cached_getter;
-#endif
#pragma warning restore 649
public override Type DeclaringType {
get {
CachePropertyInfo (PInfo.DeclaringType);
- return info.parent;
+ return info.declaring_type;
}
}
public override ParameterInfo[] GetIndexParameters()
{
- CachePropertyInfo (PInfo.GetMethod);
- if (info.get_method != null)
- return info.get_method.GetParameters ();
- return new ParameterInfo [0];
+ CachePropertyInfo (PInfo.GetMethod | PInfo.SetMethod);
+ ParameterInfo[] res;
+ if (info.get_method != null) {
+ res = info.get_method.GetParameters ();
+ } else if (info.set_method != null) {
+ ParameterInfo[] src = info.set_method.GetParameters ();
+ res = new ParameterInfo [src.Length - 1];
+ Array.Copy (src, res, res.Length);
+ } else
+ return new ParameterInfo [0];
+
+ for (int i = 0; i < res.Length; ++i) {
+ ParameterInfo pinfo = res [i];
+ res [i] = new ParameterInfo (pinfo, this);
+ }
+ return res;
}
public override MethodInfo GetSetMethod (bool nonPublic)
return null;
}
+
+ /*TODO verify for attribute based default values, just like ParameterInfo*/
+ public override object GetConstantValue ()
+ {
+ return MonoPropertyInfo.get_default_value (this);
+ }
+
+ public override object GetRawConstantValue() {
+ return MonoPropertyInfo.get_default_value (this);
+ }
+
// According to MSDN the inherit parameter is ignored here and
// the behavior always defaults to inherit = false
//
}
-#if NET_2_0
delegate object GetterAdapter (object _this);
delegate R Getter<T,R> (T _this);
delegate R StaticGetter<R> ();
+#pragma warning disable 169
+ // Used via reflection
static object GetterAdapterFrame<T,R> (Getter<T,R> getter, object obj)
{
return getter ((T)obj);
{
return getter ();
}
+#pragma warning restore 169
/*
* The idea behing this optimization is to use a pair of delegates to simulate the same effect of doing a reflection call.
return GetValue (obj, BindingFlags.Default, null, index, null);
}
-#endif
public override object GetValue (object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
return PropertyType.ToString () + " " + Name;
}
-#if NET_2_0 || BOOTSTRAP_NET_2_0
-
public override Type[] GetOptionalCustomModifiers () {
Type[] types = MonoPropertyInfo.GetTypeModifiers (this, true);
if (types == null)
return Type.EmptyTypes;
return types;
}
-#endif
// ISerializable
public void GetObjectData (SerializationInfo info, StreamingContext context)
MemberInfoSerializationHolder.Serialize (info, Name, ReflectedType,
ToString(), MemberTypes.Property);
}
+
+#if NET_4_0
+ public override IList<CustomAttributeData> GetCustomAttributesData () {
+ return CustomAttributeData.GetCustomAttributes (this);
+ }
+#endif
}
}