Dart FileSystemDeleteEvent

last modified April 4, 2025

The FileSystemDeleteEvent class in Dart represents file system deletion events. It's part of Dart's file system monitoring capabilities.

This event is triggered when files or directories are deleted from a watched location. It provides details about the deleted file system entity.

Basic Definition

FileSystemDeleteEvent is a subclass of FileSystemEvent. It indicates that a file or directory has been deleted from the file system.

Key properties include the event type, path, and whether it's a directory. These help identify what was deleted and where it was located.

Basic FileSystemDeleteEvent Usage

This example shows how to watch for file deletion events in a directory.

import 'dart:io';

void main() async {
  var dir = Directory('watch_dir');
  await dir.create();
  
  var watcher = dir.watch();
  watcher.listen((event) {
    if (event is FileSystemDeleteEvent) {
      print('Deleted: ${event.path}');
      print('Is directory: ${event.isDirectory}');
    }
  });
  
  // Simulate file deletion after delay
  await Future.delayed(Duration(seconds: 1));
  File('${dir.path}/test.txt').create().then((file) {
    Future.delayed(Duration(seconds: 1), () => file.delete());
  });
}

We create a directory watcher and listen for deletion events. When a file is deleted, the event provides the path and type information.

$ dart main.dart
Deleted: watch_dir/test.txt
Is directory: false

Handling Directory Deletion

This example demonstrates detecting directory deletion events.

import 'dart:io';

void main() async {
  var parentDir = Directory('parent_dir');
  await parentDir.create();
  
  var watcher = parentDir.watch();
  watcher.listen((event) {
    if (event is FileSystemDeleteEvent && event.isDirectory) {
      print('Directory deleted: ${event.path}');
    }
  });
  
  // Create and then delete a subdirectory
  var subDir = Directory('${parentDir.path}/sub_dir');
  await subDir.create();
  await Future.delayed(Duration(seconds: 1));
  await subDir.delete();
}

We watch for directory deletions specifically by checking the isDirectory property. The event triggers when a subdirectory is removed.

$ dart main.dart
Directory deleted: parent_dir/sub_dir

Multiple Event Types

This example shows distinguishing between different file system events.

import 'dart:io';

void main() async {
  var dir = Directory('multi_event_dir');
  await dir.create();
  
  var watcher = dir.watch();
  watcher.listen((event) {
    if (event is FileSystemDeleteEvent) {
      print('Delete event: ${event.path}');
    } else if (event is FileSystemCreateEvent) {
      print('Create event: ${event.path}');
    } else if (event is FileSystemModifyEvent) {
      print('Modify event: ${event.path}');
    }
  });
  
  // Trigger multiple events
  var file = File('${dir.path}/data.txt');
  await file.create();
  await file.writeAsString('content');
  await file.delete();
}

We handle different event types separately. The delete event fires when the file is removed after creation and modification.

$ dart main.dart
Create event: multi_event_dir/data.txt
Modify event: multi_event_dir/data.txt
Delete event: multi_event_dir/data.txt

Error Handling

This example adds error handling to file system watching.

import 'dart:io';

void main() async {
  var dir = Directory('error_dir');
  
  try {
    var watcher = dir.watch();
    watcher.listen((event) {
      if (event is FileSystemDeleteEvent) {
        print('Deleted: ${event.path}');
      }
    }, onError: (error) {
      print('Error: $error');
    });
    
    // Simulate deletion of watched directory
    await dir.create();
    await Future.delayed(Duration(seconds: 1));
    await dir.delete();
  } catch (e) {
    print('Exception: $e');
  }
}

We handle both synchronous exceptions and asynchronous errors. The watcher may error if the watched directory itself is deleted.

$ dart main.dart
Error: FileSystemException: Directory watching failed, path = 'error_dir'

Recursive Watching

This example demonstrates recursive directory watching for deletions.

import 'dart:io';

void main() async {
  var rootDir = Directory('root_dir');
  await rootDir.create();
  
  // Watch recursively
  var watcher = rootDir.watch(recursive: true);
  watcher.listen((event) {
    if (event is FileSystemDeleteEvent) {
      print('Deleted (recursive): ${event.path}');
    }
  });
  
  // Create and delete nested structure
  var nestedDir = Directory('${rootDir.path}/a/b/c');
  await nestedDir.create(recursive: true);
  var nestedFile = File('${nestedDir.path}/file.txt');
  await nestedFile.create();
  
  await Future.delayed(Duration(seconds: 1));
  await nestedFile.delete();
  await nestedDir.delete();
}

With recursive watching, we detect deletions at any level in the directory tree. Events trigger for both files and directories in subfolders.

$ dart main.dart
Deleted (recursive): root_dir/a/b/c/file.txt
Deleted (recursive): root_dir/a/b/c

Best Practices

• Resource cleanup: Always cancel watchers when done
• Error handling: Implement both try-catch and onError
• Recursive wisely: Use recursive mode only when needed
• Event filtering: Check event types before processing
• Path handling: Use absolute paths for reliable tracking

Source

Dart FileSystemDeleteEvent Documentation

This tutorial covered Dart's FileSystemDeleteEvent class with practical examples showing file and directory deletion monitoring, error handling, and recursive watching patterns.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Dart tutorials.