public static Task WriteAsync(this Stream stream, byte[] buffer, int offset, int count)
{
var tcs = new TaskCompletionSource<object>();
var sr = stream.BeginWrite(buffer, offset, count, ar =>
{
if (ar.CompletedSynchronously)
{
return;
}
try
{
stream.EndWrite(ar);
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}, null);
if (sr.CompletedSynchronously)
{
try
{
stream.EndWrite(sr);
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}
return tcs.Task;
}
public Task<bool> ShowDialogBox(string caption, string message, string leftbuttonContent, string rightButtonContent, Func<Task> leftButtonAction, Func<Task> rightButtonAction)
{
var messagebox = new CustomMessageBox()
{
Caption = caption,
Message = message,
LeftButtonContent = leftbuttonContent,
RightButtonContent = rightButtonContent
};
var tcs = new TaskCompletionSource<bool>();
messagebox.Dismissed += async (s, e) =>
{
switch (e.Result)
{
case CustomMessageBoxResult.LeftButton:
await leftButtonAction();
tcs.SetResult(true);
break;
case CustomMessageBoxResult.RightButton:
await rightButtonAction();
tcs.SetResult(true);
break;
case CustomMessageBoxResult.None:
tcs.SetResult(false);
break;
};
};
messagebox.Show();
return tcs.Task;
}
public static Task<bool> GetIssueRiskRelatedObjects()
{
var task = new TaskCompletionSource<bool>();
if (CMS.Cache.IssueRiskRelatedObjects == null)
{
CMS.Cache.IssueRiskRelatedObjects = new IssueRiskRelatedObjects();
var cee = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
DateTime now = DateTime.Now;
System.Diagnostics.Debug.WriteLine("InterlockRiskRelatedObjectsCache First {0}", now.ToString("G"));
//ReportLinks
cee.GetIssueRiskRelatedObjectsCompleted += (s, e) =>
{
CMS.Cache.IssueRiskRelatedObjects = e.Result;
var elapsed = DateTime.Now - now;
System.Diagnostics.Debug.WriteLine("InterlockRiskRelatedObjectsCache: {0}", elapsed.TotalSeconds);
task.SetResult(true);
};
cee.GetIssueRiskRelatedObjectsAsync();
}
else
{
task.SetResult(true);
return task.Task; //Already loaded
}
return task.Task;
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var tcs = new TaskCompletionSource<object>();
if (content != null && content.Headers.ContentLength == 0) return null;
try
{
var reader = new BsonReader(readStream);
if (typeof(IEnumerable).IsAssignableFrom(type)) reader.ReadRootValueAsArray = true;
using (reader)
{
var jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
var output = jsonSerializer.Deserialize(reader, type);
tcs.SetResult(output);
}
}
catch (Exception)
{
tcs.SetResult(GetDefaultValueForType(type));
}
return tcs.Task;
}
static async Task<bool?> ShowCore(XmlDocument rpDocument)
{
var rCompletionSource = new TaskCompletionSource<bool?>();
var rNotification = new ToastNotification(rpDocument);
TypedEventHandler<ToastNotification, object> rActivated = (s, e) => rCompletionSource.SetResult(true);
rNotification.Activated += rActivated;
TypedEventHandler<ToastNotification, ToastDismissedEventArgs> rDismissed = (s, e) => rCompletionSource.SetResult(false);
rNotification.Dismissed += rDismissed;
TypedEventHandler<ToastNotification, ToastFailedEventArgs> rFailed = (s, e) => rCompletionSource.SetResult(null);
rNotification.Failed += rFailed;
r_Notifier.Show(rNotification);
var rResult = await rCompletionSource.Task;
rNotification.Activated -= rActivated;
rNotification.Dismissed -= rDismissed;
rNotification.Failed -= rFailed;
return rResult;
}
public static Task<string> Display(string title, string text = null)
{
Popup popup = new Popup();
popup.Height = 240;
popup.Width = 480;
popup.VerticalOffset = 100;
popup.VerticalAlignment = VerticalAlignment.Center;
InputDialog dialog = new InputDialog();
dialog.lblTitle.Text = title;
dialog.txtContent.Text = text ?? "";
popup.Child = dialog;
TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
dialog.btnCancel.Click += (s, ea) =>
{
tcs.SetResult(null);
popup.IsOpen = false;
};
dialog.btnOk.Click += (s, ea) =>
{
tcs.SetResult(dialog.txtContent.Text);
popup.IsOpen = false;
};
popup.IsOpen = true;
return tcs.Task;
}
public Task<bool> SendReport(IReport report)
{
var tcs = new TaskCompletionSource<bool>();
if (MFMailComposeViewController.CanSendMail)
{
var c = new MFMailComposeViewController();
c.SetSubject(report.Title);
c.SetToRecipients(new[] {_settings.DevelopersEmail});
c.SetMessageBody(report.Body, false);
NSData data = new NSString(report.Attachment).DataUsingEncoding(NSStringEncoding.UTF8);
c.AddAttachmentData(data, "text/xml", "info.xml");
_application.RootController.PresentViewController(c, true, null);
c.Finished += (sender, e) =>
{
tcs.SetResult(e.Result == MFMailComposeResult.Sent);
e.Controller.DismissViewController(true, null);
};
}
else
{
var alert = new UIAlertView("Cannot send report", "E-mail messages not allowed", null, "OK");
alert.Clicked += (sender, args) => tcs.SetResult(false);
alert.Show();
}
return tcs.Task;
}
public async Task Should_call_on_error()
{
var onErrorCalled = new TaskCompletionSource<ErrorContext>();
OnTestTimeout(() => onErrorCalled.SetResult(null));
await StartPump(context =>
{
// handler enlists a failing transaction enlistment to the DTC transaction which will fail when commiting the transaction.
Transaction.Current.EnlistDurable(EnlistmentWhichFailesDuringPrepare.Id, new EnlistmentWhichFailesDuringPrepare(), EnlistmentOptions.None);
return Task.FromResult(0);
},
context =>
{
onErrorCalled.SetResult(context);
return Task.FromResult(ErrorHandleResult.Handled);
}
,TransportTransactionMode.TransactionScope);
await SendMessage(InputQueueName);
var errorContext = await onErrorCalled.Task;
Assert.IsInstanceOf<TransactionAbortedException>(errorContext.Exception);
// since some transports doesn't have native retry counters we can't expect the attempts to be fully consistent since if
// dispose throws the message might be picked up before the counter is incremented
Assert.LessOrEqual(1, errorContext.ImmediateProcessingFailures);
}
private static Task<int?> PlatformShow(string title, string description, List<string> buttons)
{
// TODO: MessageDialog only supports two buttons
if (buttons.Count == 3)
throw new NotSupportedException("This platform does not support three buttons");
tcs = new TaskCompletionSource<int?>();
MessageDialog dialog = new MessageDialog(description, title);
foreach (string button in buttons)
dialog.Commands.Add(new UICommand(button, null, dialog.Commands.Count));
dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async () =>
{
try
{
// PlatformSetResult will cancel the task, resulting in an exception
dialogResult = dialog.ShowAsync();
var result = await dialogResult;
if (!tcs.Task.IsCompleted)
tcs.SetResult((int)result.Id);
}
catch (TaskCanceledException)
{
if (!tcs.Task.IsCompleted)
tcs.SetResult(null);
}
});
return tcs.Task;
}
public Task<DiscoveryResult> DiscoverAddress(string webAPI)
{
var completionSource = new TaskCompletionSource<DiscoveryResult>();
var baseUri = new Uri(webAPI, UriKind.Absolute);
var requestUri = new Uri(baseUri, "rsd.xml");
var rsdFileRequest = webRequestFactory.Create(requestUri);
// Kick off the async discovery workflow
rsdFileRequest.GetResponseAsync()
.ContinueWith<DiscoveryResult>(ProcessRsdResponse)
.ContinueWith(c =>
{
if (c.Result.Success)
completionSource.SetResult(c.Result);
else
{
Trace.WriteLine(string.Format(
"Rsd.xml does not exist, trying to discover via link. Error was {0}", c.Result.FailMessage), "INFO");
DiscoverRsdLink(webAPI)
.ContinueWith(t => completionSource.SetResult(t.Result));
}
});
return completionSource.Task;
}
static int PICK_CONTACT_REQUEST = 42; // The request code
protected void OnActivityResult(TaskCompletionSource<ContactInfo> tcs, ActivityResultEventArgs e) //int requestCode, Android.App.Result resultCode, Intent data)
{
// Check which request it is that we're responding to
if (e.requestCode == PICK_CONTACT_REQUEST)
{
// Make sure the request was successful
if (e.resultCode == Android.App.Result.Ok)
{
var loader = new CursorLoader(MainActivity.Instance, e.data.Data, projection, null, null, null);
var cursor = (Android.Database.ICursor)loader.LoadInBackground();
var contactList = new List<ContactInfo>();
if (cursor.MoveToFirst())
{
do
{
contactList.Add(GetContactInfoFromCursor(cursor));
} while (cursor.MoveToNext());
}
tcs.SetResult(contactList.FirstOrDefault());
return;
}
}
tcs.SetResult(null);
}
public async Task Should_retry_immediately(TransportTransactionMode transactionMode)
{
var messageRetried = new TaskCompletionSource<bool>();
OnTestTimeout(() => messageRetried.SetResult(false));
var hasBeenCalled = false;
await StartPump(
context =>
{
if (hasBeenCalled)
{
messageRetried.SetResult(true);
return Task.FromResult(0);
}
hasBeenCalled = true;
throw new Exception("Simulated exception");
},
context => Task.FromResult(ErrorHandleResult.RetryRequired), transactionMode);
await SendMessage(InputQueueName);
Assert.True(await messageRetried.Task, "Should retry if asked so");
}
public async Task Should_retry_immediately(TransportTransactionMode transactionMode)
{
var messageRedelivered = new TaskCompletionSource<bool>();
OnTestTimeout(() => messageRedelivered.SetResult(false));
var hasBeenCalled = false;
var onErrorCalled = false;
await StartPump(
context =>
{
if (hasBeenCalled)
{
messageRedelivered.SetResult(true);
return Task.FromResult(0);
}
hasBeenCalled = true;
context.ReceiveCancellationTokenSource.Cancel();
return Task.FromResult(0);
},
context =>
{
onErrorCalled = true;
return Task.FromResult(ErrorHandleResult.RetryRequired);
}, transactionMode);
await SendMessage(InputQueueName);
Assert.True(await messageRedelivered.Task, "Should redeliver message");
Assert.False(onErrorCalled, "Abort should not invoke on error");
}
/// <summary>
/// Asynchronously deserializes an object of the specified type.
/// </summary>
/// <param name="type">The type of the object to deserialize.</param>
/// <param name="readStream">The <see cref="T:System.IO.Stream" /> to read.</param>
/// <param name="content">The <see cref="T:System.Net.Http.HttpContent" />, if available. It may be null.</param>
/// <param name="formatterLogger">The <see cref="T:System.Net.Http.Formatting.IFormatterLogger" /> to log events to.</param>
/// <returns>
/// A <see cref="T:System.Threading.Tasks.Task" /> whose result will be an object of the given type.
/// </returns>
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
var tcs = new TaskCompletionSource<object>();
try
{
var reader = GetJsonReader(readStream);
using (reader)
{
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.Converters.Add(new HyperNewtonsoftJsonConverter());
var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings);
var output = jsonSerializer.Deserialize(reader, type);
if (formatterLogger != null)
{
jsonSerializer.Error += (sender, e) =>
{
var exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception.Message);
e.ErrorContext.Handled = true;
};
}
tcs.SetResult(output);
}
}
catch (Exception e)
{
if (formatterLogger == null) throw;
formatterLogger.LogError(String.Empty, e.Message);
tcs.SetResult(GetDefaultValueForType(type));
}
return tcs.Task;
}
/// <summary>
/// Navigates to the given source URI and waits for the loading to complete or fail.
/// </summary>
public static async Task NavigateAsync(this WebView webView, Uri source)
{
var tcs = new TaskCompletionSource<object>();
// Need to set it to null so that the compiler does not
// complain about use of unassigned local variable.
WebViewNavigationFailedEventHandler nfeh = null;
LoadCompletedEventHandler lceh = null;
//webView.NavigationFailed
//webView.LoadCompleted
nfeh = (s, e) =>
{
webView.NavigationFailed -= nfeh;
webView.LoadCompleted -= lceh;
tcs.SetResult(null);
};
lceh = (s, e) =>
{
webView.NavigationFailed -= nfeh;
webView.LoadCompleted -= lceh;
tcs.SetResult(null);
};
webView.NavigationFailed += nfeh;
webView.LoadCompleted += lceh;
webView.Navigate(source);
await tcs.Task;
}
public static Task LoadAreasCache()
{
var task = new TaskCompletionSource<bool>();
if (CMS.Cache.Areas == null)
{
CMS.Cache.Areas = new ObservableCollection<Area>();
var cee = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
DateTime now = DateTime.Now;
System.Diagnostics.Debug.WriteLine("LoadAreasCache First {0}", now.ToString("G"));
//AREAS
cee.GetAreasCompleted += (s1, e1) =>
{
CMS.Cache.Areas = new ObservableCollection<Area>(e1.Result.OrderBy(x => x.AreaNumber));
var elapsed = DateTime.Now - now;
System.Diagnostics.Debug.WriteLine("LoadAreasCache: {0}", elapsed.TotalSeconds);
task.SetResult(true);
};
cee.GetAreasAsync();
}
else
{
System.Diagnostics.Debug.WriteLine("-----------------------------------------------------------");
System.Diagnostics.Debug.WriteLine("LoadAreasCache: ALREADY LOADED !!!");
System.Diagnostics.Debug.WriteLine("-----------------------------------------------------------");
task.SetResult(true);
return task.Task; //Already loaded
}
return task.Task;
}
public static Task<bool> DisplayYesNo(string text)
{
Popup popup = new Popup();
popup.Height = 240;
popup.Width = 480;
popup.VerticalOffset = 100;
popup.VerticalAlignment = VerticalAlignment.Center;
InputDialog dialog = new InputDialog();
dialog.lblTitle.Text = "Question";
dialog.txtContent.Text = text;
dialog.btnCancel.Content = "No";
dialog.btnOk.Content = "Yes";
popup.Child = dialog;
TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
dialog.btnCancel.Click += (s, ea) =>
{
tcs.SetResult(false);
popup.IsOpen = false;
};
dialog.btnOk.Click += (s, ea) =>
{
tcs.SetResult(true);
popup.IsOpen = false;
};
popup.IsOpen = true;
return tcs.Task;
}
/// <summary>
/// If automatic update checking is enabled, checks if there are any updates available.
/// Returns the download URL if an update is available.
/// Returns null if no update is available, or if no check was performed.
/// </summary>
public static Task<string> CheckForUpdatesIfEnabledAsync(ILSpySettings spySettings)
{
var tcs = new TaskCompletionSource<string>();
UpdateSettings s = new UpdateSettings(spySettings);
if (s.AutomaticUpdateCheckEnabled) {
// perform update check if we never did one before;
// or if the last check wasn't in the past 7 days
if (s.LastSuccessfulUpdateCheck == null
|| s.LastSuccessfulUpdateCheck < DateTime.UtcNow.AddDays(-7)
|| s.LastSuccessfulUpdateCheck > DateTime.UtcNow)
{
GetLatestVersionAsync().ContinueWith(
delegate (Task<AvailableVersionInfo> task) {
try {
s.LastSuccessfulUpdateCheck = DateTime.UtcNow;
AvailableVersionInfo v = task.Result;
if (v.Version > currentVersion)
tcs.SetResult(v.DownloadUrl);
else
tcs.SetResult(null);
} catch (AggregateException) {
// ignore errors getting the version info
tcs.SetResult(null);
}
});
} else {
tcs.SetResult(null);
}
} else {
tcs.SetResult(null);
}
return tcs.Task;
}
public Task Publish(string queue, byte[] data)
{
var tcs = new TaskCompletionSource<int>();
lock (_pending)
_pending.Add(tcs.Task);
Func<byte[], Task> handler;
lock (_handlers)
{
handler = _handlers[queue];
}
ThreadPool.QueueUserWorkItem(async _ =>
{
try
{
await handler(data);
}
catch (Exception e)
{
lock (_pending)
_pending.Remove(tcs.Task);
tcs.SetResult(0);
_logger("Error executing handler", e);
return;
}
lock (_pending)
_pending.Remove(tcs.Task);
tcs.SetResult(0);
});
return Task.FromResult(0);
}
public static async Task<JObject> GetJson(String url)
{
var tcs = new TaskCompletionSource<string>();
var client = new WebClient();
client.DownloadStringCompleted += (s, e) =>
{
if (e.Error == null)
{
tcs.SetResult(e.Result);
}
else
{
tcs.SetResult(null);
}
};
client.DownloadStringAsync(new Uri(url));
return await tcs.Task.ContinueWith<JObject>((task) =>
{
if (task.Result != null)
{
return JObject.Parse(task.Result);
}
else
{
return null;
}
});
}
public Task OpenEmailManager(string[] emails, string subject, string text, string[] attachments)
{
var tcs = new TaskCompletionSource<bool>();
if (MFMailComposeViewController.CanSendMail)
{
var c = new MFMailComposeViewController();
c.SetToRecipients(emails);
c.SetSubject(subject ?? "");
c.SetMessageBody(text ?? "", false);
foreach (string attachment in attachments)
{
NSData data = NSData.FromFile(attachment);
if (data != null)
c.AddAttachmentData(data, GetMimeType(attachment), Path.GetFileName(attachment));
}
_application.RootController.PresentViewController(c, true, null);
c.Finished += (sender, e) =>
{
tcs.SetResult(e.Result == MFMailComposeResult.Sent);
_application.InvokeOnMainThread(() => e.Controller.DismissViewController(true, null));
};
}
else
{
var alert = new UIAlertView("Cannot send report", "E-mail messages not allowed", null, "OK");
alert.Clicked += (sender, args) => tcs.SetResult(false);
alert.Show();
}
return tcs.Task;
}
public Task ContinueWith(Action<Task> continuationAction)
{
//Console.WriteLine("enter __Task.ContinueWith " + new { this.IsCompleted, continuationAction });
var x = new TaskCompletionSource<object>();
if (this.IsCompleted)
{
continuationAction(this);
x.SetResult(null);
}
else
{
InternalContinueWithAfterIsCompleted +=
delegate
{
if (x == null)
return;
continuationAction(this);
x.SetResult(null);
x = null;
};
}
//Console.WriteLine("exit __Task.ContinueWith " + new { this.IsCompleted, continuationAction });
return x.Task;
}
public async Task Should_dispatch_the_message(TransportTransactionMode transactionMode)
{
var messageReceived = new TaskCompletionSource<bool>();
OnTestTimeout(() => messageReceived.SetResult(false));
await StartPump(
context =>
{
if (context.Headers.ContainsKey("FromOnError"))
{
messageReceived.SetResult(true);
return Task.FromResult(0);
}
throw new Exception("Simulated exception");
},
async context =>
{
await SendMessage(InputQueueName, new Dictionary<string, string> { { "FromOnError", "true" } }, context.TransportTransaction);
return ErrorHandleResult.Handled;
}, transactionMode);
await SendMessage(InputQueueName);
Assert.True(await messageReceived.Task, "Message not dispatched properly");
}
static TaskCompletionSource<bool?> GenerateTcs(ToastNotification notification) {
var tcs = new TaskCompletionSource<bool?>();
notification.Dismissed += (sender, args) => tcs.SetResult(false);
notification.Activated += (sender, args) => tcs.SetResult(true);
notification.Failed += (sender, args) => tcs.SetException(args.ErrorCode);
return tcs;
}
public async static Task<ExceptionRoutedEventArgs> WaitForLoadedAsync(this BitmapImage bitmapImage)
{
var tcs = new TaskCompletionSource<ExceptionRoutedEventArgs>();
// Need to set it to noll so that the compiler does not
// complain about use of unassigned local variable.
RoutedEventHandler reh = null;
ExceptionRoutedEventHandler ereh = null;
reh = (s, e) =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
tcs.SetResult(null);
};
ereh = (s, e) =>
{
bitmapImage.ImageOpened -= reh;
bitmapImage.ImageFailed -= ereh;
tcs.SetResult(e);
};
bitmapImage.ImageOpened += reh;
bitmapImage.ImageFailed += ereh;
return await tcs.Task;
}
private static Task<string> PlatformShow(string title, string description, string defaultText, bool usePasswordMode)
{
tcs = new TaskCompletionSource<string>();
var keyboardViewController = new KeyboardInputViewController(
title, description, defaultText, usePasswordMode, gameViewController);
UIApplication.SharedApplication.InvokeOnMainThread(delegate
{
gameViewController.PresentViewController(keyboardViewController, true, null);
keyboardViewController.View.InputAccepted += (sender, e) =>
{
gameViewController.DismissViewController(true, null);
if (!tcs.Task.IsCompleted)
tcs.SetResult(keyboardViewController.View.Text);
};
keyboardViewController.View.InputCanceled += (sender, e) =>
{
gameViewController.DismissViewController(true, null);
if (!tcs.Task.IsCompleted)
tcs.SetResult(null);
};
});
return tcs.Task;
}
public static Task<string> AuthenticateAsync(Uri uri)
{
var tcs = new TaskCompletionSource<string>();
var w = new WebView
{
HorizontalAlignment = HorizontalAlignment.Stretch,
VerticalAlignment = VerticalAlignment.Stretch,
Margin = new Thickness(30.0),
};
var b = new Border
{
Background = new SolidColorBrush(Color.FromArgb(255, 255, 255, 255)),
Width = Window.Current.Bounds.Width,
Height = Window.Current.Bounds.Height,
Child = w
};
var p = new Popup
{
Width = Window.Current.Bounds.Width,
Height = Window.Current.Bounds.Height,
Child = b,
HorizontalOffset = 0.0,
VerticalOffset = 0.0
};
Window.Current.SizeChanged += (s, e) =>
{
p.Width = e.Size.Width;
p.Height = e.Size.Height;
b.Width = e.Size.Width;
b.Height = e.Size.Height;
};
w.Source = uri;
w.NavigationCompleted += (sender, args) =>
{
if (args.Uri != null)
{
if (args.Uri.OriginalString.Contains("access_token"))
{
tcs.SetResult(args.Uri.ToString());
p.IsOpen = false;
}
if (args.Uri.OriginalString.Contains("error=access_denied"))
{
tcs.SetResult(null);
p.IsOpen = false;
}
}
};
p.IsOpen = true;
return tcs.Task;
}
public Task<bool> PromptYesNo(string title, string message)
{
var tcs = new TaskCompletionSource<bool>();
var alert = UIAlertController.Create(title, message, UIAlertControllerStyle.Alert);
alert.AddAction(UIAlertAction.Create("No", UIAlertActionStyle.Cancel, x => tcs.SetResult(false)));
alert.AddAction(UIAlertAction.Create("Yes", UIAlertActionStyle.Default, x => tcs.SetResult(true)));
ViewController.PresentViewController(alert, true, null);
return tcs.Task;
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var tcs = new TaskCompletionSource<object>();
if (!_write(new ArraySegment<byte>(buffer, offset, count), () => tcs.SetResult(null)))
tcs.SetResult(null);
return tcs.Task;
}
public static void Dispose_ThenUseTaskCompletionSource()
{
var tcs = new TaskCompletionSource<int>();
tcs.SetResult(1);
tcs.Task.Dispose();
Assert.Throws<InvalidOperationException>(() => tcs.SetResult(2));
Assert.Throws<InvalidOperationException>(() => tcs.SetCanceled());
Assert.Throws<InvalidOperationException>(() => tcs.SetException(new Exception()));
Assert.Equal(1, tcs.Task.Result);
}
public void Do()
{
try
{
Action !();
Complete?.SetResult();
}
catch (Exception e)
{
Complete?.SetException(e);
}
}
private void ExecuteSynchronously(
TaskCompletionSource <object> completion,
SendOrPostCallback d,
object state)
{
// Anything run on the sync context should actually be dispatched as far as Photino
// is concerned, so that it's safe to interact with the native window/WebView.
_invokeMethodInfo.Invoke(_window, new Action[] { () =>
{
var original = Current;
try
{
_state.IsBusy = true;
SetSynchronizationContext(this);
d(state);
}
finally
{
_state.IsBusy = false;
SetSynchronizationContext(original);
completion?.SetResult(null);
}
} });
}
private async void ScheduleTimeout()
{
try
{
await Task.Delay(TimeSpan.FromMilliseconds(_sendTimeout), _cts.Token);
}
catch (TaskCanceledException)
{
return;
}
TaskCompletionSource <CommandError> ctl = null;
var isSending = false;
//spin lock
while (Interlocked.CompareExchange(ref _taskLockTag, CASHelper.LockUsed, CASHelper.LockFree) != CASHelper.LockFree)
{
}
if (_lastCommand != null)
{
isSending = true;
_lastCommand = null;
ctl = _currentTaskCtl;
_currentTaskCtl = null;
}
//free lock
Interlocked.CompareExchange(ref _taskLockTag, CASHelper.LockFree, CASHelper.LockUsed);
if (!isSending)
{
return;
}
ctl?.SetResult(CommandError.Timeout);
}
public Task <OfflinePack[]> GetPacks()
{
var tsc = new TaskCompletionSource <OfflinePack[]>();
var sharedStorage = MGLOfflineStorage.SharedOfflineStorage;
var packs = sharedStorage.Packs;
if (packs == null)
{
/*
* This property is set to nil, indicating that the receiver does not yet know the existing packs,
* for an undefined amount of time starting from the moment the shared offline storage object is initialized
* until the packs are fetched from the database. After that point, this property is always non-nil,
* but it may be empty to indicate that no packs are present.
* To detect when the shared offline storage object has finished loading its packs property,
* observe KVO change notifications on the packs key path. The initial load results in an NSKeyValueChangeSetting change.
*/
getPacksTask = tsc;
packsObservingToken = sharedStorage.AddObserver("packs", NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New, (obj) => {
var allPacks = sharedStorage.Packs;
if (allPacks != null)
{
getPacksTask?.SetResult(allPacks?.Select((arg) => arg.ToFormsPack()).ToArray());
packsObservingToken?.Dispose();
packsObservingToken = null;
getPacksTask = null;
}
});
}
else
{
tsc.SetResult(packs.Select((arg) => arg.ToFormsPack()).ToArray());
}
return(tsc.Task);
}
private void WriterRelease()
{
TaskCompletionSource <Releaser> toWake = null;
bool toWakeIsWriter = false;
lock (_waitingWriters)
{
if (_waitingWriters.Count > 0)
{
toWake = _waitingWriters.Dequeue();
toWakeIsWriter = true;
}
else if (_readersWaiting > 0)
{
toWake = _waitingReader;
_status = _readersWaiting;
_readersWaiting = 0;
_waitingReader = new TaskCompletionSource <Releaser>();
}
else
{
_status = 0;
}
}
_reset(this);
toWake?.SetResult(new Releaser(this, toWakeIsWriter));
}
/// <summary>
/// Executes at the end of each work cycle on the same task scheduler.
/// </summary>
private void CheckForMoreWork()
{
TaskCompletionSource <Task> signal = null;
Task taskToSignal = null;
lock (_lockable)
{
if (_moreWork)
{
_moreWork = false;
// see if someone created a promise for waiting for the next work cycle
// if so, take it and remove it
signal = this._nextWorkCyclePromise;
this._nextWorkCyclePromise = null;
// start the next work cycle
Start();
// the current cycle is what we need to signal
taskToSignal = _currentWorkCycle;
}
else
{
_currentWorkCycle = null;
}
}
// to be safe, must do the signalling out here so it is not under the lock
signal?.SetResult(taskToSignal);
}
/// <inheritdoc />
public void OnDataReceived(BinaryReader reader)
{
string command = reader.ReadString();
DebugLog($"Received command: {command}");
switch (command)
{
case MarkerVisualLocalizationSettings.CoordinateAssignedHeader:
coordinateId = reader.ReadString();
DebugLog($"Assigned coordinate id: {coordinateId}");
coordinateAssigned?.SetResult(coordinateId);
break;
case MarkerVisualLocalizationSettings.CoordinateFoundHeader:
string detectedId = reader.ReadString();
if (coordinateId == detectedId)
{
DebugLog($"Ending discovery: {coordinateId}");
discoveryCTS?.Cancel();
DebugLog($"Coordinate was found: {coordinateId}");
coordinateFound?.SetResult(detectedId);
}
else
{
DebugLog($"Unexpected coordinate found, expected: {coordinateId}, detected: {detectedId}");
}
break;
default:
DebugLog($"Sent unknown command: {command}");
break;
}
}
/// <summary>
/// 设置一个信号量，让一个waitone获得信号，每次调用 <see cref="Set"/> 方法最多只有一个等待通过
/// </summary>
public void Set()
{
TaskCompletionSource <bool> releaseSource = null;
bool result;
lock (_locker)
{
if (_waitQueue.Count > 0)
{
releaseSource = _waitQueue.Dequeue();
}
if (releaseSource is null)
{
if (!_isSignaled)
{
_isSignaled = true;
}
}
// 如果这个类被释放了，那么返回 false 值
result = !_isDisposed;
}
releaseSource?.SetResult(result);
}
private void DiscoverEndPoint(TaskCompletionSource <object> completionTask)
{
LogDebug("DiscoverEndPoint");
if (_state != ConnectionState.Connecting)
{
return;
}
if (_connectingPhase != ConnectingPhase.Reconnecting)
{
return;
}
_connectingPhase = ConnectingPhase.EndPointDiscovery;
_endPointDiscoverer.DiscoverAsync(_connection != null ? _connection.RemoteEndPoint : null).ContinueWith(
t => {
if (t.IsFaulted)
{
EnqueueMessage(
new CloseConnectionMessage("Failed to resolve TCP end point to which to connect.",
t.Exception));
completionTask?.SetException(
new CannotEstablishConnectionException("Cannot resolve target end point.", t.Exception));
}
else
{
EnqueueMessage(new EstablishTcpConnectionMessage(t.Result));
completionTask?.SetResult(null);
}
});
}
/// <summary>处理收到的数据</summary>
/// <param name="stream"></param>
/// <param name="remote"></param>
internal override void OnReceive(Stream stream, IPEndPoint remote)
{
// 过滤自己广播的环回数据。放在这里，兼容UdpSession
if (!Loopback && remote.Port == Port)
{
if (!Local.Address.IsAny())
{
if (remote.Address.Equals(Local.Address))
{
return;
}
}
else
{
foreach (var item in NetHelper.GetIPsWithCache())
{
if (remote.Address.Equals(item))
{
return;
}
}
}
}
#if !__MOBILE__
// 更新全局远程IP地址
NewLife.Web.WebHelper.UserHost = remote.ToString();
#endif
// 分析处理
var e = new ReceivedEventArgs();
e.Stream = stream;
e.UserState = remote;
// 同步匹配
_recv?.SetResult(e);
_recv = null;
// 为该连接单独创建一个会话，方便直接通信
var session = CreateSession(remote);
// 数据直接转交给会话，不再经过事件，那样在会话较多时极为浪费资源
var us = session as UdpSession;
if (us != null)
{
us.OnReceive(e);
}
else
{
// 没有匹配到任何会话时，才在这里显示日志。理论上不存在这个可能性
if (Log.Enable && LogReceive)
{
WriteLog("Recv [{0}]: {1}", e.Length, e.ToHex());
}
}
if (session != null)
{
RaiseReceive(session, e);
}
}
private void inputTextBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
StringTaskCompletionSource?.SetResult(inputTextBox.Text);
inputTextBox.Text = String.Empty;
}
}
private async void lv_opcion_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
var entidad = ((ListView)sender).SelectedItem as ent_mensaje;
_tcs?.SetResult(entidad.cod_mensaje);
//_ent?.SetResult(entidad);
await Navigation.PopAllPopupAsync();
}
void OnLoggedOn(SteamUser.LoggedOnCallback callback)
{
_steamAccount.SteamId = _client.SteamID;
bool isSteamGuard = callback.Result == EResult.AccountLogonDenied;
bool is2Fa = callback.Result == EResult.AccountLoginDeniedNeedTwoFactor;
tryLoginCount++;
if (tryLoginCount > 5)
{
_loginTcs?.SetResult(callback.Result);
}
if (isSteamGuard || is2Fa)
{
// Console.WriteLine("This account is SteamGuard protected!");
if (is2Fa)
{
_twoFactorAuth = _steamAccount.MobileAuth.GenerateSteamGuardCode();
}
else
{
throw new NotImplementedException("Not inplemented auth code. Only mobile auth");
}
return;
}
if (callback.Result != EResult.OK)
{
if (callback.Result == EResult.InvalidPassword)
{
_steamAccount.LoginKey = null;
_steamAccount.Save();
}
else if (callback.Result == EResult.NoConnection)
{
SteamServerList.SetBadServer(_serverRecord);
_serverRecord = SteamServerList.GetServerRecord();
}
Console.WriteLine("Unable to logon to Steam: {0} / {1}", callback.Result, callback.ExtendedResult);
return;
}
Console.WriteLine("Successfully logged on!");
_loginTcs?.SetResult(callback.Result);
}
/// <summary>
/// Require lock.
/// </summary>
/// <param name="m"></param>
/// <param name="packetId"></param>
void FreeId(IInputLogger?m, int packetId)
{
lock ( _idStore )
{
_idStore.FreeId(m, packetId);
_idFullTCS?.SetResult(null);
}
}
private void LockedUpdateEnqueueAccess()
{
for (int i = ItemsQueue.Count; EnqueueAccess.Count > 0 && (ThrottleLevelLimiter == null || i < ThrottleLevelLimiter); i++)
{
TaskCompletionSource <object> tcs = EnqueueAccess.Dequeue();
tcs?.SetResult(null);
}
}
public void ExtractResultJson(MethodResult result)
{
switch (result.Method.Name)
{
case MethodType.CheckBle:
if (bool.TryParse(result.Result, out bool bleOK))
{
bleTsc?.SetResult(bleOK);
}
else
{
bleTsc?.SetResult(false);
}
break;
case MethodType.Scan:
if (string.IsNullOrEmpty(result.Result))
{
scanTsc?.SetResult(new string[0]);
}
else
{
scanTsc?.SetResult(result.Result.Split(','));
}
break;
case MethodType.Connect:
var id = result.Method.Param;
if (connectTscDict.ContainsKey(id))
{
if (bool.TryParse(result.Result, out bool success))
{
connectTscDict[id]?.SetResult(success);
}
else
{
connectTscDict[id]?.SetResult(false);
}
}
break;
default:
// Do Nothing
break;
}
}
private void HandlePong(Packet msg)
{
if (Logger.IsTraceEnabled)
{
Logger.Trace($"{P2PSession.RemoteNodeId} P2P pong on {P2PSession.RemotePort} ({RemoteClientId})");
}
_pongCompletionSource?.SetResult(msg);
}
void BtnSend(System.Object sender, System.EventArgs e)
{
PopupNavigation.Instance.PopAsync();
Contact contact = new Contact();
contact.Name = txtFName.Text + " " + txtLName.Text;
_tcs?.SetResult(contact);
}
public Command(string command, string workingDirectory = "", params string[] args)
{
_process = new Process();
_process.StartInfo.CreateNoWindow = true;
_process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
_process.StartInfo.UseShellExecute = false;
_process.StartInfo.RedirectStandardOutput = true;
_process.StartInfo.RedirectStandardInput = true;
_process.StartInfo.RedirectStandardError = true;
_process.StartInfo.FileName = command;
if (args != null && args.Length > 0)
{
_process.StartInfo.Arguments = string.Join(" ", args);
}
if (!string.IsNullOrEmpty(workingDirectory))
{
_process.StartInfo.WorkingDirectory = workingDirectory;
}
_process.ErrorDataReceived += new DataReceivedEventHandler((sender, e) =>
{
if (!(e.Data == null))
{
stringBuilderError.AppendLine(e.Data);
if (string.IsNullOrEmpty(lastOutput) || lastOutput.Trim() == "")
{
lastOutput = e.Data;
}
}
else
{
errorCloseEvent?.SetResult(true);
}
});
_process.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
{
if (!(e.Data == null))
{
if (!string.IsNullOrEmpty(e.Data))
{
lastOutput = e.Data;
outputList.Add(e.Data);
}
outputList.Add(Environment.NewLine);
}
else
{
completeCloseEvent?.SetResult(true);
}
});
}
public void Update(ExchangeTypesItemsExchangerDescriptionForUserMessage message)
{
if (!MercyBotMain.Instance.Server.IsSubscribedToTouch || !MercyBotMain.Instance.Server.HasExtension(ExtensionsEnum.HDV))
{
return;
}
_itemDescriptionTcs?.SetResult(message.ItemTypeDescriptions);
}
/// <summary>
/// Process a received height map
/// </summary>
/// <returns>Asynchronous task</returns>
private static async Task HandleHeightMap()
{
DataTransfer.ReadHeightMap(out Heightmap map);
using (await _heightmapLock.LockAsync())
{
_getHeightmapRequest?.SetResult(map);
_getHeightmapRequest = null;
}
}
private static void PlatformCancel(string?result)
{
if (_dialog != null)
{
_dialog.Close();
}
_tcs?.SetResult(result);
}
private void WebSocketOnClosed(object sender, EventArgs e)
{
if (_response?.Task.Status != TaskStatus.RanToCompletion)
{
_response?.SetResult(string.Empty);
}
Closed?.Invoke(this, e);
}
public void OnCancelled(object sender, EventArgs args)
{
TaskCompletionSource <FileData> tcs = Interlocked.Exchange(ref this.completionSource, null);
FilePickerActivity.FilePicked -= this.OnCompleted;
FilePickerActivity.FilePickCancelled -= this.OnCancelled;
tcs?.SetResult(null);
}
public async Task Connect()
{
var taskSource = new TaskCompletionSource <bool>();
_webSocket.OnOpen += (sender, args) => { taskSource?.SetResult(true); };
_webSocket.OnError += (sender, args) => { taskSource?.SetException(args.Exception); };
_webSocket.Connect();
await taskSource.Task;
}
public BaseViewAnimator()
{
AnimatorAgent = CAAnimationGroup.CreateAnimation();
AnimatorAgent.AnimationStarted += (sender, e) => { };
AnimatorAgent.AnimationStopped += (sender, e) =>
{
tcs?.SetResult(true);
};
}
private void OutputProduced(IProjectVersionedValue <DesignTimeInputSnapshot> val)
{
_outputProduced.Add(val.Value);
if (_outputProduced.Count == _expectedOutput)
{
_outputProducedSource?.SetResult(true);
}
}
/// <summary>
/// Sets dialog invocation result.
/// Completes the task awaited in <see cref="AwaitResult{TResult}"/>.
/// </summary>
/// <param name="result">The object to return to the caller. It should be of <see cref="AwaitedResultType"/> type.</param>
/// <exception cref="ArgumentException">Thrown when given <see cref="result"/> doesn't match <see cref="AwaitedResultType"/></exception>
public void SetResult(object result)
{
if (AwaitedResultType != result.GetType())
{
throw new ArgumentException($"Result should be of {AwaitedResultType.Name} type.");
}
_resultCompletionSource?.SetResult(result);
}
void RootPush(Page newPage, TaskCompletionSource <bool> pushInfoOnCompletedTask = null)
{
Device.BeginInvokeOnMainThread(async() =>
{
try
{
if (Application.Current.MainPage == null)
{
var masterPage = GetInitializedPage(AppPages.Main.ToString());
//Xamarin.Forms return exception when master page title is null
//this title not visible in app
masterPage.Title = nameof(masterPage);
var detailPage = new NavigationPage(newPage);
Application.Current.MainPage = new MasterDetailPage
{
Master = masterPage,
Detail = detailPage
};
}
else if (Application.Current.MainPage is MasterDetailPage mp)
{
mp.IsPresented = false;
await Task.Delay(250);
if (mp.Detail is NavigationPage navigationPage)
{
var navigation = navigationPage.Navigation;
var navigationStack = navigationPage.Navigation.NavigationStack;
if (navigationStack.Any())
{
navigation.InsertPageBefore(newPage, navigationStack.FirstOrDefault());
await navigation.PopToRootAsync();
}
}
pushInfoOnCompletedTask?.SetResult(true);
}
}
catch (Exception e)
{
Console.WriteLine(e);
pushInfoOnCompletedTask?.SetResult(false);
}
});
}
private Task HubConnectionOnReconnected(string arg)
{
lock (_reconnectingLock)
{
_reconnectingTask?.SetResult(true);
_reconnectingTask = null;
}
return(Task.CompletedTask);
}
