Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / IO / System / IO / FileSystemWatcher.cs / 1305376 / 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.Diagnostics.CodeAnalysis;
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;
internal byte[] buffer;
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),
SettingsBindable(true),
]
public string Filter {
get {
return filter;
}
set {
if (String.IsNullOrEmpty(value)) {
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),
SettingsBindable(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) {
try
{
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();
}
}
}
finally
{
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
///
[SuppressMessage("Microsoft.Security","CA2109:ReviewVisibleEventHandlers", MessageId="0#", Justification="Changing from protected to private would be a breaking change")]
protected void OnChanged(FileSystemEventArgs e) {
// To avoid ---- 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
///
[SuppressMessage("Microsoft.Security","CA2109:ReviewVisibleEventHandlers", MessageId="0#", Justification="Changing from protected to private would be a breaking change")]
protected void OnCreated(FileSystemEventArgs e) {
// To avoid ---- 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
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#", Justification = "Changing from protected to private would be a breaking change")]
protected void OnDeleted(FileSystemEventArgs e) {
// To avoid ---- 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
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#", Justification = "Changing from protected to private would be a breaking change")]
protected void OnError(ErrorEventArgs e) {
// To avoid ---- 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
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#", Justification = "Changing from protected to private would be a breaking change")]
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(null);
}
///
///
/// 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 appropriately.
// Ensure that the directoryHandle is set to INVALID_HANDLE before closing it, so that
// the Monitor() can shutdown appropriately.
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;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SamlDoNotCacheCondition.cs
- PictureBoxDesigner.cs
- DataGridViewLayoutData.cs
- CatchDesigner.xaml.cs
- DescendantBaseQuery.cs
- CachedTypeface.cs
- XmlElementCollection.cs
- PublisherMembershipCondition.cs
- SingleQueryOperator.cs
- XmlSerializerAssemblyAttribute.cs
- XmlLinkedNode.cs
- HWStack.cs
- BookmarkUndoUnit.cs
- AutomationProperties.cs
- XPathDocumentBuilder.cs
- Group.cs
- SchemaObjectWriter.cs
- HandlerBase.cs
- MessageSecurityOverHttp.cs
- PrintDialog.cs
- UserPreference.cs
- FixedDocument.cs
- FlowDocumentPage.cs
- ListViewItemMouseHoverEvent.cs
- ExpressionUtilities.cs
- ContentTextAutomationPeer.cs
- XmlSchemaDocumentation.cs
- UserControl.cs
- AppliedDeviceFiltersDialog.cs
- Options.cs
- XmlCodeExporter.cs
- LiteralText.cs
- ElementHostPropertyMap.cs
- ClearCollection.cs
- ProfileSettingsCollection.cs
- ThumbAutomationPeer.cs
- NamedPermissionSet.cs
- SelectionPatternIdentifiers.cs
- WizardForm.cs
- UnknownWrapper.cs
- DataPointer.cs
- TextFormatter.cs
- MenuItemCollection.cs
- GenericArgumentsUpdater.cs
- XmlTextAttribute.cs
- TiffBitmapEncoder.cs
- PropertiesTab.cs
- FusionWrap.cs
- ExtenderProvidedPropertyAttribute.cs
- AssemblyResourceLoader.cs
- CalendarDateChangedEventArgs.cs
- DbConnectionPoolCounters.cs
- ResXResourceSet.cs
- __FastResourceComparer.cs
- WindowsStatusBar.cs
- RtfFormatStack.cs
- ReferentialConstraintRoleElement.cs
- PersonalizationDictionary.cs
- UnsupportedPolicyOptionsException.cs
- DispatcherExceptionEventArgs.cs
- DefinitionBase.cs
- documentation.cs
- DocumentPaginator.cs
- DragSelectionMessageFilter.cs
- StructuralObject.cs
- Msec.cs
- TransactionTraceIdentifier.cs
- CodeDirectoryCompiler.cs
- BindingWorker.cs
- EntityDataSourceDesigner.cs
- QueryStringParameter.cs
- ProtocolImporter.cs
- MessagePropertyVariants.cs
- KeyConstraint.cs
- UnsafeNativeMethods.cs
- TextComposition.cs
- PackWebResponse.cs
- AuthenticationSection.cs
- PersistenceTypeAttribute.cs
- XmlSchemaAll.cs
- CodeTypeConstructor.cs
- ComboBoxDesigner.cs
- CommandLibraryHelper.cs
- SelectionItemPattern.cs
- safemediahandle.cs
- HttpModuleAction.cs
- TransformerInfoCollection.cs
- ProtocolViolationException.cs
- WebPartVerb.cs
- StrongNamePublicKeyBlob.cs
- RegexRunnerFactory.cs
- ReaderWriterLock.cs
- nulltextnavigator.cs
- FontNamesConverter.cs
- Int32CollectionValueSerializer.cs
- Int32Animation.cs
- WebPartTransformerCollection.cs
- Axis.cs
- RuntimeHandles.cs
- PropertiesTab.cs