private void CommandRunScriptExecuted(object sender, ExecutedRoutedEventArgs e)
{
e.Handled = true;
var pipe = m_CreateNewScriptOutputPipe();
pipe.OnScriptOutput += new EventHandler <ScriptOutputEventArgs>(OnScriptOutput);
m_ScriptRunInfo = new ScriptRunInformation
{
Language = Model.ScriptLanguage.Language,
Script = textEditor.Text,
ScriptOutput = pipe,
};
Model.RunCommand.Execute(m_ScriptRunInfo);
m_ScriptRunInfo.ScriptRunningTask.ContinueWith(
t =>
{
if (t.Status == TaskStatus.Faulted)
{
WriteToOutputWindow(t.Exception.ToString());
}
m_ScriptRunInfo.ScriptOutput.OnScriptOutput += new EventHandler <ScriptOutputEventArgs>(OnScriptOutput);
m_ScriptRunInfo = null;
},
TaskContinuationOptions.None);
}
public void CancelScriptRun()
{
using (var source = new CancellationTokenSource())
{
using (var task = Task.Factory.StartNew(
() => { },
source.Token,
TaskCreationOptions.None,
new CurrentThreadTaskScheduler()))
{
var tuple = new Tuple <Task, CancellationTokenSource>(task, source);
var scriptHost = new Mock <IHostScripts>();
{
scriptHost.Setup(s => s.Execute(It.IsAny <ScriptLanguage>(), It.IsAny <string>(), It.IsAny <TextWriter>()))
.Returns(tuple);
}
var command = new RunScriptCommand(scriptHost.Object);
Assert.IsTrue(command.CanExecute(null));
var info = new ScriptRunInformation
{
Language = ScriptLanguage.IronPython,
Script = "a",
ScriptOutput = new ScriptOutputPipe(),
};
command.Execute(info);
Assert.AreSame(tuple.Item1, info.ScriptRunningTask);
Assert.AreSame(tuple.Item2, info.CancellationToken);
}
}
}
/// <summary>
/// Runs a given script.
/// </summary>
/// <param name="scriptHost">The object that controls the script system.</param>
/// <param name="info">The information describing the running script.</param>
private static void OnRunScript(IHostScripts scriptHost, ScriptRunInformation info)
{
// If there is no facade then we're in design mode or something
// else weird.
if ((scriptHost == null) || (info == null))
{
return;
}
var result = scriptHost.Execute(info.Language, info.Script, info.ScriptOutput as TextWriter);
info.ScriptRunningTask = result.Item1;
info.CancellationToken = result.Item2;
}
/// <summary>
/// Cancels the running of the script.
/// </summary>
/// <param name="scriptHost">The object that controls the script system.</param>
/// <param name="info">The information describing the running script.</param>
/// <param name="timer">The function that creates and stores timing intervals.</param>
private static void OnCancelScriptRun(IHostScripts scriptHost, ScriptRunInformation info, Func <string, IDisposable> timer)
{
// If there is no facade then we're in design mode or something
// else weird.
if (scriptHost == null)
{
return;
}
if (info != null)
{
using (timer("Cancelling script run"))
{
// Note that the cancellation may take some time ...?
info.CancellationToken.Cancel();
info.ScriptRunningTask.Wait();
}
}
}
private void CommandCancelRunScriptExecuted(object sender, ExecutedRoutedEventArgs e)
{
e.Handled = true;
try
{
Model.CancelRunCommand.Execute(m_ScriptRunInfo);
try
{
m_ScriptRunInfo.ScriptRunningTask.Wait();
}
catch (AggregateException exception)
{
WriteToOutputWindow(exception.ToString());
}
}
finally
{
m_ScriptRunInfo.ScriptOutput.OnScriptOutput -= new EventHandler <ScriptOutputEventArgs>(OnScriptOutput);
m_ScriptRunInfo = null;
}
}
/// <summary>
/// Closes the script host.
/// </summary>
/// <param name="scriptHost">The object that controls the script system.</param>
/// <param name="info">The information describing the running script.</param>
/// <param name="timer">The function that creates and stores timing intervals.</param>
private static void OnCloseScript(IHostScripts scriptHost, ScriptRunInformation info, Func <string, IDisposable> timer)
{
// If there is no facade then we're in design mode or something
// else weird.
if (scriptHost == null)
{
return;
}
// All we do in here is to stop the script if it is running. There is nothing else to do
if (info != null)
{
using (timer("Closing script"))
{
if ((info.CancellationToken != null) && (info.ScriptRunningTask != null))
{
info.CancellationToken.Cancel();
info.ScriptRunningTask.Wait();
}
}
}
}
public void CloseScript()
{
var scriptHost = new Mock <IHostScripts>();
{
scriptHost.Setup(s => s.IsExecutingScript)
.Returns(true);
}
Func <string, IDisposable> func = s => new MockDisposable();
var command = new CloseScriptCommand(scriptHost.Object, func);
Assert.IsTrue(command.CanExecute(null));
var info = new ScriptRunInformation
{
ScriptRunningTask = Task.Factory.StartNew(() => { }),
CancellationToken = new CancellationTokenSource(),
};
command.Execute(info);
Assert.IsTrue(info.CancellationToken.IsCancellationRequested);
}
