FileSystemWatcher.Created Événement

Définition

Se produit quand un fichier ou un répertoire du Path spécifié est créé.Occurs when a file or directory in the specified Path is created.

public:
 event System::IO::FileSystemEventHandler ^ Created;
public event System.IO.FileSystemEventHandler Created;
[System.IO.IODescription("FSW_Created")]
public event System.IO.FileSystemEventHandler Created;
[System.IO.IODescription("Occurs when a file/directory creation matches the filter")]
public event System.IO.FileSystemEventHandler Created;
member this.Created : System.IO.FileSystemEventHandler 
[<System.IO.IODescription("FSW_Created")>]
member this.Created : System.IO.FileSystemEventHandler 
[<System.IO.IODescription("Occurs when a file/directory creation matches the filter")>]
member this.Created : System.IO.FileSystemEventHandler 
Public Custom Event Created As FileSystemEventHandler 

Type d'événement

FileSystemEventHandler
Attributs

Exemples

L’exemple suivant utilise l' Created événement pour afficher le chemin d’accès de fichier à la console chaque fois que le fichier surveillé est créé.The following example uses the Created event to display the file path to the console whenever the watched file is created.

#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.IO
Imports System.Security.Permissions

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

Remarques

Certaines occurrences courantes, telles que la copie ou le déplacement d’un fichier ou d’un répertoire, ne correspondent pas directement à un événement, mais ces occurrences provoquent le déclenchement des événements.Some common occurrences, such as copying or moving a file or directory, do not correspond directly to an event, but these occurrences do cause events to be raised. Lorsque vous copiez un fichier ou un répertoire, le système déclenche un Created événement dans le répertoire dans lequel le fichier a été copié, si ce répertoire est surveillé.When you copy a file or directory, the system raises a Created event in the directory to which the file was copied, if that directory is being watched. Si le répertoire à partir duquel vous avez copié a été surveillé par une autre instance de FileSystemWatcher , aucun événement n’est déclenché.If the directory from which you copied was being watched by another instance of FileSystemWatcher, no event would be raised. Par exemple, vous créez deux instances de FileSystemWatcher .For example, you create two instances of FileSystemWatcher. FileSystemWatcher1 est défini pour surveiller « C:\Mes documents » et FileSystemWatcher2 est défini pour regarder « C:\Your documents ».FileSystemWatcher1 is set to watch "C:\My Documents", and FileSystemWatcher2 is set to watch "C:\Your Documents". Si vous copiez un fichier à partir de « mes documents » vers « vos documents », un Created événement est déclenché par FileSystemWatcher2, mais aucun événement n’est déclenché pour FileSystemWatcher1.If you copy a file from "My Documents" into "Your Documents", a Created event will be raised by FileSystemWatcher2, but no event is raised for FileSystemWatcher1. Contrairement à la copie, le déplacement d’un fichier ou d’un répertoire déclenche deux événements.Unlike copying, moving a file or directory would raise two events. Dans l’exemple précédent, si vous avez déplacé un fichier de « mes documents » vers « vos documents », un Created événement est déclenché par FileSystemWatcher2 et un Deleted événement est déclenché par FileSystemWatcher1.From the previous example, if you moved a file from "My Documents" to "Your Documents", a Created event would be raised by FileSystemWatcher2 and a Deleted event would be raised by FileSystemWatcher1.

Notes

Les opérations courantes du système de fichiers peuvent déclencher plusieurs événements.Common file system operations might raise more than one event. Par exemple, lorsqu’un fichier est déplacé d’un répertoire à un autre, plusieurs OnChanged OnCreated événements et OnDeleted peuvent être déclenchés.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Le déplacement d’un fichier est une opération complexe qui se compose de plusieurs opérations simples, déclenchant ainsi plusieurs événements.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. De même, certaines applications (par exemple, un logiciel antivirus) peuvent provoquer des événements de système de fichiers supplémentaires qui sont détectés par FileSystemWatcher .Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

Notes

L’ordre dans lequel l' Created événement est déclenché par rapport aux autres FileSystemWatcher événements peut changer lorsque la SynchronizingObject propriété n’a pas la valeur null .The order in which the Created event is raised in relation to the other FileSystemWatcher events may change when the SynchronizingObject property is not null.

L' OnCreated événement est déclenché dès qu’un fichier est créé.The OnCreated event is raised as soon as a file is created. Si un fichier est copié ou transféré dans un répertoire surveillé, l' OnCreated événement est déclenché immédiatement, suivi d’un ou plusieurs OnChanged événements.If a file is being copied or transferred into a watched directory, the OnCreated event will be raised immediately, followed by one or more OnChanged events.

S’applique à

Voir aussi