Code:
/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / Services / IO / System / IO / FileSystemWatcher.cs / 2 / FileSystemWatcher.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.IO {
using System.Text;
using System.Runtime.Serialization.Formatters;
using System.Threading;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.ComponentModel;
using System.ComponentModel.Design;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
using System.Security.Permissions;
using System.Security;
using System.Globalization;
using System.Runtime.Versioning;
///
/// Listens to the system directory change notifications and
/// raises events when a directory or file within a directory changes.
///
[
DefaultEvent("Changed"),
// Disabling partial trust scenarios
PermissionSet(SecurityAction.LinkDemand, Name="FullTrust"),
PermissionSet(SecurityAction.InheritanceDemand, Name="FullTrust"),
IODescription(SR.FileSystemWatcherDesc)
]
public class FileSystemWatcher : Component, ISupportInitialize {
///
/// Private instance variables
///
// Directory being monitored
private string directory;
// Filter for name matching
private string filter;
// Unmanaged handle to monitored directory
private SafeFileHandle directoryHandle;
// The watch filter for the API call.
private const NotifyFilters defaultNotifyFilters = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
private NotifyFilters notifyFilters = defaultNotifyFilters;
// Flag to watch subtree of this directory
private bool includeSubdirectories = false;
// Flag to note whether we are attached to the thread pool and responding to changes
private bool enabled = false;
// Are we in init?
private bool initializing = false;
// Buffer size
private int internalBufferSize = 8192;
// Used for synchronization
private WaitForChangedResult changedResult;
private bool isChanged = false;
private ISynchronizeInvoke synchronizingObject;
private bool readGranted;
private bool disposed;
// Current "session" ID to ignore old events whenever we stop then
// restart.
private int currentSession;
// Event handlers
private FileSystemEventHandler onChangedHandler = null;
private FileSystemEventHandler onCreatedHandler = null;
private FileSystemEventHandler onDeletedHandler = null;
private RenamedEventHandler onRenamedHandler = null;
private ErrorEventHandler onErrorHandler = null;
// Thread gate holder and constats
private bool stopListening = false;
// Used for async method
private bool runOnce = false;
// To validate the input for "path"
private static readonly char[] wildcards = new char[] { '?', '*' };
private static int notifyFiltersValidMask;
// Additional state information to pass to callback. Note that we
// never return this object to users, but we do pass state in it.
private sealed class FSWAsyncResult : IAsyncResult
{
internal int session;
public bool IsCompleted {
get { throw new NotImplementedException(); }
}
public WaitHandle AsyncWaitHandle {
get { throw new NotImplementedException(); }
}
public Object AsyncState {
get { throw new NotImplementedException(); }
}
public bool CompletedSynchronously {
get { throw new NotImplementedException(); }
}
}
static FileSystemWatcher() {
notifyFiltersValidMask = 0;
foreach (int enumValue in Enum.GetValues(typeof(NotifyFilters)))
notifyFiltersValidMask |= enumValue;
}
///
/// Initializes a new instance of the
///
public FileSystemWatcher() {
this.directory = String.Empty;
this.filter = "*.*";
}
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public FileSystemWatcher(string path) : this(path, "*.*") {
}
///
///
/// Initializes a new instance of the
///
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public FileSystemWatcher(string path, string filter) {
if (path == null)
throw new ArgumentNullException("path");
if (filter == null)
throw new ArgumentNullException("filter");
// Early check for directory parameter so that an exception can be thrown as early as possible.
if (path.Length == 0 || !Directory.Exists(path))
throw new ArgumentException(SR.GetString(SR.InvalidDirName, path));
this.directory = path;
this.filter = filter;
}
///
///
/// Gets or sets the type of changes to watch for.
///
///
[
DefaultValue(defaultNotifyFilters),
IODescription(SR.FSW_ChangedFilter)
]
public NotifyFilters NotifyFilter {
get {
return notifyFilters;
}
set {
if (((int) value & ~notifyFiltersValidMask) != 0)
throw new InvalidEnumArgumentException("value", (int)value, typeof(NotifyFilters));
if (notifyFilters != value) {
notifyFilters = value;
Restart();
}
}
}
///
/// Gets or sets a value indicating whether the component is enabled.
///
[
DefaultValue(false),
IODescription(SR.FSW_Enabled)
]
public bool EnableRaisingEvents {
get {
return enabled;
}
set {
if (enabled == value) {
return;
}
enabled = value;
if (!IsSuspended()) {
if (enabled) {
StartRaisingEvents();
}
else {
StopRaisingEvents();
}
}
}
}
///
/// Gets or sets the filter string, used to determine what files are monitored in a directory.
///
[
DefaultValue("*.*"),
IODescription(SR.FSW_Filter),
TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign),
RecommendedAsConfigurable(true),
]
public string Filter {
get {
return filter;
}
set {
if (value == null || value == String.Empty) {
value = "*.*";
}
if (String.Compare(filter, value, StringComparison.OrdinalIgnoreCase) != 0) {
filter = value;
}
}
}
///
///
/// Gets or sets a
/// value indicating whether subdirectories within the specified path should be monitored.
///
///
[
DefaultValue(false),
IODescription(SR.FSW_IncludeSubdirectories)
]
public bool IncludeSubdirectories {
get {
return includeSubdirectories;
}
set {
if (includeSubdirectories != value) {
includeSubdirectories = value;
Restart();
}
}
}
///
/// Gets or
/// sets the size of the internal buffer.
///
[
Browsable(false),
DefaultValue(8192)
]
public int InternalBufferSize {
get {
return internalBufferSize;
}
set {
if (internalBufferSize != value) {
if (value < 4096) {
value = 4096;
}
internalBufferSize = value;
Restart();
}
}
}
private bool IsHandleInvalid {
get {
return (directoryHandle == null || directoryHandle.IsInvalid);
}
}
///
/// Gets or sets the path of the directory to watch.
///
[
DefaultValue(""),
IODescription(SR.FSW_Path),
Editor("System.Diagnostics.Design.FSWPathEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign),
RecommendedAsConfigurable(true)
]
public string Path {
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get {
return directory;
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
set {
value = (value == null) ? string.Empty : value;
if (String.Compare(directory, value, StringComparison.OrdinalIgnoreCase) != 0) {
if (DesignMode) {
// Don't check the path if in design mode, try to do simple syntax check
if (value.IndexOfAny(FileSystemWatcher.wildcards) != -1 || value.IndexOfAny(System.IO.Path.GetInvalidPathChars()) != -1) {
throw new ArgumentException(SR.GetString(SR.InvalidDirName, value));
}
}
else {
if (!Directory.Exists(value))
throw new ArgumentException(SR.GetString(SR.InvalidDirName, value));
}
directory = value;
readGranted = false;
Restart();
}
}
}
///
///
[Browsable(false)]
public override ISite Site {
get {
return base.Site;
}
set {
base.Site = value;
// set EnableRaisingEvents to true at design time so the user
// doesn't have to manually. We can't do this in
// the constructor because in code it should
// default to false.
if (Site != null && Site.DesignMode)
EnableRaisingEvents = true;
}
}
///
///
/// Gets or sets the object used to marshal the event handler calls issued as a
/// result of a directory change.
///
///
[
Browsable(false),
DefaultValue(null),
IODescription(SR.FSW_SynchronizingObject)
]
public ISynchronizeInvoke SynchronizingObject {
get {
if (this.synchronizingObject == null && DesignMode) {
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host != null) {
object baseComponent = host.RootComponent;
if (baseComponent != null && baseComponent is ISynchronizeInvoke)
this.synchronizingObject = (ISynchronizeInvoke)baseComponent;
}
}
return this.synchronizingObject;
}
set {
this.synchronizingObject = value;
}
}
///
///
/// Occurs when a file or directory in the specified
///
[IODescription(SR.FSW_Changed)]
public event FileSystemEventHandler Changed {
add {
onChangedHandler += value;
}
remove {
onChangedHandler -= value;
}
}
///
///
/// Occurs when a file or directory in the specified
///
[IODescription(SR.FSW_Created)]
public event FileSystemEventHandler Created {
add {
onCreatedHandler += value;
}
remove {
onCreatedHandler -= value;
}
}
///
///
/// Occurs when a file or directory in the specified
///
[IODescription(SR.FSW_Deleted)]
public event FileSystemEventHandler Deleted {
add{
onDeletedHandler += value;
}
remove {
onDeletedHandler -= value;
}
}
///
///
/// Occurs when the internal buffer overflows.
///
///
[Browsable(false)]
public event ErrorEventHandler Error {
add {
onErrorHandler += value;
}
remove {
onErrorHandler -= value;
}
}
///
///
/// Occurs when a file or directory in the specified
///
[IODescription(SR.FSW_Renamed)]
public event RenamedEventHandler Renamed {
add {
onRenamedHandler += value;
}
remove {
onRenamedHandler -= value;
}
}
///
/// Notifies the object that initialization is beginning and tells it to standby.
///
public void BeginInit() {
bool oldEnabled = enabled;
StopRaisingEvents();
enabled = oldEnabled;
initializing = true;
}
///
/// Callback from thread pool.
///
///
///
protected override void Dispose(bool disposing) {
if (disposing) {
//Stop raising events cleans up managed and
//unmanaged resources.
StopRaisingEvents();
// Clean up managed resources
onChangedHandler = null;
onCreatedHandler = null;
onDeletedHandler = null;
onRenamedHandler = null;
onErrorHandler = null;
readGranted = false;
}
else {
stopListening = true;
// Clean up unmanaged resources
if (!IsHandleInvalid) {
directoryHandle.Close();
}
}
this.disposed = true;
base.Dispose(disposing);
}
///
///
/// Notifies the object that initialization is complete.
///
///
public void EndInit() {
initializing = false;
// Unless user told us NOT to start after initialization, we'll start listening
// to events
if (directory.Length != 0 && enabled == true)
StartRaisingEvents();
}
///
/// Returns true if the component is either in a Begin/End Init block or in design mode.
///
//
/// Sees if the name given matches the name filter we have.
///
///
/// Calls native API and sets up handle with the directory change API.
///
///
/// Raises the event to each handler in the list.
///
///
/// Raises the event to each handler in the list.
///
///
/// Raises the event to each handler in the list.
///
///
///
/// Raises the
///
protected void OnChanged(FileSystemEventArgs e) {
// To avoid race between remove handler and raising the event
FileSystemEventHandler changedHandler = onChangedHandler;
if (changedHandler != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(changedHandler, new object[]{this, e});
else
changedHandler(this, e);
}
}
///
///
/// Raises the
///
protected void OnCreated(FileSystemEventArgs e) {
// To avoid race between remove handler and raising the event
FileSystemEventHandler createdHandler = onCreatedHandler;
if (createdHandler != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(createdHandler, new object[]{this, e});
else
createdHandler(this, e);
}
}
///
///
/// Raises the
///
protected void OnDeleted(FileSystemEventArgs e) {
// To avoid race between remove handler and raising the event
FileSystemEventHandler deletedHandler = onDeletedHandler;
if (deletedHandler != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(deletedHandler, new object[]{this, e});
else
deletedHandler(this, e);
}
}
///
///
/// Raises the
///
protected void OnError(ErrorEventArgs e) {
// To avoid race between remove handler and raising the event
ErrorEventHandler errorHandler = onErrorHandler;
if (errorHandler != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(errorHandler, new object[]{this, e});
else
errorHandler(this, e);
}
}
///
/// Internal method used for synchronous notification.
///
///
/// Internal method used for synchronous notification.
///
///
///
/// Raises the
///
protected void OnRenamed(RenamedEventArgs e) {
RenamedEventHandler renamedHandler = onRenamedHandler;
if (renamedHandler != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(renamedHandler, new object[]{this, e});
else
renamedHandler(this, e);
}
}
///
/// Stops and starts this object.
///
///
///
/// Starts monitoring the specified directory.
///
///
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
private void StartRaisingEvents() {
//Cannot allocate the directoryHandle and the readBuffer if the object has been disposed; finalization has been suppressed.
if (this.disposed)
throw new ObjectDisposedException(GetType().Name);
try {
new EnvironmentPermission(PermissionState.Unrestricted).Assert();
if (Environment.OSVersion.Platform != PlatformID.Win32NT) {
throw new PlatformNotSupportedException(SR.GetString(SR.WinNTRequired));
}
}
finally {
CodeAccessPermission.RevertAssert();
}
// If we're called when "Initializing" is true, set enabled to true
if (IsSuspended()) {
enabled = true;
return;
}
if (!readGranted) {
string fullPath;
// Consider asserting path discovery permission here.
fullPath = System.IO.Path.GetFullPath(directory);
FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.Read, fullPath);
permission.Demand();
readGranted = true;
}
// If we're attached, don't do anything.
if (!IsHandleInvalid) {
return;
}
// Create handle to directory being monitored
directoryHandle = NativeMethods.CreateFile(directory, // Directory name
UnsafeNativeMethods.FILE_LIST_DIRECTORY, // access (read-write) mode
UnsafeNativeMethods.FILE_SHARE_READ |
UnsafeNativeMethods.FILE_SHARE_DELETE |
UnsafeNativeMethods.FILE_SHARE_WRITE, // share mode
null, // security descriptor
UnsafeNativeMethods.OPEN_EXISTING, // how to create
UnsafeNativeMethods.FILE_FLAG_BACKUP_SEMANTICS |
UnsafeNativeMethods.FILE_FLAG_OVERLAPPED, // file attributes
new SafeFileHandle(IntPtr.Zero, false) // file with attributes to copy
);
if (IsHandleInvalid) {
throw new FileNotFoundException(SR.GetString(SR.FSW_IOError, directory));
}
stopListening = false;
// Start ignoring all events that were initiated before this.
Interlocked.Increment(ref currentSession);
// Attach handle to thread pool
//SECREVIEW: At this point at least FileIOPermission has already been demanded.
SecurityPermission secPermission = new SecurityPermission(PermissionState.Unrestricted);
secPermission.Assert();
try {
ThreadPool.BindHandle(directoryHandle);
}
finally {
SecurityPermission.RevertAssert();
}
enabled = true;
// Setup IO completion port
Monitor((IntPtr)0);
}
///
///
/// Stops monitoring the specified directory.
///
///
private void StopRaisingEvents() {
if (IsSuspended()) {
enabled = false;
return;
}
// If we're not attached, do nothing.
if (IsHandleInvalid) {
return;
}
// Close directory handle
// This operation doesn't need to be atomic because the API will deal with a closed
// handle appropriatelly.
// Ensure that the directoryHandle is set to INVALID_HANDLE before closing it, so that
// the Monitor() can shutdown appropriatelly.
stopListening = true;
directoryHandle.Close();
directoryHandle = null;
// Start ignoring all events occurring after this.
Interlocked.Increment(ref currentSession);
// Set enabled to false
enabled = false;
}
///
///
/// A synchronous method that returns a structure that
/// contains specific information on the change that occurred, given the type
/// of change that you wish to monitor.
///
///
public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType) {
return WaitForChanged(changeType, -1);
}
///
///
/// A synchronous
/// method that returns a structure that contains specific information on the change that occurred, given the
/// type of change that you wish to monitor and the time (in milliseconds) to wait before timing out.
///
///
public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType, int timeout) {
FileSystemEventHandler dirHandler = new FileSystemEventHandler(this.OnInternalFileSystemEventArgs);
RenamedEventHandler renameHandler = new RenamedEventHandler(this.OnInternalRenameEventArgs);
this.isChanged = false;
this.changedResult = WaitForChangedResult.TimedOutResult;
// Register the internal event handler from the given change types.
if ((changeType & WatcherChangeTypes.Created) != 0) {
this.Created += dirHandler;
}
if ((changeType & WatcherChangeTypes.Deleted) != 0) {
this.Deleted += dirHandler;
}
if ((changeType & WatcherChangeTypes.Changed) != 0) {
this.Changed += dirHandler;
}
if ((changeType & WatcherChangeTypes.Renamed) != 0) {
this.Renamed += renameHandler;
}
// Save the Enabled state of this component to revert back to it later (if needed).
bool savedEnabled = EnableRaisingEvents;
if (savedEnabled == false) {
runOnce = true;
EnableRaisingEvents = true;
}
// For each thread entering this wait loop, addref it and wait. When the last one
// exits, reset the waiterObject.
WaitForChangedResult retVal = WaitForChangedResult.TimedOutResult;
lock (this) {
if (timeout == -1) {
while (!isChanged) {
System.Threading.Monitor.Wait(this);
}
}
else {
System.Threading.Monitor.Wait(this, timeout, true);
}
retVal = changedResult;
}
// Revert the Enabled flag to its previous state.
EnableRaisingEvents = savedEnabled;
runOnce = false;
// Decouple the event handlers added above.
if ((changeType & WatcherChangeTypes.Created) != 0) {
this.Created -= dirHandler;
}
if ((changeType & WatcherChangeTypes.Deleted) != 0) {
this.Deleted -= dirHandler;
}
if ((changeType & WatcherChangeTypes.Changed) != 0) {
this.Changed -= dirHandler;
}
if ((changeType & WatcherChangeTypes.Renamed) != 0) {
this.Renamed -= renameHandler;
}
// Return the struct.
return retVal;
}
}
///
/// Helper class to hold to N/Direct call declaration and flags.
///
[
System.Security.Permissions.SecurityPermissionAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Flags=System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)
]
internal static class Direct {
// All possible action flags
public const int FILE_ACTION_ADDED = 1;
public const int FILE_ACTION_REMOVED = 2;
public const int FILE_ACTION_MODIFIED = 3;
public const int FILE_ACTION_RENAMED_OLD_NAME = 4;
public const int FILE_ACTION_RENAMED_NEW_NAME = 5;
// All possible notifications flags
public const int FILE_NOTIFY_CHANGE_FILE_NAME = 0x00000001;
public const int FILE_NOTIFY_CHANGE_DIR_NAME = 0x00000002;
public const int FILE_NOTIFY_CHANGE_NAME = 0x00000003;
public const int FILE_NOTIFY_CHANGE_ATTRIBUTES = 0x00000004;
public const int FILE_NOTIFY_CHANGE_SIZE = 0x00000008;
public const int FILE_NOTIFY_CHANGE_LAST_WRITE = 0x00000010;
public const int FILE_NOTIFY_CHANGE_LAST_ACCESS = 0x00000020;
public const int FILE_NOTIFY_CHANGE_CREATION = 0x00000040;
public const int FILE_NOTIFY_CHANGE_SECURITY = 0x00000100;
}
}
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SmtpFailedRecipientException.cs
- StackSpiller.Temps.cs
- DataGridAutoGeneratingColumnEventArgs.cs
- SessionEndingCancelEventArgs.cs
- SoapFault.cs
- UnmanagedMemoryStream.cs
- FormViewInsertedEventArgs.cs
- TypeInfo.cs
- ServiceSettingsResponseInfo.cs
- OleDbMetaDataFactory.cs
- ToolStrip.cs
- FindCriteriaCD1.cs
- CancellationHandler.cs
- DeleteHelper.cs
- FormClosedEvent.cs
- AttributeData.cs
- EntityDataSourceWrapper.cs
- EmptyEnumerable.cs
- WebBrowser.cs
- StrokeCollection.cs
- DiagnosticSection.cs
- CodeSubDirectoriesCollection.cs
- ToolboxItemLoader.cs
- PeerDuplexChannel.cs
- Rijndael.cs
- MinimizableAttributeTypeConverter.cs
- EtwTrace.cs
- HtmlInputRadioButton.cs
- Math.cs
- StatusBarAutomationPeer.cs
- WindowAutomationPeer.cs
- EntryPointNotFoundException.cs
- ErrorWebPart.cs
- VoiceObjectToken.cs
- XPathAncestorIterator.cs
- FontStyleConverter.cs
- TypeDefinition.cs
- Stack.cs
- PageFunction.cs
- CodeVariableDeclarationStatement.cs
- TextTrailingCharacterEllipsis.cs
- ItemContainerProviderWrapper.cs
- RunInstallerAttribute.cs
- PointAnimationBase.cs
- DynamicValidatorEventArgs.cs
- BufferedGraphicsContext.cs
- base64Transforms.cs
- WebPartZoneBase.cs
- HMACRIPEMD160.cs
- SafeUserTokenHandle.cs
- TimeoutException.cs
- CodeGeneratorOptions.cs
- Line.cs
- VisualStyleElement.cs
- SHA512Managed.cs
- RawAppCommandInputReport.cs
- DataMemberAttribute.cs
- DashStyles.cs
- DrawingContextWalker.cs
- CodeValidator.cs
- WebCategoryAttribute.cs
- CompoundFileStorageReference.cs
- TextTreeInsertElementUndoUnit.cs
- MouseCaptureWithinProperty.cs
- DescendentsWalker.cs
- AppModelKnownContentFactory.cs
- CaseExpr.cs
- MediaContextNotificationWindow.cs
- TimeSpanStorage.cs
- ReaderWriterLockSlim.cs
- DeviceContext.cs
- XamlClipboardData.cs
- BitmapDownload.cs
- AvTraceFormat.cs
- ProviderCollection.cs
- Matrix3DConverter.cs
- PersonalizationProviderCollection.cs
- KeyValuePair.cs
- DragDeltaEventArgs.cs
- ClientBuildManagerTypeDescriptionProviderBridge.cs
- ActivityExecutorOperation.cs
- DBDataPermission.cs
- Rule.cs
- TemplateBuilder.cs
- AppDomainFactory.cs
- WeakReferenceKey.cs
- SmiEventStream.cs
- SecurityContextCookieSerializer.cs
- CapabilitiesState.cs
- NoClickablePointException.cs
- HScrollProperties.cs
- DirtyTextRange.cs
- SendSecurityHeader.cs
- XPathParser.cs
- SortedDictionary.cs
- HiddenFieldPageStatePersister.cs
- HTMLTextWriter.cs
- UriSection.cs
- HGlobalSafeHandle.cs
- XmlComment.cs