public static IGetBase GetInstance(IUseMethod method, IGenerateSerie reporter)
{
if (method == null)
{
return(null);
}
IGetBase result = null;
var lastClass = GetInstance(method.Next, reporter);
if (method.TypeImpl == ETypeImpl.ASYNC)
{
result = GetInstanceAsync(method, reporter, lastClass);
}
else if (method.TypeImpl == ETypeImpl.SYNC)
{
result = GetInstanceNoAsync(method, reporter, lastClass);
}
return(result);
}
public MethodSyncWithNext(IMyWorkSync pMyWork, IGetBase pNext, IGenerateSerie gen, IUseMethod pMethod)
: base(pMyWork, gen, pMethod)
{
Next = pNext;
}
public Launcher(IGenerateSerie generaSerie, IGetBase implementacion)
{
_generaSerie = generaSerie;
_implementacion = implementacion;
}
private async void bttRun_Click(object sender, EventArgs e)
{
if (Method == null)
{
MessageBox.Show("The test is not well configured");
return;
}
string validation = Method.ValidateConfigurations();
if (!string.IsNullOrEmpty(validation))
{
MessageBox.Show(validation);
return;
}
bttPrint.Visible = false;
this.Enabled = false; /*deshabilita pantalla*/
ReportGenerator reporter = new ReportGenerator();
IGetBase implementacionMain = null;
informe = null;
try
{
Launcher launcherMethods = null;
implementacionMain = HowToWorkAsync.ImpDynamic.FactoryImpl.GetInstance(Method, reporter);
string resValidate = implementacionMain.Validate();
if (!string.IsNullOrEmpty(resValidate))
{
MessageBox.Show(resValidate);
this.Enabled = true;
return;
}
try
{
launcherMethods = new Launcher(reporter, implementacionMain);
informe = await launcherMethods.Run();
}
catch (Exception ex1)
{
reporter.FillingOutTheReport(ETypePoint.START_END, "Ex1", -1, Thread.CurrentThread.ManagedThreadId);
MessageBox.Show(ex1.Message);
}
}
catch (Exception ex)
{
reporter.FillingOutTheReport(ETypePoint.START_END, "Ex2", -1, Thread.CurrentThread.ManagedThreadId);
MessageBox.Show(ex.Message);
}
finally
{
}
try
{
if (informe != null)
{
var proc = CreateProcessor();
proc.Execute(informe);
if (chkAutoSave.Checked)
{
informe.ScenarioName = GetNameforReport();
proc.WriteToFile(informe, @"C:\Source\Repos\saved\");
}
}
}
catch (Exception ex)
{
this.Enabled = true;
MessageBox.Show(ex.Message);
}
this.Enabled = true;
bttPrint.Visible = true;
}
private static IGetStringAsync GetInstanceAsync(IUseMethod method, IGenerateSerie reporter, IGetBase lastClass)
{
if (method == null)
{
return(null);
}
var processing = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
IStrategyTodo todo = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
MyWorkAsync myW = null;
switch (method.StrategyDoIndependentWork)
{
case EStrategyDoIndependentWork.WRAPPER_ASYNC:
myW = new MyWorkAsyncWait(todo, reporter);
break;
case EStrategyDoIndependentWork.WRAPPER_ASYNC_AWAITER:
myW = new MyWorkAsyncAwaiter(todo, reporter);
break;
case EStrategyDoIndependentWork.NORMAL:
myW = new MyWorkAsyncNotWait(todo, reporter);
break;
}
if (method.Next == null)
{
return(new MainAsyncFinal(myW, reporter, processing, method));
}
else
{
IGetStringAsync result = null;
if (lastClass is IGetStringAsync)
{
switch (method.CallNext)
{
case ECallNext.WAIT_FIRST:
result = new CallNextAsyncWaitFirst(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.WAIT_AFTER:
result = new CallNextAsyncWaitAfter(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.AWAITER_AFTER:
result = new CallNextAsyncAwaiter(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.NOT_WAIT:
result = new CallNextAsyncNotWait(myW, (IGetStringAsync)lastClass, reporter, method);
break;
}
}
else
{
result = new CallNextAsyncToSync(myW, (IGetString)lastClass, reporter, method);
}
return(result);
}
}
private static IGetString GetInstanceNoAsync(IUseMethod method, IGenerateSerie reporter, IGetBase lastClass)
{
if (method == null)
{
return(null);
}
var processing = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
IStrategyTodo todo = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
MyWorkSync myW = new MyWorkSync(todo, reporter);
if (method.Next == null)
{
return(new MethodSyncFinal(myW, reporter, processing, method));
}
else
{
IGetString result = null;
if (lastClass is IGetString)
{
result = new CallNextSyncIfNextMethodIsSync(myW, (IGetString)lastClass, reporter, method);
}
else if (lastClass is IGetStringAsync)
{
switch (method.CallNext)
{
case ECallNext.WAIT_FIRST:
result = new CallNextSyncWaitFirstIfNextMethodIsAsync(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.WAIT_AFTER:
case ECallNext.AWAITER_AFTER:
case ECallNext.NOT_WAIT:
result = new CallNextSyncWaitAfterIfNextMethodIsAsync(myW, (IGetStringAsync)lastClass, reporter, method);
break;
}
}
return(result);
}
}
