public void SetAction(BufferedAction action, int buffer) { if (character.BfAction <= action) { character.BfAction = action; character.BufferTimer = buffer; } }
/// <summary> /// Disposes this instance. /// </summary> public void Dispose() { // ReSharper disable ExceptionNotDocumented FileSystemWatcher watcher = Interlocked.Exchange(ref _watcher, null); watcher?.Dispose(); BufferedAction action = Interlocked.Exchange(ref _eventAction, null); action?.Dispose(); // ReSharper restore ExceptionNotDocumented }
/// <summary> /// Initializes a new instance of the <see cref="ConfigurationSection{T}" /> class. /// </summary> /// <exception cref="ConfigurationErrorsException">The selected value conflicts with a value that is already defined.</exception> // ReSharper disable once NotNullMemberIsNotInitialized protected ConfigurationSection() { // Set up change buffer _changeAction = new BufferedAction <string>( // ReSharper disable once EventExceptionNotDocumented, AssignNullToNotNullAttribute changes => Changed?.Invoke((T)this, new ConfigurationChangedEventArgs((T)this, changes)), ConfigurationExtensions.EventBufferMs); // This will get set during initialization ((IInternalConfigurationElement)this).ConfigurationElementName = $"<{SectionName}>"; // As our system supports change notification, we can default the restart on external changes to false. SectionInformation.RestartOnExternalChanges = false; }
/// <summary> /// Initializes a new instance of the <see cref="ConfigurationFileWatcher"/> class. /// </summary> /// <param name="path">The path.</param> private ConfigurationFileWatcher([NotNull] string path) { _eventAction = new BufferedAction(WatcherOnChanged, 100); Path = path; if (!File.Exists(path)) { return; } // ReSharper disable once AssignNullToNotNullAttribute _watcher = new FileSystemWatcher(System.IO.Path.GetDirectoryName(path), System.IO.Path.GetFileName(path)); _watcher.Changed += (s, e) => _eventAction.Run(); _watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size; _watcher.EnableRaisingEvents = true; }
/// <summary> /// Disposes the specified instance. /// </summary> /// <param name="disposing">Whether this is disposing or finalizing.</param> /// <remarks> /// <para><paramref name="disposing"/> indicates whether the method was invoked from the /// <see cref="IDisposable.Dispose"/> implementation or from the finalizer. The implementation should check the /// parameter before accessing other reference objects. Such objects should only be accessed when the method /// is called from the <see cref="IDisposable.Dispose"/> implementation (when the <paramref name="disposing"/> /// parameter is equal to <see langword="true"/>). If the method is invoked from the finalizer /// (disposing is false), other objects should not be accessed. The reason is that objects are finalized in an /// unpredictable order and so they, or any of their dependencies, might already have been finalized.</para> /// </remarks> // ReSharper disable once VirtualMemberNeverOverriden.Global protected virtual void Dispose(bool disposing) { IsDisposed = true; // ReSharper disable once ExceptionNotDocumented // If we're disposing the active configuration section, we want to reload the active configuration. Interlocked.CompareExchange(ref _active, null, (T)this); if (!disposing) { return; } ConfigurationFileWatcher.UnWatch(this); // ReSharper disable once ExceptionNotDocumented BufferedAction <string> action = Interlocked.Exchange(ref _changeAction, null); action?.Dispose(); }
/// <summary> /// Adds the specified logs to storage in batches. /// </summary> /// <param name="logs">The logs to add to storage.</param> /// <param name="token">The token.</param> /// <returns>Task.</returns> /// <exception cref="ObjectDisposedException">The logger has been disposed.</exception> public override Task Add(IEnumerable <Log> logs, CancellationToken token = new CancellationToken()) { BufferedAction <Log> bufferedAction = _bufferedSend; if (bufferedAction == null) { throw new ObjectDisposedException(nameof(EmailLogger)); } foreach (Log log in logs) { bufferedAction.Run(log); } return(TaskResult.Completed); }
// Update is called once per frame public void ClearBuffer() { BfAction = BufferedAction.NONE; BufferTimer = 0; }
public void Buffer(string action, float timeToBuffer) { actions[action] = new BufferedAction(timeToBuffer); }
void EnqueueUpdate(BufferedAction action) { m_QueryUpdates.Enqueue(action); }
/// <summary> /// Initializes static members of the <see cref="ConfigurationSection{T}" /> class. /// </summary> static ConfigurationSection() { _activeChangeAction = new BufferedAction <string>( // ReSharper disable EventExceptionNotDocumented, AssignNullToNotNullAttribute changes => { try { T active = Active; ActiveChanged?.Invoke(active, new ConfigurationChangedEventArgs(active, changes)); } // ReSharper disable once CatchAllClause catch { // ignored } }, // ReSharper restore EventExceptionNotDocumented, AssignNullToNotNullAttribute ConfigurationExtensions.EventBufferMs); // Try to find attribute ConfigurationSectionAttribute attribute = (ConfigurationSectionAttribute) typeof(T).GetCustomAttributes(typeof(ConfigurationSectionAttribute), false). FirstOrDefault(); string sectionName = attribute?.Name; if (string.IsNullOrEmpty(sectionName)) { sectionName = typeof(T).Name; int len = sectionName.Length; // If it ends with 'configuration' strip it. if (len > 20 && sectionName.EndsWith( "configurationsection", StringComparison.CurrentCultureIgnoreCase)) { sectionName = sectionName.Substring(0, len -= 20); } else if (len > 13 && sectionName.EndsWith( "configuration", StringComparison.CurrentCultureIgnoreCase)) { sectionName = sectionName.Substring(0, len -= 13); } else if (len > 7 && sectionName.EndsWith( "section", StringComparison.CurrentCultureIgnoreCase)) { sectionName = sectionName.Substring(0, len -= 7); } else if (len > 6 && sectionName.EndsWith( "config", StringComparison.CurrentCultureIgnoreCase)) { sectionName = sectionName.Substring(0, len -= 6); } // Convert to lower camel case sectionName = sectionName.Substring(0, 1).ToLower() + (len > 1 ? sectionName. Substring(1) : string.Empty); } SectionName = sectionName; }
/// <summary> /// Initializes a new instance of the <see cref="LoggerBase" /> class. /// </summary> /// <param name="name">The name of the logger.</param> /// <param name="fromAddress">The from address.</param> /// <param name="senderAddress">The sender address.</param> /// <param name="toAddresses">The to addresses.</param> /// <param name="ccAddresses">The CC addresses.</param> /// <param name="bccAddresses">The BCC addresses.</param> /// <param name="subject">The email subject format.</param> /// <param name="bodyHtml">The HTML body format.</param> /// <param name="bodyPlainText">The plain text body format.</param> /// <param name="bufferCount">The maximum number of logs to send in a single email.</param> /// <param name="bufferDuration">The duration of time to buffer logs to send in a single email.</param> /// <param name="host">The SMTP host.</param> /// <param name="port">The SMTP port.</param> /// <param name="timeout">The SMTP timeout.</param> /// <param name="ssl">if set to <see langword="true" /> SSL will be used.</param> /// <param name="deliveryMethod">The delivery method.</param> /// <param name="deliveryFormat">The delivery format.</param> /// <param name="username">The network username.</param> /// <param name="password">The network password.</param> /// <param name="networkDomain">The network domain.</param> /// <param name="validLevels">The valid levels.</param> /// <remarks>The SMTP connection settings will be pulled from the <c><system.net>/<mailSettings>/<smtp></c> /// configuration section if the parameters are left as their default values. /// (See https://docs.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/network/smtp-element-network-settings for details)</remarks> /// <exception cref="System.ArgumentNullException"></exception> /// <exception cref="System.ArgumentOutOfRangeException">At least one to/CC/BCC address must be given. /// or /// The bufferCount must be greater than zero.</exception> /// <exception cref="ArgumentNullException"><paramref name="name" /> is <see langword="null" /></exception> /// <exception cref="ArgumentOutOfRangeException"><para>The <paramref name="bufferCount" /> was less than or equal to zero.</para> /// <para>-or-</para> /// <para>At least one to/CC/BCC address was not given.</para></exception> public EmailLogger( [NotNull] string name, [CanBeNull] MailAddress fromAddress = null, [CanBeNull] MailAddress senderAddress = null, [CanBeNull] MailAddressCollection toAddresses = null, [CanBeNull] MailAddressCollection ccAddresses = null, [CanBeNull] MailAddressCollection bccAddresses = null, [CanBeNull] FormatBuilder subject = null, [CanBeNull] FormatBuilder bodyHtml = null, [CanBeNull] FormatBuilder bodyPlainText = null, ushort bufferCount = 10, Duration?bufferDuration = null, [CanBeNull] string host = null, ushort port = 0, [CanBeNull] Duration?timeout = null, [CanBeNull] bool?ssl = null, [CanBeNull] SmtpDeliveryMethod?deliveryMethod = null, [CanBeNull] SmtpDeliveryFormat?deliveryFormat = null, [CanBeNull] string username = null, [CanBeNull] SecureString password = null, [CanBeNull] string networkDomain = null, LoggingLevels validLevels = LoggingLevels.All) : base(name, true, validLevels) { if ((toAddresses == null || toAddresses.Count < 1) && (ccAddresses == null || ccAddresses.Count < 1) && (bccAddresses == null || bccAddresses.Count < 1)) { throw new ArgumentOutOfRangeException( nameof(toAddresses), Resources.EmailLogger_ToAddressMissing); } if (bufferCount < 1 && bufferDuration == TimeHelpers.InfiniteDuration) { throw new ArgumentOutOfRangeException( nameof(bufferCount), bufferCount, Resources.EmailLogger_InvalidBufferCount); } FromAddress = fromAddress; SenderAddress = senderAddress; ToAddresses = toAddresses; CCAddresses = ccAddresses; BccAddresses = bccAddresses; Subject = subject ?? DefaultSubject; BodyHtml = bodyHtml ?? (bodyPlainText == null ? DefaultBodyHtml : null); BodyPlainText = bodyPlainText; _smtpClient = new SmtpClient(host, port); _smtpClient.Timeout = (int?)timeout?.TotalMilliseconds() ?? DefaultTimeout; if (ssl.HasValue) { _smtpClient.EnableSsl = ssl.Value; } if (deliveryMethod.HasValue) { _smtpClient.DeliveryMethod = deliveryMethod.Value; } if (deliveryFormat.HasValue) { _smtpClient.DeliveryFormat = deliveryFormat.Value; } if (username != null && password != null) { _smtpClient.Credentials = new NetworkCredential(username, password, networkDomain ?? string.Empty); } _bufferedSend = new BufferedAction <Log>( SendLogs, bufferDuration ?? DefaultBufferDuration, bufferCount); }