public async Task Test1()
{
var lazy = new LazyAsync <int>(PauseAsync);
int value = await lazy.GetValueAsync();
Assert.Equal(123, value);
}
public PlayersTableStorageRepository(string connectionString)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException(nameof(connectionString));
}
if (!CloudStorageAccount.TryParse(connectionString, out var storageAccount))
{
throw new ArgumentException(
$"ConnectionString cannot be parsed: [{connectionString}]",
nameof(connectionString));
}
var tableClient = storageAccount.CreateCloudTableClient();
_dataSource = new LazyAsync <CloudTable>(
async() =>
{
var dataSource = tableClient.GetTableReference(PlayersTableName);
await dataSource.CreateIfNotExistsAsync();
return(dataSource);
});
}
public async Task <T> GetOrAddAsync <T>(string key, Func <Task <T> > valueFactory, Action <ICacheConfiguration> configurator)
{
var policy = new CachePolicyFactory().Create(configurator);
var asyncLazyValue = new LazyAsync <T>(valueFactory);
var existingValue = (LazyAsync <T>)Cache.AddOrGetExisting(KeyPrefix + key, asyncLazyValue, policy);
if (existingValue != null)
{
asyncLazyValue = existingValue;
}
try
{
var result = await asyncLazyValue;
if (asyncLazyValue != Cache.AddOrGetExisting(KeyPrefix + key, new LazyAsync <T>(valueFactory), policy))
{
return(await GetOrAddAsync(KeyPrefix + key, valueFactory, configurator));
}
return(result);
}
catch (Exception)
{
await RemoveAsync(KeyPrefix + key);
throw;
}
}
internal BaseCategoryService(CloudStorageContext cscCtx, MicroBlogOptions opts, ILogger logger, string tableName, string queueName)
{
this.logger = logger;
this._tableStore = new LazyAsync <SimpleTableHelper>(async() => await cscCtx.CreateTableHelper(tableName, logger));
_QueueStore = new LazyAsync <SimpleQueueHelper>(async() => await cscCtx.CreateQueueHelper(queueName, logger));
this.cscCtx = cscCtx;
}
public async Task CreatedWithConstructor_FromSyncSource_AwaitsCorrectValue()
{
LazyAsync <int> lazy = async() => 1;
var value = await lazy();
Assert.Equal(1, value);
}
internal ArticleService(CloudStorageContext cscCtx, MicroBlogOptions opts, ILogger logger)
{
this.cscCtx = cscCtx;
this.opts = opts;
this.logger = logger;
articleBlobStorage = new LazyAsync <SimpleBlobHelper>(async() => await cscCtx.CreateBlobHelper(opts[StorageList.ArticleBlob], logger));
articleDetailsStorage = new LazyAsync <SimpleTableHelper>(async() => await cscCtx.CreateTableHelper(opts[StorageList.ArticleDetails], logger));
}
private BlobStorage(Func<Task<CloudBlobContainer>> container)
{
if (container == null) throw new ArgumentNullException("container");
_container = new LazyAsync<CloudBlobContainer>(container);
// Turn container into a directory
_baseUri = new Lazy<Uri>(() => new Uri(Container.Uri + "/"));
}
public async Task AwaitTest()
{
var TestObject = new LazyAsync <int>(() => 5);
Assert.Equal(5, await TestObject);
TestObject = new LazyAsync <int>(GetValue);
Assert.Equal(50, await TestObject);
}
public WatchList()
{
Streams = new ObservableCollection <StreamModel>();
InitializeComponent();
RefreshTimer = new Timer(60000);
RefreshTimer.Elapsed += RefreshTimerOnElapsed;
LazyAsync.Invoke(() => RefreshTimerOnElapsed(null, null));
RefreshTimer.Start();
}
public AspNetUserContext(IHttpContextAccessor accessor, UserManager <User> userManager)
{
this.accessor = accessor;
if (userManager == null)
{
throw new ArgumentNullException(nameof(userManager));
}
this.userManager = userManager;
currentUser = new LazyAsync <User>(() => this.userManager.FindByIdAsync(Id.ToString()));
}
private void btnConnect_Click(object sender, RoutedEventArgs e)
{
if (Program.PlayWindow != null)
{
return;
}
Program.IsHost = false;
progressBar1.Visibility = Visibility.Visible;
_host = tbHost.Text;
_port = tbPort.Text;
LazyAsync.Invoke(Connect);
}
public async Task SetOutput(string text)
{
outputData = new LazyAsync <string>(() => Task.FromResult(text));
var outputFile = Path.Combine(ContentPath, outputFilename);
PathEx.CreateFilePath(outputFile);
using (var stream = File.Open(outputFile, FileMode.Create, FileAccess.Write))
using (var writer = new StreamWriter(stream)) {
await writer.WriteAsync(text);
}
}
public void UpdateAndRestart()
{
lock (LatestDetails)
{
if (LatestDetails.CanUpdate && LatestDetails.UpdateDownloaded)
{
var downloadUri = new Uri(LatestDetails.InstallUrl);
var filename = System.IO.Path.GetFileName(downloadUri.LocalPath);
var fi = new FileInfo(Path.Combine(Directory.GetCurrentDirectory(), filename));
LazyAsync.Invoke(() => Program.LaunchApplication(fi.FullName));
Program.Exit();
}
}
}
public void Stop()
{
lock (_socketLocker)
{
_stopping = true;
LazyAsync.Invoke(() =>
{
if (OnConnectionClosed != null)
{
OnConnectionClosed.Invoke(this);
}
Dispose();
});
}
}
public void Returns_Task()
{
// Arrange
var task = new Task <int>(() => Rnd.Int);
var l0 = new LazyAsync <int>(task);
var l1 = new LazyAsync <int>(() => task);
// Act
var r0 = l0.Value;
var r1 = l1.Value;
// Assert
Assert.Same(task, r0);
Assert.Same(task, r1);
}
public SkySocket(TcpClient c)
{
lock (_socketLocker)
{
IsDisposed = false;
_stopping = false;
Sock = c;
_builder = new SocketMessageBuilder();
//SocketThread = new Thread(ReadThreadRunner);
//SocketThread.Name = "SkySocket Read Thread";
RemoteEndPoint = Sock.Client.RemoteEndPoint;
//SocketThread.Start();
Connected = true;
LazyAsync.Invoke(AsyncRead);
}
}
public ResultViewModel(Result result, Settings settings)
{
if (result != null)
{
Result = result;
Image = new LazyAsync <ImageSource>(
SetImage,
ImageLoader.DefaultImage,
() =>
{
OnPropertyChanged(nameof(Image));
});
}
Settings = settings;
}
private void UpdateCheckDone()
{
Dispatcher.Invoke(new Action(() =>
{
_realCloseWindow = true;
if (_isNotUpToDate)
{
IsClosingDown = true;
var downloadUri = new Uri(_updateURL);
string filename = System.IO.Path.GetFileName(downloadUri.LocalPath);
UpdateStatus("Downloading new version.");
var c = new WebClient();
progressBar1.Maximum = 100;
progressBar1.IsIndeterminate = false;
progressBar1.Value = 0;
c.DownloadFileCompleted += delegate(object sender, AsyncCompletedEventArgs args)
{
if (!args.Cancelled)
{
LazyAsync.Invoke(() => Process.Start(Path.Combine(Directory.GetCurrentDirectory(), filename)));
}
else
{
UpdateStatus("Downloading the new version failed. Please manually download.");
Process.Start(_downloadURL);
}
Close();
};
c.DownloadProgressChanged += delegate(object sender, DownloadProgressChangedEventArgs args)
{
progressBar1.Value = args.ProgressPercentage;
};
c.DownloadFileAsync(downloadUri, Path.Combine(Directory.GetCurrentDirectory(), filename));
}
else
{
Close();
}
}));
}
public void WriteMessage(SocketMessage message)
{
lock (_socketLocker)
{
if (IsDisposed)
{
return;
}
byte[] data = SocketMessage.Serialize(message);
byte[] messagesize = BitConverter.GetBytes(data.LongLength);
try
{
Sock.Client.Send(messagesize);
Sock.Client.Send(data);
//Sock.GetStream().Flush();
}
catch (SocketException se)
{
if (se.ErrorCode == 10058)
{
return;
}
LazyAsync.Invoke(Stop);
}
catch (ObjectDisposedException)
{
LazyAsync.Invoke(Stop);
}
catch (NullReferenceException)
{
}
catch (Exception e)
{
Debug.WriteLine(e);
if (Debugger.IsAttached)
{
Debugger.Break();
}
}
}
}
private async Task <bool> PrepareForCompiling()
{
try
{
_compilation = await _runner.GetCompilationAsync(_code);
var tree = _compilation.CompilationObject.SyntaxTrees.Single();
_diags = _compilation.CompilationObject.GetSemanticModel(tree).GetDiagnostics();
_compiledCode = new LazyAsync <CompiledCode>
(() => _runner.EmitFromCompilationAsync(_compilation));
}
catch (Exception e) when(!(e is CompilationErrorException))
{
WriteToConsole("Something went wrong with the _compilation\r\n");
WriteToConsole("The error message is:\r\n");
WriteToConsole(" " + e.Message);
return(false);
}
return(true);
}
private void UpdateCheckDone()
{
Dispatcher.Invoke(new Action(() =>
{
_realCloseWindow = true;
if (_isNotUpToDate)
{
IsClosingDown = true;
UpdateStatus("Downloading new version.");
var c = new WebClient();
progressBar1.Maximum = 100;
progressBar1.IsIndeterminate = false;
progressBar1.Value = 0;
c.DownloadFileCompleted += delegate(object sender, AsyncCompletedEventArgs args)
{
if (!args.Cancelled)
{
LazyAsync.Invoke(() => Process.Start(Path.Combine(Directory.GetCurrentDirectory(), "Updater", "Octgn.Updater.exe")));
}
else
{
UpdateStatus("Downloading the new version failed. Please manually download.");
Process.Start(_downloadURL);
}
Close();
};
c.DownloadProgressChanged += delegate(object sender, DownloadProgressChangedEventArgs args)
{
progressBar1.Value = args.ProgressPercentage;
};
c.DownloadFileAsync(new Uri(_updateURL), Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "OCTGN", "update.zip"));
}
else
{
Close();
}
}));
}
public LoginNew()
{
InitializeComponent();
string password = Prefs.Password;
if (password != null)
{
passwordBox1.Password = password.Decrypt();
cbSavePassword.IsChecked = true;
}
textBox1.Text = Prefs.Username;
//TODO ToString for state may be wrong.
Program.LobbyClient.OnStateChanged += (sender, state) => UpdateLoginStatus(state.ToString());
Program.LobbyClient.OnLoginComplete += LobbyClientOnLoginComplete;
Program.LobbyClient.OnDisconnect += LobbyClientOnDisconnect;
this.labelRegister.MouseLeftButtonUp += (sender, args) => Process.Start(Program.WebsitePath + "register.php");
this.labelForgot.MouseLeftButtonUp +=
(sender, args) => Process.Start(Program.WebsitePath + "passwordresetrequest.php");
this.labelResend.MouseLeftButtonUp += (sender, args) =>
{
var url = Program.WebsitePath + "api/user/resendemailverify.php?username="
+ HttpUtility.UrlEncode(textBox1.Text);
using (var wc = new WebClient())
{
try
{
wc.DownloadStringAsync(new Uri(url));
}
catch (Exception)
{
}
}
};
LazyAsync.Invoke(GetTwitterStuff);
}
private void Update()
{
_realCloseWindow = true;
Log.Info("Not up to date.");
IsClosingDown = true;
var downloadUri = new Uri(_updateURL);
string filename = System.IO.Path.GetFileName(downloadUri.LocalPath);
UpdateStatus("Downloading new version.");
var c = new WebClient();
progressBar1.Maximum = 100;
progressBar1.IsIndeterminate = false;
progressBar1.Value = 0;
c.DownloadFileCompleted += delegate(object sender, AsyncCompletedEventArgs args)
{
Log.Info("Download complete");
if (!args.Cancelled)
{
Log.Info("Launching updater");
LazyAsync.Invoke(
() => Program.LaunchUrl(Path.Combine(Directory.GetCurrentDirectory(), filename)));
}
else
{
Log.Info("Download failed");
UpdateStatus("Downloading the new version failed. Please manually download.");
Program.LaunchUrl(_downloadURL);
}
Close();
};
c.DownloadProgressChanged += delegate(object sender, DownloadProgressChangedEventArgs args)
{ progressBar1.Value = args.ProgressPercentage; };
Log.InfoFormat("Downloading new version to {0}", filename);
c.DownloadFileAsync(downloadUri, Path.Combine(Directory.GetCurrentDirectory(), filename));
}
private async Task GetOrdersAsync(bool refreshCitadelData)
{
// var structureId = new SearchApi().GetCharactersCharacterIdSearchWithHttpInfo(new List<string>() { "structure" }, _charInfo.CharacterID, "1DQ");
var filePath = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Resources\\onedq.json"));
if (refreshCitadelData)
{
_allCitadelOrders =
new LazyAsync <List <GetMarketsStructuresStructureId200Ok> >(async() => await ApiExtension.GetAll(
index => _marketApi.GetMarketsStructuresStructureIdAsyncWithHttpInfo(1022734985679, page: index)));
File.WriteAllText(filePath, JsonConvert.SerializeObject(await _allCitadelOrders.Value));
return;
}
using (var file = File.OpenText(filePath))
{
var serializer = new JsonSerializer();
_allCitadelOrders = new LazyAsync <List <GetMarketsStructuresStructureId200Ok> >(async() =>
(List <GetMarketsStructuresStructureId200Ok>)serializer.Deserialize(file,
typeof(List <GetMarketsStructuresStructureId200Ok>)));
await _allCitadelOrders.Value;
}
}
public bool Connect(string host, int port)
{
lock (_socketLocker)
{
if (!Connected)
{
try
{
Sock = new TcpClient();
Sock.Connect(host, port);
RemoteEndPoint = Sock.Client.RemoteEndPoint;
//SocketThread.Start();
Connected = true;
LazyAsync.Invoke(AsyncRead);
return(true);
}
catch (SocketException)
{
return(false);
}
}
return(true);
}
}
public async Task Executes_Once()
{
// Arrange
var lazyCounter = 0;
var taskCounter = 0;
var times = 10;
var l = () => Task.FromResult(++lazyCounter);
var t = () => Task.FromResult(++taskCounter);
var a = new LazyAsync <int>(l);
// Act
for (var i = 0; i < times; i++)
{
await a.Value; // should run task once
}
for (var i = 0; i < times; i++)
{
await t(); // should run task each time
}
// Assert
Assert.Equal(1, lazyCounter);
Assert.Equal(times, taskCounter);
}
public Login()
{
InitializeComponent();
SpinnerRotate.CenterX = image2.Width / 2;
SpinnerRotate.CenterY = image2.Height / 2;
_animationTimer = new DispatcherTimer(DispatcherPriority.ContextIdle, Dispatcher)
{
Interval = new TimeSpan(0, 0, 0, 0, 100)
};
versionText.Text = string.Format("Version {0}", OctgnApp.OctgnVersion.ToString(4));
_animationTimer.Tick += HandleAnimationTick;
string password = Prefs.Password;
if (password != null)
{
passwordBox1.Password = password.Decrypt();
cbSavePassword.IsChecked = true;
}
textBox1.Text = Prefs.Username;
Program.LobbyClient.OnStateChanged += (sender, state) => UpdateLoginStatus(state);
Program.LobbyClient.OnLoginComplete += LobbyClientOnLoginComplete;
LazyAsync.Invoke(GetTwitterStuff);
}
public BuildData()
{
outputData = new LazyAsync <string>(LoadOutput);
}
public static void SetDetails(string trainTitle, LazyAsync<JourneyElement[]> journeyElementsLazyAsync)
{
LiveProgressPage.journeyElementsLazyAsync = journeyElementsLazyAsync;
LiveProgressPage.trainTitle = trainTitle;
}
private void ChattingOnOnCreateRoom(object sender, NewChatRoom room)
{
LazyAsync.Invoke(RefreshList);
}
public static void SetDetails(string trainTitle, LazyAsync <JourneyElement[]> journeyElementsLazyAsync)
{
LiveProgressPage.journeyElementsLazyAsync = journeyElementsLazyAsync;
LiveProgressPage.trainTitle = trainTitle;
}
public LazyAsyncTests()
{
TestObject = new LazyAsync <int>(() => 5);
}
