Tentukan Opsi Muat

Saat memuat dokumen, Anda dapat mengatur beberapa properti lanjutan. Aspose.Words memberi Anda kelas LoadOptions, yang memungkinkan kontrol proses pemuatan yang lebih tepat. Beberapa format pemuatan memiliki kelas terkait yang menyimpan opsi pemuatan untuk format pemuatan ini, misalnya, ada PdfLoadOptions untuk memuat ke format PDF atau TxtLoadOptions untuk memuat ke TXT. Artikel ini memberikan contoh bekerja dengan opsi dari kelas LoadOptions.

Setel Versi Microsoft Word untuk Mengubah Tampilan

Versi berbeda dari aplikasi Microsoft Word dapat menampilkan dokumen dengan acuh tak acuh. Misalnya, ada masalah umum dengan dokumen OOXML seperti DOCX atau DOTX yang diproduksi menggunakan WPS Office. Dalam kasus seperti itu, elemen markup dokumen penting mungkin hilang atau dapat ditafsirkan secara berbeda sehingga menyebabkan Microsoft Word 2019 menampilkan dokumen tersebut secara berbeda dibandingkan dengan Microsoft Word 2010.

Secara default, Aspose.Words membuka dokumen menggunakan aturan Microsoft Word 2019. Jika Anda perlu membuat pemuatan dokumen muncul seperti yang akan terjadi di salah satu versi aplikasi Microsoft Word sebelumnya, Anda harus secara eksplisit menentukan versi yang diinginkan menggunakan properti MswVersion dari kelas LoadOptions.

Contoh kode berikut menunjukkan cara menyetel versi Microsoft Word dengan opsi muat:

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

Atur Preferensi Bahasa untuk Mengubah Tampilan

Detail menampilkan dokumen dalam Microsoft Word tidak hanya bergantung pada versi aplikasi dan nilai properti MswVersion, tetapi juga pada pengaturan bahasa. Microsoft Word dapat menampilkan dokumen secara berbeda tergantung pada pengaturan dialog “Preferensi Bahasa Office”, yang dapat ditemukan di “File → Options → Dengan menggunakan dialog ini, pengguna dapat memilih, misalnya, bahasa utama, bahasa pemeriksaan, bahasa tampilan, dan sebagainya. Aspose.Words menyediakan properti LanguagePreferences yang setara dengan dialog ini. Jika keluaran Aspose.Words berbeda dari keluaran Microsoft Word, setel nilai yang sesuai untuk EditingLanguage - ini dapat meningkatkan dokumen keluaran.

Contoh kode berikut menunjukkan cara menyetel bahasa Jepang sebagai 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);

Gunakan WarningCallback untuk Mengontrol Masalah Saat Memuat Dokumen

Beberapa dokumen mungkin rusak, berisi entri yang tidak valid, atau memiliki fitur yang saat ini tidak didukung oleh Aspose.Words. Jika Anda ingin mengetahui tentang masalah yang terjadi saat memuat dokumen, Aspose.Words menyediakan antarmuka IWarningCallback.

Contoh kode berikut menunjukkan implementasi antarmuka 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>())
{
}

Untuk mendapatkan informasi tentang semua masalah selama waktu buka, gunakan properti WarningCallback.

Contoh kode berikut menunjukkan cara menggunakan properti ini:

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

Gunakan ResourceLoadingCallback untuk Mengontrol Pemuatan Sumber Daya Eksternal

Sebuah dokumen mungkin berisi tautan eksternal ke gambar yang terletak di suatu tempat di disk lokal, jaringan, atau Internet. Aspose.Words secara otomatis memuat gambar seperti itu ke dalam dokumen, tetapi ada situasi ketika proses ini perlu dikontrol. Misalnya, untuk memutuskan apakah kita benar-benar perlu memuat gambar tertentu atau mungkin melewatkannya. Opsi ResourceLoadingCallback load memungkinkan Anda untuk mengontrol ini.

Contoh kode berikut menunjukkan implementasi antarmuka 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.");
    }
}
    

Contoh kode berikut menunjukkan cara menggunakan properti 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");

Gunakan TempFolder untuk Menghindari Pengecualian Memori

Aspose.Words mendukung dokumen yang sangat besar yang memiliki ribuan halaman penuh dengan konten yang kaya. Memuat dokumen semacam itu mungkin membutuhkan banyak RAM. Dalam proses pemuatan, Aspose.Words membutuhkan lebih banyak memori untuk menyimpan struktur sementara yang digunakan untuk mengurai dokumen.

Jika Anda memiliki masalah dengan pengecualian Kehabisan Memori saat memuat dokumen, coba gunakan properti TempFolder. Dalam hal ini, Aspose.Words akan menyimpan beberapa data dalam file sementara alih-alih memori, dan ini dapat membantu menghindari pengecualian semacam itu.

Contoh kode berikut menunjukkan cara menyetel 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);

Setel Penyandian Secara Eksplisit

Sebagian besar format dokumen modern menyimpan kontennya dalam Unicode dan tidak memerlukan penanganan khusus. Di sisi lain, masih banyak dokumen yang menggunakan beberapa penyandian pra-Unicode dan terkadang melewatkan informasi penyandian atau bahkan tidak mendukung penyandian informasi secara alami. Aspose.Words mencoba mendeteksi penyandian yang sesuai secara otomatis secara default, tetapi dalam kasus yang jarang terjadi, Anda mungkin perlu menggunakan penyandian yang berbeda dari yang dideteksi oleh algoritme pengenalan penyandian kami. Dalam hal ini, gunakan properti Encoding untuk mendapatkan atau menyetel penyandian.

Contoh kode berikut menunjukkan cara mengatur penyandian untuk menimpa penyandian yang dipilih secara otomatis:

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

Muat Dokumen Terenkripsi

Anda dapat memuat dokumen Word yang dienkripsi dengan kata sandi. Untuk melakukannya, gunakan kelebihan konstruktor khusus, yang menerima objek LoadOptions. Objek ini berisi properti Password, yang menentukan string kata sandi.

Contoh kode berikut menunjukkan cara memuat dokumen yang dienkripsi dengan kata sandi:

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

Jika Anda tidak mengetahui sebelumnya apakah file tersebut dienkripsi, Anda dapat menggunakan kelas FileFormatUtil, yang menyediakan metode utilitas untuk bekerja dengan format file, seperti mendeteksi format file atau mengonversi ekstensi file ke / dari pencacahan format file. Untuk mendeteksi apakah dokumen dienkripsi dan memerlukan kata sandi untuk membukanya, gunakan properti IsEncrypted.

Contoh kode berikut menunjukkan cara memverifikasi OpenDocument apakah itu dienkripsi atau tidak:

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;