static ICrossBoard GenerateFirstCrossWord(ICrossBoard board, ICrossDictionary dictionary, string puzzle)
{
var placer = new PuzzlePlacer(board, puzzle);
var cts = new CancellationTokenSource();
var mre = new ManualResetEvent(false);
ICrossBoard successFullBoard = null;
foreach (var boardWithPuzzle in placer.GetAllPossiblePlacements(dictionary))
{
//boardWithPuzzle.WriteTo(new StreamWriter(Console.OpenStandardOutput(), Console.OutputEncoding) { AutoFlush = true });
var gen = new CrossGenerator(dictionary, boardWithPuzzle);
var t = Task.Factory.StartNew(() =>
{
foreach (var solution in gen.Generate())
{
successFullBoard = solution;
cts.Cancel();
mre.Set();
break; //interested in the first one
}
}, cts.Token);
if (cts.IsCancellationRequested)
break;
}
mre.WaitOne();
return successFullBoard;
}
public void Run()
{
while (true)
{
var fetch = CommonTasks.ExecuteScript("Crawlers\\Scripts\\Bicing.js");
var parse = fetch.ContinueWith<Tuple<Station, NameValueCollection>[]>(Parse, TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously);
var store = parse.ContinueWith(Store, TaskContinuationOptions.OnlyOnRanToCompletion);
try
{
Task.WaitAll(fetch, parse, store);
}
catch (AggregateException e)
{
e.Handle(x =>
{
System.Console.WriteLine(x.Message);
return true;
});
}
CancellationTokenSource source = new CancellationTokenSource();
Task.Factory.StartNew(() => StationLoop(parse.Result), source.Token);
Thread.Sleep(TimeSpan.FromHours(12));
source.Cancel();
}
}
public void Dulicate_message_is_detected()
{
var builder = new CqrsEngineBuilder();
builder.Memory(m =>
{
m.AddMemorySender("in", s => s.IdGenerator(() => "same"));
m.AddMemoryRouter("in", c => "memory:null");
});
var observer = new ImmediateEventsObserver();
builder.Advanced.RegisterObserver(observer);
using (var token = new CancellationTokenSource())
using (var build = builder.Build())
{
var sender = build.Resolve<IMessageSender>();
sender.SendOne(new Message());
sender.SendOne(new Message());
observer.Event += @event =>
{
var e = @event as EnvelopeDuplicateDiscarded;
if (e != null)
{
token.Cancel();
}
};
build.Start(token.Token);
token.Token.WaitHandle.WaitOne(10000);
Assert.IsTrue(token.IsCancellationRequested);
}
}
public async Task Start(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
Settings.Default.Reload();
var imageInfo = GetLatestImageInfo();
if (imageInfo != null)
{
var image = AssembleImageFrom(imageInfo);
var imageFile = SaveImage(image);
Wallpaper.Set(imageFile, Wallpaper.Style.Fit);
}
if (Settings.Default.Interval > 0)
{
_internalTokenSource = new CancellationTokenSource();
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_internalTokenSource.Token, token))
{
try
{
await Task.Delay(TimeSpan.FromMinutes(Settings.Default.Interval), linkedCts.Token);
}
catch
{
// ignore exception raised by token cancellation
}
}
}
}
}
public CancelableTask(Action task, Action onSuccess)
{
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
_task = task;
_onSuccess = onSuccess;
}
public async Task ExecuteAsync_calls_Commit_if_no_transaction()
{
var mockModificationCommandBatch = new Mock<ModificationCommandBatch>();
mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1);
var mockRelationalConnection = new Mock<IRelationalConnection>();
var transactionMock = new Mock<IDbContextTransaction>();
IDbContextTransaction currentTransaction = null;
mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object);
mockRelationalConnection.Setup(m => m.CurrentTransaction).Returns(() => currentTransaction);
var cancellationToken = new CancellationTokenSource().Token;
var batchExecutor = new BatchExecutor();
await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);
mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
mockRelationalConnection.Verify(rc => rc.Close());
transactionMock.Verify(t => t.Commit());
mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(
It.IsAny<IRelationalConnection>(),
cancellationToken));
}
static void testCancellation()
{
IEnumerable<int> million = Enumerable.Range (3, 1000000);
var cancelSource = new CancellationTokenSource();
var primeNumberQuery =
from n in million.AsParallel().WithCancellation (cancelSource.Token)
where Enumerable.Range (2, (int) Math.Sqrt (n)).All (i => n % i > 0)
select n;
new Thread (() => {
Thread.Sleep (100); // Cancel query after
cancelSource.Cancel(); // 100 milliseconds.
}).Start();
try
{
// Start query running:
int[] primes = primeNumberQuery.ToArray();
// We'll never get here because the other thread will cancel us.
}
catch (OperationCanceledException)
{
Console.WriteLine("Query canceled");
}
}
public static List<ClrType> GetDelegateTypes(ClrDump clrDump)
{
CancellationTokenSource token = new CancellationTokenSource();
clrDump.MessageBus.BeginTask("Analyzing delegate types...", token);
List<ClrType> delegates = new List<ClrType>();
var delegateType = clrDump.GetClrType(typeof(MulticastDelegate).FullName);
foreach(var type in clrDump.AllTypes)
{
clrDump.MessageBus.Status($"Analyzing delegate type: {type.Name}");
if (token.IsCancellationRequested)
{
break;
}
if ( type.BaseType != null && type.BaseType == delegateType )
{
clrDump.MessageBus.Status($"Analyzing delegate type: counting instances for {type.Name}");
int nb = clrDump.CountInstances(type);
if (nb > 0)
{
delegates.Add(type);
}
}
}
clrDump.MessageBus.EndTask("Delegate types analyzed.");
return delegates.GroupBy(t => t.Name).Select(g => g.First()).ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="AsynchronousTraceListenerWrapper" /> class.
/// </summary>
/// <param name="wrappedTraceListener">The wrapped trace listener.</param>
/// <param name="ownsWrappedTraceListener">Indicates whether the wrapper should dispose the wrapped trace listener.</param>
/// <param name="bufferSize">Size of the buffer for asynchronous requests.</param>
/// <param name="maxDegreeOfParallelism">The max degree of parallelism for thread safe listeners. Specify <see langword="null"/> to use the current core count.</param>
/// <param name="disposeTimeout">The timeout for waiting to complete buffered requests when disposing. When <see langword="null" /> the default of <see cref="Timeout.InfiniteTimeSpan" /> is used.</param>
public AsynchronousTraceListenerWrapper(
TraceListener wrappedTraceListener,
bool ownsWrappedTraceListener = true,
int? bufferSize = DefaultBufferSize,
int? maxDegreeOfParallelism = null,
TimeSpan? disposeTimeout = null)
{
Guard.ArgumentNotNull(wrappedTraceListener, "wrappedTraceListener");
CheckBufferSize(bufferSize);
CheckMaxDegreeOfParallelism(maxDegreeOfParallelism);
CheckDisposeTimeout(disposeTimeout);
this.wrappedTraceListener = wrappedTraceListener;
this.ownsWrappedTraceListener = ownsWrappedTraceListener;
this.disposeTimeout = disposeTimeout ?? Timeout.InfiniteTimeSpan;
this.closeSource = new CancellationTokenSource();
this.requests = bufferSize != null ? new BlockingCollection<Action<TraceListener>>(bufferSize.Value) : new BlockingCollection<Action<TraceListener>>();
if (this.wrappedTraceListener.IsThreadSafe)
{
this.maxDegreeOfParallelism = maxDegreeOfParallelism.HasValue ? maxDegreeOfParallelism.Value : Environment.ProcessorCount;
this.asyncProcessingTask = Task.Factory.StartNew(this.ProcessRequestsInParallel, CancellationToken.None, TaskCreationOptions.HideScheduler | TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
else
{
this.asyncProcessingTask = Task.Factory.StartNew(this.ProcessRequests, CancellationToken.None, TaskCreationOptions.HideScheduler | TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
}
public static IYubicoResponse Validate(IEnumerable<string> urls, string userAgent)
{
var tasks = new List<Task<IYubicoResponse>>();
var cancellation = new CancellationTokenSource();
foreach (var url in urls)
{
var thisUrl = url;
var task = new Task<IYubicoResponse>(() => DoVerify(thisUrl, userAgent), cancellation.Token);
task.ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted);
tasks.Add(task);
task.Start();
}
while (tasks.Count != 0)
{
// TODO: handle exceptions from the verify task. Better to be able to propagate cause for error.
var completed = Task.WaitAny(tasks.Cast<Task>().ToArray());
var task = tasks[completed];
tasks.Remove(task);
if (task.Result != null)
{
cancellation.Cancel();
return task.Result;
}
}
return null;
}
public Task SearchAsync(string searchPattern, FileSearchMode mode, int count, IFileCollection files, CancellationToken cancellationToken)
{
if (String.IsNullOrEmpty(searchPattern))
{
files.Clear();
foreach (string filePath in pinStateService.GetList())
files.Add(Path.GetFileNameWithoutExtension(filePath), filePath, true);
if (lastCancellation != null)
{
lastCancellation.Cancel();
lastCancellation = null;
}
return Task.FromResult(true);
}
if (cancellationToken.IsCancellationRequested)
return Async.CompletedTask;
lastCancellation = new CancellationTokenSource();
cancellationToken.Register(() => lastCancellation.Cancel());
Task result = innerService.SearchAsync(searchPattern, mode, count, files, lastCancellation.Token);
return result;
}
private async Task run(params string[] args)
{
_logger.LogInformation("Ready to serve");
var msg = Configuration["msg"];
var env = Configuration["ASPNET_ENV"];
if (env == "Development")
{
Console.WriteLine("You played the shareware, now buy the game");
}
else
{
Console.WriteLine("Ready to serve, my lord.");
}
if (string.IsNullOrEmpty(msg))
{
Console.WriteLine("Even elder races get tired of waiting.");
}
else
{
Console.WriteLine($"By your command: {msg}");
}
using (var currentRunCancellationSource = new CancellationTokenSource())
{
var dnxTask = WaitForDnxToExitAsync(currentRunCancellationSource.Token);
int finishedTaskIndex = Task.WaitAny(dnxTask);
}
_logger.LogInformation("Job's done");
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
var ts = new CancellationTokenSource();
var host = Bootstrapper.Boot();
host.Start(ts.Token);
// var bus = new FakeBus();
//
// var storage = new EventStore(bus);
// var rep = new Repository<InventoryItem>(storage);
// var commands = new InventoryCommandHandlers(rep);
// bus.RegisterHandler<CheckInItemsToInventory>(commands.Handle);
// bus.RegisterHandler<CreateInventoryItem>(commands.Handle);
// bus.RegisterHandler<DeactivateInventoryItem>(commands.Handle);
// bus.RegisterHandler<RemoveItemsFromInventory>(commands.Handle);
// bus.RegisterHandler<RenameInventoryItem>(commands.Handle);
// var detail = new InvenotryItemDetailView();
// bus.RegisterHandler<InventoryItemCreated>(detail.Handle);
// bus.RegisterHandler<InventoryItemDeactivated>(detail.Handle);
// bus.RegisterHandler<InventoryItemRenamed>(detail.Handle);
// bus.RegisterHandler<ItemsCheckedInToInventory>(detail.Handle);
// bus.RegisterHandler<ItemsRemovedFromInventory>(detail.Handle);
// var list = new InventoryListView();
// bus.RegisterHandler<InventoryItemCreated>(list.Handle);
// bus.RegisterHandler<InventoryItemRenamed>(list.Handle);
// bus.RegisterHandler<InventoryItemDeactivated>(list.Handle);
// ServiceLocator.Bus = bus;
}
public void WhenProcessTimesOut_TaskIsCanceled()
{
// Arrange
const int expectedExitCode = 123;
const int millisecondsForTimeout = 3 * 1000;
const int millisecondsToSleep = 5 * 1000;
const int expectedStandardOutputLineCount = 5;
const int expectedStandardErrorLineCount = 3;
// Act
var pathToConsoleApp = typeof(DummyConsoleApp.Program).Assembly.Location;
var arguments = String.Join(" ", expectedExitCode, millisecondsToSleep, expectedStandardOutputLineCount, expectedStandardErrorLineCount);
var startInfo = new ProcessStartInfo(pathToConsoleApp, arguments);
var cancellationToken = new CancellationTokenSource(millisecondsForTimeout).Token;
var task = ProcessEx.RunAsync(startInfo, cancellationToken);
// Assert
Assert.IsNotNull(task);
try
{
var results = task.Result;
Assert.Fail("Timeout did not occur");
}
catch (AggregateException aggregateException)
{
// expected
Assert.AreEqual(1, aggregateException.InnerExceptions.Count);
var innerException = aggregateException.InnerExceptions.Single();
Assert.IsInstanceOfType(innerException, typeof(OperationCanceledException));
var canceledException = innerException as OperationCanceledException;
Assert.IsNotNull(canceledException);
Assert.IsTrue(cancellationToken.IsCancellationRequested);
}
Assert.AreEqual(TaskStatus.Canceled, task.Status);
}
public CommandProcessor(ICommandProcessingStrategy processingStrategy,
ICommandQueue commandQueue)
{
_processingStrategy = processingStrategy;
_commandQueue = commandQueue;
_cancellationTokenSource = new CancellationTokenSource();
var token = _cancellationTokenSource.Token;
var task = new Task(
() =>
{
while (!token.IsCancellationRequested)
{
var cmd = _commandQueue.Dequeue();
while (cmd != null)
{
_processingStrategy.ProcessCommand(cmd.Execute);
cmd = commandQueue.Dequeue();
}
Thread.Sleep(100);
}
},
token,
TaskCreationOptions.LongRunning);
task.Start();
}
private void search_button_click(object sender, RoutedEventArgs e)
{
clear_interface();
//
// Stop the previous search.
//
if (_searchCts != null && _searchCts.IsCancellationRequested == false)
{
_searchCts.Cancel();
}
//
// Start a new search.
//
if ((_currentSearchTerm = _textBox.Text).IsNullOrEmpty())
{
return;
}
_searchCts = new CancellationTokenSource();
start_search();
}
private static void Main(string[] args)
{
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress +=
(sender, e) =>
{
e.Cancel = true;
cts.Cancel();
};
// Since Console apps do not have a SyncronizationContext, we're leveraging the built-in support
// in WPF to pump the messages via the Dispatcher.
// See the following for additional details:
// http://blogs.msdn.com/b/pfxteam/archive/2012/01/21/10259307.aspx
// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/pull/1362
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var context = new DispatcherSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
DispatcherFrame dispatcherFrame = new DispatcherFrame();
Task mainTask = MainAsync(args, cts.Token);
mainTask.ContinueWith(task => dispatcherFrame.Continue = false);
Dispatcher.PushFrame(dispatcherFrame);
mainTask.GetAwaiter().GetResult();
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public void Start(Func<Task> callback, TimeSpan? interval, Action<Exception> errorCallback)
{
tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
task = Task.Run(async () =>
{
while (!token.IsCancellationRequested)
{
try
{
if (interval.HasValue)
{
await Task.Delay(interval.Value, token).ConfigureAwait(false);
}
else
{
tokenSource.Cancel();
}
await callback().ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// nop
}
catch (Exception ex)
{
errorCallback(ex);
}
}
}, CancellationToken.None);
}
public async Task<XLocation> GetQuickLocation()
{
Setup();
var loc = new XLocation();
_cancelSource = new CancellationTokenSource();
await _geolocator.GetPositionAsync(1500, _cancelSource.Token, false)
.ContinueWith(t =>
{
if (t.IsCanceled || t.IsFaulted)
{
var x = new XLocation();
x.IsResolved = false;
x.Status = XPositionStatus.NotAvailble;
return x;
}
loc.Latitude = t.Result.Latitude;
loc.Longitude = t.Result.Longitude;
loc.Accuracy = t.Result.Accuracy;
loc.Heading = t.Result.Heading;
loc.IsEnabled = true;
loc.IsResolved = true;
loc.Status = XPositionStatus.Ready;
return loc;
}, _scheduler);
return loc;
}
//probe==StartBounder
public bool GeneratePasswords(int[] probe, int[] startBoundary, int[] endBoundary, int depth, int range, CancellationToken ct, CancellationTokenSource tokenSource, Action<string> sendPassword)
{
bool result = false;
char[] probeChar = CharForThread(probe, _options);
string probeString = String.Join("", probeChar);
if (depth==0)
{
Console.WriteLine(probeString);
if (VerifyMd5Hash(probeString))
{
Password = probeString;
sendPassword(Password);
return true;
}
return false;
}
if (ct.IsCancellationRequested)
{
Console.WriteLine("Task is canceled");
}
if (probe.SequenceEqual(endBoundary)) return false;
for (int i = 0; i < range; i++)
{
probe[depth - 1] = i;
result = GeneratePasswords(probe, startBoundary, endBoundary, depth - 1, range, ct, tokenSource, sendPassword);
if (result) break;
}
return result;
}
internal AnalysisQueue(VsProjectAnalyzer analyzer) {
_workEvent = new AutoResetEvent(false);
_cancel = new CancellationTokenSource();
_analyzer = analyzer;
// save the analysis once it's ready, but give us a little time to be
// initialized and start processing stuff...
_lastSave = DateTime.Now - _SaveAnalysisTime + TimeSpan.FromSeconds(10);
_queue = new List<IAnalyzable>[PriorityCount];
for (int i = 0; i < PriorityCount; i++) {
_queue[i] = new List<IAnalyzable>();
}
_enqueuedGroups = new HashSet<IGroupableAnalysisProject>();
_workThread = new Thread(Worker);
_workThread.Name = "Node.js Analysis Queue";
_workThread.Priority = ThreadPriority.BelowNormal;
_workThread.IsBackground = true;
// start the thread, wait for our synchronization context to be created
using (AutoResetEvent threadStarted = new AutoResetEvent(false)) {
_workThread.Start(threadStarted);
threadStarted.WaitOne();
}
}
public DatabaseBulkOperations(DocumentDatabase database, TransactionInformation transactionInformation, CancellationTokenSource tokenSource, CancellationTimeout timeout)
{
this.database = database;
this.transactionInformation = transactionInformation;
this.tokenSource = tokenSource;
this.timeout = timeout;
}
/// <summary>
/// Starts to run a build inside the SharpDevelop GUI.
/// Only one build can run inside the GUI at one time.
/// </summary>
/// <param name="project">The project/solution to build.</param>
/// <param name="options">The build options.</param>
public static void BuildInGui(IBuildable project, BuildOptions options)
{
if (project == null)
throw new ArgumentNullException("project");
if (options == null)
throw new ArgumentNullException("options");
WorkbenchSingleton.AssertMainThread();
if (guiBuildCancellation != null) {
BuildResults results = new BuildResults();
WorkbenchSingleton.StatusBar.SetMessage(Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
BuildError error = new BuildError(null, Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
results.Add(error);
TaskService.Add(new Task(error));
results.Result = BuildResultCode.MSBuildAlreadyRunning;
if (options.Callback != null) {
options.Callback(results);
}
} else {
guiBuildCancellation = new CancellationTokenSource();
IProgressMonitor progressMonitor = WorkbenchSingleton.StatusBar.CreateProgressMonitor(guiBuildCancellation.Token);
guiBuildTrackedFeature = AnalyticsMonitorService.TrackFeature("ICSharpCode.SharpDevelop.Project.BuildEngine.Build");
WorkbenchSingleton.StatusBar.SetMessage(StringParser.Parse("${res:MainWindow.CompilerMessages.BuildVerb}..."));
ProjectService.RaiseEventBuildStarted(new BuildEventArgs(project, options));
StartBuild(project, options,
new MessageViewSink(TaskService.BuildMessageViewCategory, progressMonitor, WorkbenchSingleton.StatusBar));
}
}
public static int Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("KestrelHelloWorld <url to host>");
return 1;
}
var url = new Uri(args[0]);
Args = string.Join(" ", args);
var host = new WebHostBuilder()
.UseServer("Microsoft.AspNetCore.Server.Kestrel")
.UseUrls(url.ToString())
.UseStartup<Startup>()
.Build();
ServerCancellationTokenSource = new CancellationTokenSource();
// shutdown server after 20s.
var shutdownTask = Task.Run(async () =>
{
await Task.Delay(20000);
ServerCancellationTokenSource.Cancel();
});
host.Run(ServerCancellationTokenSource.Token);
shutdownTask.Wait();
return 0;
}
public void TestWaitReleaseAsyncWithCancellation()
{
// TODO: rewrite test once cancellation is properly supported during systematic testing.
this.Test(async() =>
{
Semaphore semaphore = Semaphore.Create(1, 1);
Specification.Assert(semaphore.CurrentCount is 1, "Semaphore count is {0} instead of 1.",
semaphore.CurrentCount);
SystemTasks.CancellationTokenSource tokenSource = new SystemTasks.CancellationTokenSource();
Task task = Task.Run(async() =>
{
await Task.Delay(1);
tokenSource.Cancel();
});
await semaphore.WaitAsync(tokenSource.Token);
Specification.Assert(semaphore.CurrentCount is 0 || semaphore.CurrentCount is 1,
"Semaphore count is {0} instead of 0 or 1.", semaphore.CurrentCount);
semaphore.Release();
Specification.Assert(semaphore.CurrentCount is 1, "Semaphore count is {0} instead of 1.",
semaphore.CurrentCount);
await task;
semaphore.Dispose();
});
}
private async void button1_Click(object sender, EventArgs e)
{
progressBarSample = new ProgressBarSample();
progressBarSample.ProgressChanged += OnProgressChanged;
cancellationTokenSource = new System.Threading.CancellationTokenSource();
var token = cancellationTokenSource.Token;
string message = "";
bool isError = false;
try
{
var task = await Task <bool> .Factory.StartNew(() => progressBarSample.Work(token), token);
//await task;
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
isError = true;
message = $"Произошла ошибка {ex.Message}";
}
if (!isError)
{
message = true ? "Процесс отменет" : "Процесс завершен";
}
MessageBox.Show(message);
}
/// <summary>
/// Classe à utiliser dans les tâches, pour retourner une progression et permettre l'annulation, Ajouter dans les boucles une vérification de IsCancellationRequested
/// </summary>
/// <param name="iProgressAction">Action à executer lors d'une progression, ex : Action<NotifierProgress> progressAction = (value) => {textBox1.Text = value.ProgressCount + " " + value.Message; }; </param>
public ProgressCancelNotifier(Action <NotifierProgress> iProgressAction, string iName = null)
{
CancellationTokenSource = new System.Threading.CancellationTokenSource();
Name = iName;
SetProgressAction(iProgressAction);
Guid = new Guid().ToString();
}
public async Task SendMessage(WebSocket socket, string message)
{
System.Threading.CancellationTokenSource cancelationTokenSource = new System.Threading.CancellationTokenSource();
ArraySegment <byte> buffer = new ArraySegment <byte>(System.Text.Encoding.ASCII.GetBytes(message.ToCharArray()));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, cancelationTokenSource.Token);
}
public Generator()
{
cancelSource = new CancellationTokenSource();
cancelToken = cancelSource.Token;
Stalled += StalledEventHandler;
running = false;
}
public FetchedJobsWatcherFacts()
{
var options = new RedisStorageOptions() { Db = RedisUtils.GetDb() };
_storage = new RedisStorage(RedisUtils.GetHostAndPort(), options);
_cts = new CancellationTokenSource();
_cts.Cancel();
}
// Message per hour
//const string TimeUnit = "h";
//private readonly long TicksPerTimeUnit = Stopwatch.Frequency * 3600;
public void Start()
{
Log.Info("Starting...");
stopLoop = new CancellationTokenSource();
loopTask = Task.Factory.StartNew(Loop, TaskCreationOptions.LongRunning);
Log.Info("Started");
}
private void UpdateData()
{
rootGrid.DataContext = null;
// обновление данных согласно нового временного периода
var cts = new System.Threading.CancellationTokenSource();
var task = EmcosSiteWrapper.Instance.ExecuteAction(cts, () =>
{
//State = State.Busy;
var substation = _balance.Substation.Copy() as Model.Balance.Substation;
substation.ClearData();
Utils.GetArchiveDataForSubstation(_balance.Period.StartDate, _balance.Period.EndDate, substation, cts, UpdateCallBack);
foreach (Model.Balance.IBalanceItem i in substation.Items)
{
i.SetSubstation(substation);
}
_balance.Initialize(_balance.Period);
DispatcherExtensions.InUi(() =>
{
Create_tableColumns();
rootGrid.DataContext = _balance;
table.ItemsSource = _balance.Items;
//Progress = 0;
});
//State = State.Idle;
});
}
private static void ScheduleNewJob(Project proj)
{
var cts = new System.Threading.CancellationTokenSource();
var token = cts.Token;
var jobInfo = CreateJob_DaylightFactor();
//var jobInfo = CreateJob_AnnualDaylight();
try
{
jobInfo.SetJobSubFolderPath("round1/test");
jobInfo.SetJobName("A new daylight simulation");
// run a job
var task = jobInfo.RunJobOnCloud(proj, (s) => Console.WriteLine(s), token);
//cts.CancelAfter(60000);
var scheduledJob = task.Result;
// watch status
var watchTask = scheduledJob.WatchJobStatusAsync((s) => Console.WriteLine(s), token);
watchTask.Wait();
Console.WriteLine($"Canceled check: {token.IsCancellationRequested}");
cts.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException.Message);
//throw;
}
}
public async Task Register(string user, WebSocket websocket)
{
WebSocket currentWebSocket;
if (connections.TryGetValue(user, out currentWebSocket))
{
if (currentWebSocket.State == WebSocketState.CloseReceived)
{
await currentWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Existing connection", CancellationToken.None)
.ContinueWith(a => currentWebSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Existing connection", CancellationToken.None))
.ContinueWith(a => Console.Write("closed connection"));
connections.Remove(user);
}
else
{
var userConnection = connections[user];
System.Threading.CancellationTokenSource cancelationTokenSource = new System.Threading.CancellationTokenSource();
ArraySegment <byte> buffer = new ArraySegment <byte>(System.Text.Encoding.ASCII.GetBytes($"Ooops!This connection is already open under ID {userConnection.GetHashCode()} and its status is {userConnection.State}".ToCharArray()));
await userConnection.SendAsync(buffer, WebSocketMessageType.Text, true, cancelationTokenSource.Token).ContinueWith(task => Console.WriteLine("Message Sent"));
}
}
else
{
connections.Add(user, websocket);
await StartListening(user, websocket);
}
}
/// <summary>
/// Execute a delegate and if it does not finish in the timeout period then terminate it
/// </summary>
/// <param name="obj">the extension object</param>
/// <param name="timeout">the amount of time to wait before terminating the action</param>
/// <param name="action">the delegate to execute</param>
/// <param name="responseDelegate">(optional) delgate to receive reporting text on how the action finished</param>
/// <returns>True if the action delegate completes and false otherwise</returns>
/// <exception cref="AggregateException">Aggregates exceptions thrown in the action delegate(see InnerExceptions)</exception>
public static bool ExecuteActionOrTimeout(this object obj, TimeSpan timeout, Action action, Action <string> responseDelegate = null)
{
DateTime end = DateTime.Now + timeout;
TaskFactory factory = new TaskFactory();
var cancelSource = new System.Threading.CancellationTokenSource(timeout);
var task = factory.StartNew(action, cancelSource.Token);
while (DateTime.Now < end)
{
if (task.IsCanceled)
{
responseDelegate?.Invoke($"\n{action.Target}.{action.Method} cancelled before timeout");
return(false);
}
else if (task.IsFaulted)
{
responseDelegate?.Invoke($"\n{action.Target}.{action.Method} faulted before timeout");
throw task.Exception;
}
else if (task.IsCompleted)
{
responseDelegate?.Invoke($"\n{action.Target}.{action.Method} completed before timeout");
return(true);
}
}
cancelSource.Cancel();
responseDelegate?.Invoke($"\n{action.Target}.{action.Method} timed out");
return(false);
}
public static T.CancellationToken ToTpl(this CancellationToken ct)
{
var cts = new T.CancellationTokenSource();
ct.Register(() => cts.Cancel());
return(cts.Token);
}
internal void StopAll()
{
_reloadingCts.Cancel();
var oldsrc = _reloadingCts;
_reloadingCts = new System.Threading.CancellationTokenSource();
}
void IBackgroundTask.Run(IBackgroundTaskInstance taskInstance)
{
var cancel = new System.Threading.CancellationTokenSource();
taskInstance.Canceled += (s, e) =>
{
cancel.Cancel();
cancel.Dispose();
};
BackgroundTaskDeferral deferral = taskInstance.GetDeferral();
try
{
// Handle geofence state change reports
GetGeofenceStateChangedReports(GeofenceMonitor.Current.LastKnownGeoposition);
}
catch (UnauthorizedAccessException)
{
WriteStatusToAppData("Location permissions are disabled. Enable access through the settings.");
}
finally
{
deferral.Complete();
}
}
public SimulatorForm()
{
InitializeComponent();
this.SetStyle(
ControlStyles.AllPaintingInWmPaint |
ControlStyles.UserPaint |
ControlStyles.DoubleBuffer, true);
this.log = Log.Logger;
this.updateActions = new List <Action>();
this.cancelSource = new System.Threading.CancellationTokenSource();
this.senderTask = new Task(x =>
{
while (!this.cancelSource.IsCancellationRequested)
{
lock (this.updateActions)
{
foreach (var action in this.updateActions)
{
action();
}
}
System.Threading.Thread.Sleep(100);
}
}, this.cancelSource.Token, TaskCreationOptions.LongRunning);
this.senderTask.Start();
}
public async void ReloadServerList()
{
BeginLoading();
_reloadingCts.Cancel();
var oldsrc = _reloadingCts;
_reloadingCts = new System.Threading.CancellationTokenSource();
CancellationToken token = _reloadingCts.Token;
oldsrc.Cancel(false);
try
{
await Task.Factory.StartNew(o => ReloadInternal((CancellationToken)o), token, token).
ContinueWith(t =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
RememberLastVisiblyItems();
}
});
}
catch (Exception)
{
// ignored
}
EndLoading();
}
static void Main(string[] args)
{
map.Add(0, 0);
map.Add(1, 1);
System.Threading.CancellationTokenSource cts = new System.Threading.CancellationTokenSource();
//signalDetect(outputFolder + "signal.csv", cts);
//BitSignalDetect(outputFolder + "signal.csv", cts);
//MorseSignalDetect("morse.csv", cts);
//simpleTest(cts);
WeatherDataOutput("WeatherData.csv", cts);
//dumpSignalIQ(outputFolder + "IQ.csv", cts);
//dumpSignalIQRAW(outputFolder + "IQRaw.bin", cts);
//downSameTest("SingalIQ.csv", "SingalIQ_Down1000.csv",cts);
//dumpIQToWaveFile(outputFolder+"IQ.csv", outputFolder+"Wave.csv", cts);
//dumpIQToLPFWaveFile(outputFolder + "IQ.csv", outputFolder + "LPF.csv", cts);
//dumpIQToLPFWaveSQFile(outputFolder + "IQ.csv", outputFolder + "LPFSQ.csv", 0.6f,cts);
//dumpIQToLPF_Wave_MA_SQFile(outputFolder + "IQ.csv", outputFolder + "LPF_MV_SQ.csv", 0.3f, cts);
//dumpIQToLPF_Wave_MA_SQ_SCFile(outputFolder + "IQ.csv", outputFolder + "LPF_MV_SQ_SC.csv", 0.3f, cts);
dumpQueue(cts.Token);
Console.ReadLine();
cts.Cancel();
Console.WriteLine("waiting for threads exit...");
PipelineManager.Default.WaitAllExit();
Console.WriteLine("done");
}
private static void CancelTasksWithSoftExit()
{
var cts = new System.Threading.CancellationTokenSource();
var token = cts.Token;
var t = new Task(
() =>
{
int i = 0;
while (true)
{
// Soft exit -> check the token if cancellation is requested
if (token.IsCancellationRequested)
{
break;
}
Console.WriteLine($"{i++}\t");
}
}, token
);
t.Start();
Console.ReadKey();
cts.Cancel();
}
private static async Task CancelAllWhenAnyCompletes(Task leaderTask, Task renewLeaseTask, CancellationTokenSource cts)
{
await Task.WhenAny(leaderTask, renewLeaseTask);
// Cancel the user's leader task or the renewLease Task, as it is no longer the leader.
cts.Cancel();
var allTasks = Task.WhenAll(leaderTask, renewLeaseTask);
try
{
await Task.WhenAll(allTasks);
}
catch (Exception)
{
if (allTasks.Exception != null)
{
allTasks.Exception.Handle(ex =>
{
if (!(ex is OperationCanceledException))
{
Trace.TraceError(ex.Message);
}
return true;
});
}
}
}
void loadFaceCallback(ICollection[] result, Exception ex)
{
if (ex != null)
{
MessageBox.Show(this, "系统发生异常，请重试。", this.Text);
return;
}
_cts = new CancellationTokenSource();
var worker = Task.Factory.StartNew(CompareFaces, result, _cts.Token);
worker.ContinueWith(ant =>
{
if (ant.Exception != null)
{
if (!(ant.Exception.InnerException is OperationCanceledException))
{
MessageBox.Show("系统发生异常，请重试。");
}
}
ShowCompareStatus(false);
ShowCompareButton(true);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
/// <summary>
/// Specifies a path to directory where to save/load images.
/// </summary>
/// <param name="directory">
/// The path to directory with images.
/// </param>
/// <returns>
/// The instance of the loader.
/// </returns>
/// <remarks>
/// If the directory is not specified, i.e. <see cref="WithDirectory"/> is not called, then the default temp directory will be used.
/// </remarks>
public FileSystemImageLoader WithDirectory(string directory)
{
if (string.IsNullOrWhiteSpace(directory))
{
throw new ArgumentNullException("directory");
}
lock (this.indexSyncObject)
{
if (StringComparer.OrdinalIgnoreCase.Compare(this.directory, directory) != 0)
{
EnsureDireactoryExist(directory);
if (this.updateIndexToken != null)
{
this.updateIndexToken.Cancel();
}
this.ClearIndex();
this.directory = directory;
this.updateIndexToken = new CancellationTokenSource();
this.UpdateIndexAsync(directory, this.updateIndexToken.Token);
}
}
return this;
}
public Task<ProcessResults> RunAsync(ProcessStartInfo processStartInfo, CancellationTokenSource cancellationToken)
{
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardOutput = true;
processStartInfo.RedirectStandardError = true;
var tcs = new TaskCompletionSource<ProcessResults>();
var standardOutput = new List<string>();
var standardError = new List<string>();
var process = new Process
{
StartInfo = processStartInfo,
EnableRaisingEvents = true
};
process.OutputDataReceived += (sender, args) =>
{
if (args.Data != null)
{
standardOutput.Add(args.Data);
}
};
process.ErrorDataReceived += (sender, args) =>
{
if (args.Data != null)
{
standardError.Add(args.Data);
}
};
cancellationToken.Token.ThrowIfCancellationRequested();
_log.Debug("Registering cancellation for " + cancellationToken.GetHashCode());
cancellationToken.Token.Register(() =>
{
tcs.TrySetCanceled();
KillProcessAndChildren(process.Id);
});
process.Exited += (sender, args) =>
{
tcs.TrySetResult(new ProcessResults(process, standardOutput, standardError));
};
if (process.Start() == false)
{
tcs.TrySetException(new InvalidOperationException("Failed to start process"));
}
process.BeginOutputReadLine();
process.BeginErrorReadLine();
return tcs.Task;
}
public void Enable()
{
lock (_gate)
{
if (_instanceTask != null)
{
// already enabled
return;
}
if (!_workspace.Options.GetOption(RemoteHostOptions.RemoteHost))
{
// not turned on
return;
}
var remoteHostClientFactory = _workspace.Services.GetService<IRemoteHostClientFactory>();
if (remoteHostClientFactory == null)
{
// dev14 doesn't have remote host client factory
return;
}
// make sure we run it on background thread
_shutdownCancellationTokenSource = new CancellationTokenSource();
var token = _shutdownCancellationTokenSource.Token;
_instanceTask = Task.Run(() => EnableAsync(token), token);
}
}
/// <summary>
/// ファイルからドキュメントを構築する
/// </summary>
/// <param name="filepath">ファイルパス</param>
/// <param name="enc">エンコード</param>
/// <param name="token">キャンセル用トークン</param>
/// <returns>Taskオブジェクト</returns>
public async Task LoadFileAsync(string filepath, Encoding enc, System.Threading.CancellationTokenSource token)
{
var fs = new System.IO.StreamReader(filepath, enc);
await this.Document.LoadAsync(fs, token);
fs.Close();
}
public Task Run(out System.Threading.CancellationTokenSource cts)
{
Task task;
cts = Executor.Current.Execute(this, out task);
return(task);
}
private static CancellationTokenSource ResetCancellationTokenSource(System.Threading.CancellationTokenSource cts)
{
if (cts != null)
{
cts.Dispose();
}
// Create a new cancellation token source so that can cancel all the tokens again
return(new CancellationTokenSource());
}
public void Clear()
{
lock (queue)
{
CancellationTokenSource = new System.Threading.CancellationTokenSource();
queue.Clear();
Monitor.Pulse(queue);
}
}
public bool Enqueue(T item)
{
lock (queue)
{
if (this.Count > 0)
{
var _item = queue.Dequeue();
if (_item.WaitForResponse)
{
L4Logger.Info("Can not insert item must WaitForResponse => " + _item.MethodName);
queue.Enqueue(_item);
item.Dispose();
return(false);
}
else
{
}
}
if (closing || null == item)
{
return(false);
}
queue.Enqueue(item);
CancellationTokenSource?.Dispose();
CancellationTokenSource = new System.Threading.CancellationTokenSource();
System.Threading.Tasks.Task.Run(async delegate
{
await Task.Delay(item.CommandTimeSpan, CancellationTokenSource.Token);
if (!CancellationTokenSource.IsCancellationRequested)
{
if (ObjectTimeout != null)
{
if (queue.Count > 0)
{
var value = (T)queue.Dequeue();
L4Logger.Info(string.Format("object Dequeue Timeout method {0} guid {1} ", value.MethodName, value.guid));
value.Dispose();
ObjectTimeout.Invoke(value);
}
}
}
});
L4Logger.Info(string.Format("item inserted {0} Timeout {1} WaitForResponse {2} guid {3}",
item.MethodName, item.CommandTimeSpan, item.WaitForResponse, item.guid));
if (queue.Count == 1)
{
// wake up any blocked dequeue
Monitor.PulseAll(queue);
}
item = null;
return(true);
}
}
/// <summary>
/// ドキュメントの内容をファイルに保存する
/// </summary>
/// <param name="filepath">ファイルパス</param>
/// <param name="newLine">改行コード</param>
/// <param name="enc">エンコード</param>
/// <param name="token">キャンセル用トークン</param>
/// <returns>Taskオブジェクト</returns>
public async Task SaveFile(string filepath, Encoding enc, string newLine, System.Threading.CancellationTokenSource token)
{
var fs = new System.IO.StreamWriter(filepath, false, enc);
fs.NewLine = newLine;
await this.Document.SaveAsync(fs, token);
fs.Close();
}
protected override void OnConnected(bool bSuccess, string strErrors)
{
try
{
if ((bSuccess == true) && (Client.Connected == true))
{
this.Client.NoDelay = true;
#if !WINDOWS_PHONE
this.Client.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket, Windows.Networking.Sockets.SocketOptionName.KeepAlive, true);
#endif
#if WINDOWS_PHONE
var cancellationTokenSource = new System.Threading.CancellationTokenSource();
var task = Repeat.Interval(
TimeSpan.FromSeconds(60),
() => OnKeepAlive(),
cancellationTokenSource.Token
);
// this.Client.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket, Windows.Networking.Sockets.SocketOptionName.KeepAlive, true);
#endif
XMPPClient.XMPPState = XMPPState.Connected;
XMPPClient.FireConnectAttemptFinished(true);
System.Diagnostics.Debug.WriteLine(string.Format("Successful TCP connection"));
}
else
{
XMPPClient.XMPPState = XMPPState.Unknown;
XMPPClient.FireConnectAttemptFinished(false);
System.Diagnostics.Debug.WriteLine(string.Format("Failed to connect: {0}", strErrors));
return;
}
if (XMPPClient.UseOldStyleTLS == true)
{
StartTLS();
}
/// Send stream header if we haven't yet
XMPPClient.XMPPState = XMPPState.Authenticating;
OpenStreamStanza open = new OpenStreamStanza(this.XMPPClient);
string strSend = open.XML;
byte[] bStanza = System.Text.UTF8Encoding.UTF8.GetBytes(strSend);
this.Send(bStanza);
}
catch (TimeoutException tx)
{
Console.WriteLine(tx.InnerException.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// Classe à utiliser dans les tâches, pour retourner une progression et permettre l'annulation. Ajouter dans les boucles une vérification de IsCancellationRequested. Action de progression est par défaut une ligne en débug.
/// </summary>
public ProgressCancelNotifier(string iName = null)
{
CancellationTokenSource = new System.Threading.CancellationTokenSource();
Name = iName;
//Action<NotifierProgress> theAction = (NotifierProgress iProgress) => { };
Action <NotifierProgress> theAction = (value) => { MyDebug.PrintInformation(value); };
SetProgressAction(theAction);
Guid = System.Guid.NewGuid().ToString();
}
public Button(InputPinConfiguration outputPin, IGpioConnectionDriver driver = null)
{
PinConfig = outputPin;
Driver = driver ?? GpioConnectionSettings.DefaultDriver;
Driver.Allocate(PinConfig.Pin, PinDirection.Output);
TokenScource = new System.Threading.CancellationTokenSource();
Action a = Watch;
Task.Run(a, TokenScource.Token);
// Task.Start(Watch);
}
/// <summary>
/// <c>Dispose</c>パターンによる実装.
/// </summary>
/// <param name="disposing"><c>Dispose()</c>から呼ばれたかどうかを示す</param>
private void Dispose(bool disposing)
{
if (disposing)
{
if (this.cancellationTokenSource != null)
{
this.cancellationTokenSource.Dispose();
this.cancellationTokenSource = null;
}
}
}
public void StreamThreadCommitIntervalWorkflow()
{
var source = new System.Threading.CancellationTokenSource();
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test";
config.Guarantee = ProcessingGuarantee.AT_LEAST_ONCE;
config.PollMs = 1;
config.CommitIntervalMs = 1;
var serdes = new StringSerDes();
var builder = new StreamBuilder();
builder.Stream <string, string>("topic").To("topic2");
var topo = builder.Build();
var supplier = new SyncKafkaSupplier();
var producer = supplier.GetProducer(config.ToProducerConfig());
var consumer = supplier.GetConsumer(config.ToConsumerConfig("test-consum"), null);
consumer.Subscribe("topic2");
var thread = StreamThread.Create(
"thread-0", "c0",
topo.Builder, new StreamMetricsRegistry(), config,
supplier, supplier.GetAdmin(config.ToAdminConfig("admin")),
0) as StreamThread;
thread.Start(source.Token);
producer.Produce("topic", new Confluent.Kafka.Message <byte[], byte[]>
{
Key = serdes.Serialize("key1", new SerializationContext()),
Value = serdes.Serialize("coucou", new SerializationContext())
});
//WAIT STREAMTHREAD PROCESS MESSAGE
System.Threading.Thread.Sleep(100);
var message = consumer.Consume(100);
Assert.AreEqual("key1", serdes.Deserialize(message.Message.Key, new SerializationContext()));
Assert.AreEqual("coucou", serdes.Deserialize(message.Message.Value, new SerializationContext()));
var offsets = thread.GetCommittedOffsets(new List <TopicPartition> {
new TopicPartition("topic", 0)
},
TimeSpan.FromSeconds(10)).ToList();
Assert.AreEqual(1, offsets.Count);
Assert.AreEqual(1, offsets[0].Offset.Value);
Assert.AreEqual(0, offsets[0].TopicPartition.Partition.Value);
Assert.AreEqual("topic", offsets[0].Topic);
source.Cancel();
thread.Dispose();
}
public void Cancel(bool isInner = false)
{
AcioningItems.Remove(this);
if (_targetModel.ResourceModel.Progress > 0.98)
{
AppData.MainMV.TipMessage = "视频消息已发出无法取消！";
return;
}
if (ChatViewModel != null)
{
if (_operateTask != null)
{
_operateTask.Cancel();
_operateTask = null;
if (isInner)
{
return;
}
}
string tip = _targetModel.Sender.ID == AppData.Current.LoginUser.ID ? "发送" : "接收";
string size = Helper.FileHelper.FileSizeToString(_targetModel.ResourceModel.Length);
string msg = $"您取消了\"{_targetModel.ResourceModel.FileName}\"({size})的{tip}，文件传输失败。";
_targetModel.MsgType = MessageType.notification;
_targetModel.MessageState = MessageStates.Fail;
_targetModel.Content = msg;
ChatViewModel.UpdateMsg(_targetModel);
int roomID = ChatViewModel.Model.ID;
var chatType = ChatViewModel.IsGroup ? SDKClient.SDKProperty.chatType.groupChat : SDKClient.SDKProperty.chatType.chat;
Task.Run(async() =>
await SDKClient.SDKClient.Instance.AppendLocalData_NotifyMessage(AppData.Current.LoginUser.ID.ToString(), roomID.ToString(),
msg, roomID, SDKClient.SDKProperty.MessageType.notification, chatType: chatType));
if (this.FileState == FileStates.SendOnline ||
_targetModel.ResourceModel.RefInfo is SDKClient.Model.OnlineFileBody body) //在线消息会发送取消给对方
{
SDKClient.SDKProperty.chatType messageType = ChatViewModel.IsGroup ? SDKClient.SDKProperty.chatType.groupChat : SDKClient.SDKProperty.chatType.chat;
SDKClient.SDKClient.Instance.SendRetractMessage(_targetModel.MsgKey, ChatViewModel.ID.ToString(), messageType, ChatViewModel.IsGroup ? ChatViewModel.ID : 0, SDKClient.SDKProperty.RetractType.SourceEndOnlineRetract);
}
else //离线消息不发送
{
_targetModel.Sender = null;
SDKClient.SDKClient.Instance.CancelOfflineFileRecv(_targetModel.MsgKey);
}
_targetModel.ResourceModel.FileState = FileStates.Fail;
}
}
private CancellationToken GetCancellationToken()
{
lock (_lock)
{
if (_cancellationTokenSource is null)
{
_cancellationTokenSource = new CancellationTokenSource();
}
return(_cancellationTokenSource.Token);
}
}
