public async Task SetupAsync(ObjectLock <DiscordClientEx> discordClient) { _discordClient = discordClient; await _discordClient.DoAsync((client) => { client.ReactionAdded += DiscordClient_ReactionAdded; client.ReactionRemoved += DiscordClient_ReactionRemoved; client.ReactionsCleared += DiscordClient_ReactionsCleared; }).ConfigureAwait(false); }
/// <inheritdoc /> public async Task <bool> LockedAsync(TDataType objectId) { ObjectLock <TDataType>?exists = await this._database.QuerySingleOrDefaultAsync(builder : this._lockBuilder, storedProcedure : this._objectLockProcedures.IsLocked, new { ObjectId = objectId }); if (exists != null) { this._logger.LogDebug($"Object is currently locked by {exists.LockedBy} on {exists.LockedAt}"); return(true); } return(false); }
/// <inheritdoc /> public async Task <bool> AcquireAsync(TDataType objectId) { ObjectLock <TDataType>?exists = await this._database.QuerySingleOrDefaultAsync(builder : this._lockBuilder, storedProcedure : this._objectLockProcedures.Acquire, new { ObjectId = objectId, MachineName = this._machineName }); if (exists != null) { this._logger.LogDebug($"Object was locked by {exists.LockedBy} on {exists.LockedAt}"); return(true); } return(false); }
public static void SaveLock(ObjectLock oLock) { if (GameInformation.ObjectLocks.Count <= oLock.lockIndex) { LockData newLock = new LockData(); for (int i = 0; i < oLock.lockIndex + 1; i++) { if (i <= GameInformation.ObjectLocks.Count) { GameInformation.ObjectLocks.Insert(i, newLock); } } //GameInformation.NPCData.Insert(npc.NPCIndex, newNPC); } GameInformation.ObjectLocks[oLock.lockIndex].locked = oLock.IsLocked(); GameInformation.ObjectLocks[oLock.lockIndex].index = oLock.lockIndex; }
protected Task <IDisposable> WriteLock() { lock (lockLock) { var ts = new TaskCompletionSource <IDisposable> (); var ol = new ObjectLock { Object = this, IsWriteLock = true, TaskSource = ts }; if (writeLockTaken || readLocksTaken > 0) { if (lockRequests == null) { lockRequests = new Queue <ObjectLock> (); } lockRequests.Enqueue(ol); } else { writeLockTaken = true; ts.SetResult(ol); } return(ts.Task); } }
public async Task <bool> RunAsync() { if (_firstStart) { Log.Setup(true, false); Log.Info("Starting Ditto..."); } // Try to load the settings from the XML file. // Should this not exist, it will automatically create one. try { Settings = await SettingsConfiguration.ReadAsync("data/settings.xml"); // Write the settings again to update it with any new properties that might have been added. await Settings.WriteAsync("data/settings.xml").ConfigureAwait(false); } catch (Exception ex) { Log.Fatal(ex); return(false); } // Try to initialize the database try { (Database = new DatabaseHandler()).Setup(Settings.Credentials.Sql.Type, Settings.Credentials.Sql.ConnectionString); } catch (Exception ex) { Log.Fatal("Unable to create a connection with the database, please check the file \"/data/settings.xml\"", ex); return(false); } // Try to initialise the service 'Google' try { await(Google = new GoogleService()).SetupAsync(Settings.Credentials.GoogleApiKey).ConfigureAwait(false); } catch (Exception ex) { Log.Error("Could not initialize Google {0}\n", ex.ToString()); } // Try to initialise 'Giphy' try { Giphy = new Giphy(Settings.Credentials.GiphyApiKey); } catch (ApiException ex) { Log.Warn("Could not initialize Giphy {0}\n", ex.ToString()); } // Try to initialise 'Twitch' try { Twitch = new TwitchLib.Api.TwitchAPI(); Twitch.Settings.ClientId = Settings.Credentials.TwitchApiClientId; Twitch.Settings.Secret = Settings.Credentials.TwitchApiSecret; var twitchResult = await Twitch.V5.Auth.CheckCredentialsAsync().ConfigureAwait(false); if (Twitch.Settings.ClientId == null || !twitchResult.Result) { Twitch = null; throw new ApiException("Twitch credentials check failed."); } } catch (Exception ex) { Log.Warn("Could not initialize Twitch {0}\n", ex.ToString()); } // Create our discord client Client?.Dispose(); Client = new ObjectLock <DiscordClientEx>(new DiscordClientEx(new DiscordSocketConfig() { MessageCacheSize = Settings.Cache.AmountOfCachedMessages, LogLevel = LogSeverity.Warning, //TotalShards = 1, ConnectionTimeout = (int)(Settings.Timeout * 60), HandlerTimeout = (int)(Settings.Timeout * 60), DefaultRetryMode = RetryMode.AlwaysRetry, //AlwaysDownloadUsers = true, }), 1, 1); // Various services if (Cache == null) { (Cache = new CacheHandler()).Setup(TimeSpan.FromSeconds(Settings.Cache.CacheTime)); } CommandHandler?.Dispose(); await(CommandHandler = new CommandHandler(Client)).SetupAsync().ConfigureAwait(false); await Client.DoAsync((client) => client.Connected += async() => { // Setup services await CommandHandler.SetupAsync().ConfigureAwait(false); ReactionHandler?.Dispose(); await(ReactionHandler = new ReactionHandler()).SetupAsync(Client).ConfigureAwait(false); PlayingStatusHandler.Setup(TimeSpan.FromMinutes(1)); } ).ConfigureAwait(false); if (_firstStart) { Connected += async() => { // Start services await CommandHandler.StartAsync().ConfigureAwait(false); PlayingStatusHandler.Start(); Connected -= Initialised; }; // Call this once after a successful connection. Connected += Initialised; } await Client.DoAsync((client) => client.Ready += async() => { if (!Running) { Running = true; await Connected().ConfigureAwait(false); } Log.Info("Connected"); if (Type == BotType.Bot) { await client.SetGameAsync(null); await client.SetStatusAsync(UserStatusEx.Online); } } ).ConfigureAwait(false); await Client.DoAsync((client) => client.Disconnected += (e) => { if (Reconnecting) { //_reconnecting = false; } else { Log.Warn("Bot has been disconnected. {0}", (object)(Exiting ? null : $"| {e}")); if (!Exiting && Settings.AutoReconnect && !Reconnecting) { var _ = Task.Run(() => ReconnectAsync()); } } return(Task.CompletedTask); } ).ConfigureAwait(false); await Client.DoAsync((client) => client.LoggedOut += () => { Log.Warn("Bot has logged out."); if (!Exiting && Settings.AutoReconnect && !Reconnecting) { var _ = Task.Run(() => ReconnectAsync()); } return(Task.CompletedTask); } ).ConfigureAwait(false); var autoReconnect = Settings.AutoReconnect; Settings.AutoReconnect = false; try { await LoginAsync().ConfigureAwait(false); Settings.AutoReconnect = autoReconnect; } catch (Exception ex) { Log.Fatal("Failed to login, please check your internet connection and bot token.", ex); return(false); } await Client.DoAsync((c) => c.StartAsync()).ConfigureAwait(false); _firstStart = false; return(true); }
private void Awake() { objLock = GameObject.FindGameObjectWithTag("Player").GetComponent <ObjectLock>(); }
public void TestObjectLockPerformance() { bool _IsSingleCore = (Environment.ProcessorCount == 1); //--------------------------------------------------------------- { object target = new object(); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { lock (target) { lockedCount++; } } sw.Stop(); Debug.Print("BenchmarkC#LockPattern : {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- // ----------- this is the lowest overhead technique ------------ //--------------------------------------------------------------- { Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; int _Spinlock = 0; for (int i = 0; i < TestIterations; i++) { while (Interlocked.CompareExchange(ref _Spinlock, 1, 0) != 0) { if (_IsSingleCore) { Thread.Sleep(0); } } try { lockedCount++; } finally { Interlocked.Exchange(ref _Spinlock, 0); } } sw.Stop(); Debug.Print("InlineInterlockedInt32 : {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { object target = new object(); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { Monitor.Enter(target); try { lockedCount++; } finally { Monitor.Exit(target); } } sw.Stop(); Debug.Print("SystemMonitorEnterExit : {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { object target = new object(); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { int spinCount = 0; object lockedObject = null; while ((lockedObject = Interlocked.Exchange <object>(ref target, null)) == null) { if (_IsSingleCore) { Thread.Sleep(0); } else { spinCount++; if (spinCount % 4000 == 0) { Thread.Sleep(0); } } } try { lockedCount++; } finally { Interlocked.Exchange <object>(ref target, lockedObject); } } sw.Stop(); Debug.Print("InlineInterlockedObject: {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { SpinLock spinlockFast = new SpinLock(false); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { bool lockTaken = false; while (!lockTaken) { spinlockFast.Enter(ref lockTaken); try { if (lockTaken) { lockedCount++; } } finally { if (lockTaken) { spinlockFast.Exit(); } } } } sw.Stop(); Debug.Print("Net4SpinlockPatternFast: {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { SpinLock spinlockSlow = new SpinLock(true); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { bool lockTaken = false; while (!lockTaken) { spinlockSlow.Enter(ref lockTaken); try { if (lockTaken) { lockedCount++; } } finally { if (lockTaken) { spinlockSlow.Exit(); } } } } sw.Stop(); Debug.Print("Net4SpinlockPatternSlow: {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { object target = new object(); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { object lockedObject = ObjectLock <object> .Enter(ref target); try { lockedCount++; } finally { ObjectLock <object> .Leave(ref target, lockedObject); } } sw.Stop(); Debug.Print("EnterLeaveCallsPattern : {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { object target = new object(); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { ObjectLock <object> .Protect(ref target, delegate(object lockedObject) { lockedCount++; }); } sw.Stop(); Debug.Print("LockedDelegatePattern : {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } //--------------------------------------------------------------- { object target = new object(); Guarded <object> wrapper = new Guarded <object>(target); Stopwatch sw = new Stopwatch(); sw.Start(); int lockedCount = 0; for (int i = 0; i < TestIterations; i++) { //int n = (i % TargetObjects); wrapper.Locked((lockedObject) => { lockedCount++; }); } sw.Stop(); Debug.Print("GuardedWrapperPattern : {0} seconds, {1} locks/ms", sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds); } }
private void UnlockObject(ObjectLock activeLock) { _repository.Remove(activeLock); _repository.UnitOfWork.Commit(); }
private void RefreshLock(ObjectLock activeLock) { activeLock.LastModified = DateTime.UtcNow; _repository.Update(activeLock); _repository.UnitOfWork.Commit(); }