Soporte para la biblioteca interruptible

Biblioteca Interrumpible

En Aspose.Slides 18.4, introdujimos las clases InterruptionToken y InterruptionTokenSource. Permiten interrumpir tareas de larga duración como deserialización, serialización y renderizado.

• InterruptionTokenSource es la fuente del/los token(s) que se pasan a ILoadOptions::set_InterruptionToken.
• Cuando se establece ILoadOptions::set_InterruptionToken y la instancia de LoadOptions se pasa al constructor de Presentation, invocar InterruptionTokenSource::Interrupt() interrumpe cualquier tarea de larga duración asociada a esa Presentation.

El siguiente fragmento de código muestra cómo interrumpir una tarea en ejecución:

void Run(Action<SharedPtr<IInterruptionToken>> action, SharedPtr<IInterruptionToken> token)
{
    auto threadFunction = std::function<void()>([&action, &token]() -> void
    {
        action(token);
    });

    auto thread = System::MakeObject<Threading::Thread>(threadFunction);
    thread->Start();
}

void Run()
{
    String dataDir = GetDataPath();

    auto function = std::function<void(SharedPtr<IInterruptionToken> token)> ([&dataDir](SharedPtr<IInterruptionToken> token) -> void
    {
        auto options = System::MakeObject<LoadOptions>();
        options->set_InterruptionToken(token);

        auto presentation = System::MakeObject<Presentation>(dataDir + u"sample.pptx", options);
        presentation->Save(dataDir + u"sample.ppt", Export::SaveFormat::Ppt);
    });

    auto action = System::Action<SharedPtr<IInterruptionToken>>(function);
    auto tokenSource = System::MakeObject<InterruptionTokenSource>();
    
    Run(action, tokenSource->get_Token()); // ejecutar la acción en un hilo separado
    Threading::Thread::Sleep(10000);       // tiempo de espera
    tokenSource->Interrupt();              // detener la conversión
}

FAQ

¿Cuál es el propósito de la biblioteca de interrupción de Aspose.Slides?

Proporciona un mecanismo para interrumpir operaciones de larga duración —como cargar, guardar o renderizar presentaciones— antes de que se completen. Es útil cuando se debe limitar el tiempo de procesamiento o la tarea ya no es necesaria.

¿Cuál es la diferencia entre InterruptionToken y InterruptionTokenSource?

• InterruptionToken se pasa a la API de Aspose.Slides y se verifica durante las operaciones de larga duración.
• InterruptionTokenSource se utiliza en tu código para crear tokens y generar interrupciones llamando a Interrupt().

¿Qué tareas pueden interrumpirse?

Cualquier tarea de Aspose.Slides que acepte un InterruptionToken —como cargar una presentación con Presentation(path, loadOptions) o guardar con Presentation::Save(...)— puede interrumpirse.

¿La interrupción ocurre inmediatamente?

No. La interrupción es cooperativa: la operación verifica periódicamente el token y se detiene tan pronto como detecta que se ha llamado a Interrupt().

¿Qué ocurre si llamo a Interrupt() después de que una tarea ya se haya completado?

Nada —la llamada no tiene efecto si la tarea correspondiente ya ha finalizado.

¿Puedo reutilizar el mismo InterruptionTokenSource para varias tareas?

Sí, pero después de llamar a Interrupt() en esa fuente, todas las tareas que usan sus tokens serán interrumpidas. Utiliza fuentes de token separadas para gestionar las tareas de forma independiente.