Opties Voor Laden Opgeven

Bij het laden van een document kunt u een aantal geavanceerde eigenschappen instellen. Aspose.Words biedt u de LoadOptions - klasse, die een nauwkeuriger controle van het belastingproces mogelijk maakt. Sommige laadindelingen hebben een overeenkomstige klasse die laadopties bevat voor deze laadindeling, bijvoorbeeld is er PdfLoadOptions voor het laden naar PDF - indeling of TxtLoadOptions Voor het laden naar TXT. Dit artikel geeft voorbeelden van het werken met opties van de LoadOptions klasse.

Stel Microsoft Word versie in om het uiterlijk te wijzigen

Verschillende versies van de toepassing Microsoft Word kunnen documenten onverschillig weergeven. Er is bijvoorbeeld een bekend probleem met OOXML documenten zoals DOCX of DOTX geproduceerd met WPS Office. In een dergelijk geval kunnen essentiële documentmarkup-elementen ontbreken of anders worden geïnterpreteerd, waardoor Microsoft Word 2019 een dergelijk document anders weergeeft dan Microsoft Word 2010.

Standaard opent Aspose.Words documenten met Microsoft Word 2019-regels. Als u het laden van documenten wilt laten verschijnen zoals het zou gebeuren in een van de vorige Microsoft Word toepassingsversies, moet u expliciet de gewenste versie opgeven met behulp van de MswVersion eigenschap van de LoadOptions klasse.

Het volgende codevoorbeeld laat zien hoe u de Microsoft Word versie instelt met opties voor laden:

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

Taalvoorkeuren Instellen om het uiterlijk te wijzigen

De details van het weergeven van een document in Microsoft Word zijn niet alleen afhankelijk van de toepassingsversie en de eigenschap MswVersion, maar ook van de taalinstellingen. Microsoft Word kan documenten anders weergeven, afhankelijk van de instellingen van het dialoogvenster “Office Language Preferences”, die te vinden zijn in “File → Options → Language”. Met behulp van dit dialoogvenster kan een gebruiker bijvoorbeeld primaire taal, proeftalen, weergavetalen, enzovoort selecteren. Aspose.Words geeft de eigenschap LanguagePreferences als equivalent van dit dialoogvenster. Als de uitvoer van Aspose.Words afwijkt van de uitvoer van Microsoft Word, stelt u de juiste waarde in voor EditingLanguage – Dit kan het uitvoerdocument verbeteren.

Het volgende codevoorbeeld laat zien hoe je Japans instelt als 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);

WarningCallback gebruiken om problemen te regelen tijdens het laden van een Document

Sommige documenten kunnen beschadigd zijn, ongeldige vermeldingen bevatten of functies hebben die momenteel niet worden ondersteund door Aspose.Words. Als u wilt weten over problemen die zich hebben voorgedaan tijdens het laden van een document, biedt Aspose.Words de interface IWarningCallback.

Het volgende codevoorbeeld toont de implementatie van de IWarningCallback interface:

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>())
{
}

Gebruik de eigenschap WarningCallback om informatie te krijgen over alle problemen gedurende de laadtijd.

Het volgende codevoorbeeld laat zien hoe deze eigenschap te gebruiken:

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

Gebruik ResourceLoadingCallback om het laden van externe bronnen te regelen

Een document kan externe links bevatten naar afbeeldingen die zich ergens op een lokale schijf, netwerk of Internet bevinden. Aspose.Words laadt dergelijke afbeeldingen automatisch in een document, maar er zijn situaties waarin dit proces moet worden gecontroleerd. Bijvoorbeeld om te beslissen of we een bepaalde afbeelding echt moeten laden of misschien overslaan. Met de optie ResourceLoadingCallback laden kunt u dit regelen.

Het volgende codevoorbeeld toont de implementatie van de IResourceLoadingCallback interface:

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

Het volgende codevoorbeeld laat zien hoe u de eigenschap ResourceLoadingCallback gebruikt:

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

Gebruik TempFolder om een geheugenuitbreiding te vermijden

Aspose.Words ondersteunt extreem grote documenten met duizenden pagina ' s vol rijke inhoud. Het laden van dergelijke documenten kan veel RAM vereisen. Tijdens het laden heeft Aspose.Words nog meer geheugen nodig om tijdelijke structuren te bewaren die worden gebruikt om een document te ontleden.

Als u een probleem ondervindt met de uitzondering voor geheugenverlies tijdens het laden van een document, probeert u de eigenschap TempFolder te gebruiken. In dit geval zal Aspose.Words Sommige gegevens opslaan in tijdelijke bestanden in plaats van geheugen, en dit kan helpen een dergelijke uitzondering te voorkomen.

Het volgende codevoorbeeld laat zien hoe u TempFolderinstelt:

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

Stel de codering expliciet in

De meeste moderne documentformaten slaan hun inhoud op in Unicode en vereisen geen speciale behandeling. Aan de andere kant zijn er nog steeds veel documenten die een pre-Unicode-codering gebruiken en soms coderingsinformatie missen of zelfs coderingsinformatie van nature niet ondersteunen. Aspose.Words probeert standaard automatisch de juiste codering te detecteren, maar in een zeldzaam geval moet u mogelijk een andere codering gebruiken dan die gedetecteerd door ons algoritme voor coderingherkenning. Gebruik in dit geval de eigenschap Encoding om de codering op te halen of in te stellen.

Het volgende codevoorbeeld laat zien hoe u de codering instelt om de automatisch gekozen codering te overschrijven:

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

Versleutelde Documenten Laden

U kunt Word documenten versleuteld laden met een wachtwoord. Gebruik hiervoor een speciale constructor overload, die een LoadOptions object accepteert. Dit object bevat de eigenschap Password, die de wachtwoordsteken specificeert.

Het volgende codevoorbeeld laat zien hoe u een document kunt laden dat is gecodeerd met een wachtwoord:

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

Als u niet van tevoren weet of het bestand versleuteld is, kunt u de klasse FileFormatUtil gebruiken, die hulpprogramma ' s biedt voor het werken met bestandsindelingen, zoals het detecteren van de bestandsindeling of het converteren van bestandsextensies naar/van bestandsindeling. Om te detecteren of het document versleuteld is en een wachtwoord vereist om het te openen, gebruikt u de Eigenschap IsEncrypted.

Het volgende codevoorbeeld laat zien hoe u kunt controleren of OpenDocument versleuteld is of niet:

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;