Określ Opcje Ładowania

Podczas ładowania dokumentu możesz ustawić niektóre zaawansowane właściwości. Aspose.Words zapewnia klasę LoadOptions, która umożliwia bardziej precyzyjną kontrolę procesu ładowania. Niektóre formaty ładowania mają odpowiednią klasę, która przechowuje opcje ładowania dla tego formatu ładowania, na przykład istnieje PdfLoadOptions do ładowania do formatu PDF lub TxtLoadOptions do ładowania do TXT. Ten artykuł zawiera przykłady pracy z opcjami klasy LoadOptions.

Ustaw wersję Microsoft Word, aby zmienić wygląd

Różne wersje aplikacji Microsoft Word mogą wyświetlać dokumenty obojętnie. Na przykład istnieje dobrze znany problem z dokumentami OOXML, takimi jak DOCX lub DOTX, utworzonymi przy użyciu WPS Office. W takim przypadku istotne elementy znaczników dokumentu mogą brakować lub mogą być interpretowane inaczej, powodując, że Microsoft Word 2019 pokazuje taki dokument inaczej niż Microsoft Word 2010.

Domyślnie Aspose.Words otwiera dokumenty przy użyciu reguł Microsoft Word 2019. Jeśli chcesz, aby Ładowanie dokumentu wyglądało tak, jak miało to miejsce w jednej z poprzednich wersji aplikacji Microsoft Word, powinieneś jawnie określić żądaną wersję za pomocą właściwości MswVersion klasy LoadOptions.

Poniższy przykład kodu pokazuje, jak ustawić wersję Microsoft Word z opcjami ładowania:

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);

Ustaw preferencje językowe, aby zmienić wygląd

Szczegóły wyświetlania dokumentu w Microsoft Word zależą nie tylko od wersji aplikacji i wartości właściwości MswVersion, ale także od ustawień języka. Microsoft Word może wyświetlać dokumenty w różny sposób w zależności od ustawień okna dialogowego “Preferencje języka pakietu Office”, które można znaleźć w “Plik → Opcje → Język”. Za pomocą tego okna dialogowego użytkownik może wybrać na przykład język podstawowy, języki sprawdzania, języki wyświetlania i tak dalej. Aspose.Words zapewnia Właściwość LanguagePreferences jako odpowiednik tego okna dialogowego. Jeśli Wyjście Aspose.Words różni się od wyjścia Microsoft Word, ustaw odpowiednią wartość dla EditingLanguage – może to poprawić dokument wyjściowy.

Poniższy przykład kodu pokazuje, jak ustawić Japoński jako 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);

Użyj WarningCallback, aby kontrolować problemy podczas ładowania dokumentu

Niektóre dokumenty mogą być uszkodzone, zawierać nieprawidłowe wpisy lub mieć funkcje, które nie są obecnie obsługiwane przez Aspose.Words. Jeśli chcesz wiedzieć o problemach, które wystąpiły podczas ładowania dokumentu, Aspose.Words udostępnia interfejs IWarningCallback.

Poniższy przykład kodu pokazuje implementację interfejsu 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>())
{
}

Aby uzyskać informacje o wszystkich problemach w czasie ładowania, użyj właściwości WarningCallback.

Poniższy przykład kodu pokazuje, jak korzystać z tej właściwości:

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);

Użyj ResourceLoadingCallback, aby kontrolować ładowanie zasobów zewnętrznych

Dokument może zawierać zewnętrzne łącza do obrazów znajdujących się gdzieś na dysku lokalnym, sieci lub Internecie. Aspose.Words automatycznie ładuje takie obrazy do dokumentu, ale zdarzają się sytuacje, w których proces ten wymaga kontroli. Na przykład, aby zdecydować, czy naprawdę musimy załadować określony obraz, czy może go pominąć. Opcja ładowania ResourceLoadingCallback Pozwala to kontrolować.

Poniższy przykład kodu pokazuje implementację interfejsu 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.");
    }
}
    

Poniższy przykład kodu pokazuje, jak używać właściwości 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");

Użyj TempFolder, aby uniknąć wyjątku pamięci

Aspose.Words obsługuje bardzo duże dokumenty, które mają tysiące stron pełnych bogatej zawartości. Ładowanie takich dokumentów może wymagać dużo RAM. W procesie ładowania Aspose.Words potrzebuje jeszcze więcej pamięci do przechowywania tymczasowych struktur używanych do analizowania dokumentu.

Jeśli masz problem z wyjątkiem braku pamięci podczas ładowania dokumentu, spróbuj użyć właściwości TempFolder. W takim przypadku Aspose.Words będzie przechowywać niektóre dane w plikach tymczasowych zamiast w pamięci, co może pomóc uniknąć takiego wyjątku.

Poniższy przykład kodu pokazuje, jak ustawić 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);

Ustaw kodowanie jawnie

Większość nowoczesnych formatów dokumentów przechowuje ich zawartość w Unicode i nie wymaga specjalnej obsługi. Z drugiej strony nadal istnieje wiele dokumentów, które używają kodowania przed Unicode i czasami albo brakuje informacji o kodowaniu, albo nawet nie obsługują informacji o kodowaniu z natury. Aspose.Words domyślnie próbuje automatycznie wykryć odpowiednie kodowanie, ale w rzadkich przypadkach może być konieczne użycie kodowania innego niż wykryte przez nasz algorytm rozpoznawania kodowania. W takim przypadku użyj właściwości Encoding, aby uzyskać lub ustawić kodowanie.

Poniższy przykład kodu pokazuje, jak ustawić kodowanie tak, aby zastępowało automatycznie wybrane kodowanie:

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);

Załaduj Zaszyfrowane Dokumenty

Możesz załadować Word dokumenty zaszyfrowane hasłem. Aby to zrobić, użyj specjalnego przeciążenia konstruktora, który akceptuje obiekt LoadOptions. Ten obiekt zawiera właściwość Password, która określa ciąg hasła.

Poniższy przykład kodu pokazuje, jak załadować dokument zaszyfrowany hasłem:

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"));

Jeśli nie wiesz z góry, czy plik jest zaszyfrowany, możesz użyć klasy FileFormatUtil, która zapewnia metody narzędziowe do pracy z formatami plików, takie jak wykrywanie formatu pliku lub konwertowanie rozszerzeń plików do/z wyliczeń formatów plików. Aby wykryć, czy dokument jest zaszyfrowany i wymaga hasła do jego otwarcia, użyj właściwości IsEncrypted.

Poniższy przykład kodu pokazuje, jak zweryfikować OpenDocument, czy jest zaszyfrowany, czy nie:

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;