private TransactionHierarchyManager(
ClientTransaction thisTransaction,
IClientTransactionEventSink thisEventSink,
IClientTransactionHierarchy transactionHierarchy,
ClientTransaction parentTransaction,
ITransactionHierarchyManager parentHierarchyManager,
IClientTransactionEventSink parentEventSink)
{
ArgumentUtility.CheckNotNull("thisTransaction", thisTransaction);
ArgumentUtility.CheckNotNull("thisEventSink", thisEventSink);
ArgumentUtility.CheckNotNull("transactionHierarchy", transactionHierarchy);
_thisTransaction = thisTransaction;
_thisEventSink = thisEventSink;
_parentTransaction = parentTransaction;
_parentHierarchyManager = parentHierarchyManager;
_parentEventSink = parentEventSink;
_transactionHierarchy = transactionHierarchy;
_readOnlyClientTransactionListener = new ReadOnlyClientTransactionListenerWithLoadRules();
_newObjectHierarchyInvalidationClientTransactionListener = new NewObjectHierarchyInvalidationClientTransactionListener();
}
public static T CreateWithComponents <T> (
Dictionary <Enum, object> applicationData = null,
IClientTransactionEventBroker eventBroker = null,
ITransactionHierarchyManager transactionHierarchyManager = null,
IEnlistedDomainObjectManager enlistedDomainObjectManager = null,
IInvalidDomainObjectManager invalidDomainObjectManager = null,
IPersistenceStrategy persistenceStrategy = null,
IDataManager dataManager = null,
IObjectLifetimeAgent objectLifetimeAgent = null,
IQueryManager queryManager = null,
ICommitRollbackAgent commitRollbackAgent = null,
IEnumerable <IClientTransactionExtension> extensions = null)
where T : ClientTransaction
{
var componentFactoryStub = CreateComponentFactory(
applicationData,
eventBroker,
transactionHierarchyManager,
enlistedDomainObjectManager,
invalidDomainObjectManager,
persistenceStrategy,
dataManager,
objectLifetimeAgent,
queryManager,
commitRollbackAgent,
extensions);
return(CreateWithComponents <T> (componentFactoryStub));
}
protected override IObjectLoader CreateObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
var fetchEnabledPersistenceStrategy =
ArgumentUtility.CheckNotNullAndType <IFetchEnabledPersistenceStrategy> ("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("dataManager", dataManager);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
var loadedObjectDataProvider = new LoadedObjectDataProvider(dataManager, invalidDomainObjectManager);
var registrationListener = new LoadedObjectDataRegistrationListener(eventSink, hierarchyManager);
var loadedObjectDataRegistrationAgent = new LoadedObjectDataRegistrationAgent(constructedTransaction, dataManager, registrationListener);
IFetchedRelationDataRegistrationAgent registrationAgent =
new DelegatingFetchedRelationDataRegistrationAgent(
new FetchedRealObjectRelationDataRegistrationAgent(),
new FetchedVirtualObjectRelationDataRegistrationAgent(dataManager),
new FetchedCollectionRelationDataRegistrationAgent(dataManager));
var eagerFetcher = new EagerFetcher(registrationAgent);
return(new FetchEnabledObjectLoader(
fetchEnabledPersistenceStrategy,
loadedObjectDataRegistrationAgent,
loadedObjectDataProvider,
eagerFetcher));
}
protected abstract IObjectLoader CreateObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager);
public virtual IDataManager CreateDataManager(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IInvalidDomainObjectManager invalidDomainObjectManager,
IPersistenceStrategy persistenceStrategy,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
var dataContainerEventListener = CreateDataContainerEventListener(eventSink);
var delegatingDataManager = new DelegatingDataManager();
var objectLoader = CreateObjectLoader(
constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, delegatingDataManager, hierarchyManager);
var endPointManager = CreateRelationEndPointManager(
constructedTransaction,
GetEndPointProvider(delegatingDataManager),
GetLazyLoader(delegatingDataManager),
eventSink);
var dataManager = new DataManager(
constructedTransaction, eventSink, dataContainerEventListener, invalidDomainObjectManager, objectLoader, endPointManager);
delegatingDataManager.InnerDataManager = dataManager;
return(dataManager);
}
public LoadedObjectDataRegistrationListener(
IClientTransactionEventSink eventSink, ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
_eventSink = eventSink;
_hierarchyManager = hierarchyManager;
}
public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_eventSinkWithMock = _mockRepository.StrictMock <IClientTransactionEventSink>();
_hierarchyManagerMock = _mockRepository.StrictMock <ITransactionHierarchyManager> ();
_decorator = new LoadedObjectDataRegistrationListener(_eventSinkWithMock, _hierarchyManagerMock);
}
public IObjectLoader CallCreateObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
return(CreateObjectLoader(constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, dataManager, hierarchyManager));
}
public static SubClientTransactionComponentFactory Create(
ClientTransaction parentTransaction,
IInvalidDomainObjectManager parentInvalidDomainObjectManager,
IEnlistedDomainObjectManager parentEnlistedDomainObjectManager,
ITransactionHierarchyManager parentTransactionHierarchyManager,
IClientTransactionEventSink parentEventSink)
{
return(ObjectFactory.Create <SubClientTransactionComponentFactory> (
true,
ParamList.Create(
parentTransaction,
parentInvalidDomainObjectManager,
parentEnlistedDomainObjectManager,
parentTransactionHierarchyManager,
parentEventSink)));
}
protected override IObjectLoader CreateObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("dataManager", dataManager);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
return(CreateBasicObjectLoader(constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, dataManager, hierarchyManager));
}
public override void SetUp()
{
base.SetUp();
_thisTransaction = ClientTransactionObjectMother.Create();
_thisEventSinkWithStrictMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_hierarchyStrictMock = MockRepository.GenerateStrictMock <IClientTransactionHierarchy>();
_parentTransaction = ClientTransactionObjectMother.Create();
_parentHierarchyManagerStrictMock = MockRepository.GenerateStrictMock <ITransactionHierarchyManager>();
_parentHierarchyManagerStrictMock.Stub(stub => stub.TransactionHierarchy).Return(_hierarchyStrictMock);
_parentEventSinkWithStrictMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_manager = new TransactionHierarchyManager(
_thisTransaction, _thisEventSinkWithStrictMock, _parentTransaction, _parentHierarchyManagerStrictMock, _parentEventSinkWithStrictMock);
_managerWithoutParent = new TransactionHierarchyManager(_thisTransaction, _thisEventSinkWithStrictMock);
}
public virtual IQueryManager CreateQueryManager(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IInvalidDomainObjectManager invalidDomainObjectManager,
IPersistenceStrategy persistenceStrategy,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("dataManager", dataManager);
var objectLoader = CreateObjectLoader(
constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, dataManager, hierarchyManager);
return(new QueryManager(persistenceStrategy, objectLoader, eventSink));
}
private object CallCreateBasicObjectLoader(
SubClientTransactionComponentFactory factory,
TestableClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
return(PrivateInvoke.InvokeNonPublicMethod(
factory,
"CreateBasicObjectLoader",
constructedTransaction,
eventSink,
persistenceStrategy,
invalidDomainObjectManager,
dataManager,
hierarchyManager));
}
protected SubClientTransactionComponentFactory(
ClientTransaction parentTransaction,
IInvalidDomainObjectManager parentInvalidDomainObjectManager,
IEnlistedDomainObjectManager parentEnlistedDomainObjectManager,
ITransactionHierarchyManager parentHierarchyManager,
IClientTransactionEventSink parentEventSink)
{
ArgumentUtility.CheckNotNull("parentTransaction", parentTransaction);
ArgumentUtility.CheckNotNull("parentInvalidDomainObjectManager", parentInvalidDomainObjectManager);
ArgumentUtility.CheckNotNull("parentEnlistedDomainObjectManager", parentEnlistedDomainObjectManager);
ArgumentUtility.CheckNotNull("parentHierarchyManager", parentHierarchyManager);
ArgumentUtility.CheckNotNull("parentEventSink", parentEventSink);
_parentTransaction = parentTransaction;
_parentInvalidDomainObjectManager = parentInvalidDomainObjectManager;
_parentEnlistedDomainObjectManager = parentEnlistedDomainObjectManager;
_parentHierarchyManager = parentHierarchyManager;
_parentEventSink = parentEventSink;
}
public TransactionHierarchyManager(
ClientTransaction thisTransaction,
IClientTransactionEventSink thisEventSink,
ClientTransaction parentTransaction,
ITransactionHierarchyManager parentHierarchyManager,
IClientTransactionEventSink parentEventSink)
: this(
thisTransaction,
thisEventSink,
parentHierarchyManager.TransactionHierarchy,
parentTransaction,
ArgumentUtility.CheckNotNull("parentHierarchyManager", parentHierarchyManager),
parentEventSink)
{
ArgumentUtility.CheckNotNull("parentTransaction", parentTransaction);
ArgumentUtility.CheckNotNull("parentEventSink", parentEventSink);
_parentTransaction = parentTransaction;
_parentHierarchyManager = parentHierarchyManager;
_parentEventSink = parentEventSink;
}
public override void SetUp()
{
base.SetUp();
_parentTransaction = new TestableClientTransaction();
_parentInvalidDomainObjectManagerStub = MockRepository.GenerateStub <IInvalidDomainObjectManager> ();
_parentEnlistedDomainObjectManagerStub = MockRepository.GenerateStub <IEnlistedDomainObjectManager> ();
_parentTransactionHierarchyManagerStub = MockRepository.GenerateStub <ITransactionHierarchyManager> ();
_parentTransactionHierarchyManagerStub
.Stub(stub => stub.TransactionHierarchy)
.Return(MockRepository.GenerateStub <IClientTransactionHierarchy>());
_parentEventSink = MockRepository.GenerateStub <IClientTransactionEventSink>();
_factory = SubClientTransactionComponentFactory.Create(
_parentTransaction,
_parentInvalidDomainObjectManagerStub,
_parentEnlistedDomainObjectManagerStub,
_parentTransactionHierarchyManagerStub,
_parentEventSink);
_fakeConstructedTransaction = new TestableClientTransaction();
}
protected virtual IObjectLoader CreateBasicObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("dataManager", dataManager);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
var loadedObjectDataProvider = new LoadedObjectDataProvider(dataManager, invalidDomainObjectManager);
var registrationListener = new LoadedObjectDataRegistrationListener(eventSink, hierarchyManager);
var loadedObjectDataRegistrationAgent = new LoadedObjectDataRegistrationAgent(constructedTransaction, dataManager, registrationListener);
return(new ObjectLoader(
persistenceStrategy,
loadedObjectDataRegistrationAgent,
loadedObjectDataProvider));
}
public static IClientTransactionComponentFactory CreateComponentFactory(
Dictionary <Enum, object> applicationData = null,
IClientTransactionEventBroker eventBroker = null,
ITransactionHierarchyManager transactionHierarchyManager = null,
IEnlistedDomainObjectManager enlistedDomainObjectManager = null,
IInvalidDomainObjectManager invalidDomainObjectManager = null,
IPersistenceStrategy persistenceStrategy = null,
IDataManager dataManager = null,
IObjectLifetimeAgent objectLifetimeAgent = null,
IQueryManager queryManager = null,
ICommitRollbackAgent commitRollbackAgent = null,
IEnumerable <IClientTransactionExtension> extensions = null)
{
applicationData = applicationData ?? new Dictionary <Enum, object>();
transactionHierarchyManager = transactionHierarchyManager ?? MockRepository.GenerateStub <ITransactionHierarchyManager>();
enlistedDomainObjectManager = enlistedDomainObjectManager ?? MockRepository.GenerateStub <IEnlistedDomainObjectManager>();
invalidDomainObjectManager = invalidDomainObjectManager ?? MockRepository.GenerateStub <IInvalidDomainObjectManager>();
persistenceStrategy = persistenceStrategy ?? MockRepository.GenerateStub <IPersistenceStrategy>();
dataManager = dataManager ?? MockRepository.GenerateStub <IDataManager>();
objectLifetimeAgent = objectLifetimeAgent ?? MockRepository.GenerateStub <IObjectLifetimeAgent>();
eventBroker = eventBroker ?? MockRepository.GenerateStub <IClientTransactionEventBroker>();
queryManager = queryManager ?? MockRepository.GenerateStub <IQueryManager>();
commitRollbackAgent = commitRollbackAgent ?? MockRepository.GenerateStub <ICommitRollbackAgent>();
extensions = extensions ?? Enumerable.Empty <IClientTransactionExtension>();
var componentFactoryStub = MockRepository.GenerateStub <IClientTransactionComponentFactory>();
componentFactoryStub.Stub(stub => stub.CreateApplicationData(Arg <ClientTransaction> .Is.Anything)).Return(applicationData);
componentFactoryStub
.Stub(stub => stub.CreateEventBroker(Arg <ClientTransaction> .Is.Anything))
.Return(eventBroker);
componentFactoryStub
.Stub(stub => stub.CreateTransactionHierarchyManager(Arg <ClientTransaction> .Is.Anything, Arg <IClientTransactionEventSink> .Is.Anything))
.Return(transactionHierarchyManager);
componentFactoryStub.Stub(stub => stub.CreateEnlistedObjectManager(Arg <ClientTransaction> .Is.Anything)).Return(enlistedDomainObjectManager);
componentFactoryStub
.Stub(stub => stub.CreateInvalidDomainObjectManager(Arg <ClientTransaction> .Is.Anything, Arg <IClientTransactionEventSink> .Is.Anything))
.Return(invalidDomainObjectManager);
componentFactoryStub.Stub(stub => stub.CreatePersistenceStrategy(Arg <ClientTransaction> .Is.Anything)).Return(persistenceStrategy);
componentFactoryStub
.Stub(stub => stub.CreateDataManager(
Arg <ClientTransaction> .Is.Anything,
Arg <IClientTransactionEventSink> .Is.Anything,
Arg <IInvalidDomainObjectManager> .Is.Anything,
Arg <IPersistenceStrategy> .Is.Anything,
Arg <ITransactionHierarchyManager> .Is.Anything))
.Return(dataManager);
componentFactoryStub
.Stub(
stub =>
stub.CreateObjectLifetimeAgent(
Arg <ClientTransaction> .Is.Anything,
Arg <IClientTransactionEventSink> .Is.Anything,
Arg <IInvalidDomainObjectManager> .Is.Anything,
Arg <IDataManager> .Is.Anything,
Arg <IEnlistedDomainObjectManager> .Is.Anything,
Arg <IPersistenceStrategy> .Is.Anything))
.Return(objectLifetimeAgent);
componentFactoryStub
.Stub(stub => stub.CreateQueryManager(
Arg <ClientTransaction> .Is.Anything,
Arg <IClientTransactionEventSink> .Is.Anything,
Arg <IInvalidDomainObjectManager> .Is.Anything,
Arg <IPersistenceStrategy> .Is.Anything,
Arg <IDataManager> .Is.Anything,
Arg <ITransactionHierarchyManager> .Is.Anything))
.Return(queryManager);
componentFactoryStub
.Stub(stub => stub.CreateCommitRollbackAgent(
Arg <ClientTransaction> .Is.Anything,
Arg <IClientTransactionEventSink> .Is.Anything,
Arg <IPersistenceStrategy> .Is.Anything,
Arg <IDataManager> .Is.Anything))
.Return(commitRollbackAgent);
componentFactoryStub.Stub(stub => stub.CreateExtensions(Arg <ClientTransaction> .Is.Anything)).Return(extensions);
return(componentFactoryStub);
}
protected override IObjectLoader CreateObjectLoader(ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink, IPersistenceStrategy persistenceStrategy, IInvalidDomainObjectManager invalidDomainObjectManager, IDataManager dataManager, ITransactionHierarchyManager hierarchyManager)
{
var objectLoader = base.CreateObjectLoader(constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, dataManager, hierarchyManager);
return(_factory(objectLoader));
}
protected override IObjectLoader CreateObjectLoader(ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink, IPersistenceStrategy persistenceStrategy, IInvalidDomainObjectManager invalidDomainObjectManager, IDataManager dataManager, ITransactionHierarchyManager hierarchyManager)
{
throw new NotImplementedException();
}
public override IQueryManager CreateQueryManager(ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink, IInvalidDomainObjectManager invalidDomainObjectManager, IPersistenceStrategy persistenceStrategy, IDataManager dataManager, ITransactionHierarchyManager hierarchyManager)
{
return(_queryManager);
}
