static void Main(string[] args)
{
var pattern = Environment.GetEnvironmentVariable("Pattern");
switch (pattern)
{
case { } p when p == "1:Strategy":
StrategyExecutor.Execute();
break;
case { } p when p == "2:ObserverAndIterator":
ObserverAndIteratorExecutor.Execute();
break;
case { } p when p == "3:IoC":
IoCExecutor.Execute();
break;
case { } p when p == "4:AbstractFactoryAndBuilder":
AbstractFactoryAndBuilderExecutor.Execute();
break;
case { } p when p == "5:BFS_DFS_Iterator":
BfsDfsIteratorExecutor.Execute();
break;
}
}
static void Main(string[] args)
{
Console.WriteLine("=======================================");
Console.WriteLine("Benvindo ao Executor de Design Patterns");
Console.WriteLine("=======================================");
Console.WriteLine('\n');
Console.WriteLine("=======================================");
Console.WriteLine("Pressione : ");
Console.WriteLine("=======================================");
Console.WriteLine("(1) FactoryMethod ");
Console.WriteLine("(2) AbstractFactory ");
Console.WriteLine("(3) Singleton ");
Console.WriteLine("(4) Adapter ");
Console.WriteLine("(5) Facade ");
Console.WriteLine("(6) Strategy ");
Console.WriteLine('\n');
Console.WriteLine("Qualquer outra tecla para sair");
Console.WriteLine("=======================================");
var opcao = Console.ReadKey();
switch (opcao.KeyChar)
{
case '1':
FactoryMethodExecutor.Execute();
break;
case '2':
AbstractFactoryExecutor.Execute();
break;
case '3':
SingletonExecutor.Execute();
break;
case '4':
AdapterExecutor.Execute();
break;
case '5':
FacadeExecutor.Execute();
break;
case '6':
StrategyExecutor.Execute();
break;
default:
Environment.Exit(0);
break;
}
Console.ReadKey();
Console.Clear();
Main(new string[] { });
}
/// <summary>
/// Add new strategy instance
/// </summary>
/// <param name="strategyInstance"></param>
public void AddStrategyInstance(StrategyInstance strategyInstance)
{
//create strategy executor instance responsible for entire Strategy Instance life cycle
StrategyExecutor executor = new StrategyExecutor(strategyInstance, _currentDispatcher);
//subscribe to strategy event changed event
executor.StatusChanged += OnStrategyStatusChanged;
executor.ExecutionReceived += OnExecutionReceived;
//map the executor instance in dictionary
_strategiesCollection.TryAdd(strategyInstance.InstanceKey, executor);
}
public async System.Threading.Tasks.Task <TOut> ProcessAsync(TIn input)
{
TContext applicationContext = this._contextFactory.BuildContext();
applicationContext.Input = input;
IInvokeable applicationManager = new StrategyExecutor <TContext>(this._functions, applicationContext);
await applicationManager.InvokeAsync();
return(applicationContext.Result);
}
/// <summary>
/// Start Strategy Optimization
/// </summary>
/// <param name="optimizationParameters">Contains info for the parameters to be used for optimization</param>
private void StartOptimization(OptimizeStrategyBruteForce optimizationParameters)
{
try
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Getting argument combinations", _type.FullName, "StartOptimization");
}
// Clear all previous information
_strategiesCollection.Clear();
// Save Parameter Details
_parmatersDetails = optimizationParameters.ParmatersDetails;
// Get all ctor arguments to be used for optimization
CreateCtorCombinations(optimizationParameters.CtorArgs, optimizationParameters.ConditionalParameters);
// Initialize Stratgey for each set of arguments
foreach (object[] ctorArgument in _ctorArguments)
{
// Get new Key.
string key = ApplicationIdGenerator.NextId();
// Save Strategy details in new Strategy Executor object
StrategyExecutor strategyExecutor = new StrategyExecutor(key, optimizationParameters.StrategyType, ctorArgument);
// Register Event
strategyExecutor.StatusChanged += OnStrategyExecutorStatusChanged;
// Add to local map
_strategiesCollection.AddOrUpdate(key, strategyExecutor, (ky, value) => strategyExecutor);
}
// Start executing each instance
StartStrategyExecution();
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartOptimization");
}
}
/// <summary>
/// Start Strategy Optimization
/// </summary>
/// <param name="optimizationParameters">Contains info for the parameters to be used for optimization</param>
private void StartOptimization(BruteForceParameters optimizationParameters)
{
try
{
// Save instance
_optimizationParameters = optimizationParameters;
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Getting argument combinations", _type.FullName, "StartOptimization");
}
// Change Status to indicate on UI
_optimizationParameters.Status = OptimizationStatus.Working;
// Clear all previous information
_strategiesCollection.Clear();
_ctorArguments.Clear();
// Get Parameter values to be used in the Constructor
object[] ctorArguments = optimizationParameters.GetParameterValues();
// Get Conditional Parameter values to be used for creating Iterations
Tuple <int, object, double>[] conditionalParameters = optimizationParameters.GetConditionalParameters();
// Save Parameter Details
_parmatersDetails = optimizationParameters.ParameterDetails;
// Get all ctor arguments to be used for optimization
CreateCtorCombinations(ctorArguments, conditionalParameters);
// Initialize Stratgey for each set of arguments
foreach (object[] ctorArgumentValues in _ctorArguments)
{
// Get new Key.
string key = ApplicationIdGenerator.NextId();
var instanceParameterDetails = new Dictionary <string, ParameterDetail>();
for (int i = 0; i < ctorArgumentValues.Length; i++)
{
// Create new parameter details to be when creating Strategy Instance object
ParameterDetail tempParameterDetail = new ParameterDetail(_parmatersDetails[i].ParameterType, ctorArgumentValues[i]);
instanceParameterDetails.Add(_parmatersDetails[i].Description, tempParameterDetail);
}
// Create Strategy Instance object
var instance = new StrategyInstance(key, instanceParameterDetails, optimizationParameters.StrategyType);
// Save Strategy details in new Strategy Executor object
var strategyExecutor = new StrategyExecutor(instance, _currentDispatcher);
// Register Event
strategyExecutor.StatusChanged += OnStrategyExecutorStatusChanged;
// Add to local map
_strategiesCollection.AddOrUpdate(key, strategyExecutor, (ky, value) => strategyExecutor);
StringBuilder parametersInfo = new StringBuilder();
foreach (object ctorArgument in strategyExecutor.CtorArguments)
{
parametersInfo.Append(ctorArgument.ToString());
parametersInfo.Append(" | ");
}
// Create new object to be used with Event Aggregator
var optimizationStatistics = new OptimizationStatistics(strategyExecutor.StrategyKey);
optimizationStatistics.Description = parametersInfo.ToString();
optimizationStatistics.ExecutionDetails = instance.ExecutionDetails;
// Raise event to Bind statistics to UI and will be updated as each instance is executed
EventSystem.Publish <OptimizationStatistics>(optimizationStatistics);
}
// Save total number of iterations count
_optimizationParameters.TotalIterations = _strategiesCollection.Count;
// Start executing each instance
StartStrategyExecution();
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartOptimization");
}
}
