483 lines
14 KiB
C#
483 lines
14 KiB
C#
//
|
|
// RuntimePropertyInfo.cs: The class used to represent Properties from the mono runtime.
|
|
//
|
|
// Authors:
|
|
// Paolo Molaro (lupus@ximian.com)
|
|
// Patrik Torstensson (patrik.torstensson@labs2.com)
|
|
// Marek Safar (marek.safar@gmail.com)
|
|
//
|
|
// (C) 2001 Ximian, Inc. http://www.ximian.com
|
|
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
|
|
// Copyright 2013 Xamarin, Inc (http://www.xamarin.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// 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;
|
|
using System.Runtime.Serialization;
|
|
using System.Security;
|
|
using System.Text;
|
|
using System.Diagnostics.Contracts;
|
|
using Mono;
|
|
|
|
namespace System.Reflection {
|
|
|
|
internal struct MonoPropertyInfo {
|
|
public Type parent;
|
|
public Type declaring_type;
|
|
public String name;
|
|
public MethodInfo get_method;
|
|
public MethodInfo set_method;
|
|
public PropertyAttributes attrs;
|
|
}
|
|
|
|
[Flags]
|
|
internal enum PInfo {
|
|
Attributes = 1,
|
|
GetMethod = 1 << 1,
|
|
SetMethod = 1 << 2,
|
|
ReflectedType = 1 << 3,
|
|
DeclaringType = 1 << 4,
|
|
Name = 1 << 5
|
|
|
|
}
|
|
|
|
internal delegate object GetterAdapter (object _this);
|
|
internal delegate R Getter<T,R> (T _this);
|
|
|
|
[Serializable]
|
|
[StructLayout (LayoutKind.Sequential)]
|
|
internal class RuntimePropertyInfo : PropertyInfo
|
|
#if !NETCORE
|
|
, ISerializable
|
|
#endif
|
|
{
|
|
#pragma warning disable 649
|
|
internal IntPtr klass;
|
|
internal IntPtr prop;
|
|
MonoPropertyInfo info;
|
|
PInfo cached;
|
|
GetterAdapter cached_getter;
|
|
#pragma warning restore 649
|
|
|
|
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
|
internal static extern void get_property_info (RuntimePropertyInfo prop, ref MonoPropertyInfo info,
|
|
PInfo req_info);
|
|
|
|
[MethodImplAttribute (MethodImplOptions.InternalCall)]
|
|
internal static extern Type[] GetTypeModifiers (RuntimePropertyInfo prop, bool optional);
|
|
|
|
[MethodImplAttribute (MethodImplOptions.InternalCall)]
|
|
internal static extern object get_default_value (RuntimePropertyInfo prop);
|
|
|
|
internal BindingFlags BindingFlags {
|
|
get {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public override Module Module {
|
|
get {
|
|
return GetRuntimeModule ();
|
|
}
|
|
}
|
|
|
|
internal RuntimeType GetDeclaringTypeInternal ()
|
|
{
|
|
return (RuntimeType) DeclaringType;
|
|
}
|
|
|
|
RuntimeType ReflectedTypeInternal {
|
|
get {
|
|
return (RuntimeType) ReflectedType;
|
|
}
|
|
}
|
|
|
|
internal RuntimeModule GetRuntimeModule ()
|
|
{
|
|
return GetDeclaringTypeInternal ().GetRuntimeModule ();
|
|
}
|
|
|
|
#region Object Overrides
|
|
public override String ToString()
|
|
{
|
|
return FormatNameAndSig(false);
|
|
}
|
|
|
|
private string FormatNameAndSig(bool serialization)
|
|
{
|
|
#if NETCORE
|
|
throw new NotImplementedException ();
|
|
#else
|
|
StringBuilder sbName = new StringBuilder(PropertyType.FormatTypeName(serialization));
|
|
|
|
sbName.Append(" ");
|
|
sbName.Append(Name);
|
|
|
|
var pi = GetIndexParameters ();
|
|
if (pi.Length > 0) {
|
|
sbName.Append (" [");
|
|
RuntimeParameterInfo.FormatParameters (sbName, pi, 0, serialization);
|
|
sbName.Append ("]");
|
|
}
|
|
|
|
return sbName.ToString();
|
|
#endif
|
|
}
|
|
#endregion
|
|
|
|
#if !NETCORE
|
|
#region ISerializable Implementation
|
|
public void GetObjectData(SerializationInfo info, StreamingContext context)
|
|
{
|
|
if (info == null)
|
|
throw new ArgumentNullException("info");
|
|
Contract.EndContractBlock();
|
|
|
|
MemberInfoSerializationHolder.GetSerializationInfo(
|
|
info,
|
|
Name,
|
|
ReflectedTypeInternal,
|
|
ToString(),
|
|
SerializationToString(),
|
|
MemberTypes.Property,
|
|
null);
|
|
}
|
|
|
|
internal string SerializationToString()
|
|
{
|
|
return FormatNameAndSig(true);
|
|
}
|
|
#endregion
|
|
#endif
|
|
|
|
void CachePropertyInfo (PInfo flags)
|
|
{
|
|
if ((cached & flags) != flags) {
|
|
get_property_info (this, ref info, flags);
|
|
cached |= flags;
|
|
}
|
|
}
|
|
|
|
public override PropertyAttributes Attributes {
|
|
get {
|
|
CachePropertyInfo (PInfo.Attributes);
|
|
return info.attrs;
|
|
}
|
|
}
|
|
|
|
public override bool CanRead {
|
|
get {
|
|
CachePropertyInfo (PInfo.GetMethod);
|
|
return (info.get_method != null);
|
|
}
|
|
}
|
|
|
|
public override bool CanWrite {
|
|
get {
|
|
CachePropertyInfo (PInfo.SetMethod);
|
|
return (info.set_method != null);
|
|
}
|
|
}
|
|
|
|
public override Type PropertyType {
|
|
get {
|
|
CachePropertyInfo (PInfo.GetMethod | PInfo.SetMethod);
|
|
|
|
if (info.get_method != null) {
|
|
return info.get_method.ReturnType;
|
|
} else {
|
|
ParameterInfo[] parameters = info.set_method.GetParametersInternal ();
|
|
|
|
return parameters [parameters.Length - 1].ParameterType;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Type ReflectedType {
|
|
get {
|
|
CachePropertyInfo (PInfo.ReflectedType);
|
|
return info.parent;
|
|
}
|
|
}
|
|
|
|
public override Type DeclaringType {
|
|
get {
|
|
CachePropertyInfo (PInfo.DeclaringType);
|
|
return info.declaring_type;
|
|
}
|
|
}
|
|
|
|
public override string Name {
|
|
get {
|
|
CachePropertyInfo (PInfo.Name);
|
|
return info.name;
|
|
}
|
|
}
|
|
|
|
public override MethodInfo[] GetAccessors (bool nonPublic)
|
|
{
|
|
int nget = 0;
|
|
int nset = 0;
|
|
|
|
CachePropertyInfo (PInfo.GetMethod | PInfo.SetMethod);
|
|
|
|
if (info.set_method != null && (nonPublic || info.set_method.IsPublic))
|
|
nset = 1;
|
|
if (info.get_method != null && (nonPublic || info.get_method.IsPublic))
|
|
nget = 1;
|
|
|
|
MethodInfo[] res = new MethodInfo [nget + nset];
|
|
int n = 0;
|
|
if (nset != 0)
|
|
res [n++] = info.set_method;
|
|
if (nget != 0)
|
|
res [n++] = info.get_method;
|
|
return res;
|
|
}
|
|
|
|
public override MethodInfo GetGetMethod (bool nonPublic)
|
|
{
|
|
CachePropertyInfo (PInfo.GetMethod);
|
|
if (info.get_method != null && (nonPublic || info.get_method.IsPublic))
|
|
return info.get_method;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
public override ParameterInfo[] GetIndexParameters ()
|
|
{
|
|
CachePropertyInfo (PInfo.GetMethod | PInfo.SetMethod);
|
|
ParameterInfo[] src;
|
|
int length;
|
|
if (info.get_method != null) {
|
|
src = info.get_method.GetParametersInternal ();
|
|
length = src.Length;
|
|
} else if (info.set_method != null) {
|
|
src = info.set_method.GetParametersInternal ();
|
|
length = src.Length - 1;
|
|
} else
|
|
return EmptyArray<ParameterInfo>.Value;
|
|
|
|
var dest = new ParameterInfo [length];
|
|
for (int i = 0; i < length; ++i) {
|
|
dest [i] = RuntimeParameterInfo.New (src [i], this);
|
|
}
|
|
return dest;
|
|
}
|
|
|
|
public override MethodInfo GetSetMethod (bool nonPublic)
|
|
{
|
|
CachePropertyInfo (PInfo.SetMethod);
|
|
if (info.set_method != null && (nonPublic || info.set_method.IsPublic))
|
|
return info.set_method;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
/*TODO verify for attribute based default values, just like ParameterInfo*/
|
|
public override object GetConstantValue ()
|
|
{
|
|
return get_default_value (this);
|
|
}
|
|
|
|
public override object GetRawConstantValue() {
|
|
return get_default_value (this);
|
|
}
|
|
|
|
// According to MSDN the inherit parameter is ignored here and
|
|
// the behavior always defaults to inherit = false
|
|
//
|
|
public override bool IsDefined (Type attributeType, bool inherit)
|
|
{
|
|
return MonoCustomAttrs.IsDefined (this, attributeType, false);
|
|
}
|
|
|
|
public override object[] GetCustomAttributes (bool inherit)
|
|
{
|
|
return MonoCustomAttrs.GetCustomAttributes (this, false);
|
|
}
|
|
|
|
public override object[] GetCustomAttributes (Type attributeType, bool inherit)
|
|
{
|
|
return MonoCustomAttrs.GetCustomAttributes (this, attributeType, false);
|
|
}
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
static object StaticGetterAdapterFrame<R> (StaticGetter<R> getter, object 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.
|
|
* The first delegate cast the this argument to the right type and the second does points to the target method.
|
|
*/
|
|
static GetterAdapter CreateGetterDelegate (MethodInfo method)
|
|
{
|
|
Type[] typeVector;
|
|
Type getterType;
|
|
object getterDelegate;
|
|
MethodInfo adapterFrame;
|
|
Type getterDelegateType;
|
|
string frameName;
|
|
|
|
if (method.IsStatic) {
|
|
typeVector = new Type[] { method.ReturnType };
|
|
getterDelegateType = typeof (StaticGetter<>);
|
|
frameName = "StaticGetterAdapterFrame";
|
|
} else {
|
|
typeVector = new Type[] { method.DeclaringType, method.ReturnType };
|
|
getterDelegateType = typeof (Getter<,>);
|
|
frameName = "GetterAdapterFrame";
|
|
}
|
|
|
|
getterType = getterDelegateType.MakeGenericType (typeVector);
|
|
getterDelegate = Delegate.CreateDelegate (getterType, method);
|
|
adapterFrame = typeof (RuntimePropertyInfo).GetMethod (frameName, BindingFlags.Static | BindingFlags.NonPublic);
|
|
adapterFrame = adapterFrame.MakeGenericMethod (typeVector);
|
|
return (GetterAdapter)Delegate.CreateDelegate (typeof (GetterAdapter), getterDelegate, adapterFrame, true);
|
|
}
|
|
|
|
public override object GetValue (object obj, object[] index)
|
|
{
|
|
if (index == null || index.Length == 0) {
|
|
/*FIXME we should check if the number of arguments matches the expected one, otherwise the error message will be pretty criptic.*/
|
|
#if !FULL_AOT_RUNTIME
|
|
if (cached_getter == null) {
|
|
MethodInfo method = GetGetMethod (true);
|
|
if (method == null)
|
|
throw new ArgumentException ($"Get Method not found for '{Name}'");
|
|
if (!DeclaringType.IsValueType && !method.ContainsGenericParameters) { //FIXME find a way to build an invoke delegate for value types.
|
|
cached_getter = CreateGetterDelegate (method);
|
|
// The try-catch preserves the .Invoke () behaviour
|
|
try {
|
|
return cached_getter (obj);
|
|
} catch (Exception ex) {
|
|
throw new TargetInvocationException (ex);
|
|
}
|
|
}
|
|
} else {
|
|
try {
|
|
return cached_getter (obj);
|
|
} catch (Exception ex) {
|
|
throw new TargetInvocationException (ex);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return GetValue (obj, BindingFlags.Default, null, index, null);
|
|
}
|
|
|
|
public override object GetValue (object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
|
|
{
|
|
object ret = null;
|
|
|
|
MethodInfo method = GetGetMethod (true);
|
|
if (method == null)
|
|
throw new ArgumentException ($"Get Method not found for '{Name}'");
|
|
|
|
try {
|
|
if (index == null || index.Length == 0)
|
|
ret = method.Invoke (obj, invokeAttr, binder, null, culture);
|
|
else
|
|
ret = method.Invoke (obj, invokeAttr, binder, index, culture);
|
|
}
|
|
catch (SecurityException se) {
|
|
throw new TargetInvocationException (se);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public override void SetValue (object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
|
|
{
|
|
MethodInfo method = GetSetMethod (true);
|
|
if (method == null)
|
|
throw new ArgumentException ("Set Method not found for '" + Name + "'");
|
|
|
|
object [] parms;
|
|
if (index == null || index.Length == 0)
|
|
parms = new object [] {value};
|
|
else {
|
|
int ilen = index.Length;
|
|
parms = new object [ilen+ 1];
|
|
index.CopyTo (parms, 0);
|
|
parms [ilen] = value;
|
|
}
|
|
|
|
method.Invoke (obj, invokeAttr, binder, parms, culture);
|
|
}
|
|
|
|
public override Type[] GetOptionalCustomModifiers () => GetCustomModifiers (true);
|
|
|
|
public override Type[] GetRequiredCustomModifiers () => GetCustomModifiers (false);
|
|
|
|
private Type[] GetCustomModifiers (bool optional) => GetTypeModifiers (this, optional) ?? Type.EmptyTypes;
|
|
|
|
public override IList<CustomAttributeData> GetCustomAttributesData () {
|
|
return CustomAttributeData.GetCustomAttributes (this);
|
|
}
|
|
|
|
#if !NETCORE
|
|
public sealed override bool HasSameMetadataDefinitionAs (MemberInfo other) => HasSameMetadataDefinitionAsCore<RuntimePropertyInfo> (other);
|
|
#endif
|
|
|
|
public override int MetadataToken {
|
|
get {
|
|
return get_metadata_token (this);
|
|
}
|
|
}
|
|
|
|
[MethodImplAttribute (MethodImplOptions.InternalCall)]
|
|
internal static extern int get_metadata_token (RuntimePropertyInfo monoProperty);
|
|
|
|
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
|
private static extern PropertyInfo internal_from_handle_type (IntPtr event_handle, IntPtr type_handle);
|
|
|
|
internal static PropertyInfo GetPropertyFromHandle (RuntimePropertyHandle handle, RuntimeTypeHandle reflectedType)
|
|
{
|
|
if (handle.Value == IntPtr.Zero)
|
|
throw new ArgumentException ("The handle is invalid.");
|
|
PropertyInfo pi = internal_from_handle_type (handle.Value, reflectedType.Value);
|
|
if (pi == null)
|
|
throw new ArgumentException ("The property handle and the type handle are incompatible.");
|
|
return pi;
|
|
}
|
|
}
|
|
}
|