InterruptMonitor

InterruptMonitor class

Rappresenta le informazioni sull’interruzione.

public class InterruptMonitor : IInterruptMonitor

Costruttori

NomeDescrizione
InterruptMonitor()Default_Costruttore

Proprietà

NomeDescrizione
virtual IsInterrupted { get; }Ottiene il valore che indica se le operazioni devono essere interrotte.
static ThreadLocalInstance { get; set; }Ottiene o imposta l’istanza di IInterruptMonitor che è univoca per ogni thread.

Metodi

NomeDescrizione
virtual Interrupt()Invia una richiesta di interruzione delle operazioni.

Esempi

L’esempio seguente mostra come eseguire la conversione dell’immagine in un thread dedicato e interrompere il processo in pochi secondi dopo l’avvio.

[C#]

/// <summary>
/// Questa è una classe helper che avvia la conversione dell'immagine e attende la sua interruzione.
/// </summary>
private class Worker
{
    /// <summary>
    /// Il percorso dell'immagine di input.
    /// </summary>
    private readonly string inputPath;

    /// <summary>
    /// Il percorso dell'immagine di output.
    /// </summary>
    private readonly string outputPath;

    /// <summary>
    /// Le opzioni di salvataggio.
    /// </summary>
    private readonly Aspose.Imaging.ImageOptionsBase saveOptions;

    /// <summary>
    /// Il monitor di interruzione.
    /// </summary>
    private readonly Aspose.Imaging.Multithreading.InterruptMonitor monitor;

    /// <summary>
    /// Inizializza una nuova istanza di <see cref="Worker" /> classe.
    /// </summary>
    /// <param name="inputPath">Il percorso dell'immagine di input.</param>
    /// <param name="outputPath">Il percorso dell'immagine di output.</param>
    /// <param name="saveOptions">Le opzioni di salvataggio.</param>
    /// <param name="monitor">Il monitor di interruzione.</param>
    public Worker(string inputPath, string outputPath, Aspose.Imaging.ImageOptionsBase saveOptions, Aspose.Imaging.Multithreading.InterruptMonitor monitor)
    {
        this.inputPath = inputPath;
        this.outputPath = outputPath;
        this.saveOptions = saveOptions;
        this.monitor = monitor;
    }

    /// <summary>
    /// Converte un'immagine da un formato all'altro. Gestisce l'interruzione.
    /// </summary>
    public void ThreadProc()
    {
        try
        {
            Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(this.inputPath);
            
            // Imposta un'istanza thread-local del monitor di interrupt.
            Aspose.Imaging.Multithreading.InterruptMonitor.ThreadLocalInstance = this.monitor;

            try
            {
                image.Save(this.outputPath, this.saveOptions);
            }
            catch (Aspose.Imaging.CoreExceptions.OperationInterruptedException e)
            {
                System.Console.WriteLine(
                    "The worker thread #{0} has been interrupted at {1}",
                    System.Threading.Thread.CurrentThread.ManagedThreadId,
                    System.DateTime.Now);
            }
            finally
            {
                image.Dispose();

                // Reimposta l'istanza thread-local del monitor di interrupt.
                Aspose.Imaging.Multithreading.InterruptMonitor.ThreadLocalInstance = null;
            }
        }
        catch (System.Exception e)
        {
            // Stampa informazioni dettagliate su eventuali eccezioni impreviste.
            System.Console.WriteLine(e);
        }
    }
}

// Ecco l'esempio principale usando la classe Worker.
string baseDir = "c:\\temp\\";

Aspose.Imaging.Multithreading.InterruptMonitor monitor = new Aspose.Imaging.Multithreading.InterruptMonitor();
Worker worker = new Worker(baseDir + "big.png", baseDir + "big.bmp", new Aspose.Imaging.ImageOptions.BmpOptions(), monitor);

// Avvia il lavoro in un thread dedicato.
System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ThreadStart(worker.ThreadProc));
thread.Start();

// Fai un lavoro significativo qui
System.Threading.Thread.Sleep(2000);

// Richiesta di interruzione del thread di lavoro
monitor.Interrupt();
System.Console.WriteLine("Interrupting the worker thread #{0} at {1}", thread.ManagedThreadId, System.DateTime.Now);

// Attendi l'interruzione.
thread.Join();

System.Console.WriteLine("Done. Press ENTER to exit.");
System.Console.ReadLine();

// L'output potrebbe essere simile a questo:
// Interruzione del thread di lavoro n. 14 al 06/08/2019 15:57:53
// Il thread di lavoro n. 14 è stato interrotto il 06/08/2019 15:58:09
// Fatto. Premere INVIO per uscire.

Guarda anche

IInterruptMonitor