Ejemplo n.º 1
0
 static void OnFilesFinishedChangingEvent(object sender, FilesFinishedChangingEventArgs e)
 {
     lock (Lock)
     {
         Console.WriteLine("OnFilesFinishedChangingEvent:");
         foreach (var fileFinishedChangingEventArgs in e.FilesFinishedChanging)
         {
             Console.WriteLine("  FilePath = {0}", fileFinishedChangingEventArgs.FilePath);
             Console.WriteLine("  ChangeType = {0}",
                               Enum.GetName(typeof (FileEventType), fileFinishedChangingEventArgs.ChangeType));
         }
         Console.WriteLine();
     }
 }
        /// <summary>
        /// Will raise the event on the current thread synchronously.
        /// i.e. it will wait until all event handlers have processed the event.
        /// </summary>
        /// <param name="e">The state to be passed to the event.</param>
        private void RaiseOnFilesFinishedChangingEvent(FilesFinishedChangingEventArgs e)
        {
            // Make a temporary copy of the event to avoid possibility of
            // a race condition if the last subscriber unsubscribes
            // immediately after the null check and before the event is raised.

            FilesFinishedChangingEventHandler eventHandler;

            if (!Monitor.TryEnter(_filesFinishedChangingEventLock, _lockTimeout))
            {
                throw new ApplicationException("Timeout waiting for lock - RaiseOnFilesFinishedChangingEvent");
            }
            try
            {
                eventHandler = _filesFinishedChangingEvent;
            }
            finally
            {
                Monitor.Exit(_filesFinishedChangingEventLock);
            }

            OnFilesFinishedChangingEvent(e);

            if (eventHandler != null)
            {
                eventHandler(this, e);
            }
        }
 /// <summary>
 /// Will raise the event on the calling thread synchronously. 
 /// i.e. it will wait until all event handlers have processed the event.
 /// </summary>
 /// <param name="state">The state to be passed to the event.</param>
 private void RaiseCrossThreadOnFilesFinishedChangingEvent(FilesFinishedChangingEventArgs e)
 {
     _asyncOperation.SynchronizationContext.Send(new SendOrPostCallback(AsynchronousOnFilesFinishedChangingEventRaised), e);
 }
 /// <summary>
 /// Will raise the event on the calling thread asynchronously. 
 /// i.e. it will immediatly continue processing even though event 
 /// handlers have not processed the event yet.
 /// </summary>
 /// <param name="state">The state to be passed to the event.</param>
 private void RaiseAsynchronousOnFilesFinishedChangingEvent(FilesFinishedChangingEventArgs e)
 {
     _asyncOperation.Post(new SendOrPostCallback(AsynchronousOnFilesFinishedChangingEventRaised), e);
 }
 /// <summary>
 /// Template method to add default behaviour for the event
 /// </summary>
 private void OnFilesFinishedChangingEvent(FilesFinishedChangingEventArgs e)
 {
     // TODO: Implement default behaviour of OnFilesFinishedChangingEvent
 }
        private void OnFileFinishedChanging(FileFinishedChangingEventArgs e)
        {
            lock (_filesRaisingEventsLock)
            {
                var filePath = e.FilePath;
                if (_filesChanging.ContainsKey(filePath))
                {
                    if ( IsFileLocked(filePath))
                    {
                        //The file is still currently in use, lets try raise the event later
                        Touch(filePath);
                    }
                    else
                    {
                        Pop(filePath);

                        var fileFinishedChangingEventArgs = new FileFinishedChangingEventArgs(e.FilePath, e.ChangeType, UserState);

                        //We only want to know about the last event, not any that may have happened in the mean time
                        _filesFinishedChanging[fileFinishedChangingEventArgs.FilePath] = fileFinishedChangingEventArgs;

                        RaiseAsynchronousOnFileFinishedChangingEvent(fileFinishedChangingEventArgs);

                        if (_filesChanging == null || _filesChanging.Count < 1)
                        {
                            if (_filesFinishedChanging != null && _filesFinishedChanging.Count > 0)
                            {
                                //There are no more files that are in the change queue so let everyone know the files have finished changing
                                var filesFinishedChangingEventArgs = new FilesFinishedChangingEventArgs(new List<FileFinishedChangingEventArgs>(_filesFinishedChanging.Values), UserState);
                                RaiseAsynchronousOnFilesFinishedChangingEvent(filesFinishedChangingEventArgs);

                                _filesFinishedChanging = new Dictionary<string, FileFinishedChangingEventArgs>();
                            }
                        }
                    }
                }
            }
        }