Menghentikan operasi penyimpanan yang menggantung

Sayangnya, ada situasi di mana aplikasi menggantung saat menyimpan dokumen dan berhenti merespons. Fitur ini memungkinkan Anda untuk membatalkan operasi yang berjalan lama dengan baik, seperti menyimpan dokumen PDF yang besar atau kompleks, mencegah pembekuan aplikasi, dan meningkatkan responsivitas. Anda akan menemukan informasi relevan untuk mengintegrasikan fungsionalitas ini ke dalam aplikasi Anda. Perlu dicatat bahwa pendekatan ini memastikan bahwa aplikasi Anda tetap responsif bahkan selama operasi yang memerlukan banyak sumber daya.

Kelas ‘InterruptMonitor’ menyediakan kemampuan untuk menghentikan proses penyimpanan dokumen jika memakan waktu terlalu lama. (https://reference.aspose.com/pdf/net/aspose.pdf.forms/form/properties/xfa).

Potongan kode berikut juga bekerja dengan pustaka Aspose.PDF.Drawing.

Menggunakan InterruptMonitor

Mari kita soroti bahwa implementasi melibatkan beberapa langkah kunci:

1. InterruptMonitor Pembuatan: Buat objek InterruptMonitor. Objek ini bertindak sebagai sinyal untuk interupsi thread.

2. ThreadLocalInstance Penugasan: Sebelum memulai operasi Aspose.PDF yang berjalan lama, tetapkan instance InterruptMonitor ke InterruptMonitor.ThreadLocalInstance untuk thread saat ini. Ini menghubungkan monitor ke thread.

3. Eksekusi Thread: Eksekusi kode yang berisi operasi Aspose.PDF (misalnya, Document.Save()) dalam thread terpisah.

4. Sinyal Interupsi: Pada titik yang sesuai (misalnya, setelah waktu habis atau tindakan pengguna), panggil monitor.Interrupt(). Ini memberi sinyal kepada thread untuk menghentikan.

5. Penanganan Pengecualian: Metode Document.Save() melempar OperationCanceledException jika terinterupsi. Tangani pengecualian ini menggunakan blok try-catch. Ingat bahwa penanganan pengecualian yang tepat sangat penting untuk stabilitas aplikasi.

Potongan kode berikut menunjukkan kepada Anda cara menggunakan InterruptMonitor dalam pemrosesan PDF.

.NET Core 3.1

// For complete examples and data files, visit https://github.com/aspose-pdf/Aspose.PDF-for-.NET
private static void InterruptMonitorExample()
{
    // The path to the documents directory
    var dataDir = RunExamples.GetDataDir_AsposePdf_Text();
    // Path to a large text file 
    var longTextFile = dataDir + "LongTextFile.txt";
    var outputFile = dataDir + "interrupt_output.pdf";
    var longText = File.ReadAllText(longTextFile);

    // Create an InterruptMonitor instance
    using (var monitor = new InterruptMonitor())
    {
        // Create a RowSpanWorker instance, passing the monitor
        var worker = new RowSpanWorker(outputFile, monitor, longText);

        // Start the worker thread
        var thread = new Thread(worker.Work);
        thread.Start();

        // Simulate a timeout (adjust as needed)
        Thread.Sleep(500);

        // Interrupt the thread
        monitor.Interrupt();

        // Wait for the thread to finish
        thread.Join();
    }
}

// Helper class to demonstrate how to handle PDF generation with interruption support
private class RowSpanWorker
{
    private readonly string outputPath;
    private readonly string longText;
    private readonly Aspose.Pdf.Multithreading.InterruptMonitor monitor;

    public RowSpanWorker(string outputPath, Aspose.Pdf.Multithreading.InterruptMonitor monitor, string longText)
    {
        this.outputPath = outputPath;
        this.monitor = monitor;
        this.longText = longText;
    }

    public void Work()
    {
        // Create PDF document
        using (var document  = new Aspose.Pdf.Document())
        {
            // Assign the InterruptMonitor to the current thread
            Aspose.Pdf.Multithreading.InterruptMonitor.ThreadLocalInstance = this.monitor;
            var page = document.Pages.Add();

            var table = new Aspose.Pdf.Table
            {
                DefaultCellBorder = new Aspose.Pdf.BorderInfo(Aspose.Pdf.BorderSide.All, 0.1F)
            };

            var row0 = table.Rows.Add();

            // Add a cell spanning multiple rows with long text
            var cell00 = row0.Cells.Add(this.longText);
            cell00.RowSpan = 2;
            cell00.IsWordWrapped = true;
            row0.Cells.Add("Ipsum Ipsum Ipsum");
            row0.Cells.Add("Dolor Dolor Dolor");

            var row1 = table.Rows.Add();
            row1.Cells.Add("Ipsum Dolor");
            row1.Cells.Add("Dolor Dolor");

            page.Paragraphs.Add(table);

            try
            {
                // Save the document (this operation can be interrupted)
                document.Save(this.outputPath);
            }
            catch (OperationCanceledException ex)
            {
                Console.WriteLine($"Operation cancelled: {ex.Message}");
            }
        }
    }
}

.NET 8

private static void InterruptMonitorExample()
{
    // The path to the documents directory
    var dataDir = RunExamples.GetDataDir_AsposePdf_Text();

    // Construct a long text string to simulate a long process
    var longTextFile = Path.Combine(dataDir, "LongTextFile.txt");
    var outputFile = Path.Combine(dataDir, "interrupt_output.pdf");
    var longText = File.ReadAllText(longTextFile);

    // Create an InterruptMonitor instance
    using Aspose.Pdf.Multithreading.InterruptMonitor monitor = new();

    // Create a RowSpanWorker instance, passing the monitor
    var worker = new RowSpanWorker(outputFile, monitor, longText);

    // Start the worker thread
    var thread = new Thread(worker.Work);
    thread.Start();

    // Simulate a timeout (adjust as needed)
    Thread.Sleep(500);

    // Interrupt the thread
    monitor.Interrupt();

    // Wait for the thread to finish
    thread.Join();    
}

// Helper class to demonstrate how to handle PDF generation with interruption support
public class RowSpanWorker
{
    private readonly string _outputFile;
    private readonly InterruptMonitor _monitor;
    private readonly string _longText;

    public RowSpanWorker(string outputFile, Aspose.Pdf.Multithreading.InterruptMonitor monitor, string longText)
    {
        _outputFile = outputFile;
        _monitor = monitor;
        _longText = longText;
    }

    public void Work()
    {
        // Create PDF document
        using Aspose.Pdf.Document document = new();

        // Assign the InterruptMonitor to the current thread
        Aspose.Pdf.Multithreading.InterruptMonitor.ThreadLocalInstance = this._monitor;
        var page = document.Pages.Add();

        var table = new Aspose.Pdf.Table
        {
            DefaultCellBorder = new Aspose.Pdf.BorderInfo(Aspose.Pdf.BorderSide.All, 0.1F)
        };

        var row0 = table.Rows.Add();

        // Add a cell spanning multiple rows with long text
        var cell00 = row0.Cells.Add(this._longText);
        cell00.RowSpan = 2;
        cell00.IsWordWrapped = true;
        row0.Cells.Add("Ipsum Ipsum Ipsum Ipsum Ipsum Ipsum ");
        row0.Cells.Add("Dolor Dolor Dolor Dolor Dolor Dolor ");

        var row1 = table.Rows.Add();
        row1.Cells.Add("IpsumDolor Dolor Dolor Dolor Dolor ");
        row1.Cells.Add("DolorDolor Dolor Dolor Dolor Dolor ");

        page.Paragraphs.Add(table);
        try
        {
            //Save() operation supports interruption 
            document.Save(this._outputFile);
        }
        catch (OperationCanceledException ex)
        {
            //print operation cancel exception's message to console 
            Console.WriteLine(ex.Message);
        }
    }
}