Slow File Copy/Move/Delete Dialog in Windows 11? Copy Hook Handlers Are Likely the Cause

Updated February 2026 — Windows 11 24H2

You press Ctrl+C then Ctrl+V to copy a file, and the familiar Windows copy dialog takes 5-10 seconds to appear. Or worse, the “Preparing to copy” or “Calculating time remaining” stage hangs indefinitely before any data actually transfers. Moving and deleting files is equally sluggish, even when the files are small.

While most troubleshooting guides focus on disk speed, antivirus interference, or indexing service issues, there is a less well-known cause that affects a surprising number of systems: Copy Hook Handlers — a specific type of Shell Extension that intercepts file operations in Explorer.

What Are Copy Hook Handlers?

A Copy Hook Handler (ICopyHook) is a Shell Extension that Windows calls before executing any file copy, move, rename, or delete operation in Explorer. The handler receives the operation details and can:

1. Allow the operation (return IDYES)
2. Deny the operation (return IDNO)
3. Cancel the operation (return IDCANCEL)

Legitimate Uses

• Cloud sync services (Dropbox, OneDrive, Google Drive) use copy hooks to detect when synced files are moved or renamed, so they can update their sync state.
• Version control tools (TortoiseSVN, TortoiseGit) intercept file moves to update their internal tracking.
• Backup software may use copy hooks to exclude certain directories from backup.
• Enterprise DLP (Data Loss Prevention) tools use copy hooks to prevent copying confidential files to unauthorized locations.

The Performance Problem

The critical issue is that all registered copy hook handlers are called synchronously before the operation begins. Explorer waits for every handler to respond before proceeding. If any single handler:

• Performs a network request (checking cloud status)
• Scans the file (antivirus on-access scanning)
• Queries a database (DLP policy lookup)
• Has a bug (infinite loop, deadlock)

…then the entire file operation is delayed.

Diagnosing Copy Hook Delays

Method 1: ShellExView

1. Open ShellExView as Administrator.
2. Sort by Type column.
3. Look for entries with type “Copy Hook Handler” or “Copy Hook”.
4. Note all third-party entries (non-Microsoft).

Common copy hook handlers you might find:

Method 2: Process Monitor (Precise Timing)

Use Process Monitor to trace exactly what happens during a file copy:

1. Open Process Monitor and set these filters:
   • Process Name is explorer.exe
   • Operation contains RegQueryValue (to see registry lookups for copy hooks)
   • Operation is LoadImage (to see DLLs being loaded)
2. Start the trace.
3. Copy a small file in Explorer.
4. Stop the trace.
5. Look for:
   • DLL loads immediately before the copy dialog appears — these are the copy hook handlers
   • Any DLL load with a long duration (>500ms) is suspicious
   • Registry queries to HKCR\Directory\shellex\CopyHookHandlers

Method 3: Performance Monitor Counter

Track file operation latency over time:

typeperf "\Process(explorer)\Elapsed Time" -si 1 > perf_log.csv

Copy files at regular intervals and correlate spikes in the log with the operations.

Method 4: Event Tracing for Windows (ETW)

For advanced diagnosis, enable ETW tracing for the Shell:

logman create trace ShellTrace -o shell_trace.etl -p Microsoft-Windows-Shell-Core -ets
:: Perform copy/move operations
logman stop ShellTrace -ets

Analyze the trace with Windows Performance Analyzer (WPA) to see the exact sequence of copy hook calls and their durations.

Fixing the Problem

Fix 1: Disable Specific Copy Hook Handlers

Using ShellExView:

1. Identify the problematic copy hook handler(s) from the diagnosis step.
2. Select the handler.
3. Press F7 to disable.
4. Restart Explorer: Options → Restart Explorer.
5. Test file copy performance.

Fix 2: Registry Removal

Copy hook handlers are registered under:

HKEY_CLASSES_ROOT\Directory\shellex\CopyHookHandlers\

To remove a specific handler:

reg delete "HKCR\Directory\shellex\CopyHookHandlers\{HandlerName}" /f

Warning: Back up the key first with reg export "HKCR\Directory\shellex\CopyHookHandlers" backup.reg.

Fix 3: Update Cloud Sync Software

Many copy hook delays are caused by older versions of cloud sync tools making synchronous network requests inside the hook. Update to the latest versions:

• Dropbox: v200+ significantly improved copy hook performance
• Google Drive for Desktop: v90+ uses asynchronous file tracking
• OneDrive: Windows 11 built-in version typically handles this well

Fix 4: Antivirus On-Access Scan Optimization

If your antivirus registers a copy hook handler, it may be scanning every file before allowing the copy to proceed. Configure exclusions:

1. Open your antivirus settings.
2. Add exclusions for directories where you frequently copy files (e.g., project folders, temp directories).
3. Some antivirus products allow you to disable the shell integration component specifically:
   • Kaspersky: Settings → Application → Self-Defense → Uncheck “Shell Extension”
   • Avast: Settings → Components → File Shield → Customize → Exclude paths
   • Norton: Settings → Antivirus → Scans and Risks → Exclusions

Fix 5: Reconfigure TortoiseSVN/Git

If TortoiseSVN or TortoiseGit copy hooks are causing delays:

1. Open TortoiseSVN → Settings → General.
2. Reduce the “Overlay Handlers” scope to only folders you work in.
3. In the “Dialogs 3” tab, adjust timeout settings.
4. Consider disabling the copy hook entirely if you do not need SVN-aware file operations in Explorer.

Understanding the Copy Operation Pipeline

Here is exactly what happens when you copy a file in Windows Explorer:

User presses Ctrl+C, Ctrl+V
    │
    ├── 1. Explorer enumerates CopyHookHandlers from registry
    │       └── Calls each handler's CopyCallback() method
    │           ├── Handler 1 (Dropbox): Checks sync status → 200ms
    │           ├── Handler 2 (TortoiseSVN): Checks WC status → 150ms
    │           ├── Handler 3 (Antivirus): Scans file → 500ms
    │           └── Handler 4 (DLP): Policy check → 1000ms
    │       Total overhead: ~1850ms BEFORE copy even starts
    │
    ├── 2. "Preparing to copy" dialog appears
    │       └── Explorer calculates total file sizes
    │           └── May trigger thumbnail/metadata handlers → more overhead
    │
    ├── 3. Actual file copy begins
    │       └── Data transfer (typically fast on modern SSDs)
    │
    └── 4. Post-copy notifications
            └── Shell change notifications trigger overlay updates

By disabling unnecessary copy hook handlers, you eliminate step 1 overhead entirely.

The “Preparing to Copy” Freeze

A special case of copy dialog slowness is the “Preparing to copy…” phase that seems to hang forever. This is usually caused by:

1. Property Sheet Handlers trying to read metadata from each file being copied
2. Thumbnail extractors generating previews during the “discovery” phase
3. Network-mapped drives where the file system enumeration is slow

Fix for “Preparing” Freeze

Disable unnecessary property and thumbnail handlers:

:: Disable Windows Search indexing on the source folder
attrib +I "C:\SourceFolder" /S /D

:: Clear thumbnail cache
del /f /s /q /a "%LocalAppData%\Microsoft\Windows\Explorer\thumbcache_*.db"

:: Restart Explorer
taskkill /f /im explorer.exe && start explorer.exe

Performance Benchmarks

After removing unnecessary copy hook handlers, users typically see dramatic improvements:

For Developers: Writing Efficient Copy Hook Handlers

If you develop software that registers a copy hook handler, follow these critical guidelines:

Do

• Return IDYES immediately if the operation does not concern your application
• Use asynchronous processing — record the operation and process it later
• Implement a quick path that avoids disk I/O or network requests for common cases
• Cache frequently-checked states (e.g., “is this folder in my sync scope?”)

Do Not

• ❌ Make network requests inside CopyCallback() — this blocks the UI thread
• ❌ Scan file contents synchronously — offload to a background service
• ❌ Show dialog boxes or prompts — this creates a jarring user experience
• ❌ Assume the operation will be fast — always implement timeouts

Minimal CopyHook Implementation

STDMETHODIMP_(UINT) CMyCopyHook::CopyCallback(
    HWND hwnd, UINT wFunc, UINT wFlags,
    LPCTSTR pszSrcFile, DWORD dwSrcAttribs,
    LPCTSTR pszDestFile, DWORD dwDestAttribs
) {
    // Quick check: is this file in our scope?
    if (!IsInManagedFolder(pszSrcFile)) {
        return IDYES;  // Not our file, allow immediately
    }

    // Queue the operation for async processing
    QueueOperationNotification(wFunc, pszSrcFile, pszDestFile);

    return IDYES;  // Allow the operation, process asynchronously
}

Summary

Slow file copy, move, and delete dialogs in Windows are often caused by copy hook handler shell extensions that intercept every file operation synchronously. To fix:

1. Identify copy hook handlers with ShellExView (filter by type “Copy Hook”)
2. Diagnose with Process Monitor to find the slowest handler
3. Disable problematic handlers or update the parent application
4. Configure antivirus exclusions to reduce on-access scan overhead
5. Clear thumbnail cache to fix “Preparing” freezes