Supporto per la libreria interrompibile

Panoramica

Aspose.Slides fornisce un meccanismo di elaborazione interrompibile per attività di presentazione a lunga durata, come la deserializzazione, la serializzazione e il rendering. Questo meccanismo si basa sulle classi InterruptionToken e InterruptionTokenSource.

InterruptionToken può essere assegnato a LoadOptions e passato al costruttore Presentation. Quando viene chiamato InterruptionTokenSource::Interrupt(), l’attività a lunga durata associata viene interrotta.

Libreria Interrompibile

In Aspose.Slides 18.4, abbiamo introdotto le classi InterruptionToken e InterruptionTokenSource. Esse consentono di interrompere attività a lunga durata come la deserializzazione, la serializzazione e il rendering.

• InterruptionTokenSource è la sorgente del token(i) passato a ILoadOptions::set_InterruptionToken.
• Quando ILoadOptions::set_InterruptionToken è impostato e l’istanza LoadOptions viene passata al costruttore Presentation, l’invocazione di InterruptionTokenSource::Interrupt() interrompe qualsiasi attività a lunga durata associata a quel Presentation.

Il seguente frammento di codice dimostra come interrompere un’attività in esecuzione:

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()); // esegui l'azione in un thread separato
    Threading::Thread::Sleep(10000);       // tempo di attesa
    tokenSource->Interrupt();              // interrompi la conversione
}

FAQ

Qual è lo scopo della libreria di interruzione di Aspose.Slides?

Fornisce un meccanismo per interrompere operazioni a lunga durata—come il caricamento, il salvataggio o il rendering di presentazioni—prima che vengano completate. Questo è utile quando è necessario limitare il tempo di elaborazione o l’operazione non è più necessaria.

Qual è la differenza tra InterruptionToken e InterruptionTokenSource?

• InterruptionToken viene passato all’API di Aspose.Slides e controllato durante le operazioni a lunga durata.
• InterruptionTokenSource viene utilizzato nel tuo codice per creare token e attivare le interruzioni chiamando Interrupt().

Quali attività possono essere interrotte?

Qualsiasi attività di Aspose.Slides che accetta un InterruptionToken—come il caricamento di una presentazione con Presentation(path, loadOptions) o il salvataggio con Presentation::Save(...)—può essere interrotta.

L’interruzione avviene immediatamente?

No. L’interruzione è cooperativa: l’operazione verifica periodicamente il token e si ferma non appena rileva che Interrupt() è stato chiamato.

Cosa succede se chiamo Interrupt() dopo che un’attività è già terminata?

Niente—la chiamata non ha effetto se l’attività corrispondente è già completata.

Posso riutilizzare lo stesso InterruptionTokenSource per più attività?

Sì—but after you call Interrupt() on that source, all tasks using its tokens will be interrupted. Use separate token sources to manage tasks independently.