Class InterruptMonitor

Class InterruptMonitor

이름 공간 : Aspose.Imaging.Multithreading 모임: Aspose.Imaging.dll (25.4.0)

중단에 관한 정보를 제공합니다.

public class InterruptMonitor : IInterruptMonitor

Inheritance

object InterruptMonitor

Implements

IInterruptMonitor

상속 회원들

object.GetType() , object.MemberwiseClone() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

다음 예제는 이미지 변환을 전용 스트립으로 수행하고 시작 후 몇 초 안에 프로세스를 중단하는 방법을 보여줍니다.

/// <summary>
                                                                                                                                                           /// This is helper class which initiates image conversion and waits for its interruption.
                                                                                                                                                           /// </summary>
                                                                                                                                                           private class Worker
                                                                                                                                                           {
                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The path to the input image.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly string inputPath;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The path to the output image.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly string outputPath;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The save options.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly Aspose.Imaging.ImageOptionsBase saveOptions;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The interrupt monitor.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly Aspose.Imaging.Multithreading.InterruptMonitor monitor;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// Initializes a new instance of the <see cref="Worker"></see> class.
                                                                                                                                                               /// </summary>
                                                                                                                                                               /// <param name="inputPath"/>The path to the input image.
                                                                                                                                                               /// <param name="outputPath"/>The path to the output image.
                                                                                                                                                               /// <param name="saveOptions"/>The save options.
                                                                                                                                                               /// <param name="monitor"/>The interrupt monitor.
                                                                                                                                                               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>
                                                                                                                                                               /// Converts an image from one format to another. Handles interruption.
                                                                                                                                                               /// </summary>
                                                                                                                                                               public void ThreadProc()
                                                                                                                                                               {
                                                                                                                                                                   try
                                                                                                                                                                   {
                                                                                                                                                                       Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(this.inputPath);

                                                                                                                                                                       // Set a thread-local instance of the interrupt monitor.
                                                                                                                                                                       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();

                                                                                                                                                                           // Reset the thread-local instance of the interrupt monitor.
                                                                                                                                                                           Aspose.Imaging.Multithreading.InterruptMonitor.ThreadLocalInstance = null;
                                                                                                                                                                       }
                                                                                                                                                                   }
                                                                                                                                                                   catch (System.Exception e)
                                                                                                                                                                   {
                                                                                                                                                                       // Print detailed information about any unexpected exception.
                                                                                                                                                                       System.Console.WriteLine(e);
                                                                                                                                                                   }
                                                                                                                                                               }
                                                                                                                                                           }

                                                                                                                                                           // Here is the main example using the Worker class.
                                                                                                                                                           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);

                                                                                                                                                           // Start the worker in a dedicated thread.
                                                                                                                                                           System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ThreadStart(worker.ThreadProc));
                                                                                                                                                           thread.Start();

                                                                                                                                                           // Do some meaningful work here
                                                                                                                                                           System.Threading.Thread.Sleep(2000);

                                                                                                                                                           // Request to interrupt the worker thread
                                                                                                                                                           monitor.Interrupt();
                                                                                                                                                           System.Console.WriteLine("Interrupting the worker thread #{0} at {1}", thread.ManagedThreadId, System.DateTime.Now);

                                                                                                                                                           // Wait for interruption.
                                                                                                                                                           thread.Join();

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

                                                                                                                                                           // The output may look like this:
                                                                                                                                                           // Interrupting the worker thread #14 at 8/6/2019 3:57:53 PM
                                                                                                                                                           // The worker thread #14 has been interrupted at 8/6/2019 3:58:09 PM
                                                                                                                                                           // Done. Press ENTER to exit.

Constructors

InterruptMonitor()

public InterruptMonitor()

Properties

IsInterrupted

작업이 중단되어야 하는지 여부를 나타내는 값을 얻습니다.

public virtual bool IsInterrupted { get; }

부동산 가치

bool

ThreadLocalInstance

각 스트립에 대해 독특한 IInterruptMonitor 인스턴스를 얻거나 설정합니다.

public static IInterruptMonitor ThreadLocalInstance { get; set; }

부동산 가치

IInterruptMonitor

Methods

Interrupt()

작업을 중단하도록 요청합니다.

public virtual void Interrupt()

Examples

다음 예제는 이미지 변환을 전용 스트립으로 수행하고 시작 후 몇 초 안에 프로세스를 중단하는 방법을 보여줍니다.

/// <summary>
                                                                                                                                                           /// This is helper class which initiates image conversion and waits for its interruption.
                                                                                                                                                           /// </summary>
                                                                                                                                                           private class Worker
                                                                                                                                                           {
                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The path to the input image.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly string inputPath;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The path to the output image.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly string outputPath;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The save options.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly Aspose.Imaging.ImageOptionsBase saveOptions;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// The interrupt monitor.
                                                                                                                                                               /// </summary>
                                                                                                                                                               private readonly Aspose.Imaging.Multithreading.InterruptMonitor monitor;

                                                                                                                                                               /// <summary>
                                                                                                                                                               /// Initializes a new instance of the <see cref="Worker"></see> class.
                                                                                                                                                               /// </summary>
                                                                                                                                                               /// <param name="inputPath"/>The path to the input image.
                                                                                                                                                               /// <param name="outputPath"/>The path to the output image.
                                                                                                                                                               /// <param name="saveOptions"/>The save options.
                                                                                                                                                               /// <param name="monitor"/>The interrupt monitor.
                                                                                                                                                               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>
                                                                                                                                                               /// Converts an image from one format to another. Handles interruption.
                                                                                                                                                               /// </summary>
                                                                                                                                                               public void ThreadProc()
                                                                                                                                                               {
                                                                                                                                                                   try
                                                                                                                                                                   {
                                                                                                                                                                       Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(this.inputPath);

                                                                                                                                                                       // Set a thread-local instance of the interrupt monitor.
                                                                                                                                                                       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();

                                                                                                                                                                           // Reset the thread-local instance of the interrupt monitor.
                                                                                                                                                                           Aspose.Imaging.Multithreading.InterruptMonitor.ThreadLocalInstance = null;
                                                                                                                                                                       }
                                                                                                                                                                   }
                                                                                                                                                                   catch (System.Exception e)
                                                                                                                                                                   {
                                                                                                                                                                       // Print detailed information about any unexpected exception.
                                                                                                                                                                       System.Console.WriteLine(e);
                                                                                                                                                                   }
                                                                                                                                                               }
                                                                                                                                                           }

                                                                                                                                                           // Here is the main example using the Worker class.
                                                                                                                                                           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);

                                                                                                                                                           // Start the worker in a dedicated thread.
                                                                                                                                                           System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ThreadStart(worker.ThreadProc));
                                                                                                                                                           thread.Start();

                                                                                                                                                           // Do some meaningful work here
                                                                                                                                                           System.Threading.Thread.Sleep(2000);

                                                                                                                                                           // Request to interrupt the worker thread
                                                                                                                                                           monitor.Interrupt();
                                                                                                                                                           System.Console.WriteLine("Interrupting the worker thread #{0} at {1}", thread.ManagedThreadId, System.DateTime.Now);

                                                                                                                                                           // Wait for interruption.
                                                                                                                                                           thread.Join();

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

                                                                                                                                                           // The output may look like this:
                                                                                                                                                           // Interrupting the worker thread #14 at 8/6/2019 3:57:53 PM
                                                                                                                                                           // The worker thread #14 has been interrupted at 8/6/2019 3:58:09 PM
                                                                                                                                                           // Done. Press ENTER to exit.
 한국어