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;
}
