public override void SetUp() { base.SetUp(); _mockRepository = new MockRepository(); _eventSinkWithMock = _mockRepository.StrictMock <IClientTransactionEventSink>(); _persistenceStrategyMock = _mockRepository.StrictMock <IPersistenceStrategy> (); _dataManagerMock = _mockRepository.StrictMock <IDataManager> (); _clientTransaction = ClientTransactionObjectMother.Create(); _agent = new CommitRollbackAgent(_clientTransaction, _eventSinkWithMock, _persistenceStrategyMock, _dataManagerMock); _fakeChangedDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty); _fakeNewDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty); _fakeDeletedDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty); var fakeDataContainer1 = DataContainerObjectMother.Create(); var fakeDataContainer2 = DataContainerObjectMother.Create(); var fakeDataContainer3 = DataContainerObjectMother.Create(); _fakeChangedPersistableItem = new PersistableData(_fakeChangedDomainObject, StateType.Changed, fakeDataContainer1, new IRelationEndPoint[0]); _fakeNewPersistableItem = new PersistableData(_fakeNewDomainObject, StateType.New, fakeDataContainer2, new IRelationEndPoint[0]); _fakeDeletedPersistableItem = new PersistableData(_fakeDeletedDomainObject, StateType.Deleted, fakeDataContainer3, new IRelationEndPoint[0]); }
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)); }
public override void SetUp() { base.SetUp(); _persistenceStrategyMock = MockRepository.GenerateStrictMock <IPersistenceStrategy> (); _objectLoaderMock = MockRepository.GenerateStrictMock <IObjectLoader> (); _transactionEventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>(); _queryManager = new QueryManager( _persistenceStrategyMock, _objectLoaderMock, _transactionEventSinkWithMock); _collectionQuery = QueryFactory.CreateQueryFromConfiguration("OrderQuery"); _scalarQuery = QueryFactory.CreateQueryFromConfiguration("OrderNoSumByCustomerNameQuery"); _customQuery = QueryFactory.CreateQueryFromConfiguration("CustomQuery"); _fakeOrder1 = DomainObjectMother.CreateFakeObject <Order> (); _fakeOrder2 = DomainObjectMother.CreateFakeObject <Order>(); _loadedObjectDataStub1 = MockRepository.GenerateStub <ILoadedObjectData> (); _loadedObjectDataStub2 = MockRepository.GenerateStub <ILoadedObjectData> (); _rowConversion = qrr => qrr.GetRawValue(0); }
public ErrorContext(IEnumerable <DeserializationErrorDetails> deserializationErrorDetails, IPersistenceStrategy persistenceStrategy, string collectionId, string objectId) { if (deserializationErrorDetails == null) { throw new ArgumentNullException(nameof(deserializationErrorDetails)); } if (persistenceStrategy == null) { throw new ArgumentNullException(nameof(persistenceStrategy)); } if (collectionId == null) { throw new ArgumentNullException(nameof(collectionId)); } if (objectId == null) { throw new ArgumentNullException(nameof(objectId)); } this.persistenceStrategy = persistenceStrategy; this.collectionId = collectionId; this.objectId = objectId; DeserializationErrorDetails = deserializationErrorDetails; // default decision: Decision = Decision.DoNotIgnoreAndRethrowTheException; }
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)); }
private static IPersistenceStrategy <TEntity> RecuperarEstrategia(TEntity entity) { IPersistenceStrategy <TEntity> result = DependencyService.StrategyDependencyManager.RecuperarEstrategiaPersistencia(entity); result.Entidade = entity; return(result); }
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 ObjectResolver(string objectId, string collectionId, IPersistenceStrategy persistenceStrategy, ISerializationStrategy serializationStrategy, IObjectDeserializationErrorHandlingStrategy objectDeserializationErrorHandlingStrategy) { if (objectId == null) { throw new ArgumentNullException(nameof(objectId)); } if (collectionId == null) { throw new ArgumentNullException(nameof(collectionId)); } if (persistenceStrategy == null) { throw new ArgumentNullException(nameof(persistenceStrategy)); } if (serializationStrategy == null) { throw new ArgumentNullException(nameof(serializationStrategy)); } if (objectDeserializationErrorHandlingStrategy == null) { throw new ArgumentNullException(nameof(objectDeserializationErrorHandlingStrategy)); } this.objectId = objectId; this.collectionId = collectionId; this.persistenceStrategy = persistenceStrategy; this.serializationStrategy = serializationStrategy; this.objectDeserializationErrorHandlingStrategy = objectDeserializationErrorHandlingStrategy; }
public override void SetUp() { base.SetUp(); _transaction = ClientTransactionObjectMother.Create(); _eventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>(); _invalidDomainObjectManagerMock = MockRepository.GenerateStrictMock <IInvalidDomainObjectManager> (); _dataManagerMock = MockRepository.GenerateStrictMock <IDataManager> (); _enlistedDomainObjectManagerMock = MockRepository.GenerateStrictMock <IEnlistedDomainObjectManager> (); _persistenceStrategyMock = MockRepository.GenerateStrictMock <IPersistenceStrategy>(); _agent = new ObjectLifetimeAgent( _transaction, _eventSinkWithMock, _invalidDomainObjectManagerMock, _dataManagerMock, _enlistedDomainObjectManagerMock, _persistenceStrategyMock); _objectID1 = DomainObjectIDs.Order1; _domainObject1 = DomainObjectMother.CreateFakeObject(_objectID1); _dataContainer1 = DataContainerObjectMother.CreateExisting(_domainObject1); _objectID2 = DomainObjectIDs.Order3; _domainObject2 = DomainObjectMother.CreateFakeObject(_objectID2); _dataContainer2 = DataContainerObjectMother.CreateExisting(_domainObject2); _domainObjectCreatorMock = MockRepository.GenerateStrictMock <IDomainObjectCreator>(); _typeDefinitionWithCreatorMock = ClassDefinitionObjectMother.CreateClassDefinitionWithTable( TestDomainStorageProviderDefinition, classType: typeof(OrderItem), instanceCreator: _domainObjectCreatorMock); _objectIDWithCreatorMock = new ObjectID(_typeDefinitionWithCreatorMock, Guid.NewGuid()); }
/// <summary> /// Instantiate a new PersistentState instance. Each PersistentState object represents /// a slice of state for a particular contract address. /// </summary> public PersistentState(IPersistenceStrategy persistenceStrategy, ISerializer serializer, uint160 contractAddress) { this.persistenceStrategy = persistenceStrategy; this.Serializer = serializer; this.ContractAddress = contractAddress; }
/// <summary> /// Instantiate a new PersistentState instance. Each PersistentState object represents /// a slice of state for a particular contract address. /// </summary> public PersistentState( IPersistenceStrategy persistenceStrategy, IContractPrimitiveSerializer contractPrimitiveSerializer, uint160 contractAddress) { this.persistenceStrategy = persistenceStrategy; this.serializer = contractPrimitiveSerializer; this.ContractAddress = contractAddress; }
internal PersistentCollection(string collectionId, IPersistenceStrategy persistenceStrategy, ISerializationStrategy serializationStrategy, IObjectDeserializationErrorHandlingStrategy deserializationErrorHandlingStrategy) { this.collectionId = collectionId; this.persistenceStrategy = persistenceStrategy; this.serializationStrategy = serializationStrategy; this.deserializationErrorHandlingStrategy = deserializationErrorHandlingStrategy; }
public IObjectLoader CallCreateObjectLoader( ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink, IPersistenceStrategy persistenceStrategy, IInvalidDomainObjectManager invalidDomainObjectManager, IDataManager dataManager, ITransactionHierarchyManager hierarchyManager) { return(CreateObjectLoader(constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, dataManager, hierarchyManager)); }
public Rating( RatingDto dto, IPersistenceStrategy persistenceStrategy, IMovieBinding movieBinding, ICriticBinding criticBinding) { _dto = dto; _persistenceStrategy = persistenceStrategy; _movieBinding = movieBinding; _criticBinding = criticBinding; }
public PersistenceManager([NotNull] PersistenceManagerConfig config, ISerializationStrategy serializationStrategy, IPersistenceStrategy persistenceStrategy) { if (config == null) { throw new ArgumentNullException(nameof(config)); } this.config = config; SerializationStrategy = serializationStrategy; PersistenceStrategy = persistenceStrategy; }
private PruningContext(IPruningStrategy pruningStrategy, IPersistenceStrategy persistenceStrategy) { _logManager = new TestLogManager(LogLevel.Trace); _logger = _logManager.GetClassLogger(); _dbProvider = TestMemDbProvider.Init(); _persistenceStrategy = persistenceStrategy; _pruningStrategy = pruningStrategy; _trieStore = new TrieStore(_dbProvider.StateDb, _pruningStrategy, _persistenceStrategy, _logManager); _stateProvider = new StateProvider(_trieStore, _dbProvider.CodeDb, _logManager); _storageProvider = new StorageProvider(_trieStore, _stateProvider, _logManager); _stateReader = new StateReader(_trieStore, _dbProvider.CodeDb, _logManager); }
public T CreateStubbableTransaction <T> () where T : ClientTransaction { _persistenceStrategyStub = MockRepository.GenerateStub <IFetchEnabledPersistenceStrategy>(); _persistenceStrategyStub .Stub(stub => stub.CreateNewObjectID(Arg <ClassDefinition> .Is.Anything)) .Return(null) .WhenCalled(mi => { mi.ReturnValue = new ObjectID((ClassDefinition)mi.Arguments[0], Guid.NewGuid()); }); IClientTransactionComponentFactory componentFactory = new ComponentFactoryWithSpecificPersistenceStrategy(_persistenceStrategyStub); return((T)PrivateInvoke.CreateInstanceNonPublicCtor(typeof(T), componentFactory)); }
public CommitRollbackAgent( ClientTransaction clientTransaction, IClientTransactionEventSink eventSink, IPersistenceStrategy persistenceStrategy, IDataManager dataManager) { ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction); ArgumentUtility.CheckNotNull("eventSink", eventSink); ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy); ArgumentUtility.CheckNotNull("dataManager", dataManager); _clientTransaction = clientTransaction; _eventSink = eventSink; _persistenceStrategy = persistenceStrategy; _dataManager = dataManager; }
// construction and disposing /// <summary> /// Initializes a new instance of the <see cref="QueryManager"/> class. /// </summary> /// <param name="persistenceStrategy">The <see cref="IPersistenceStrategy"/> used to load query results not involving <see cref="DomainObject"/> instances.</param> /// <param name="objectLoader">An <see cref="IObjectLoader"/> implementation that can be used to load objects. This parameter determines /// the <see cref="ClientTransaction"/> housing the objects loaded by queries.</param> /// <param name="transactionEventSink">The transaction event sink to use for raising query-related notifications.</param> public QueryManager( IPersistenceStrategy persistenceStrategy, IObjectLoader objectLoader, IClientTransactionEventSink transactionEventSink) { ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy); ArgumentUtility.CheckNotNull("objectLoader", objectLoader); ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink); _persistenceStrategy = persistenceStrategy; _objectLoader = objectLoader; _transactionEventSink = transactionEventSink; }
public virtual ICommitRollbackAgent CreateCommitRollbackAgent( ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink, IPersistenceStrategy persistenceStrategy, IDataManager dataManager) { ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction); ArgumentUtility.CheckNotNull("eventSink", eventSink); ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy); ArgumentUtility.CheckNotNull("dataManager", dataManager); return(new CommitRollbackAgent(constructedTransaction, eventSink, persistenceStrategy, dataManager)); }
public ObjectLoader( IPersistenceStrategy persistenceStrategy, ILoadedObjectDataRegistrationAgent loadedObjectDataRegistrationAgent, ILoadedObjectDataProvider loadedObjectDataProvider) { ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy); ArgumentUtility.CheckNotNull("loadedObjectDataRegistrationAgent", loadedObjectDataRegistrationAgent); ArgumentUtility.CheckNotNull("loadedObjectDataProvider", loadedObjectDataProvider); _persistenceStrategy = persistenceStrategy; _loadedObjectDataRegistrationAgent = loadedObjectDataRegistrationAgent; _loadedObjectDataProvider = loadedObjectDataProvider; }
public ErrorContext(IEnumerable<DeserializationErrorDetails> deserializationErrorDetails, IPersistenceStrategy persistenceStrategy, string collectionId, string objectId) { if (deserializationErrorDetails == null) throw new ArgumentNullException("deserializationErrorDetails"); if (persistenceStrategy == null) throw new ArgumentNullException("persistenceStrategy"); if (collectionId == null) throw new ArgumentNullException("collectionId"); if (objectId == null) throw new ArgumentNullException("objectId"); this.persistenceStrategy = persistenceStrategy; this.collectionId = collectionId; this.objectId = objectId; DeserializationErrorDetails = deserializationErrorDetails; // default decision: Decision = Decision.DoNotIgnoreAndRethrowTheException; }
public static IPersistenceStrategy Or(this IPersistenceStrategy strategy, IPersistenceStrategy otherStrategy) { if (strategy is CompositePersistenceStrategy compositeStrategy) { return(compositeStrategy.AddStrategy(otherStrategy)); } else if (otherStrategy is CompositePersistenceStrategy otherCompositeStrategy) { return(otherCompositeStrategy.AddStrategy(strategy)); } else { return(new CompositePersistenceStrategy(strategy, otherStrategy)); } }
public override void SetUp() { base.SetUp(); _mockRepository = new MockRepository(); _persistenceStrategyMock = _mockRepository.StrictMock <IPersistenceStrategy> (); _loadedObjectDataRegistrationAgentMock = _mockRepository.StrictMock <ILoadedObjectDataRegistrationAgent>(); _loadedObjectDataProviderStub = _mockRepository.Stub <ILoadedObjectDataProvider>(); _objectLoader = new ObjectLoader(_persistenceStrategyMock, _loadedObjectDataRegistrationAgentMock, _loadedObjectDataProviderStub); _fakeQuery = CreateFakeQuery(); _loadedObjectDataStub1 = MockRepository.GenerateStub <ILoadedObjectData> (); _loadedObjectDataStub2 = MockRepository.GenerateStub <ILoadedObjectData> (); }
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 PersistentCollectionsLibrary(IPersistenceStrategy persistenceStrategy, IObjectDeserializationErrorHandlingStrategy deserializationErrorHandlingStrategy = null) { if (persistenceStrategy == null) throw new ArgumentNullException("persistenceStrategy"); this.persistenceStrategy = persistenceStrategy; if (deserializationErrorHandlingStrategy == null) { this.deserializationErrorHandlingStrategy = new DefaultObjectDeserializationErrorHandlingStrategy(); } else { this.deserializationErrorHandlingStrategy = deserializationErrorHandlingStrategy; } serializationStrategy = new JsonSerializationStrategy(); }
public virtual IObjectLifetimeAgent CreateObjectLifetimeAgent( ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink, IInvalidDomainObjectManager invalidDomainObjectManager, IDataManager dataManager, IEnlistedDomainObjectManager enlistedDomainObjectManager, IPersistenceStrategy persistenceStrategy) { ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction); ArgumentUtility.CheckNotNull("eventSink", eventSink); ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager); ArgumentUtility.CheckNotNull("dataManager", dataManager); ArgumentUtility.CheckNotNull("enlistedDomainObjectManager", enlistedDomainObjectManager); ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy); return(new ObjectLifetimeAgent( constructedTransaction, eventSink, invalidDomainObjectManager, dataManager, enlistedDomainObjectManager, persistenceStrategy)); }
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)); }
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)); }
public PersistentCollectionsLibrary(IPersistenceStrategy persistenceStrategy, IObjectDeserializationErrorHandlingStrategy deserializationErrorHandlingStrategy = null) { if (persistenceStrategy == null) { throw new ArgumentNullException(nameof(persistenceStrategy)); } this.persistenceStrategy = persistenceStrategy; if (deserializationErrorHandlingStrategy == null) { this.deserializationErrorHandlingStrategy = new DefaultObjectDeserializationErrorHandlingStrategy(); } else { this.deserializationErrorHandlingStrategy = deserializationErrorHandlingStrategy; } serializationStrategy = new JsonSerializationStrategy(); }
public ObjectLifetimeAgent( ClientTransaction clientTransaction, IClientTransactionEventSink eventSink, IInvalidDomainObjectManager invalidDomainObjectManager, IDataManager dataManager, IEnlistedDomainObjectManager enlistedDomainObjectManager, IPersistenceStrategy persistenceStrategy) { ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction); ArgumentUtility.CheckNotNull("eventSink", eventSink); ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager); ArgumentUtility.CheckNotNull("dataManager", dataManager); ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy); _clientTransaction = clientTransaction; _eventSink = eventSink; _invalidDomainObjectManager = invalidDomainObjectManager; _dataManager = dataManager; _enlistedDomainObjectManager = enlistedDomainObjectManager; _persistenceStrategy = persistenceStrategy; }
public PersistenceMethod(IPersistenceStrategy strategy, Uri uri) { this.strategy = strategy; this.uri = uri; }