public NavigationViewModel(
Lessons lessons,
IRegionManager regionManager,
IEventResolver <LessonSelectedEvent> lessonSelectedResolver)
{
if (lessons == null)
{
throw new ArgumentNullException(nameof(lessons));
}
if (regionManager == null)
{
throw new ArgumentNullException(nameof(regionManager));
}
if (lessonSelectedResolver == null)
{
throw new ArgumentNullException(nameof(lessonSelectedResolver));
}
if (lessons.Count == 0)
{
throw new InvalidOperationException("lessons collection was empty.");
}
_lessons = lessons;
_regionManager = regionManager;
_lessonSelectedResolver = lessonSelectedResolver;
// navigate to the initial view, HomeView
LessonSelectedExecute(Lessons[0]);
}
private ViewManager ResolveMissingEventsUsing(IEventResolver eventResolver)
{
Guard.Against.Null(() => eventResolver);
this.eventResolver = eventResolver;
return(this);
}
public void EventReplayingOnStartUp(
List <SomeEvent> eventStore,
IRepository <string, SomeData> repository,
View view,
ISequenceResolver sequenceResolver,
IEventResolver eventResolver,
IViewManager viewManager)
{
"Given an event store with three events"._(() => eventStore =
new List <SomeEvent>
{
new SomeEvent {
Sequence = 1, Id = "test"
},
new SomeEvent {
Sequence = 2, Id = "test2"
},
new SomeEvent {
Sequence = 3, Id = "test3"
},
});
"and a view repository"._(() => repository = new MemoryRepository <string, SomeData>());
"and a view"._(() => view = new SomeView(repository));
"and a sequence resolver"._(() => sequenceResolver = new CustomSequenceResolver());
"and an event resolver"._(() => eventResolver = new CustomEventResolver(eventStore));
"when a view manager is created"._(ctx => viewManager =
ViewManager.ForViews(view)
.OrderEventsUsing(sequenceResolver).StartAtSequenceNumber(0)
.ResolveMissingEventsUsing(eventResolver).WithATimeoutOf(Timeout.Infinite)
.Create().Using(ctx));
"and the operation is given time to process"._(() => Thread.Sleep(1000));
"then the view received the third event last"._(() => repository.Get("root").LastEventId.Should().Be(eventStore[2].Id));
"and the view received three events"._(() => repository.Get("root").EventCount.Should().Be(3));
}
public ShellViewModel(IEventResolver <LessonSelectedEvent> lessonSelectedResolver)
{
if (lessonSelectedResolver == null)
{
throw new ArgumentNullException(nameof(lessonSelectedResolver));
}
lessonSelectedResolver.Resolve().Subscribe(t => this.LessonTitle = t);
}
public static IEventReference Resolve(this IEventResolver resolver, IServiceDefinition serviceDefinition, EventId eventId)
{
if (resolver.TryResolve(serviceDefinition, eventId, out var eventReference))
{
return(eventReference);
}
throw new EventResolveException(serviceDefinition.Name, eventId);
}
public CommunicationModelConfiguration(
IEnumerable <IConfiguration> safeConfiguration,
IServiceResolver serviceResolver,
IMethodResolver methodResolver,
IEventResolver eventResolver)
{
_serviceResolver = serviceResolver;
_methodResolver = methodResolver;
_eventResolver = eventResolver;
var rootSection = safeConfiguration.FirstOrDefault()?.GetSection("dasync");
_configMap = ReadConfiguration(rootSection);
}
public EventPublisherProvider(
ICommunicationSettingsProvider communicationSettingsProvider,
IEnumerable <IConfiguration> safeConfiguration,
IServiceResolver serviceResolver,
IEventResolver eventResolver,
IExternalCommunicationModel externalCommunicationModel,
IEnumerable <IEventingMethod> eventingMethods)
{
_communicationSettingsProvider = communicationSettingsProvider;
_serviceResolver = serviceResolver;
_eventResolver = eventResolver;
_externalCommunicationModel = externalCommunicationModel;
_configuration = safeConfiguration.FirstOrDefault()?.GetSection("dasync")
?? (IConfiguration) new ConfigurationRoot(Array.Empty <IConfigurationProvider>());
_eventingMethods = eventingMethods.ToDictionary(m => m.Type, m => m, StringComparer.OrdinalIgnoreCase);
}
public TransitionRunner(
ITransitionScope transitionScope,
IAsyncStateMachineMetadataProvider asyncStateMachineMetadataProvider,
//IServiceStateValueContainerProvider serviceStateValueContainerProvider,
IUniqueIdGenerator idGenerator,
ITaskCompletionSourceRegistry taskCompletionSourceRegistry,
IServiceResolver serviceResolver,
IMethodResolver methodResolver,
IEventResolver eventResolver,
ICommunicatorProvider communicatorProvider,
IEventPublisherProvider eventPublisherProvider,
IRoutineCompletionSink routineCompletionSink,
ICommunicationSettingsProvider communicationSettingsProvider,
IDefaultSerializerProvider defaultSerializerProvider,
ISerializerProvider serializeProvder,
IMethodStateStorageProvider methodStateStorageProvider,
IValueContainerCopier valueContainerCopier,
IEventSubscriber eventSubscriber,
ITaskContinuationClassifier taskContinuationClassifier)
{
_transitionScope = transitionScope;
_asyncStateMachineMetadataProvider = asyncStateMachineMetadataProvider;
//_serviceStateValueContainerProvider = serviceStateValueContainerProvider;
_idGenerator = idGenerator;
_taskCompletionSourceRegistry = taskCompletionSourceRegistry;
_serviceResolver = serviceResolver;
_methodResolver = methodResolver;
_eventResolver = eventResolver;
_communicatorProvider = communicatorProvider;
_eventPublisherProvider = eventPublisherProvider;
_routineCompletionSink = routineCompletionSink;
_communicationSettingsProvider = communicationSettingsProvider;
_defaultSerializer = defaultSerializerProvider.DefaultSerializer;
_serializeProvder = serializeProvder;
_methodStateStorageProvider = methodStateStorageProvider;
_valueContainerCopier = valueContainerCopier;
_eventSubscriber = eventSubscriber;
_taskContinuationClassifier = taskContinuationClassifier;
}
internal EventManager(ISequenceResolver sequenceResolver, IEventResolver eventResolver, int timeout, IEventBuffer eventBuffer, bool disposeBuffer)
{
Trace.WriteLine("EventManager.ctor(ISequenceResolver sequenceResolver, IEventResolver eventResolver, IEventBuffer eventBuffer, int timeout, bool disposeBuffer)");
Guard.Against.Null(() => sequenceResolver);
Guard.Against.Null(() => eventResolver);
Guard.Against.Null(() => eventBuffer);
Guard.Against.NegativeTimeout(() => timeout);
this.sequenceResolver = sequenceResolver;
this.eventResolver = eventResolver;
this.eventBuffer = eventBuffer;
this.timeout = timeout;
this.disposeBuffer = disposeBuffer;
Trace.WriteLine("EventManager.ctor: Timer.ctor(Timeout.Infinite, Timeout.Infinite)");
this.timer = new Timer(state => this.ResolveMissingEvents(this.cancellationTokenSource.Token), null, Timeout.Infinite, Timeout.Infinite);
// NOTE (Cameron): This will immediately resolve all missing events from the specified sequence number (eg. event re-playing).
this.IsEventReplaying = true;
new Task(() => this.ResolveMissingEvents(this.cancellationTokenSource.Token)).Start();
}
Configuration.EventResolvingWithOptionalViewSnapshottingOptions Configuration.EventResolvingWithOptionalViewSnapshotting.ResolveMissingEventsUsing(IEventResolver eventResolver)
{
return(this.ResolveMissingEventsUsing(eventResolver));
}
public EventManager(ISequenceResolver sequenceResolver, IEventResolver eventResolver, int timeout, IEventBuffer eventBuffer)
: this(sequenceResolver, eventResolver, timeout, eventBuffer, false)
{
}
public EventManager(ISequenceResolver sequenceResolver, IEventResolver eventResolver, int timeout)
: this(sequenceResolver, eventResolver, timeout, new EventBuffer(0L), true)
{
}
