private void InitAccessors()
{
if (!this.hasAccessors)
{
lock (this.locktarget)
{
if (!this.hasAccessors)
{
if (this.storageMember != null)
{
this.accPrivate = MakeMemberAccessor(this.member.ReflectedType, this.storageMember, null);
if (this.isDeferred)
{
MakeDeferredAccessors(this.member.ReflectedType, this.accPrivate, out this.accPrivate, out this.accDefValue, out this.accDefSource);
}
this.accPublic = MakeMemberAccessor(this.member.ReflectedType, this.member, this.accPrivate);
}
else
{
this.accPublic = this.accPrivate = MakeMemberAccessor(this.member.ReflectedType, this.member, null);
if (this.isDeferred)
{
MakeDeferredAccessors(this.member.ReflectedType, this.accPrivate, out this.accPrivate, out this.accDefValue, out this.accDefSource);
}
}
this.hasAccessors = true;
}
}
}
}
private static void MakeDeferredAccessors(
Type objectDeclaringType, MetaAccessor accessor,
out MetaAccessor accessorValue, out MetaAccessor accessorDeferredValue, out MetaAccessor accessorDeferredSource
)
{
if (accessor.Type.IsGenericType)
{
Type gtype = accessor.Type.GetGenericTypeDefinition();
Type itemType = accessor.Type.GetGenericArguments()[0];
if (gtype == typeof(Link <>))
{
accessorValue = CreateAccessor(typeof(LinkValueAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
accessorDeferredValue = CreateAccessor(typeof(LinkDefValueAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
accessorDeferredSource = CreateAccessor(typeof(LinkDefSourceAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
return;
}
else if (typeof(EntityRef <>).IsAssignableFrom(gtype))
{
accessorValue = CreateAccessor(typeof(EntityRefValueAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
accessorDeferredValue = CreateAccessor(typeof(EntityRefDefValueAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
accessorDeferredSource = CreateAccessor(typeof(EntityRefDefSourceAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
return;
}
else if (typeof(EntitySet <>).IsAssignableFrom(gtype))
{
accessorValue = CreateAccessor(typeof(EntitySetValueAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
accessorDeferredValue = CreateAccessor(typeof(EntitySetDefValueAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
accessorDeferredSource = CreateAccessor(typeof(EntitySetDefSourceAccessor <,>).MakeGenericType(objectDeclaringType, itemType), accessor);
return;
}
}
throw Error.UnhandledDeferredStorageType(accessor.Type);
}
private void InitAccessors()
{
if(!this.hasAccessors)
{
lock(this.locktarget)
{
if(!this.hasAccessors)
{
if(this.storageMember != null)
{
this.accPrivate = MakeMemberAccessor(this.member.ReflectedType, this.storageMember, null);
if(this.isDeferred)
{
MakeDeferredAccessors(this.member.ReflectedType, this.accPrivate, out this.accPrivate, out this.accDefValue, out this.accDefSource);
}
this.accPublic = MakeMemberAccessor(this.member.ReflectedType, this.member, this.accPrivate);
}
else
{
this.accPublic = this.accPrivate = MakeMemberAccessor(this.member.ReflectedType, this.member, null);
if(this.isDeferred)
{
MakeDeferredAccessors(this.member.ReflectedType, this.accPrivate, out this.accPrivate, out this.accDefValue, out this.accDefSource);
}
}
this.hasAccessors = true;
}
}
}
}
private void InitAccessors()
{
if (areAccessorsInitialized)
{
return;
}
lock (metaDataMemberLock)
{
if (areAccessorsInitialized)
{
return;
}
if (DoesRequireProxy)
{
storageAccessor = MakeProxyAccessor(member.ReflectedType, member);
if (isDeferred)
{
MakeDeferredAccessors(
member.ReflectedType,
storageAccessor,
out storageAccessor,
out deferredValueAccessor,
out deferredSourceAccessor);
}
memberAccessor = MakeMemberAccessor(member.ReflectedType, member, storageAccessor);
}
else if (storageMember == null)
{
memberAccessor = storageAccessor = MakeMemberAccessor(member.ReflectedType, member, null);
if (isDeferred)
{
MakeDeferredAccessors(
member.ReflectedType,
storageAccessor,
out storageAccessor,
out deferredValueAccessor,
out deferredSourceAccessor);
}
}
else
{
storageAccessor = MakeMemberAccessor(member.ReflectedType, storageMember, null);
if (isDeferred)
{
MakeDeferredAccessors(
member.ReflectedType,
storageAccessor,
out storageAccessor,
out deferredValueAccessor,
out deferredSourceAccessor);
}
memberAccessor = MakeMemberAccessor(member.ReflectedType, member, storageAccessor);
}
areAccessorsInitialized = true;
}
}
internal Accessor(PropertyInfo pi, DGet <T, V> dget, DSet <T, V> dset, DRSet <T, V> drset, MetaAccessor <T, V2> storage)
{
this.pi = pi;
this.dget = dget;
this.dset = dset;
this.drset = drset;
this.storage = storage;
}
private void InitAccessors()
{
if(this.accPublic == null)
{
lock(this.lockTarget)
{
if(this.accPublic == null)
{
this.accPublic = MakeMemberAccessor(this.member.ReflectedType, this.member);
}
}
}
}
private void InitAccessors()
{
if (this.accPublic == null)
{
lock (this.lockTarget)
{
if (this.accPublic == null)
{
this.accPublic = MakeMemberAccessor(this.member.ReflectedType, this.member);
}
}
}
}
internal static MetaAccessor Create(Type objectType, PropertyInfo pi, MetaAccessor storageAccessor)
{
Delegate dset = null;
Delegate drset = null;
Type dgetType = typeof(DGet <,>).MakeGenericType(objectType, pi.PropertyType);
MethodInfo getMethod = pi.GetGetMethod(true);
Delegate dget = Delegate.CreateDelegate(dgetType, getMethod, true);
if (dget == null)
{
throw Error.CouldNotCreateAccessorToProperty(objectType, pi.PropertyType, pi);
}
if (pi.CanWrite)
{
if (!objectType.IsValueType)
{
dset = Delegate.CreateDelegate(typeof(DSet <,>).MakeGenericType(objectType, pi.PropertyType), pi.GetSetMethod(true), true);
}
else
{
DynamicMethod mset = new DynamicMethod(
"xset_" + pi.Name,
typeof(void),
new Type[] { objectType.MakeByRefType(), pi.PropertyType },
true
);
ILGenerator gen = mset.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
if (!objectType.IsValueType)
{
gen.Emit(OpCodes.Ldind_Ref);
}
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Call, pi.GetSetMethod(true));
gen.Emit(OpCodes.Ret);
drset = mset.CreateDelegate(typeof(DRSet <,>).MakeGenericType(objectType, pi.PropertyType));
}
}
Type saType = (storageAccessor != null) ? storageAccessor.Type : pi.PropertyType;
return((MetaAccessor)Activator.CreateInstance(
typeof(Accessor <, ,>).MakeGenericType(objectType, pi.PropertyType, saType),
BindingFlags.Instance | BindingFlags.NonPublic, null,
new object[] { pi, dget, dset, drset, storageAccessor }, null
));
}
private static MetaAccessor MakeMemberAccessor(Type accessorType, MemberInfo mi)
{
FieldInfo fi = mi as FieldInfo;
MetaAccessor acc = null;
if (fi != null)
{
acc = FieldAccessor.Create(accessorType, fi);
}
else
{
PropertyInfo pi = (PropertyInfo)mi;
acc = PropertyAccessor.Create(accessorType, pi, null);
}
return(acc);
}
private static MetaAccessor MakeMemberAccessor(Type accessorType, MemberInfo mi, MetaAccessor storage)
{
FieldInfo fi = mi as FieldInfo;
MetaAccessor acc = null;
if(fi != null)
{
acc = FieldAccessor.Create(accessorType, fi);
}
else
{
PropertyInfo pi = (PropertyInfo)mi;
acc = PropertyAccessor.Create(accessorType, pi, storage);
}
return acc;
}
private static MetaAccessor MakeMemberAccessor(Type accessorType, MemberInfo member, MetaAccessor storageAccessor)
{
var field = member as FieldInfo;
if (field != null)
{
return(FieldAccessor.Create(accessorType, field));
}
var property = (PropertyInfo)member;
return(PropertyAccessor.Create(accessorType, property, storageAccessor));
}
internal EntitySetDefSourceAccessor(MetaAccessor <T, EntitySet <V> > acc)
{
this.acc = acc;
}
internal EntitySetValueAccessor(MetaAccessor <T, EntitySet <V> > acc)
{
this.acc = acc;
}
internal LinkValueAccessor(MetaAccessor <T, Link <V> > acc)
{
this.acc = acc;
}
private static void MakeDeferredAccessors(
Type declaringType, MetaAccessor accessor,
out MetaAccessor accessorValue, out MetaAccessor accessorDeferredValue, out MetaAccessor accessorDeferredSource
)
{
if(accessor.Type.IsGenericType)
{
Type gtype = accessor.Type.GetGenericTypeDefinition();
Type itemType = accessor.Type.GetGenericArguments()[0];
if(gtype == typeof(Link<>))
{
accessorValue = CreateAccessor(typeof(LinkValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
accessorDeferredValue = CreateAccessor(typeof(LinkDefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
accessorDeferredSource = CreateAccessor(typeof(LinkDefSourceAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
return;
}
else if(typeof(EntityRef<>).IsAssignableFrom(gtype))
{
accessorValue = CreateAccessor(typeof(EntityRefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
accessorDeferredValue = CreateAccessor(typeof(EntityRefDefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
accessorDeferredSource = CreateAccessor(typeof(EntityRefDefSourceAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
return;
}
else if(typeof(EntitySet<>).IsAssignableFrom(gtype))
{
accessorValue = CreateAccessor(typeof(EntitySetValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
accessorDeferredValue = CreateAccessor(typeof(EntitySetDefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
accessorDeferredSource = CreateAccessor(typeof(EntitySetDefSourceAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
return;
}
}
throw Error.UnhandledDeferredStorageType(accessor.Type);
}
internal LinkDefSourceAccessor(MetaAccessor <T, Link <V> > acc)
{
this.acc = acc;
}
internal EntityRefDefValueAccessor(MetaAccessor <T, EntityRef <V> > acc)
{
this.acc = acc;
}
