FileSystemWatcher.Filter FileSystemWatcher.Filter FileSystemWatcher.Filter FileSystemWatcher.Filter Property

Definición

Obtiene o establece la cadena de filtro utilizada para determinar qué archivos se supervisan en un directorio.Gets or sets the filter string used to determine what files are monitored in a directory.

public:
 property System::String ^ Filter { System::String ^ get(); void set(System::String ^ value); };
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.IO.IODescription("File name filter pattern")]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.IO.IODescription("FSW_Filter")]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.SettingsBindable(true)]
public string Filter { get; set; }
member this.Filter : string with get, set
Public Property Filter As String

Valor de propiedad

La cadena de filtro.The filter string. El valor predeterminado es "*. *"(Inspecciona todos los archivos).The default is "*.*" (Watches all files.)

Ejemplos

En el ejemplo siguiente se crea un FileSystemWatcher para inspeccionar el directorio especificado en tiempo de ejecución.The following example creates a FileSystemWatcher to watch the directory specified at run time. El componente se establece para ver los cambios en LastWrite y LastAccess de tiempo, la creación, eliminación, o cambiar el nombre de los archivos de texto en el directorio.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Si se cambia, se crea o se elimina un archivo, se imprime la ruta de acceso al archivo en la consola.If a file is changed, created, or deleted, the path to the file prints to the console. Cuando se cambia el nombre de un archivo, imprimen las rutas de acceso antiguos y nuevos en la consola.When a file is renamed, the old and new paths print to the console.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;

public ref class Watcher
{
private:
   // Define the event handlers.
   static void OnChanged( Object^ /*source*/, FileSystemEventArgs^ e )
   {
      // Specify what is done when a file is changed, created, or deleted.
      Console::WriteLine( "File: {0} {1}", e->FullPath, e->ChangeType );
   }

   static void OnRenamed( Object^ /*source*/, RenamedEventArgs^ e )
   {
      // Specify what is done when a file is renamed.
      Console::WriteLine( "File: {0} renamed to {1}", e->OldFullPath, e->FullPath );
   }

public:
   [PermissionSet(SecurityAction::Demand, Name="FullTrust")]
   int static run()
   {
      array<String^>^args = System::Environment::GetCommandLineArgs();

      // If a directory is not specified, exit program.
      if ( args->Length != 2 )
      {
         // Display the proper way to call the program.
         Console::WriteLine( "Usage: Watcher.exe (directory)" );
         return 0;
      }

      // Create a new FileSystemWatcher and set its properties.
      FileSystemWatcher^ watcher = gcnew FileSystemWatcher;
      watcher->Path = args[ 1 ];

      /* Watch for changes in LastAccess and LastWrite times, and 
          the renaming of files or directories. */
      watcher->NotifyFilter = static_cast<NotifyFilters>(NotifyFilters::LastAccess |
            NotifyFilters::LastWrite | NotifyFilters::FileName | NotifyFilters::DirectoryName);

      // Only watch text files.
      watcher->Filter = "*.txt";

      // Add event handlers.
      watcher->Changed += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Created += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Deleted += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Renamed += gcnew RenamedEventHandler( Watcher::OnRenamed );

      // Begin watching.
      watcher->EnableRaisingEvents = true;

      // Wait for the user to quit the program.
      Console::WriteLine( "Press \'q\' to quit the sample." );
      while ( Console::Read() != 'q' );

      return 0;
   }
};

int main() {
   Watcher::run();
}
using System;
using System.IO;
using System.Security.Permissions;

public class Watcher
{
    public static void Main()
    {
        Run();
    }

    [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
    private static void Run()
    {
        string[] args = Environment.GetCommandLineArgs();

        // If a directory is not specified, exit program.
        if (args.Length != 2)
        {
            // Display the proper way to call the program.
            Console.WriteLine("Usage: Watcher.exe (directory)");
            return;
        }

        // Create a new FileSystemWatcher and set its properties.
        using (FileSystemWatcher watcher = new FileSystemWatcher())
        {
            watcher.Path = args[1];

            // Watch for changes in LastAccess and LastWrite times, and
            // the renaming of files or directories.
            watcher.NotifyFilter = NotifyFilters.LastAccess
                                 | NotifyFilters.LastWrite
                                 | NotifyFilters.FileName
                                 | NotifyFilters.DirectoryName;

            // Only watch text files.
            watcher.Filter = "*.txt";

            // Add event handlers.
            watcher.Changed += OnChanged;
            watcher.Created += OnChanged;
            watcher.Deleted += OnChanged;
            watcher.Renamed += OnRenamed;

            // Begin watching.
            watcher.EnableRaisingEvents = true;

            // Wait for the user to quit the program.
            Console.WriteLine("Press 'q' to quit the sample.");
            while (Console.Read() != 'q') ;
        }
    }

    // Define the event handlers.
    private static void OnChanged(object source, FileSystemEventArgs e) =>
        // Specify what is done when a file is changed, created, or deleted.
        Console.WriteLine($"File: {e.FullPath} {e.ChangeType}");

    private static void OnRenamed(object source, RenamedEventArgs e) =>
        // Specify what is done when a file is renamed.
        Console.WriteLine($"File: {e.OldFullPath} renamed to {e.FullPath}");
}
Imports System
Imports System.IO
Imports System.Security.Permissions
Imports Microsoft.VisualBasic

Public Class Watcher

    Public Shared Sub Main()

        Run()

    End Sub

    <PermissionSet(SecurityAction.Demand, Name:="FullTrust")>
    Private Shared Sub Run()

        Dim args() As String = Environment.GetCommandLineArgs()

        ' If a directory is not specified, exit the program.
        If args.Length <> 2 Then
            ' Display the proper way to call the program.
            Console.WriteLine("Usage: Watcher.exe (directory)")
            Return
        End If

        ' Create a new FileSystemWatcher and set its properties.
        Using watcher As New FileSystemWatcher()
            watcher.Path = args(1)

            ' Watch for changes in LastAccess and LastWrite times, and
            ' the renaming of files or directories. 
            watcher.NotifyFilter = (NotifyFilters.LastAccess _
                                 Or NotifyFilters.LastWrite _
                                 Or NotifyFilters.FileName _
                                 Or NotifyFilters.DirectoryName)

            ' Only watch text files.
            watcher.Filter = "*.txt"

            ' Add event handlers.
            AddHandler watcher.Changed, AddressOf OnChanged
            AddHandler watcher.Created, AddressOf OnChanged
            AddHandler watcher.Deleted, AddressOf OnChanged
            AddHandler watcher.Renamed, AddressOf OnRenamed

            ' Begin watching.
            watcher.EnableRaisingEvents = True

            ' Wait for the user to quit the program.
            Console.WriteLine("Press 'q' to quit the sample.")
            While Chr(Console.Read()) <> "q"c
            End While
        End Using
    End Sub

    ' Define the event handlers.
    Private Shared Sub OnChanged(source As Object, e As FileSystemEventArgs)
        ' Specify what is done when a file is changed, created, or deleted.
        Console.WriteLine($"File: {e.FullPath} {e.ChangeType}")
    End Sub

    Private Shared Sub OnRenamed(source As Object, e As RenamedEventArgs)
        ' Specify what is done when a file is renamed.
        Console.WriteLine($"File: {e.OldFullPath} renamed to {e.FullPath}")
    End Sub

End Class

Comentarios

Para inspeccionar los cambios en todos los archivos, establezca el Filter propiedad en una cadena vacía ("").To watch changes in all files, set the Filter property to an empty string (""). Para inspeccionar un archivo específico, establezca el Filter propiedad en el nombre de archivo.To watch a specific file, set the Filter property to the file name. Por ejemplo, para ver los cambios en el archivo MyDoc.txt, establezca el Filter propiedad en "MyDoc.txt".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". También puede ver los cambios en un determinado tipo de archivo.You can also watch for changes in a certain type of file. Por ejemplo, para ver los cambios en los archivos de texto, establezca el Filter propiedad como "*.txt".For example, to watch for changes in any text files, set the Filter property to "*.txt". Uso de varios filtros, como "*.txt|*.doc" no se admite.Use of multiple filters such as "*.txt|*.doc" is not supported.

El Filter propiedad se puede cambiar después el FileSystemWatcher objeto haya empezado a recibir eventos.The Filter property can be changed after the FileSystemWatcher object has started receiving events.

Para obtener más información acerca del filtrado de notificaciones no deseadas, vea el NotifyFilter, IncludeSubdirectories, y InternalBufferSize propiedades.For more information about filtering out unwanted notifications, see the NotifyFilter, IncludeSubdirectories, and InternalBufferSize properties.

Filter acepta caracteres comodín para los archivos coincidentes, como se muestra en los ejemplos siguientes.Filter accepts wildcards for matching files, as shown in the following examples.

Cadena de filtroFilter string Supervisa los siguientes archivosWatches the following files
*.**.* Todos los archivos (valor predeterminado).All files (default). Una cadena vacía ("") también inspecciona todos los archivos.An empty string ("") also watches all files.
*.txt*.txt Todos los archivos con la extensión "txt".All files with a "txt" extension.
*recipe.doc*recipe.doc Todos los archivos que terminan en "receta" con una extensión "doc".All files ending in "recipe" with a "doc" extension.
Win*.Xmlwin*.xml Todos los archivos que comienzan por "win" con la extensión "xml".All files beginning with "win" with an "xml" extension.
Ventas * 200?. xlsSales*200?.xls Coincide con lo siguiente:Matches the following:

-Julio ventas 2001.xls- Sales July 2001.xls
-Ventas Ago 2002.xls- Sales Aug 2002.xls
-2004.xls de marzo ventas- Sales March 2004.xls

pero no coincide con:but does not match:

-1999.xls Nov ventas- Sales Nov 1999.xls
MyReport.DocMyReport.Doc Inspecciona sólo MyReport.docWatches only MyReport.doc

Se aplica a

Consulte también: