private static EntityProxyTypeInfo BuildType(
ModuleBuilder moduleBuilder,
ClrEntityType ospaceEntityType,
MetadataWorkspace workspace)
{
EntityProxyFactory.ProxyTypeBuilder proxyTypeBuilder = new EntityProxyFactory.ProxyTypeBuilder(ospaceEntityType);
Type type = proxyTypeBuilder.CreateType(moduleBuilder);
EntityProxyTypeInfo proxyTypeInfo;
if (type != (Type)null)
{
Assembly assembly = type.Assembly();
if (!EntityProxyFactory._proxyRuntimeAssemblies.Contains(assembly))
{
EntityProxyFactory._proxyRuntimeAssemblies.Add(assembly);
EntityProxyFactory.AddAssemblyToResolveList(assembly);
}
proxyTypeInfo = new EntityProxyTypeInfo(type, ospaceEntityType, proxyTypeBuilder.CreateInitalizeCollectionMethod(type), proxyTypeBuilder.BaseGetters, proxyTypeBuilder.BaseSetters, workspace);
foreach (EdmMember lazyLoadMember in proxyTypeBuilder.LazyLoadMembers)
{
EntityProxyFactory.InterceptMember(lazyLoadMember, type, proxyTypeInfo);
}
EntityProxyFactory.SetResetFKSetterFlagDelegate(type, proxyTypeInfo);
EntityProxyFactory.SetCompareByteArraysDelegate(type);
}
else
{
proxyTypeInfo = (EntityProxyTypeInfo)null;
}
return(proxyTypeInfo);
}
// See IPropertyAccessorStrategy
public void SetNavigationPropertyValue(RelatedEnd relatedEnd, object value)
{
if (relatedEnd != null)
{
if (relatedEnd.TargetAccessor.ValueSetter == null)
{
var type = GetDeclaringType(relatedEnd);
var propertyInfo = type.GetTopProperty(relatedEnd.TargetAccessor.PropertyName);
if (propertyInfo == null)
{
throw new EntityException(
Strings.PocoEntityWrapper_UnableToSetFieldOrProperty(relatedEnd.TargetAccessor.PropertyName, type.FullName));
}
var factory = new EntityProxyFactory();
relatedEnd.TargetAccessor.ValueSetter = factory.CreateBaseSetter(propertyInfo.DeclaringType, propertyInfo);
}
try
{
relatedEnd.TargetAccessor.ValueSetter(_entity, value);
}
catch (Exception ex)
{
throw new EntityException(
Strings.PocoEntityWrapper_UnableToSetFieldOrProperty(
relatedEnd.TargetAccessor.PropertyName, _entity.GetType().FullName), ex);
}
}
}
private static Func <object, IEntityWrapper> CreateWrapperDelegate(Type entityType)
{
// For entities that implement all our interfaces we create a special lightweight wrapper that is both
// smaller and faster than the strategy-based wrapper.
// Otherwise, the wrapper is provided with different delegates depending on which interfaces are implemented.
var isIEntityWithRelationships = typeof(IEntityWithRelationships).IsAssignableFrom(entityType);
var isIEntityWithChangeTracker = typeof(IEntityWithChangeTracker).IsAssignableFrom(entityType);
var isIEntityWithKey = typeof(IEntityWithKey).IsAssignableFrom(entityType);
var isProxy = EntityProxyFactory.IsProxyType(entityType);
MethodInfo createDelegate;
if (isIEntityWithRelationships &&
isIEntityWithChangeTracker &&
isIEntityWithKey &&
!isProxy)
{
createDelegate = typeof(EntityWrapperFactory).GetMethod(
"CreateWrapperDelegateTypedLightweight", BindingFlags.NonPublic | BindingFlags.Static);
}
else if (isIEntityWithRelationships)
{
// This type of strategy wrapper is used when the entity implements IEntityWithRelationships
// In this case it is important that the entity itself is used to create the RelationshipManager
createDelegate = typeof(EntityWrapperFactory).GetMethod(
"CreateWrapperDelegateTypedWithRelationships", BindingFlags.NonPublic | BindingFlags.Static);
}
else
{
createDelegate = typeof(EntityWrapperFactory).GetMethod(
"CreateWrapperDelegateTypedWithoutRelationships", BindingFlags.NonPublic | BindingFlags.Static);
}
createDelegate = createDelegate.MakeGenericMethod(entityType);
return((Func <object, IEntityWrapper>)createDelegate.Invoke(null, new object[0]));
}
/// <summary>
/// Called to create a new wrapper outside of the normal materialization process.
/// This method is typically used when a new entity is created outside the context and then is
/// added or attached. The materializer bypasses this method and calls wrapper constructors
/// directory for performance reasons.
/// This method does not check whether or not the wrapper already exists in the context.
/// </summary>
/// <param name="entity"> The entity for which a wrapper will be created </param>
/// <param name="key"> The key associated with that entity, or null </param>
/// <returns> The new wrapper instance </returns>
internal static IEntityWrapper CreateNewWrapper(object entity, EntityKey key)
{
Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity.");
if (entity == null)
{
return(NullEntityWrapper.NullWrapper);
}
// We used a cache of functions based on the actual type of entity that we need to wrap.
// Creatung these functions is slow, but once they are created they are relatively fast.
var wrappedEntity = _delegateCache.Evaluate(entity.GetType())(entity);
wrappedEntity.RelationshipManager.SetWrappedOwner(wrappedEntity, entity);
// We cast to object here to avoid calling the overridden != operator on EntityKey.
// This creates a very small perf gain, which is none-the-less significant for lean no-tracking cases.
if ((object)key != null &&
(object)wrappedEntity.EntityKey == null)
{
wrappedEntity.EntityKey = key;
}
// If the entity is a proxy, set the wrapper to match
EntityProxyTypeInfo proxyTypeInfo;
if (EntityProxyFactory.TryGetProxyType(entity.GetType(), out proxyTypeInfo))
{
proxyTypeInfo.SetEntityWrapper(wrappedEntity);
}
return(wrappedEntity);
}
public object GetNavigationPropertyValue(RelatedEnd relatedEnd)
{
object obj = (object)null;
if (relatedEnd != null)
{
if (relatedEnd.TargetAccessor.ValueGetter == null)
{
Type declaringType = PocoPropertyAccessorStrategy.GetDeclaringType(relatedEnd);
PropertyInfo topProperty = declaringType.GetTopProperty(relatedEnd.TargetAccessor.PropertyName);
if (topProperty == (PropertyInfo)null)
{
throw new EntityException(Strings.PocoEntityWrapper_UnableToSetFieldOrProperty((object)relatedEnd.TargetAccessor.PropertyName, (object)declaringType.FullName));
}
EntityProxyFactory entityProxyFactory = new EntityProxyFactory();
relatedEnd.TargetAccessor.ValueGetter = entityProxyFactory.CreateBaseGetter(topProperty.DeclaringType, topProperty);
}
bool state = relatedEnd.DisableLazyLoading();
try
{
obj = relatedEnd.TargetAccessor.ValueGetter(this._entity);
}
catch (Exception ex)
{
throw new EntityException(Strings.PocoEntityWrapper_UnableToSetFieldOrProperty((object)relatedEnd.TargetAccessor.PropertyName, (object)this._entity.GetType().FullName), ex);
}
finally
{
relatedEnd.ResetLazyLoading(state);
}
}
return(obj);
}
public void SetNavigationPropertyValue(RelatedEnd relatedEnd, object value)
{
if (relatedEnd == null)
{
return;
}
if (relatedEnd.TargetAccessor.ValueSetter == null)
{
Type declaringType = PocoPropertyAccessorStrategy.GetDeclaringType(relatedEnd);
PropertyInfo topProperty = declaringType.GetTopProperty(relatedEnd.TargetAccessor.PropertyName);
if (topProperty == (PropertyInfo)null)
{
throw new EntityException(Strings.PocoEntityWrapper_UnableToSetFieldOrProperty((object)relatedEnd.TargetAccessor.PropertyName, (object)declaringType.FullName));
}
EntityProxyFactory entityProxyFactory = new EntityProxyFactory();
relatedEnd.TargetAccessor.ValueSetter = entityProxyFactory.CreateBaseSetter(topProperty.DeclaringType, topProperty);
}
try
{
relatedEnd.TargetAccessor.ValueSetter(this._entity, value);
}
catch (Exception ex)
{
throw new EntityException(Strings.PocoEntityWrapper_UnableToSetFieldOrProperty((object)relatedEnd.TargetAccessor.PropertyName, (object)this._entity.GetType().FullName), ex);
}
}
// See IPropertyAccessorStrategy
public object GetNavigationPropertyValue(RelatedEnd relatedEnd)
{
object navPropValue = null;
if (relatedEnd != null)
{
if (relatedEnd.TargetAccessor.ValueGetter == null)
{
var type = GetDeclaringType(relatedEnd);
var propertyInfo = EntityUtil.GetTopProperty(ref type, relatedEnd.TargetAccessor.PropertyName);
if (propertyInfo == null)
{
throw new EntityException(
Strings.PocoEntityWrapper_UnableToSetFieldOrProperty(relatedEnd.TargetAccessor.PropertyName, type.FullName));
}
var factory = new EntityProxyFactory();
relatedEnd.TargetAccessor.ValueGetter = factory.CreateBaseGetter(type, propertyInfo);
}
try
{
navPropValue = relatedEnd.TargetAccessor.ValueGetter(_entity);
}
catch (Exception ex)
{
throw new EntityException(
Strings.PocoEntityWrapper_UnableToSetFieldOrProperty(
relatedEnd.TargetAccessor.PropertyName, _entity.GetType().FullName), ex);
}
}
return(navPropValue);
}
private static void SetResetFKSetterFlagDelegate(
Type proxyType,
EntityProxyTypeInfo proxyTypeInfo)
{
FieldInfo field = proxyType.GetField("_resetFKSetterFlag", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.NonPublic);
EntityProxyFactory.AssignInterceptionDelegate((Delegate)EntityProxyFactory.GetResetFKSetterFlagDelegate(proxyTypeInfo.EntityWrapperDelegate), field);
}
private static Func <object, IEntityWrapper> CreateWrapperDelegate(
Type entityType)
{
bool flag1 = typeof(IEntityWithRelationships).IsAssignableFrom(entityType);
bool flag2 = typeof(IEntityWithChangeTracker).IsAssignableFrom(entityType);
bool flag3 = typeof(IEntityWithKey).IsAssignableFrom(entityType);
bool flag4 = EntityProxyFactory.IsProxyType(entityType);
return((Func <object, IEntityWrapper>)(!flag1 || !flag2 || (!flag3 || flag4) ? (!flag1 ? EntityWrapperFactory.CreateWrapperDelegateTypedWithoutRelationshipsMethod : EntityWrapperFactory.CreateWrapperDelegateTypedWithRelationshipsMethod) : EntityWrapperFactory.CreateWrapperDelegateTypedLightweightMethod).MakeGenericMethod(entityType).Invoke((object)null, new object[0]));
}
internal static bool TryGetProxyWrapper(object instance, out IEntityWrapper wrapper)
{
wrapper = (IEntityWrapper)null;
EntityProxyTypeInfo proxyTypeInfo;
if (EntityProxyFactory.IsProxyType(instance.GetType()) && EntityProxyFactory.TryGetProxyType(instance.GetType(), out proxyTypeInfo))
{
wrapper = proxyTypeInfo.GetEntityWrapper(instance);
}
return(wrapper != null);
}
private void CheckType(EntityType ospaceEntityType)
{
_scalarMembers = new HashSet <EdmMember>();
_relationshipMembers = new HashSet <EdmMember>();
foreach (var member in ospaceEntityType.Members)
{
var clrProperty = ospaceEntityType.ClrType.GetTopProperty(member.Name);
if (clrProperty != null &&
EntityProxyFactory.CanProxySetter(clrProperty))
{
if (member.BuiltInTypeKind
== BuiltInTypeKind.EdmProperty)
{
if (_implementIEntityWithChangeTracker)
{
_scalarMembers.Add(member);
}
}
else if (member.BuiltInTypeKind
== BuiltInTypeKind.NavigationProperty)
{
if (_implementIEntityWithRelationships)
{
var navProperty = (NavigationProperty)member;
var multiplicity = navProperty.ToEndMember.RelationshipMultiplicity;
if (multiplicity == RelationshipMultiplicity.Many)
{
if (clrProperty.PropertyType.IsGenericType()
&&
clrProperty.PropertyType.GetGenericTypeDefinition() == typeof(ICollection <>))
{
_relationshipMembers.Add(member);
}
}
else
{
_relationshipMembers.Add(member);
}
}
}
}
}
if (ospaceEntityType.Members.Count
!= _scalarMembers.Count + _relationshipMembers.Count)
{
_scalarMembers.Clear();
_relationshipMembers.Clear();
_implementIEntityWithChangeTracker = false;
_implementIEntityWithRelationships = false;
}
}
internal static IEnumerable <AssociationType> TryGetAllAssociationTypesFromProxyInfo(
IEntityWrapper wrappedEntity)
{
EntityProxyTypeInfo proxyTypeInfo;
if (!EntityProxyFactory.TryGetProxyType(wrappedEntity.Entity.GetType(), out proxyTypeInfo))
{
return((IEnumerable <AssociationType>)null);
}
return(proxyTypeInfo.GetAllAssociationTypes());
}
private void CheckType(EntityType ospaceEntityType)
{
this._members = new HashSet <EdmMember>();
foreach (EdmMember member in ospaceEntityType.Members)
{
PropertyInfo topProperty = ospaceEntityType.ClrType.GetTopProperty(member.Name);
if (topProperty != (PropertyInfo)null && EntityProxyFactory.CanProxyGetter(topProperty) && LazyLoadBehavior.IsLazyLoadCandidate(ospaceEntityType, member))
{
this._members.Add(member);
}
}
}
internal virtual IEntityWrapper WrapEntityUsingStateManagerGettingEntry(
object entity,
ObjectStateManager stateManager,
out EntityEntry existingEntry)
{
IEntityWrapper wrapper = (IEntityWrapper)null;
existingEntry = (EntityEntry)null;
if (entity == null)
{
return(NullEntityWrapper.NullWrapper);
}
if (stateManager != null)
{
existingEntry = stateManager.FindEntityEntry(entity);
if (existingEntry != null)
{
return(existingEntry.WrappedEntity);
}
if (stateManager.TransactionManager.TrackProcessedEntities && stateManager.TransactionManager.WrappedEntities.TryGetValue(entity, out wrapper))
{
return(wrapper);
}
}
IEntityWithRelationships withRelationships = entity as IEntityWithRelationships;
if (withRelationships != null)
{
RelationshipManager relationshipManager = withRelationships.RelationshipManager;
if (relationshipManager == null)
{
throw new InvalidOperationException(Strings.RelationshipManager_UnexpectedNull);
}
IEntityWrapper wrappedOwner = relationshipManager.WrappedOwner;
if (!object.ReferenceEquals(wrappedOwner.Entity, entity))
{
throw new InvalidOperationException(Strings.RelationshipManager_InvalidRelationshipManagerOwner);
}
return(wrappedOwner);
}
EntityProxyFactory.TryGetProxyWrapper(entity, out wrapper);
if (wrapper == null)
{
IEntityWithKey entityWithKey = entity as IEntityWithKey;
wrapper = EntityWrapperFactory.CreateNewWrapper(entity, entityWithKey == null ? (EntityKey)null : entityWithKey.EntityKey);
}
if (stateManager != null && stateManager.TransactionManager.TrackProcessedEntities)
{
stateManager.TransactionManager.WrappedEntities.Add(entity, wrapper);
}
return(wrapper);
}
private static void InterceptMember(
EdmMember member,
Type proxyType,
EntityProxyTypeInfo proxyTypeInfo)
{
PropertyInfo topProperty = proxyType.GetTopProperty(member.Name);
FieldInfo field = proxyType.GetField(LazyLoadImplementor.GetInterceptorFieldName(member.Name), BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.NonPublic);
EntityProxyFactory.AssignInterceptionDelegate(EntityProxyFactory.GetInterceptorDelegateMethod.MakeGenericMethod(proxyType, topProperty.PropertyType).Invoke((object)null, new object[2]
{
(object)member,
(object)proxyTypeInfo.EntityWrapperDelegate
}) as Delegate, field);
}
/// <summary>
/// Constructs a wrapper for the given entity.
/// Note: use EntityWrapperFactory instead of calling this constructor directly.
/// </summary>
/// <param name="entity"> The entity to wrap </param>
internal LightweightEntityWrapper(TEntity entity)
: base(entity, entity.RelationshipManager)
{
Debug.Assert(
entity is IEntityWithChangeTracker,
"LightweightEntityWrapper only works with entities that implement IEntityWithChangeTracker");
Debug.Assert(
entity is IEntityWithRelationships,
"LightweightEntityWrapper only works with entities that implement IEntityWithRelationships");
Debug.Assert(entity is IEntityWithKey, "LightweightEntityWrapper only works with entities that implement IEntityWithKey");
Debug.Assert(
!EntityProxyFactory.IsProxyType(entity.GetType()), "LightweightEntityWrapper only works with entities that are not proxies");
_entity = entity;
}
internal static bool TryGetAssociationTypeFromProxyInfo(
IEntityWrapper wrappedEntity,
string relationshipName,
out AssociationType associationType)
{
associationType = (AssociationType)null;
EntityProxyTypeInfo proxyTypeInfo;
if (EntityProxyFactory.TryGetProxyType(wrappedEntity.Entity.GetType(), out proxyTypeInfo) && proxyTypeInfo != null)
{
return(proxyTypeInfo.TryGetNavigationPropertyAssociationType(relationshipName, out associationType));
}
return(false);
}
public void TryGetAssociationTypeFromProxyInfo_can_get_association_using_full_name()
{
using (var context = new RelationshipsContext())
{
var proxy = context.WithRelationships.Create();
var mockWrapper = new Mock <IEntityWrapper>();
mockWrapper.Setup(m => m.Entity).Returns(proxy);
AssociationType associationType;
Assert.True(EntityProxyFactory.TryGetAssociationTypeFromProxyInfo(
mockWrapper.Object, "System.Data.Entity.Core.Objects.Internal.ProxyWithRelationships_ManyToOnes", out associationType));
Assert.Equal("System.Data.Entity.Core.Objects.Internal.ProxyWithRelationships_ManyToOnes", associationType.FullName);
}
}
private static bool TrySetBasePropertyValue(
Type proxyType,
string propertyName,
object entity,
object value)
{
EntityProxyTypeInfo proxyTypeInfo;
if (!EntityProxyFactory.TryGetProxyType(proxyType, out proxyTypeInfo) || !proxyTypeInfo.ContainsBaseSetter(propertyName))
{
return(false);
}
proxyTypeInfo.BaseSetter(entity, propertyName, value);
return(true);
}
/// <summary>
/// Constructs a wrapper as part of the materialization process. This constructor is only used
/// during materialization where it is known that the entity being wrapped is newly constructed.
/// This means that some checks are not performed that might be needed when thw wrapper is
/// created at other times, and information such as the identity type is passed in because
/// it is readily available in the materializer.
/// </summary>
/// <param name="entity"> The entity to wrap </param>
/// <param name="key"> The key for the entity </param>
/// <param name="entitySet"> The entity set, or null if none is known </param>
/// <param name="context"> The context to which the entity should be attached </param>
/// <param name="mergeOption"> NoTracking for non-tracked entities, AppendOnly otherwise </param>
/// <param name="identityType"> The type of the entity ignoring any possible proxy type </param>
internal LightweightEntityWrapper(
TEntity entity, EntityKey key, EntitySet entitySet, ObjectContext context, MergeOption mergeOption, Type identityType, bool overridesEquals)
: base(entity, entity.RelationshipManager, entitySet, context, mergeOption, identityType, overridesEquals)
{
Debug.Assert(
entity is IEntityWithChangeTracker,
"LightweightEntityWrapper only works with entities that implement IEntityWithChangeTracker");
Debug.Assert(
entity is IEntityWithRelationships,
"LightweightEntityWrapper only works with entities that implement IEntityWithRelationships");
Debug.Assert(entity is IEntityWithKey, "LightweightEntityWrapper only works with entities that implement IEntityWithKey");
Debug.Assert(
!EntityProxyFactory.IsProxyType(entity.GetType()), "LightweightEntityWrapper only works with entities that are not proxies");
_entity = entity;
_entity.EntityKey = key;
}
private void CheckType(EntityType ospaceEntityType)
{
_members = new HashSet <EdmMember>();
foreach (var member in ospaceEntityType.Members)
{
var clrProperty = EntityUtil.GetTopProperty(ospaceEntityType.ClrType, member.Name);
if (clrProperty != null
&&
EntityProxyFactory.CanProxyGetter(clrProperty)
&&
LazyLoadBehavior.IsLazyLoadCandidate(ospaceEntityType, member))
{
_members.Add(member);
}
}
}
public void TryGetAllAssociationTypesFromProxyInfo_returns_all_associations_with_no_duplicates()
{
using (var context = new RelationshipsContext())
{
var proxy = context.WithRelationships.Create();
var mockWrapper = new Mock <IEntityWrapper>();
mockWrapper.Setup(m => m.Entity).Returns(proxy);
var associations = EntityProxyFactory.TryGetAllAssociationTypesFromProxyInfo(mockWrapper.Object).Select(a => a.Name);
Assert.Equal(3, associations.Count());
Assert.Contains("ProxyWithRelationships_OneToOne", associations);
Assert.Contains("ProxyOneToMany_WithRelationships", associations);
Assert.Contains("ProxyWithRelationships_ManyToOnes", associations);
}
}
internal static void TryCreateProxyTypes(
IEnumerable <EntityType> ospaceEntityTypes,
MetadataWorkspace workspace)
{
EntityProxyFactory._typeMapLock.EnterUpgradeableReadLock();
try
{
foreach (EntityType ospaceEntityType in ospaceEntityTypes)
{
EntityProxyFactory.TryCreateProxyType(ospaceEntityType, workspace);
}
}
finally
{
EntityProxyFactory._typeMapLock.ExitUpgradeableReadLock();
}
}
public virtual Action <object, object> CreateBaseSetter(
Type declaringType,
PropertyInfo propertyInfo)
{
Action <object, object> nonProxySetter = DelegateFactory.CreateNavigationPropertySetter(declaringType, propertyInfo);
string propertyName = propertyInfo.Name;
return((Action <object, object>)((entity, value) =>
{
Type type = entity.GetType();
if (EntityProxyFactory.IsProxyType(type) && EntityProxyFactory.TrySetBasePropertyValue(type, propertyName, entity, value))
{
return;
}
nonProxySetter(entity, value);
}));
}
public virtual Func <object, object> CreateBaseGetter(
Type declaringType,
PropertyInfo propertyInfo)
{
ParameterExpression parameterExpression;
Func <object, object> nonProxyGetter = Expression.Lambda <Func <object, object> >((Expression)Expression.Property((Expression)Expression.Convert((Expression)parameterExpression, declaringType), propertyInfo), parameterExpression).Compile();
string propertyName = propertyInfo.Name;
return((Func <object, object>)(entity =>
{
Type type = entity.GetType();
object obj;
if (EntityProxyFactory.IsProxyType(type) && EntityProxyFactory.TryGetBasePropertyValue(type, propertyName, entity, out obj))
{
return obj;
}
return nonProxyGetter(entity);
}));
}
private static void EmitBaseGetter(
TypeBuilder typeBuilder,
PropertyBuilder propertyBuilder,
PropertyInfo baseProperty)
{
if (!EntityProxyFactory.CanProxyGetter(baseProperty))
{
return;
}
MethodInfo meth = baseProperty.Getter();
MethodAttributes methodAttributes = meth.Attributes & MethodAttributes.MemberAccessMask;
MethodBuilder mdBuilder = typeBuilder.DefineMethod("get_" + baseProperty.Name, methodAttributes | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName, baseProperty.PropertyType, Type.EmptyTypes);
ILGenerator ilGenerator = mdBuilder.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Call, meth);
ilGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(mdBuilder);
}
private void CheckType(EntityType ospaceEntityType)
{
this._scalarMembers = new HashSet <EdmMember>();
this._relationshipMembers = new HashSet <EdmMember>();
foreach (EdmMember member in ospaceEntityType.Members)
{
PropertyInfo topProperty = ospaceEntityType.ClrType.GetTopProperty(member.Name);
if (topProperty != (PropertyInfo)null && EntityProxyFactory.CanProxySetter(topProperty))
{
if (member.BuiltInTypeKind == BuiltInTypeKind.EdmProperty)
{
if (this._implementIEntityWithChangeTracker)
{
this._scalarMembers.Add(member);
}
}
else if (member.BuiltInTypeKind == BuiltInTypeKind.NavigationProperty && this._implementIEntityWithRelationships)
{
if (((NavigationProperty)member).ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
{
if (topProperty.PropertyType.IsGenericType() && topProperty.PropertyType.GetGenericTypeDefinition() == typeof(ICollection <>))
{
this._relationshipMembers.Add(member);
}
}
else
{
this._relationshipMembers.Add(member);
}
}
}
}
if (ospaceEntityType.Members.Count == this._scalarMembers.Count + this._relationshipMembers.Count)
{
return;
}
this._scalarMembers.Clear();
this._relationshipMembers.Clear();
this._implementIEntityWithChangeTracker = false;
this._implementIEntityWithRelationships = false;
}
internal static EntityProxyTypeInfo GetProxyType(
ClrEntityType ospaceEntityType,
MetadataWorkspace workspace)
{
EntityProxyTypeInfo proxyTypeInfo = (EntityProxyTypeInfo)null;
if (EntityProxyFactory.TryGetProxyType(ospaceEntityType.ClrType, ospaceEntityType.CSpaceTypeName, out proxyTypeInfo))
{
proxyTypeInfo?.ValidateType(ospaceEntityType);
return(proxyTypeInfo);
}
EntityProxyFactory._typeMapLock.EnterUpgradeableReadLock();
try
{
return(EntityProxyFactory.TryCreateProxyType((EntityType)ospaceEntityType, workspace));
}
finally
{
EntityProxyFactory._typeMapLock.ExitUpgradeableReadLock();
}
}
internal static IEntityWrapper CreateNewWrapper(object entity, EntityKey key)
{
if (entity == null)
{
return(NullEntityWrapper.NullWrapper);
}
IEntityWrapper entityWrapper = EntityWrapperFactory._delegateCache.Evaluate(entity.GetType())(entity);
entityWrapper.RelationshipManager.SetWrappedOwner(entityWrapper, entity);
if ((object)key != null && (object)entityWrapper.EntityKey == null)
{
entityWrapper.EntityKey = key;
}
EntityProxyTypeInfo proxyTypeInfo;
if (EntityProxyFactory.TryGetProxyType(entity.GetType(), out proxyTypeInfo))
{
proxyTypeInfo.SetEntityWrapper(entityWrapper);
}
return(entityWrapper);
}
// Creates delegates that create strategy objects appropriate for the type of entity.
private static void CreateStrategies <TEntity>(
out Func <object, IPropertyAccessorStrategy> createPropertyAccessorStrategy,
out Func <object, IChangeTrackingStrategy> createChangeTrackingStrategy,
out Func <object, IEntityKeyStrategy> createKeyStrategy)
{
var entityType = typeof(TEntity);
var isIEntityWithRelationships = typeof(IEntityWithRelationships).IsAssignableFrom(entityType);
var isIEntityWithChangeTracker = typeof(IEntityWithChangeTracker).IsAssignableFrom(entityType);
var isIEntityWithKey = typeof(IEntityWithKey).IsAssignableFrom(entityType);
var isProxy = EntityProxyFactory.IsProxyType(entityType);
if (!isIEntityWithRelationships || isProxy)
{
createPropertyAccessorStrategy = GetPocoPropertyAccessorStrategyFunc();
}
else
{
createPropertyAccessorStrategy = GetNullPropertyAccessorStrategyFunc();
}
if (isIEntityWithChangeTracker)
{
createChangeTrackingStrategy = GetEntityWithChangeTrackerStrategyFunc();
}
else
{
createChangeTrackingStrategy = GetSnapshotChangeTrackingStrategyFunc();
}
if (isIEntityWithKey)
{
createKeyStrategy = GetEntityWithKeyStrategyStrategyFunc();
}
else
{
createKeyStrategy = GetPocoEntityKeyStrategyFunc();
}
}
