基于C# COM调用场景：如何检查Adobe InDesign是否运行或已挂起？

Great question! When dealing with long-running batch PDF conversions via InDesign's COM API in C#, detecting hangs is super important to avoid wasting resources or leaving orphaned processes. Let’s break down practical, actionable approaches you can use:

1. Monitor the InDesign Process's Responsiveness #

One of the simplest ways is to check if the underlying InDesign Windows process is responding. COM objects tied to a hung process will often stop responding to requests, and the process itself will show as "Not Responding" in Task Manager.

Here’s how to implement this in C#:

using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;

// Assume you've already instantiated the InDesign Application COM object
dynamic indesignApp = Activator.CreateInstance(Type.GetTypeFromProgID("InDesign.Application"));

// Get InDesign's main window handle via COM property
int hwnd = (int)indesignApp.GetType().InvokeMember("HWND", BindingFlags.GetProperty, null, indesignApp, null);

// Find the matching process using the window handle
Process indesignProcess = Process.GetProcesses().FirstOrDefault(p => p.MainWindowHandle == (IntPtr)hwnd);

// Periodically check if the process is responding
if (indesignProcess != null && !indesignProcess.Responding)
{
    // Handle the hang: log error, terminate process, restart conversion, etc.
    Console.WriteLine("InDesign has stopped responding!");
    indesignProcess.Kill(); // Use with caution - ensure unsaved work is accounted for
}

Note: This method can have false positives. InDesign might temporarily show as unresponsive when processing extremely large files, even though it's still working. Pair this with other checks for better accuracy.

2. Send Lightweight COM Requests with Timeouts #

A more reliable approach is to send a simple, non-intrusive request to the InDesign COM object and check if it responds within a reasonable timeout. This directly verifies that the COM bridge is still functional.

Here’s a reusable method to check responsiveness:

using System.Threading.Tasks;
using System;

public bool IsInDesignResponsive(dynamic indesignApp, int timeoutSeconds = 10)
{
    try
    {
        // Launch a background task to fetch a lightweight property (e.g., app name)
        var responsivenessTask = Task.Run(() => indesignApp.Name);

        // Wait for the task to complete; if it times out, assume a hang
        if (responsivenessTask.Wait(TimeSpan.FromSeconds(timeoutSeconds)))
        {
            return true;
        }
        return false;
    }
    catch (AggregateException ex)
    {
        // Catch COM exceptions (e.g., object disconnected, process terminated)
        Console.WriteLine($"COM communication error: {ex.InnerException.Message}");
        return false;
    }
}

// Usage example
if (!IsInDesignResponsive(indesignApp))
{
    Console.WriteLine("InDesign appears to be hung - COM requests are timing out!");
}

Tip: Adjust the timeout based on your typical workload. For large files, a 15-20 second timeout might be more appropriate than 10 seconds.

3. Embed Progress Updates in Your Conversion Script #

If you’re using JSX scripts to handle the PDF export, you can add progress markers that your C# code can monitor. For example, write progress updates to a temporary file or use a shared status variable.

Example JSX Script with Progress Logging #

// JSX script to export an InDesign file to PDF
var sourceFile = new File(app.scriptArgs.get("sourcePath"));
var outputFile = new File(app.scriptArgs.get("outputPath"));
var progressLog = new File(app.scriptArgs.get("progressLogPath"));

progressLog.open("w");
var doc = app.open(sourceFile);

// Log progress at key stages
progressLog.writeLine("Document opened successfully");
progressLog.flush();

// For multi-page documents, log page-by-page progress (optional)
var totalPages = doc.pages.length;
for (var i = 0; i < totalPages; i++) {
    progressLog.writeLine($"Processed page {i+1}/{totalPages}");
    progressLog.flush();
    $.sleep(500); // Give InDesign breathing room
}

// Execute export
progressLog.writeLine("Starting PDF export");
progressLog.flush();
doc.exportFile(ExportFormat.PDF_TYPE, outputFile);

progressLog.writeLine("Export completed");
progressLog.close();
doc.close(SaveOptions.NO);

C# Code to Monitor the Progress Log #

using System.IO;
using System.Threading;

public bool IsConversionActive(string progressLogPath, int timeoutMinutes = 3)
{
    if (!File.Exists(progressLogPath))
        return false;

    DateTime lastUpdate = File.GetLastWriteTime(progressLogPath);
    TimeSpan timeSinceLastUpdate = DateTime.Now - lastUpdate;

    // If no update in X minutes, assume the conversion is stuck
    return timeSinceLastUpdate.TotalMinutes < timeoutMinutes;
}

// Periodically check during batch processing
while (isBatchRunning)
{
    if (!IsConversionActive(@"C:\temp\indesign_progress.log"))
    {
        Console.WriteLine("Conversion is stuck - no progress updates in 3 minutes!");
        break;
    }
    Thread.Sleep(60000); // Check every minute
}

4. Track PDF File Size Increment #

For PDF exports, you can monitor the output file’s size over time. If the file stops growing for an extended period (longer than your expected processing time for a large file), it’s a strong indicator that InDesign has hung.

using System.IO;
using System.Threading;

public bool IsFileGrowing(string pdfOutputPath, int timeoutMinutes = 3)
{
    if (!File.Exists(pdfOutputPath))
        return true; // File hasn't been created yet - still active

    long previousSize = new FileInfo(pdfOutputPath).Length;
    Thread.Sleep(60000); // Wait 1 minute
    long currentSize = new FileInfo(pdfOutputPath).Length;

    // If size hasn't changed in the timeout window, assume hang
    return currentSize > previousSize || DateTime.Now - File.GetLastWriteTime(pdfOutputPath) < TimeSpan.FromMinutes(timeoutMinutes);
}

Key Considerations #

• Avoid over-checking: Frequent checks (e.g., every 10 seconds) can add unnecessary overhead. Stick to 30-second to 1-minute intervals.
• Clean up COM objects: When a hang is detected, always terminate the InDesign process and release the COM object properly to avoid memory leaks:

  Marshal.ReleaseComObject(indesignApp);
  indesignApp = null;
  GC.Collect();
  GC.WaitForPendingFinalizers();
  

• Batch per-file monitoring: For bulk conversions, track each file’s progress individually. Don’t let one hung file block the entire batch.

内容的提问来源于stack exchange，提问作者Osama