async void HandleDocumentChanged(object sender, DocumentChangedEventArgs e)
{
if (server.ClientsCount == 0)
{
return;
}
FormsViewClassDeclaration classDecl = null;
try
{
classDecl = await DocumentParser.ParseDocument(e.Filename, e.Text, e.SyntaxTree, e.SemanticModel);
}
catch (Exception ex)
{
Log.Exception(ex);
await server.Send(new ErrorMessage($"Error parsing {e.Filename}",
ex.ToString()));
return;
}
if (classDecl == null)
{
return;
}
EvalRequestMessage request = new EvalRequestMessage
{
Declarations = classDecl.Code,
NeedsRebuild = classDecl.NeedsRebuild,
OriginalTypeName = classDecl.FullNamespace,
NewTypeName = classDecl.CurrentFullNamespace,
Xaml = classDecl.Xaml,
XamlResourceName = classDecl.XamlResourceId,
StyleSheets = classDecl.StyleSheets
};
try
{
await server.Send(request);
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
async Task <EvalResult> EvalOnMainThread(EvalRequestMessage code, CancellationToken token)
{
EvalResult evalResult = new EvalResult();
var sw = new System.Diagnostics.Stopwatch();
Log.Debug($"Evaluating code");
sw.Start();
currentEvalRequest = code;
if (evaluator.IsEvaluationSupported)
{
if (code.NeedsRebuild)
{
await evaluator.EvaluateCode($"new {code.NewTypeName} ()", evalResult, code.Declarations);
if (!evalResult.HasErrors && evalResult.HasResult)
{
evalResult.ResultType = evalResult.Result.GetType();
}
}
else
{
evalResult.ResultType = GetTypeByName(code.NewTypeName);
}
}
else
{
evalResult.ResultType = GetTypeByName(code.OriginalTypeName);
}
sw.Stop();
Log.Debug($"Evaluation ended with result");
evalResult.Duration = sw.Elapsed;
return(evalResult);
}
public Task <EvalResult> Eval(EvalRequestMessage code, TaskScheduler mainScheduler, CancellationToken token)
{
var tcs = new TaskCompletionSource <EvalResult>();
var r = new EvalResult();
lock (mutex)
{
Task.Factory.StartNew(async() =>
{
try
{
r = await EvalOnMainThread(code, token);
tcs.SetResult(r);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}, token, TaskCreationOptions.None, mainScheduler).Wait();
return(tcs.Task);
}
}
async Task HandleEvalRequest(EvalRequestMessage request)
{
EvalResponse evalResponse = new EvalResponse();
EvalResult result;
try
{
result = await vm.Eval(request, mainScheduler, CancellationToken.None);
if (result.HasResult || result.ResultType != null)
{
await uiToolkit.RunInUIThreadAsync(async() =>
{
try
{
await previewer.Preview(result);
}
catch (Exception ex)
{
errorViewModel.SetError("Oh no! An exception!", ex);
await previewer.NotifyError(errorViewModel);
}
});
}
else
{
await uiToolkit.RunInUIThreadAsync(async() =>
{
errorViewModel.SetError("Oh no! An evaluation error!", result);
await previewer.NotifyError(errorViewModel);
});
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
