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); }