public void SaveAndLoadWithEntityRepository()
{
Converts.Repository
.AddJsonKey()
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler();
ICompositeTypeProvider compositeTypeProvider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
IFactory <ICompositeStorage> storageFactory = new GetterFactory <ICompositeStorage>(() => new JsonCompositeStorage());
EventSourcingContext context = new EventSourcingContext(@"Data Source=.\sqlexpress; Initial Catalog=EventStore;Integrated Security=SSPI");
EntityEventStore eventStore = new EntityEventStore(context);
PersistentEventDispatcher eventDispatcher = new PersistentEventDispatcher(eventStore);
AggregateRootRepository <Order> repository = new AggregateRootRepository <Order>(
eventStore,
new CompositeEventFormatter(compositeTypeProvider, storageFactory),
new ReflectionAggregateRootFactory <Order>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
PersistentCommandDispatcher commandDispatcher = new PersistentCommandDispatcher(
new SerialCommandDistributor(),
new EntityCommandStore(context),
new CompositeCommandFormatter(compositeTypeProvider, storageFactory)
);
CreateOrderHandler createHandler = new CreateOrderHandler(repository);
AddOrderItemHandler addItemHandler = new AddOrderItemHandler(repository);
commandDispatcher.Handlers
.Add <CreateOrder>(createHandler)
.Add <AddOrderItem>(addItemHandler);
CreateOrder create = new CreateOrder();
commandDispatcher.HandleAsync(create);
eventDispatcher.Handlers.Await <OrderPlaced>().Wait();
IEnumerable <EventModel> serializedEvents = eventStore.Get(create.OrderKey).ToList();
Assert.AreEqual(1, serializedEvents.Count());
AddOrderItem addItem = new AddOrderItem(create.OrderKey, GuidKey.Create(Guid.NewGuid(), "Product"), 5);
commandDispatcher.HandleAsync(Envelope.Create(addItem).AddDelay(TimeSpan.FromMinutes(1)));
Task <OrderTotalRecalculated> task = eventDispatcher.Handlers.Await <OrderTotalRecalculated>();
task.Wait();
Console.WriteLine(task.Result);
serializedEvents = eventStore.Get(create.OrderKey).ToList();
Assert.AreEqual(4, serializedEvents.Count());
}
public void Reflection_SingleVersion()
{
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
Assert.AreEqual(true, provider.TryGet(typeof(SingleVersion), out compositeType));
AssertSingleVersion(compositeType);
}
public void Reflection_Reflection_FullyDefined()
{
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
Assert.AreEqual(true, provider.TryGet(typeof(UserModel), out compositeType));
AssertUserModel(compositeType);
}
public void Reflection_DefaultConstructorExplicitProperties()
{
Converts.Repository
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler();
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
Assert.AreEqual(false, provider.TryGet(typeof(MisspelledParameterName), out compositeType));
}
private long BuildComposityType()
{
Stopwatch sw = new Stopwatch();
sw.Start();
ICompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
provider.TryGet(typeof(UserModel), out compositeType);
sw.Stop();
return(sw.ElapsedMilliseconds);
}
private void Domain()
{
Converts.Repository
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler()
.AddJsonKey()
.AddJsonTimeSpan()
.Add(new ColorConverter());
EventStore = new EntityEventStore(Factory.Default <EventSourcingContext>());
eventDispatcher = new PersistentEventDispatcher(new EmptyEventStore());
eventDispatcher.DispatcherExceptionHandlers.Add(this);
eventDispatcher.EventExceptionHandlers.Add(this);
IFactory <ICompositeStorage> compositeStorageFactory = Factory.Default <JsonCompositeStorage>();
ICompositeTypeProvider typeProvider = new ReflectionCompositeTypeProvider(
new ReflectionCompositeDelegateFactory(),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
);
EventFormatter = new CompositeEventFormatter(typeProvider, compositeStorageFactory);
OutcomeRepository = new AggregateRootRepository <Outcome>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <Outcome>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
CategoryRepository = new AggregateRootRepository <Category>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <Category>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
PriceFactory = new PriceFactory("CZK");
DomainFacade = new DefaultDomainFacade(
OutcomeRepository,
CategoryRepository,
PriceFactory
);
}
private KeyValuePair <long, long> CompositeTypeFormatter(int count)
{
Converts.Repository
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler();
ICompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
provider.TryGet(typeof(UserModel), out compositeType);
CompositeTypeFormatter formatter = new CompositeTypeFormatter(provider, new DefaultFactory <JsonCompositeStorage>());
Stopwatch sw = new Stopwatch();
Stopwatch streamSw = new Stopwatch();
sw.Start();
for (int i = 0; i < count; i++)
{
UserModel model = new UserModel(1, "UserName", "Password");
using (MemoryStream stream = new MemoryStream())
{
Task <bool> isSerializedTask = formatter.TrySerializeAsync(model, new DefaultSerializerContext(typeof(UserModel), stream));
isSerializedTask.Wait();
streamSw.Start();
stream.Seek(0, SeekOrigin.Begin);
string json = null;
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8, true, 1024, true))
json = reader.ReadToEnd();
stream.Seek(0, SeekOrigin.Begin);
streamSw.Stop();
IDeserializerContext context = new DefaultDeserializerContext(typeof(UserModel));
Task <bool> isDeserializedTask = formatter.TryDeserializeAsync(stream, context);
isDeserializedTask.Wait();
model = (UserModel)context.Output;
}
}
sw.Stop();
return(new KeyValuePair <long, long>(sw.ElapsedMilliseconds, streamSw.ElapsedMilliseconds));
}
public void Reflection_SingleModel()
{
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory(), BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
CompositeType compositeType;
Assert.AreEqual(true, provider.TryGet(typeof(SingleModel), out compositeType));
Assert.AreEqual(typeof(SingleModel), compositeType.Type);
Assert.AreEqual(1, compositeType.Versions.Count());
IEnumerator <CompositeVersion> versionEnumerator = compositeType.Versions.GetEnumerator();
Assert.AreEqual(true, versionEnumerator.MoveNext());
CompositeVersion version = versionEnumerator.Current;
Assert.AreEqual(1, version.Version);
Assert.AreEqual(1, version.Properties.Count());
}
public void Reflection_TwoVersionWithFirstImplied()
{
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
Assert.AreEqual(true, provider.TryGet(typeof(TwoVersionWithFirstImplied), out compositeType));
Assert.AreEqual(typeof(TwoVersionWithFirstImplied), compositeType.Type);
Assert.AreEqual(2, compositeType.Versions.Count());
IEnumerator <CompositeVersion> versionEnumerator = compositeType.Versions.GetEnumerator();
Assert.AreEqual(true, versionEnumerator.MoveNext());
CompositeVersion version = versionEnumerator.Current;
Assert.AreEqual(1, version.Version);
Assert.AreEqual(1, version.Properties.Count());
Assert.AreEqual(true, versionEnumerator.MoveNext());
version = versionEnumerator.Current;
Assert.AreEqual(2, version.Version);
Assert.AreEqual(2, version.Properties.Count());
}
