Example #1
0
        /// <summary>
        /// Process a single event.
        /// </summary>
        /// <param name="factory"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private async Task ProcessEventAsync(IConnectionFactory factory, IFileSystemEvent e)
        {
            // try process as created.
            await TryProcessAddedAsync(factory, e).ConfigureAwait(false);

            // try process as deleted.
            await TryProcessRemovedAsync(factory, e).ConfigureAwait(false);

            // try process as changed.
            await TryProcessTouchedAsync(factory, e).ConfigureAwait(false);

            // process as a renamed event
            await TryProcessRenamedAsync(factory, e).ConfigureAwait(false);
        }
Example #2
0
        /// <summary>
        /// Try and process a changed file event.
        /// </summary>
        /// <param name="factory"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private async Task TryProcessTouchedAsync(IConnectionFactory factory, IFileSystemEvent e)
        {
            try
            {
                if (e.Action != EventAction.Touched)
                {
                    return;
                }

                await ProcessTouchedAsync(factory, e, _token).ConfigureAwait(false);
            }
            catch
            {
                Logger.Error($"There was an error trying to process changed game event {e.FullName}!");

                // the exception is logged
                throw;
            }
        }
Example #3
0
 /// <summary>
 /// Add a file event to the list.
 /// </summary>
 /// <param name="fileSystemEventArgs"></param>
 /// <param name="token"></param>
 public async Task AddAsync(IFileSystemEvent fileSystemEventArgs, CancellationToken token)
 {
     await Task.Run(() =>
     {
         lock (_lockEvents)
         {
             try
             {
                 if (_token.IsCancellationRequested)
                 {
                     return;
                 }
                 _currentEvents.Add(fileSystemEventArgs);
             }
             catch (Exception e)
             {
                 Logger.Exception(e);
             }
         }
     }, token);
 }
Example #4
0
        /// <summary>
        /// Try and process a changed file event.
        /// </summary>
        /// <param name="factory"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private async Task TryProcessRenamedAsync(IConnectionFactory factory, IFileSystemEvent e)
        {
            try
            {
                if (e.Action != EventAction.Renamed)
                {
                    return;
                }

                var rfse = e as IRenamedFileSystemEvent;

                // we have both a new and old name...
                await ProcessRenamedAsync(factory, rfse, _token).ConfigureAwait(false);
            }
            catch
            {
                var rfse = e as IRenamedFileSystemEvent;
                Logger.Error($"There was an error trying to rename {rfse?.FullName ?? "???"} to {rfse?.PreviousFullName ?? "???"}!");
                throw;
            }
        }
Example #5
0
 /// <summary>
 /// Process a created event
 /// </summary>
 /// <param name="factory"></param>
 /// <param name="fileSystemEvent"></param>
 /// <param name="token"></param>
 protected abstract Task ProcessTouchedAsync(IConnectionFactory factory, IFileSystemEvent fileSystemEvent, CancellationToken token);