public void InvokeOnUiThread(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, "action");
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (IsUiThread)
{
action();
return;
}
#if WPF
Dispatcher.Invoke(action, ConvertToDispatcherPriority(priority), cancellationToken);
#else
using (EventWaitHandle wait = new AutoResetEvent(false))
{
Dispatcher.BeginInvoke(() =>
{
action();
wait.Set();
});
wait.WaitOne();
}
#endif
}
void IThreadManager.InvokeOnUiThread(Action action, OperationPriority priority,
CancellationToken cancellationToken)
{
InvokeOnUiThread = action;
if (ImmediateInvokeOnUiThread)
action();
}
/// <summary>
/// Invokes an action on the UI thread synchronous using the UiDispatcher.
/// </summary>
/// <param name="action">
/// The specified <see cref="Action" />.
/// </param>
/// <param name="priority">The specified <see cref="OperationPriority" /> to invoke the action.</param>
/// <param name="cancellationToken">An object that indicates whether to cancel the operation.</param>
public void InvokeOnUiThread(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, "action");
if (!cancellationToken.IsCancellationRequested)
action();
}
public void InvokeAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
Should.NotBeNull(action, nameof(action));
Task.Factory.StartNew(action, cancellationToken);
}
public void InvokeOnUiThread(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
if (cancellationToken.IsCancellationRequested)
return;
if (IsUiThread)
{
action();
return;
}
#if WPF
Dispatcher.Invoke(action, ConvertToDispatcherPriority(priority), cancellationToken);
#else
using (EventWaitHandle wait = new AutoResetEvent(false))
{
Dispatcher.BeginInvoke(() =>
{
action();
wait.Set();
});
wait.WaitOne();
}
#endif
}
public void InvokeAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
Should.NotBeNull(action, nameof(action));
Task.Factory.StartNew(action, cancellationToken);
}
void IThreadManager.InvokeOnUiThreadAsync(Action action, OperationPriority priority,
CancellationToken cancellationToken)
{
_invokeOnUiThreadAsync += action;
if (ImmediateInvokeOnUiThreadAsync)
InvokeOnUiThreadAsync();
}
void IThreadManager.InvokeAsync(Action action, OperationPriority priority, CancellationToken cancellationToken)
{
InvokeAsync = action;
if (ImmediateInvokeAsync)
{
InvokeAsync();
}
}
void IThreadManager.InvokeOnUiThread(Action action, OperationPriority priority,
CancellationToken cancellationToken)
{
InvokeOnUiThread = action;
if (ImmediateInvokeOnUiThread)
{
action();
}
}
public void InvokeOnUiThread(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, "action");
if (!cancellationToken.IsCancellationRequested)
{
action();
}
}
public void InvokeOnUiThread(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
if (cancellationToken.IsCancellationRequested)
return;
if (IsUiThread)
action();
else
_synchronizationContext.Send(state => ((Action)state).Invoke(), action);
}
public void InvokeOnUiThreadAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
if (cancellationToken.IsCancellationRequested)
return;
if (priority != OperationPriority.Low && IsUiThread)
action();
else
Dispatcher
.RunAsync(ConvertToDispatcherPriority(priority), new DispatchedHandler(action))
.AsTask(cancellationToken);
}
private static DispatcherPriority ConvertToDispatcherPriority(OperationPriority priority)
{
switch (priority)
{
case OperationPriority.Low:
return(DispatcherPriority.Background);
case OperationPriority.Normal:
return(DispatcherPriority.Normal);
case OperationPriority.High:
return(DispatcherPriority.Send);
default:
return(DispatcherPriority.Normal);
}
}
public void InvokeOnUiThread(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (IsUiThread)
{
action();
}
else
{
_synchronizationContext.Send(state => ((Action)state).Invoke(), action);
}
}
private static CoreDispatcherPriority ConvertToDispatcherPriority(OperationPriority priority)
{
switch (priority)
{
case OperationPriority.Low:
return(CoreDispatcherPriority.Low);
case OperationPriority.Normal:
return(CoreDispatcherPriority.Normal);
case OperationPriority.High:
return(CoreDispatcherPriority.High);
default:
return(CoreDispatcherPriority.Normal);
}
}
public void InvokeOnUiThreadAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (priority != OperationPriority.Low && IsUiThread)
{
action();
}
else
{
Dispatcher
.RunAsync(ConvertToDispatcherPriority(priority), new DispatchedHandler(action))
.AsTask(cancellationToken);
}
}
public void BeginInvoke(Action action, OperationPriority priority)
{
if (_isShuttingDown)
{
return;
}
_queue.Enqueue(new DispatcherJob(action), priority);
if (_isWaiting &&
_therad.ManagedThreadId != Thread.CurrentThread.ManagedThreadId)
{
_awakeFunction?.Invoke();
}
if (!_awaiter.IsSet && _awaiter is null)
{
_awaiter.Set();
}
}
public void InvokeOnUiThreadAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, nameof(action));
if (cancellationToken.IsCancellationRequested)
return;
if (priority != OperationPriority.Low && IsUiThread)
{
action();
return;
}
#if WPF
#if NET45
Dispatcher.InvokeAsync(action, ConvertToDispatcherPriority(priority), cancellationToken);
#else
Dispatcher.BeginInvoke(action, ConvertToDispatcherPriority(priority));
#endif
#else
Dispatcher.BeginInvoke(action);
#endif
}
private static ExpressionBase ParseExpression(PositionalTokenizer tokenizer, OperationPriority priority)
{
var expressionTokenizer = tokenizer as ExpressionTokenizer;
if (expressionTokenizer != null)
{
var queuedExpression = expressionTokenizer.DequeueExpression();
if (queuedExpression != null)
{
return(queuedExpression);
}
}
SkipWhitespace(tokenizer);
if (tokenizer.NextChar == '\0')
{
return(ParseError(tokenizer, "Unexpected end of script"));
}
var clause = ParseClause(tokenizer);
if (clause.Type == ExpressionType.ParseError || clause.Type == ExpressionType.Comment)
{
return(clause);
}
clause = ParseClauseExtension(clause, tokenizer, priority);
if (clause.Type == ExpressionType.ParseError)
{
return(clause);
}
Debug.Assert(clause.Location.Start.Line != 0);
Debug.Assert(clause.Location.Start.Column != 0);
Debug.Assert(clause.Location.End.Line != 0);
Debug.Assert(clause.Location.End.Column != 0);
return(clause);
}
public void InvokeOnUiThreadAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
Should.NotBeNull(action, "action");
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (priority != OperationPriority.Low && IsUiThread)
{
action();
return;
}
#if WPF
#if NET45
Dispatcher.InvokeAsync(action, ConvertToDispatcherPriority(priority), cancellationToken);
#else
Dispatcher.BeginInvoke(action, ConvertToDispatcherPriority(priority));
#endif
#else
Dispatcher.BeginInvoke(action);
#endif
}
private static DispatcherPriority ConvertToDispatcherPriority(OperationPriority priority)
{
switch (priority)
{
case OperationPriority.Low:
return DispatcherPriority.Background;
case OperationPriority.Normal:
return DispatcherPriority.Normal;
case OperationPriority.High:
return DispatcherPriority.Send;
default:
return DispatcherPriority.Normal;
}
}
static bool ShouldWrap(Expr expr, OperationPriority priority, ExpressionOrder order)
{
Func<OperationPriority, bool> shouldWrap = x => priority >= x;
return expr.MatchStrict(
add: x => shouldWrap(OperationPriority.Add),
mult: x => IsMinusExpression(x) || shouldWrap(OperationPriority.Multiply),
div: (x, y) => shouldWrap(OperationPriority.Divide),
power: (x, y) => true, //shouldWrap(OperationPriority.Power),
sqrt: x => false,
param: x => false,
@const: x => {
if(x.IsFraction())
return shouldWrap(OperationPriority.Power);
if(order == ExpressionOrder.Head)
return false;
return x < 0;
}
);
}
/// <summary>
/// Invokes an action asynchronous.
/// </summary>
/// <param name="action">
/// The specified <see cref="Action" />.
/// </param>
/// <param name="priority">The specified <see cref="OperationPriority" /> to invoke the action.</param>
/// <param name="cancellationToken">An object that indicates whether to cancel the operation.</param>
public void InvokeAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
InvokeOnUiThread(action, priority, cancellationToken);
}
static string Wrap(Expr expr, OperationPriority currentPriority, ExpressionOrder order)
{
bool wrap = ShouldWrap(expr, currentPriority, order);
string s = expr.Print();
if(wrap)
return "(" + s + ")";
return s;
}
public void InvokeAsync(Action action, OperationPriority priority = OperationPriority.Normal,
CancellationToken cancellationToken = default(CancellationToken))
{
InvokeOnUiThread(action, priority, cancellationToken);
}
private static ExpressionBase ParseClauseExtension(ExpressionBase clause, PositionalTokenizer tokenizer, OperationPriority priority)
{
do
{
var clauseEndLine = tokenizer.Line;
var clauseEndColumn = tokenizer.Column;
SkipWhitespace(tokenizer);
var joinerLine = tokenizer.Line;
var joinerColumn = tokenizer.Column;
switch (tokenizer.NextChar)
{
case '+':
if (priority == OperationPriority.AddSubtract && clause.Type == ExpressionType.StringConstant)
{
priority = OperationPriority.AppendString;
}
if (priority >= OperationPriority.AddSubtract)
{
return(clause);
}
tokenizer.Advance();
clause = ParseMathematic(tokenizer, clause, MathematicOperation.Add, joinerLine, joinerColumn);
break;
case '-':
if (priority >= OperationPriority.AddSubtract)
{
return(clause);
}
tokenizer.Advance();
clause = ParseMathematic(tokenizer, clause, MathematicOperation.Subtract, joinerLine, joinerColumn);
break;
case '*':
if (priority >= OperationPriority.MulDivMod)
{
return(clause);
}
tokenizer.Advance();
clause = ParseMathematic(tokenizer, clause, MathematicOperation.Multiply, joinerLine, joinerColumn);
break;
case '/':
if (priority >= OperationPriority.MulDivMod)
{
return(clause);
}
tokenizer.Advance();
clause = ParseMathematic(tokenizer, clause, MathematicOperation.Divide, joinerLine, joinerColumn);
break;
case '%':
if (priority >= OperationPriority.MulDivMod)
{
return(clause);
}
tokenizer.Advance();
clause = ParseMathematic(tokenizer, clause, MathematicOperation.Modulus, joinerLine, joinerColumn);
break;
case '=':
if (tokenizer.MatchSubstring("==") == 2)
{
if (priority >= OperationPriority.Compare)
{
return(clause);
}
tokenizer.Advance(2);
clause = ParseComparison(tokenizer, clause, ComparisonOperation.Equal, joinerLine, joinerColumn);
}
else
{
if (priority > OperationPriority.Assign)
{
return(clause);
}
tokenizer.Advance();
if (tokenizer.NextChar == '>')
{
tokenizer.Advance();
clause = AnonymousUserFunctionDefinitionExpression.ParseAnonymous(tokenizer, clause);
}
else
{
clause = ParseAssignment(tokenizer, clause, joinerLine, joinerColumn);
}
}
break;
case '!':
if (priority >= OperationPriority.Compare)
{
return(clause);
}
tokenizer.Advance();
if (tokenizer.NextChar != '=')
{
ParseError(tokenizer, "= expected following !", joinerLine, joinerColumn);
}
else
{
tokenizer.Advance();
clause = ParseComparison(tokenizer, clause, ComparisonOperation.NotEqual, joinerLine, joinerColumn);
}
break;
case '<':
if (priority >= OperationPriority.Compare)
{
return(clause);
}
tokenizer.Advance();
if (tokenizer.NextChar == '=')
{
tokenizer.Advance();
clause = ParseComparison(tokenizer, clause, ComparisonOperation.LessThanOrEqual, joinerLine, joinerColumn);
}
else
{
clause = ParseComparison(tokenizer, clause, ComparisonOperation.LessThan, joinerLine, joinerColumn);
}
break;
case '>':
if (priority >= OperationPriority.Compare)
{
return(clause);
}
tokenizer.Advance();
if (tokenizer.NextChar == '=')
{
tokenizer.Advance();
clause = ParseComparison(tokenizer, clause, ComparisonOperation.GreaterThanOrEqual, joinerLine, joinerColumn);
}
else
{
clause = ParseComparison(tokenizer, clause, ComparisonOperation.GreaterThan, joinerLine, joinerColumn);
}
break;
case '&':
if (tokenizer.MatchSubstring("&&") == 2)
{
if (priority >= OperationPriority.And)
{
return(clause);
}
tokenizer.Advance(2);
clause = ParseConditional(tokenizer, clause, ConditionalOperation.And, joinerLine, joinerColumn);
}
else
{
if (priority >= OperationPriority.BitwiseAnd)
{
return(clause);
}
tokenizer.Advance();
clause = ParseMathematic(tokenizer, clause, MathematicOperation.BitwiseAnd, joinerLine, joinerColumn);
}
break;
case '|':
if (priority >= OperationPriority.Or)
{
return(clause);
}
tokenizer.Advance();
if (tokenizer.NextChar != '|')
{
ParseError(tokenizer, "| expected following |", joinerLine, joinerColumn);
}
else
{
tokenizer.Advance();
clause = ParseConditional(tokenizer, clause, ConditionalOperation.Or, joinerLine, joinerColumn);
}
break;
default:
if (clause.Location.End.Column == 0)
{
clause.Location = new TextRange(clause.Location.Start, new TextLocation(clauseEndLine, clauseEndColumn));
}
return(clause);
}
if (clause.Type == ExpressionType.ParseError)
{
return(clause);
}
} while (true);
}
private static CoreDispatcherPriority ConvertToDispatcherPriority(OperationPriority priority)
{
switch (priority)
{
case OperationPriority.Low:
return CoreDispatcherPriority.Low;
case OperationPriority.Normal:
return CoreDispatcherPriority.Normal;
case OperationPriority.High:
return CoreDispatcherPriority.High;
default:
return CoreDispatcherPriority.Normal;
}
}
public OperationBase(OperationPriority priority, bool isUnary)
{
this.Priority = priority;
this.IsUnary = isUnary;
}
public DecimalOperationBase(OperationPriority priority, bool isUnary)
: base(priority, isUnary)
{
}
public int StartRoutine(IEnumerator routine, OperationType type = OperationType.Continuous, OperationPriority priority = OperationPriority.Normal)
{
var operation = new Operation
{
Id = _idCounter,
Enumerator = routine,
Priority = priority,
Type = type
};
_idCounter++;
_operations.Add(operation);
return(operation.Id);
}
