Specificare le opzioni di caricamento

Quando si carica un documento, è possibile impostare alcune proprietà avanzate. Aspose.Words fornisce la classe LoadOptions, che consente un controllo più preciso del processo di carico. Alcuni formati di caricamento hanno una classe corrispondente che contiene le opzioni di caricamento per questo formato di caricamento, ad esempio, c’è PdfLoadOptions per il caricamento in formato PDF o TxtLoadOptions per il caricamento in TXT. Questo articolo fornisce esempi di utilizzo delle opzioni della classe LoadOptions.

Imposta la versione Microsoft Word per modificare l’aspetto

Diverse versioni dell’applicazione Microsoft Word possono visualizzare i documenti indifferentemente. Ad esempio, c’è un problema ben noto con documenti OOXML come DOCX o DOTX prodotti utilizzando WPS Office. In tal caso, gli elementi essenziali di markup del documento potrebbero mancare o essere interpretati in modo diverso, facendo sì che Microsoft Word 2019 mostri tale documento in modo diverso rispetto a Microsoft Word 2010.

Per impostazione predefinita Aspose.Words apre i documenti utilizzando le regole Microsoft Word 2019. Se è necessario far apparire il caricamento del documento come accadrebbe in una delle precedenti versioni dell’applicazione Microsoft Word, è necessario specificare esplicitamente la versione desiderata utilizzando la proprietà MswVersion della classe LoadOptions.

L’esempio di codice seguente mostra come impostare la versione Microsoft Word con le opzioni di caricamento:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>();
// Change the loading version to Microsoft Word 2010.
loadOptions->set_MswVersion(MsWordVersion::Word2010);
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.docx", loadOptions);

System::String outputPath = outputDataDir + u"Load_Options.SetMSWordVersion.docx";
doc->Save(outputPath);

Impostare le preferenze di lingua per modificare l’aspetto

I dettagli della visualizzazione di un documento in Microsoft Word dipendono non solo dalla versione dell’applicazione e dal valore della proprietà MswVersion, ma anche dalle impostazioni della lingua. Microsoft Word può mostrare i documenti in modo diverso a seconda delle impostazioni della finestra di dialogo “Preferenze lingua di Office”, che si trovano in"File → Opzioni → Lingua". Utilizzando questa finestra di dialogo, un utente può selezionare, ad esempio, la lingua principale, le lingue di correzione, le lingue di visualizzazione e così via. Aspose.Words fornisce la proprietà LanguagePreferences come equivalente di questa finestra di dialogo. Se l’output Aspose.Words differisce dall’output Microsoft Word, impostare il valore appropriato per EditingLanguage – questo può migliorare il documento di output.

Il seguente esempio di codice mostra come impostare il giapponese come EditingLanguage:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Create a new LoadOptions object.
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>();
// Set language preferences that will be used when document is loading.
loadOptions->get_LanguagePreferences()->AddEditingLanguage(EditingLanguage::Japanese);

System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"languagepreferences.docx", loadOptions);

Utilizzare WarningCallback per controllare i problemi durante il caricamento di un documento

Alcuni documenti potrebbero essere danneggiati, contenere voci non valide o avere funzionalità non attualmente supportate da Aspose.Words. Se si desidera conoscere i problemi che si sono verificati durante il caricamento di un documento, Aspose.Words fornisce l’interfaccia IWarningCallback.

Il seguente esempio di codice mostra l’implementazione dell’interfaccia IWarningCallback:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
class DocumentLoadingWarningCallback : public IWarningCallback
{
    public:
        System::SharedPtr<WarningInfoCollection> mWarnings;
        void Warning(System::SharedPtr<WarningInfo> info) override;
        DocumentLoadingWarningCallback();
};

void DocumentLoadingWarningCallback::Warning(System::SharedPtr<WarningInfo> info)
{
    // Prints warnings and their details as they arise during document loading.
    std::cout << "WARNING: {info->get_WarningType} " << std::endl;
    std::cout << "Source: {info->get_Source} " << std::endl;
    std::cout << "\tDescription: {info->get_Description} " << std::endl;
}

DocumentLoadingWarningCallback::DocumentLoadingWarningCallback() : mWarnings(System::MakeObject<WarningInfoCollection>())
{
}

Per ottenere informazioni su tutti i problemi durante il tempo di caricamento, utilizzare la proprietà WarningCallback.

Il seguente esempio di codice mostra come utilizzare questa proprietà:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Create a new LoadOptions object and set its WarningCallback property. 
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>();

System::SharedPtr<DocumentLoadingWarningCallback> callback = System::MakeObject<DocumentLoadingWarningCallback>();
loadOptions->set_WarningCallback(callback);

System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.docx", loadOptions);

Utilizzare ResourceLoadingCallback per controllare il caricamento delle risorse esterne

Un documento può contenere collegamenti esterni a immagini che si trovano da qualche parte su un disco locale, rete o Internet. Aspose.Words carica automaticamente tali immagini in un documento, ma ci sono situazioni in cui questo processo deve essere controllato. Ad esempio, per decidere se abbiamo davvero bisogno di caricare una certa immagine o forse saltarla. L’opzione ResourceLoadingCallback load consente di controllare questo.

Il seguente esempio di codice mostra l’implementazione dell’interfaccia IResourceLoadingCallback:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
class HtmlLinkedResourceLoadingCallback : public IResourceLoadingCallback
{
    public:
        ResourceLoadingAction ResourceLoading(System::SharedPtr<ResourceLoadingArgs> args) override;
        HtmlLinkedResourceLoadingCallback();
};

HtmlLinkedResourceLoadingCallback::HtmlLinkedResourceLoadingCallback()
{
}

ResourceLoadingAction HtmlLinkedResourceLoadingCallback::ResourceLoading(System::SharedPtr<ResourceLoadingArgs> args)
{
    switch (args->get_ResourceType())
    {
        case ResourceType::CssStyleSheet:
        {
            std::cout << "External CSS Stylesheet found upon loading: " << args->get_OriginalUri().ToUtf8String() << std::endl;

            // CSS file will don't used in the document
            return ResourceLoadingAction::Skip;
        }
        case ResourceType::Image:
        {
            // Replaces all images with a substitute
            System::String newImageFilename = u"Logo.jpg";
            std::cout << "\tImage will be substituted with: " << newImageFilename.ToUtf8String() << std::endl;

            System::SharedPtr<System::Drawing::Image> newImage = System::Drawing::Image::FromFile(GetInputDataDir_LoadingAndSaving() + newImageFilename);
            System::SharedPtr<System::Drawing::ImageConverter> converter = System::MakeObject<System::Drawing::ImageConverter>();
            auto imageBytes = System::DynamicCast<System::Array<uint8_t>>(converter->ConvertTo(nullptr, nullptr, newImage, System::ObjectExt::GetType<System::Array<uint8_t>>()));
            //System::ArrayPtr<uint8_t> imageBytes = System::IO::File::ReadAllBytes(GetInputDataDir_LoadingAndSaving() + newImageFilename);
            args->SetData(imageBytes);

            // New images will be used instead of presented in the document
            return ResourceLoadingAction::UserProvided;
        }
        case ResourceType::Document:
        {
            std::cout << "External document found upon loading: " << args->get_OriginalUri().ToUtf8String() << std::endl;

            // Will be used as usual
            return ResourceLoadingAction::Default;
        }
        default:
            throw System::InvalidOperationException(u"Unexpected ResourceType value.");
    }
}
    

L’esempio di codice seguente mostra come utilizzare la proprietà ResourceLoadingCallback:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Create a new LoadOptions object and set its ResourceLoadingCallback attribute as an instance of our IResourceLoadingCallback implementation
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>();
loadOptions->set_ResourceLoadingCallback(System::MakeObject<HtmlLinkedResourceLoadingCallback>());

// When we open an Html document, external resources such as references to CSS stylesheet files and external images
// will be handled in a custom manner by the loading callback as the document is loaded
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Images.html", loadOptions);
doc->Save(outputDataDir + u"Load_Options.LoadOptionsResourceLoadingCallback.pdf");

Utilizzare TempFolder per evitare un’eccezione di memoria

Aspose.Words supporta documenti estremamente grandi con migliaia di pagine piene di contenuti ricchi. Il caricamento di tali documenti potrebbe richiedere molta RAM. Nel processo di caricamento, Aspose.Words ha bisogno di ancora più memoria per contenere le strutture temporanee utilizzate per analizzare un documento.

Se si verifica un problema con l’eccezione di memoria esaurita durante il caricamento di un documento, provare a utilizzare la proprietà TempFolder. In questo caso, Aspose.Words memorizzerà alcuni dati in file temporanei anziché in memoria, e questo può aiutare a evitare tale eccezione.

Il seguente esempio di codice mostra come impostare TempFolder:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>();
loadOptions->set_TempFolder(u"C:/TempFolder/");

System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.docx", loadOptions);

Imposta la codifica in modo esplicito

La maggior parte dei formati di documenti moderni memorizzano il loro contenuto in Unicode e non richiedono una gestione speciale. D’altra parte, ci sono ancora molti documenti che utilizzano una codifica pre-Unicode e talvolta mancano le informazioni di codifica o non supportano nemmeno le informazioni di codifica per natura. Aspose.Words tenta di rilevare automaticamente la codifica appropriata per impostazione predefinita, ma in un raro caso potrebbe essere necessario utilizzare una codifica diversa da quella rilevata dal nostro algoritmo di riconoscimento della codifica. In questo caso, utilizzare la proprietà Encoding per ottenere o impostare la codifica.

Il seguente esempio di codice mostra come impostare la codifica per sovrascrivere la codifica scelta automaticamente:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Set the Encoding attribute in a LoadOptions object to override the automatically chosen encoding with the one we know to be correct
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>();
loadOptions->set_Encoding(System::Text::Encoding::get_UTF7());

System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Encoded in UTF-7.txt", loadOptions);

Carica documenti crittografati

È possibile caricare documenti Word crittografati con una password. Per fare ciò, utilizzare un sovraccarico del costruttore speciale, che accetta un oggetto LoadOptions. Questo oggetto contiene la proprietà Password, che specifica la stringa della password.

Il seguente esempio di codice mostra come caricare un documento crittografato con una password:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// The path to the documents directory.
System::String dataDir = GetInputDataDir_LoadingAndSaving();

// Loads encrypted document.
System::SharedPtr<Document> doc = System::MakeObject<Document>(dataDir + u"LoadEncrypted.docx", System::MakeObject<LoadOptions>(u"aspose"));

Se non si sa in anticipo se il file è crittografato, è possibile utilizzare la classe FileFormatUtil, che fornisce metodi di utilità per lavorare con i formati dei file, ad esempio il rilevamento del formato dei file o la conversione di estensioni di file in/dalle enumerazioni del formato dei file. Per rilevare se il documento è crittografato e richiede una password per aprirlo, utilizzare la proprietà IsEncrypted.

L’esempio di codice seguente mostra come verificare che OpenDocument sia crittografato o meno:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<FileFormatInfo> info = FileFormatUtil::DetectFileFormat(inputDataDir + u"encrypted.odt");
std::cout << info->get_IsEncrypted() << std::endl;