PropertyAccessor.cs

Go to the documentation of this file.

using System;
using System.Reflection;
using System.Reflection.Emit;
 
namespace IKVM.Runtime.Accessors
{
 
#if FIRST_PASS == false && EXPORTER == false && IMPORTER == false
 
    internal abstract class PropertyAccessor
    {
 
        readonly Type type;
        readonly string name;
        PropertyInfo property;
 
        protected PropertyAccessor(Type type, string name)
        {
            this.type = type ?? throw new ArgumentNullException(nameof(type));
            this.name = name ?? throw new ArgumentNullException(nameof(name));
        }
 
        protected Type Type => type;
 
        protected string Name => name;
 
        protected PropertyInfo Property => AccessorUtil.LazyGet(ref property, () => type.GetProperty(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) ?? throw new InvalidOperationException();
 
    }
 
    internal sealed class PropertyAccessor<TProperty> : PropertyAccessor
    {
 
        public static PropertyAccessor<TProperty> LazyGet(ref PropertyAccessor<TProperty> location, Type type, string name)
        {
            return AccessorUtil.LazyGet(ref location, () => new PropertyAccessor<TProperty>(type, name));
        }
 
        Func<TProperty> getter;
        Action<TProperty> setter;
 
        public PropertyAccessor(Type type, string name) :
            base(type, name)
        {
 
        }
 
        Func<TProperty> Getter => AccessorUtil.LazyGet(ref getter, MakeGetter);
 
        Action<TProperty> Setter => AccessorUtil.LazyGet(ref setter, MakeSetter);
 
        Func<TProperty> MakeGetter()
        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<PropertyAccessorGet>__{Type.Name.Replace(".", "_")}__{Property.Name}", Type, false, typeof(TProperty), Array.Empty<Type>());
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(Property.GetMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, Property.GetMethod);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (Func<TProperty>)dm.CreateDelegate(typeof(Func<TProperty>));
#endif
        }
 
        Action<TProperty> MakeSetter()
        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<PropertyAccessorSet>__{Type.Name.Replace(".", "_")}__{Property.Name}", Type, false, typeof(void), new[] { typeof(TProperty) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(Property.SetMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, Property.SetMethod);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (Action<TProperty>)dm.CreateDelegate(typeof(Action<TProperty>));
#endif
        }
 
        public TProperty GetValue() => Getter();
 
        public void SetValue(TProperty value) => Setter(value);
 
    }
 
    internal sealed class PropertyAccessor<TObject, TProperty> : PropertyAccessor
    {
 
        public static PropertyAccessor<TObject, TProperty> LazyGet(ref PropertyAccessor<TObject, TProperty> location, Type type, string name)
        {
            return AccessorUtil.LazyGet(ref location, () => new PropertyAccessor<TObject, TProperty>(type, name));
        }
 
        Func<TObject, TProperty> getter;
        Action<TObject, TProperty> setter;
 
        public PropertyAccessor(Type type, string name) :
            base(type, name)
        {
 
        }
 
        Func<TObject, TProperty> Getter => AccessorUtil.LazyGet(ref getter, MakeGetter);
 
        Action<TObject, TProperty> Setter => AccessorUtil.LazyGet(ref setter, MakeSetter);
 
        Func<TObject, TProperty> MakeGetter()
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            if (Property.CanRead == false)
                throw new InternalException($"Property {Property.Name} cannot be read.");
 
            var dm = DynamicMethodUtil.Create($"__<PropertyAccessorGet>__{Property.DeclaringType.Name.Replace(".", "_")}__{Property.Name}", Type, false, typeof(TProperty), new[] { typeof(TObject) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, Type);
            il.Emit(Property.GetMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, Property.GetMethod);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (Func<TObject, TProperty>)dm.CreateDelegate(typeof(Func<TObject, TProperty>));
#endif
        }
 
        Action<TObject, TProperty> MakeSetter()
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            if (Property.CanWrite == false)
                throw new InternalException($"Property {Property.Name} cannot be written.");
 
            var dm = DynamicMethodUtil.Create($"__<PropertyAccessorSet>__{Property.DeclaringType.Name.Replace(".", "_")}__{Property.Name}", Type, false, typeof(void), new[] { typeof(TObject), typeof(TProperty) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, Type);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(Property.SetMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, Property.SetMethod);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (Action<TObject, TProperty>)dm.CreateDelegate(typeof(Action<TObject, TProperty>));
#endif
        }
 
        public TProperty GetValue(TObject self) => Getter(self);
 
        public void SetValue(TObject self, TProperty value) => Setter(self, value);
 
    }
 
#endif
 
}