public void depdendencies_are_incremented_when_property_set()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                var parent  = factory.Create(new Parent {
                    Id = "parent"
                }, session);
                var child = factory.Create(new Child {
                    Id = "child"
                }, session);
                parent.Child = child;

                var parentState = stateTracker.Get(parent);
                Assert.Equal(2, parentState.Dependencies.Sequence);

                var childState = stateTracker.Get(child);
                Assert.Equal(1, childState.Dependencies.Sequence);
            }
        }
Esempio n. 2
0
        /// <exception cref="InvalidOperationException">
        /// Attempt to associate non-null <paramref name="tuple"/> with <paramref name="key"/> of unknown type.
        /// </exception>
        internal EntityState UpdateStateInCache(Key key, Tuple tuple, bool isStale)
        {
            var result = EntityStateCache[key, true];

            if (result == null)
            {
                if (!key.HasExactType && tuple != null)
                {
                    throw Exceptions.InternalError(
                              Strings.ExCannotAssociateNonEmptyEntityStateWithKeyOfUnknownType,
                              OrmLog.Instance);
                }
                result = AddEntityStateToCache(key, tuple, isStale);
                SystemEvents.NotifyEntityMaterialized(result);
                Events.NotifyEntityMaterialized(result);
            }
            else
            {
                if (!result.Key.HasExactType && key.HasExactType)
                {
                    EntityStateCache.RemoveKey(result.Key);
                    result = AddEntityStateToCache(key, tuple, result.IsStale);
                }
                result.Update(tuple);
                result.IsStale = isStale;
                if (IsDebugEventLoggingEnabled)
                {
                    OrmLog.Debug(Strings.LogSessionXUpdatingCacheY, this, result);
                }
            }
            return(result);
        }
        public void properties_which_are_marked_as_ignored_are_not_proxied()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                var item    = new EntityWithIgnoredProperty
                {
                    Id      = "1",
                    Ignored = new AnotherEntity {
                        Id = "2"
                    },
                    Proxied = new AnotherEntity {
                        Id = "3"
                    }
                };
                var proxy = factory.Create(item, session);
                Assert.True(ProxyUtils.IsProxy(proxy));
                Assert.True(ProxyUtils.IsProxy(proxy.Proxied));
                Assert.False(ProxyUtils.IsProxy(proxy.Ignored));
            }
        }
Esempio n. 4
0
        private async ValueTask RemapEntityKeys(KeyMapping keyMapping, bool isAsync, CancellationToken token = default)
        {
            if (keyMapping.Map.Count == 0)
            {
                return;
            }
            using (Activate()) {
                if (!LazyKeyGenerationIsEnabled)
                {
                    await Persist(PersistReason.RemapEntityKeys, isAsync, token).ConfigureAwait(false);

                    Invalidate();
                }
                if (IsDebugEventLoggingEnabled)
                {
                    OrmLog.Debug(Strings.LogSessionXRemappingEntityKeys, this);
                }

                foreach (var entityState in EntityChangeRegistry.GetItems(PersistenceState.New))
                {
                    var key         = entityState.Key;
                    var remappedKey = keyMapping.TryRemapKey(key);
                    if (remappedKey != key)
                    {
                        entityState.RemapKey(remappedKey);
                    }
                    EntityStateCache.Add(entityState);
                }
                ProcessChangesOfEntitySets(entitySetState => entitySetState.RemapKeys(keyMapping));
                EntityEvents.RemapKeys(keyMapping);
            }
        }
        public void objects_with_inheritance_chain_are_proxied_correctly()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new RepositoryFactory(proxyFactory);
            var parentMapper         = new Mock <IMapper <Parent> >();

            repositoryFactory.Register <Parent>(x => parentMapper.Object);
            var childMapper = new Mock <IMapper <Child> >();

            repositoryFactory.Register <Child>(x => childMapper.Object);

            var stateTracker = new EntityStateCache();

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
            {
                var entity = new ParentWithInheritedChild
                {
                    Id   = "1",
                    Type = new SuperTypeA {
                        Id = "1"
                    }
                };
                var proxy = proxyFactory.Create(entity, session);
                Assert.True(proxy.Type is SuperTypeA);
            }
        }
Esempio n. 6
0
 internal void RemapEntityKeys(KeyMapping keyMapping)
 {
     if (keyMapping.Map.Count == 0)
     {
         return;
     }
     using (Activate()) {
         if (!LazyKeyGenerationIsEnabled)
         {
             Persist(PersistReason.RemapEntityKeys);
             Invalidate();
         }
         OrmLog.Debug(Strings.LogSessionXRemappingEntityKeys, this);
         foreach (var entityState in EntityChangeRegistry.GetItems(PersistenceState.New))
         {
             var key         = entityState.Key;
             var remappedKey = keyMapping.TryRemapKey(key);
             if (remappedKey != key)
             {
                 entityState.RemapKey(remappedKey);
             }
             EntityStateCache.Add(entityState);
         }
         ProcessChangesOfEntitySets(entitySetState => entitySetState.RemapKeys(keyMapping));
         EntityEvents.RemapKeys(keyMapping);
     }
 }
Esempio n. 7
0
        internal void RemoveOrCreateRemovedEntity(Type type, Key key, EntityRemoveReason reason)
        {
            // Checking for deleted entity with the same key
            var result = EntityStateCache[key, false];

            if (result != null)
            {
                if (result.PersistenceState == PersistenceState.Removed)
                {
                    return;
                }
                result.Entity.RemoveLaterInternal(reason);
                return;
            }

            EnforceChangeRegistrySizeLimit(); // Must be done before new entity registration
            result = new EntityState(this, key, null)
            {
                PersistenceState = PersistenceState.Removed
            };
            EntityStateCache.Add(result);

            if (IsDebugEventLoggingEnabled)
            {
                OrmLog.Debug(Strings.LogSessionXCachingY, this, result);
            }
        }
        public void nullable_types_are_ignored()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new RepositoryFactory(proxyFactory);
            var parentMapper         = new Mock <IMapper <Parent> >();

            repositoryFactory.Register <Parent>(x => parentMapper.Object);
            var childMapper = new Mock <IMapper <Child> >();

            repositoryFactory.Register <Child>(x => childMapper.Object);

            var stateTracker = new EntityStateCache();

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
            {
                var entity = new EntityWithNullableType
                {
                    Id   = "1",
                    Date = DateTime.Now
                };
                var proxy = proxyFactory.Create(entity, session);
                Assert.NotNull(proxy.Date);
            }
        }
        public void all_objects_in_the_object_graph_are_proxied()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                var item    = new Person
                {
                    Id       = "1",
                    Contacts = new List <Contact>
                    {
                        new Contact {
                            Id = "1"
                        }
                    }
                };
                var proxy = factory.Create(item, session);
                Assert.True(ProxyUtils.IsProxy(proxy));
                Assert.True(proxy.Contacts is ITrackableCollection <Contact>);
                Assert.True(ProxyUtils.IsProxy(proxy.Contacts[0]));
            }
        }
        public void change_tracking_is_applied_when_entity_set_in_constructor()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();

            var mapper            = new Mock <IMapper <Parent> >();
            var repositoryFactory = new Mock <IRepositoryFactory>();

            repositoryFactory.Setup(x => x.Create(It.IsAny <IGraphSession>(), It.IsAny <Type>())).Returns <IGraphSession, Type>((s, t) => new GenericAbstractRepository <Parent>(mapper.Object, s, new DynamicProxyFactory(metadataFactory, new NullLogger())));
            var stateTracker = new EntityStateCache();
            var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var proxy = session.Create(new Parent
                {
                    Id    = "1",
                    Child = new Child {
                        Id = "2"
                    }
                });
                var state = stateTracker.Get(proxy.Child);
                Assert.Equal(EntityStatus.New, state.Status);
            }
        }
Esempio n. 11
0
        // IDisposable implementation

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            if (isDisposed)
            {
                return;
            }
            try {
                OrmLog.Debug(Strings.LogSessionXDisposing, this);

                SystemEvents.NotifyDisposing();
                Events.NotifyDisposing();

                Services.DisposeSafely();
                Handler.DisposeSafely();
                CommandProcessorContextProvider.DisposeSafely();

                Domain.ReleaseSingleConnection();

                disposableSet.DisposeSafely();
                disposableSet = null;

                EntityChangeRegistry.Clear();
                EntitySetChangeRegistry.Clear();
                EntityStateCache.Clear();
                ReferenceFieldsChangesRegistry.Clear();
                NonPairedReferencesRegistry.Clear();
            }
            finally {
                isDisposed = true;
            }
        }
Esempio n. 12
0
        public void factory_creates_meta_data_correctly_from_a_proxy_object()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                var item    = new Parent
                {
                    Id    = "1",
                    Child = new Child {
                        Id = "2"
                    },
                    Children = new List <Child> {
                        new Child {
                            Id = "3"
                        }
                    }
                };
                var proxy          = factory.Create(item, session);
                var parentMetadata = metadataFactory.Create(proxy);
                Assert.Equal("Parent", parentMetadata.Name);

                var childMetadta = metadataFactory.Create(proxy.Child);
                Assert.Equal("Child", childMetadta.Name);
            }
        }
        public void circular_dependencies_are_proxied_correctly()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new RepositoryFactory(proxyFactory);
            var parentMapper         = new Mock <IMapper <Parent> >();

            repositoryFactory.Register <Parent>(x => parentMapper.Object);
            var childMapper = new Mock <IMapper <Child> >();

            repositoryFactory.Register <Child>(x => childMapper.Object);

            var stateTracker = new EntityStateCache();

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
            {
                var a = new EntityA
                {
                    Id = "a"
                };
                var b = new EntityB
                {
                    Id = "b"
                };
                a.EntityB = b;
                b.EntityA = a;
                var proxy = proxyFactory.Create(a, session);
                Assert.NotNull(proxy);
                Assert.NotNull(proxy.EntityB);
                Assert.NotNull(proxy.EntityB.EntityA);
                Assert.Same(proxy, proxy.EntityB.EntityA);
            }
        }
Esempio n. 14
0
        public void dependencies_are_incremented_as_relationships_are_created()
        {
            var stateTracker = new EntityStateCache();
            var stateFactory = new Mock <IEntityStateCacheFactory>();

            stateFactory.Setup(x => x.Create()).Returns(stateTracker);
            var metadataFactory = new AttributeMetadataFactory(new NullLogger());
            var proxyFactory    = new DynamicProxyFactory(metadataFactory, new NullLogger());

            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new RepositoryFactory(proxyFactory);

            repositoryFactory.Register <Organisation>(session => new Mapper <Organisation>(session, metadataFactory));
            repositoryFactory.Register <AccessGroup>(session => new Mapper <AccessGroup>(session, metadataFactory));
            repositoryFactory.Register <Site>(session => new Mapper <Site>(session, metadataFactory));
            repositoryFactory.Register <Person>(session => new Mapper <Person>(session, metadataFactory));
            var sessionFactory = new GraphSessionFactory(queryExecutorFactory.Object, repositoryFactory, stateFactory.Object, proxyFactory);

            using (var session = sessionFactory.OpenSession())
            {
                var organisation = session.Create(new Organisation
                {
                    Id = "organisation"
                });

                var site = session.Create(new Site
                {
                    Id = "site"
                });

                var accessGroup = session.Create(new AccessGroup
                {
                    Id = "accessGroup"
                });

                var person = session.Create(new Person
                {
                    Id = "person"
                });

                organisation.Add(site);
                organisation.Add(accessGroup);
                site.Add(accessGroup);
                person.Add(organisation);
                person.Add(site);

                var organisationMetadata = stateTracker.Get(organisation);
                var siteMetadata         = stateTracker.Get(site);
                var accessGroupMetadata  = stateTracker.Get(accessGroup);
                var personMetadata       = stateTracker.Get(person);

                Assert.Equal(1, accessGroupMetadata.Dependencies.Sequence);
                Assert.Equal(2, siteMetadata.Dependencies.Sequence);
                Assert.Equal(3, organisationMetadata.Dependencies.Sequence);
                Assert.Equal(4, personMetadata.Dependencies.Sequence);
            }
        }
Esempio n. 15
0
        private EntityState AddEntityStateToCache(Key key, Tuple tuple, bool isStale)
        {
            var result = new EntityState(this, key, tuple, isStale)
            {
                PersistenceState = PersistenceState.Synchronized
            };

            EntityStateCache.Add(result);
            OrmLog.Debug(Strings.LogSessionXCachingY, this, result);
            return(result);
        }
        public void interceptors_are_not_created_for_re_entrant_proxies()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new RepositoryFactory(proxyFactory);
            var parentMapper         = new Mock <IMapper <Parent> >();

            repositoryFactory.Register <Parent>(x => parentMapper.Object);
            var childMapper = new Mock <IMapper <Child> >();

            repositoryFactory.Register <Child>(x => childMapper.Object);

            var stateTracker = new EntityStateCache();

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
            {
                var proxy = session.Create(new Parent
                {
                    Id = "1"
                });
                proxy.Child = session.Create(new Child
                {
                    Id = "1"
                });

                var metadata = metadataFactory.Create(proxy);
                var deleted  = ProxyUtils.Flush(proxy, metadata["Child"].Relationship);

                Assert.Equal(0, deleted.SelectMany(x => x.Flush().Cast <object>()).Count());

                var reentrant = session.Create(proxy);
                Assert.Equal(proxy, reentrant);

                metadata = metadataFactory.Create(reentrant);
                deleted  = ProxyUtils.Flush(reentrant, metadata["Child"].Relationship);
                Assert.Equal(0, deleted.SelectMany(x => x.Flush().Cast <object>()).Count());

                proxy.Child = session.Create(new Child
                {
                    Id = "2"
                });
                metadata = metadataFactory.Create(reentrant);
                deleted  = ProxyUtils.Flush(reentrant, metadata["Child"].Relationship);
                Assert.Equal(1, deleted.SelectMany(x => x.Flush().Cast <object>()).Count());
            }
        }
        public void properties_set_during_construction_are_restored_after_proxy_created()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                var item    = new EntityWithPropertiesSetInConstructor("1", "Test");
                var proxy   = factory.Create(item, session);
                Assert.Equal("1", proxy.Id);
                Assert.Equal("Test", proxy.Name);
            }
        }
Esempio n. 18
0
        private async ValueTask DisposeImpl(bool isAsync)
        {
            if (isDisposed)
            {
                return;
            }

            sessionLifetimeToken.Expire();

            try {
                if (IsDebugEventLoggingEnabled)
                {
                    OrmLog.Debug(Strings.LogSessionXDisposing, this);
                }

                SystemEvents.NotifyDisposing();
                Events.NotifyDisposing();

                Services.DisposeSafely();
                if (isAsync)
                {
                    await Handler.DisposeSafelyAsync().ConfigureAwait(false);
                }
                else
                {
                    Handler.DisposeSafely();
                }
                CommandProcessorContextProvider.DisposeSafely();

                Domain.ReleaseSingleConnection();

                disposableSet.DisposeSafely();
                disposableSet = null;

                EntityChangeRegistry.Clear();
                EntitySetChangeRegistry.Clear();
                EntityStateCache.Clear();
                ReferenceFieldsChangesRegistry.Clear();
                NonPairedReferencesRegistry.Clear();
                Extensions.Clear();
            }
            finally {
                isDisposed = true;
            }
        }
        public void an_exception_is_thrown_if_id_null()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                Assert.Throws <PropertyNotSetException>(() =>
                {
                    var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                    var notSet  = new AnotherEntity();
                    factory.Create(notSet, session);
                });
            }
        }
Esempio n. 20
0
        internal EntityState CreateEntityState(Key key, bool failIfStateIsAlreadyBound)
        {
            // Checking for deleted entity with the same key
            var result = EntityStateCache[key, false];

            EnforceChangeRegistrySizeLimit(); // Must be done before new entity registration

            // If type is unknown, we consider tuple is null,
            // so its Entity is considered as non-existing
            Tuple tuple = null;

            if (key.HasExactType)
            {
                // A tuple with all the fields set to default values rather then N/A
                var typeInfo = key.TypeInfo;
                tuple = typeInfo.CreateEntityTuple(key.Value, StorageNode.TypeIdRegistry[typeInfo]);
            }

            if (result == null)
            {
                result = new EntityState(this, key, tuple)
                {
                    PersistenceState = PersistenceState.New
                };
                EntityStateCache.Add(result);
            }
            else
            {
                if (result.Entity != null && !result.Entity.IsRemoved && failIfStateIsAlreadyBound)
                {
                    throw new UniqueConstraintViolationException(string.Format(Strings.ExEntityWithKeyXAlreadyExists, key));
                }
                result.Key              = key;
                result.Tuple            = tuple;
                result.PersistenceState = PersistenceState.New;
            }

            if (IsDebugEventLoggingEnabled)
            {
                OrmLog.Debug(Strings.LogSessionXCachingY, this, result);
            }

            return(result);
        }
        public void a_proxy_is_generated_for_trackable_relationships()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var person = new Person
                {
                    Id      = "1",
                    Name    = "Test",
                    Address = new Address
                    {
                        Id   = "1",
                        Name = "first address"
                    }
                };
                var proxy = proxyFactory.Create(person, session);
                proxy.Address = null;
                proxy.Address = proxyFactory.Create(new Address {
                    Id = "2"
                }, session);
                var metadata = metadataFactory.Create(proxy);
                var trackableRelationships = ProxyUtils.Flush(proxy, metadata["Address"].Relationship).ToList();
                Assert.Equal(1, trackableRelationships.Count);
                foreach (var trackableRelationship in trackableRelationships)
                {
                    var enumerable = trackableRelationship.Flush();
                    var results    = enumerable.Cast <object>().ToList();
                    Assert.Equal(1, results.Count);
                    Assert.Equal("1", ((Address)results[0]).Id);
                    Assert.Equal("2", proxy.Address.Id);
                }
            }
        }
Esempio n. 22
0
        public void reverse_property_is_set_correctly_on_one_to_one_relationships()
        {
            var metadataFactory      = new AttributeMetadataFactory(new NullLogger());
            var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
            var repositoryFactory    = new Mock <IRepositoryFactory>();
            var stateTracker         = new EntityStateCache();
            var proxyFactory         = new DynamicProxyFactory(metadataFactory, new NullLogger());

            using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
            {
                var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
                var alpha   = factory.Create(new ClassAlpha
                {
                    Id = "1"
                }, session);
                var beta = factory.Create(new ClassBeta
                {
                    Id = "2"
                }, session);
                alpha.Beta = beta;
                var metadata = metadataFactory.Create(beta);
                Assert.True(metadata["Alpha"].Relationship.IsReverse);
            }
        }
Esempio n. 23
0
 internal void RemoveStateFromCache(Key key, bool removeFromInnerCache = false)
 {
     EntityStateCache.RemoveKey(key, removeFromInnerCache);
 }
Esempio n. 24
0
 public CacheManager(EntityAreaCache entityAreaCache, EntityStateCache entityStateCache)
 {
     _entityAreaCache  = entityAreaCache;
     _entityStateCache = entityStateCache;
 }
Esempio n. 25
0
 internal bool LookupStateInCache(Key key, out EntityState entityState)
 {
     return(EntityStateCache.TryGetItem(key, true, out entityState));
 }