public override void Execute()
{
if (!CanExecute())
{
throw new CannotExecuteCommandException(GetType());
}
var processingChainTemplate = _processingChainBuilderDataStore.ProcessingChainTemplate;
var processingStrategy = _processingChainBuilderDataStore.ProcessingStrategy;
var imageProviderTemplate = GetImageProviderTemplate(processingChainTemplate);
var imageProcessingChainAlgorithmsTemplates = GetImageProcessingChainAlgorithmsTemplates(processingChainTemplate);
var imageProvider = _imageProviderFactory.CreateInstance(imageProviderTemplate);
var imageProcessingChain = _imageProcessingChainFactory.BuildChain(imageProcessingChainAlgorithmsTemplates, imageProviderTemplate.ImageModel);
var processingEngineTemplate = new ProcessingEngineTemplate
{
ImageProvider = imageProvider,
ImageProcessingChain = imageProcessingChain,
ProcessingStrategy = processingStrategy
};
_shouldUpdateProcessingEngineEvent.Publish(processingEngineTemplate);
}
private void UpdateProcessingEngine(ProcessingEngineTemplate template)
{
template.ReceiveProcessedImageCommand = SetOutputImageCommand;
if (StopImageProcessingCommand.CanExecute())
{
StopImageProcessingCommand.Execute();
}
_processingService.UpdateProcessingEngine(template);
OnPropertyChanged(string.Empty);
}
public IProcessingEngine CreateInstance(ProcessingEngineTemplate template)
{
var imageProvider = template.ImageProvider;
var imageProcessingChain = template.ImageProcessingChain;
var receiveProcessedImageCommand = template.ReceiveProcessedImageCommand;
var processingStrategy = template.ProcessingStrategy;
switch (processingStrategy)
{
case ProcessingStrategy.Sync:
return(new SyncProcessingEngine(imageProvider, imageProcessingChain, receiveProcessedImageCommand));
case ProcessingStrategy.Async:
return(new AsyncProcessingEngine(imageProvider, imageProcessingChain, receiveProcessedImageCommand));
default:
throw new ArgumentOutOfRangeException(nameof(template.ProcessingStrategy));
}
}
public void ShouldThrowWhenProvidedUnsupportedProcessingStrategy()
{
// Given
const ProcessingStrategy processingStrategy = (ProcessingStrategy)3;
var imageProvider = new Mock <IImageProvider>().Object;
var imageProcessingChain = new Mock <IImageProcessingChain>().Object;
var receiveProcessedImageCommand = new Mock <IReceiveProcessedImageCommand>().Object;
var factory = new ProcessingEngineFactory();
var template = new ProcessingEngineTemplate
{
ProcessingStrategy = processingStrategy,
ImageProvider = imageProvider,
ImageProcessingChain = imageProcessingChain,
ReceiveProcessedImageCommand = receiveProcessedImageCommand
};
// When
// Then
Assert.Throws <ArgumentOutOfRangeException>(() => factory.CreateInstance(template));
}
public void ShouldCreateInstanceOfProcessingEngine(ProcessingStrategy processingStrategy)
{
// Given
var imageProvider = new Mock <IImageProvider>().Object;
var imageProcessingChain = new Mock <IImageProcessingChain>().Object;
var receiveProcessedImageCommand = new Mock <IReceiveProcessedImageCommand>().Object;
var factory = new ProcessingEngineFactory();
var template = new ProcessingEngineTemplate
{
ProcessingStrategy = processingStrategy,
ImageProvider = imageProvider,
ImageProcessingChain = imageProcessingChain,
ReceiveProcessedImageCommand = receiveProcessedImageCommand
};
// When
var engine = factory.CreateInstance(template);
// Then
Assert.IsNotNull(engine);
}
public void UpdateProcessingEngine(ProcessingEngineTemplate template)
{
ProcessingEngine?.Dispose();
ProcessingEngine = _processingEngineFactory.CreateInstance(template);
}
