Stöd för avbrottsbibliotek

Översikt

Aspose.Slides tillhandahåller en avbrottbar bearbetningsmekanism för långvariga presentationsuppgifter, såsom deserialisering, serialisering och rendering. Denna mekanism baseras på klasserna InterruptionToken och InterruptionTokenSource.

Ett InterruptionToken kan tilldelas LoadOptions och skickas till Presentation‑konstruktorn. När InterruptionTokenSource::Interrupt() anropas avbryts den associerade långvariga uppgiften.

Avbrottsbibliotek

I Aspose.Slides 18.4 introducerade vi klasserna InterruptionToken och InterruptionTokenSource. De gör det möjligt att avbryta långvariga uppgifter såsom deserialisering, serialisering och rendering.

• InterruptionTokenSource är källan till token(s) som skickas till ILoadOptions::set_InterruptionToken.
• När ILoadOptions::set_InterruptionToken är inställt och LoadOptions-instansen skickas till Presentation-konstruktorn, avbryter ett anrop av InterruptionTokenSource::Interrupt() alla långvariga uppgifter som är kopplade till den Presentation.

Följande kodsnutt demonstrerar hur en pågående uppgift avbryts:

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()); // kör åtgärden i en separat tråd
    Threading::Thread::Sleep(10000);       // tidsgräns
    tokenSource->Interrupt();              // stoppa konverteringen
}

Vanliga frågor

Vad är syftet med Aspose.Slides avbrottsbibliotek?

Det ger en mekanism för att avbryta långvariga operationer—såsom att läsa in, spara eller rendera presentationer—innan de är slutförda. Detta är användbart när bearbetningstiden måste begränsas eller när uppgiften inte längre behövs.

Vad är skillnaden mellan InterruptionToken och InterruptionTokenSource?

• InterruptionToken skickas till Aspose.Slides‑API:et och kontrolleras under långvariga operationer.
• InterruptionTokenSource används i din kod för att skapa token och utlösa avbrott genom att anropa Interrupt().

Vilka uppgifter kan avbrytas?

Alla Aspose.Slides‑uppgifter som accepterar ett InterruptionToken—såsom att läsa in en presentation med Presentation(path, loadOptions) eller att spara med Presentation::Save(...)—kan avbrytas.

Sker avbrottet omedelbart?

Nej. Avbrottet är samarbetsinriktat: operationen kontrollerar periodiskt token och stoppar så snart den upptäcker att Interrupt() har anropats.

Vad händer om jag anropar Interrupt() efter att en uppgift redan har slutförts?

Ingenting—anropet har ingen effekt om den motsvarande uppgiften redan är färdig.

Kan jag återanvända samma InterruptionTokenSource för flera uppgifter?

Ja—men efter att du har anropat Interrupt() på den källan kommer alla uppgifter som använder dess token att avbrytas. Använd separata token‑källor för att hantera uppgifter oberoende av varandra.