Installing Documentize via NuGet

How to Install via NuGet Package Manager Console

1. Open Your Project:

   • Launch Visual Studio and open your .NET application.

2. Access the Package Manager Console:

   • Navigate to Tools > NuGet Package Manager > Package Manager Console.

3. Install the Package:

   • To install the latest full release, enter the command Install-Package Documentize.
   • To install the latest release including hot fixes, use Install-Package Documentize -prerelease.
   • Press Enter to execute the command.

How to Update Package via NuGet Package Manager Console

If you have already installed Documentize via NuGet and want to update to the latest version:

1. Open Your Project:

   • Launch Visual Studio and open your .NET application.

2. Access the Package Manager Console:

   • Navigate to Tools > NuGet Package Manager > Package Manager Console.

3. Update the Package:

   • To update to the latest full release, enter Update-Package Documentize.
   • To update to the latest release including hot fixes, use Update-Package Documentize -prerelease.
   • Press Enter to execute the command.

How to Install via NuGet Package Manager GUI

1. Open Your Project:

   • Launch Visual Studio and open your .NET application.

2. Navigate to Manage NuGet Packages:

   • From the Project menu, select Manage NuGet Packages.

3. Search for Documentize:

   • Go to the Browse tab and enter Documentize into the search box.

4. Install the Package:

   • Click Install/Update next to the latest version of Documentize.
   • Confirm by clicking Accept in the pop-up window.

Pros of Using the NuGet

• Automatic Dependency Management:

  • NuGet automatically handles dependencies, ensuring that all required libraries are included and updated correctly. This reduces the risk of missing or incompatible dependencies.

• Simplified Updates:

  • Updating packages is straightforward with NuGet, either through the Package Manager Console or GUI. This makes it easy to keep your libraries up-to-date with the latest features and bug fixes.

• Integrated with Visual Studio:

  • NuGet is seamlessly integrated with Visual Studio, providing a user-friendly interface for managing packages without leaving the development environment.

• Versioning:

  • NuGet allows you to specify and manage different versions of libraries, enabling you to easily revert to previous versions or test new releases without disrupting your development.

Cons of Using the NuGet

• Limited to Visual Studio:

  • NuGet is primarily designed for use within Visual Studio. While it can be used in other environments, the integration is most robust in Visual Studio.

• Potential for Version Conflicts:

  • In larger projects with many dependencies, managing versions and resolving conflicts can become complex. NuGet provides tools to manage this, but it requires careful attention.

• Network Dependency:

  • Installing and updating packages requires an internet connection. If you’re working in an environment with restricted or no internet access, you may need to use offline methods or pre-download packages.

• Complexity for Large Projects:

  • For very large projects with extensive dependency trees, the overhead of managing packages through NuGet can become cumbersome. In such cases, additional tools or strategies may be needed to manage dependencies effectively.

Installing Documentize via MSI

How to Install via MSI Installer

1. Download the MSI Installer:

   • Click the v24.12 MSI to download the MSI installer for the latest version of Documentize.

2. Run the Installer:

   • Double-click the downloaded MSI file to launch the installation wizard.

3. Follow the Installation Wizard:

   • Follow the on-screen instructions provided by the installer. You may need to agree to the license agreement and select installation options.

4. Complete the Installation:

   • Once the installation is complete, the Documentize DLLs will be installed into your system’s Global Assembly Cache (GAC) or another specified location.

5. Verify Installation:

   • Check that the DLLs are correctly installed by verifying their presence in the designated installation directory or GAC.

Pros of Using the MSI Installer

• Ease of Use:

  • The MSI installer provides a simple and guided installation process. It handles all necessary configurations and places the DLLs in a central location, making it easy to use Documentize across multiple projects.

• System-wide Installation:

  • The MSI method installs Documentize into the system’s Global Assembly Cache (GAC) or another central location. This allows any application on the system to access the DLLs without needing to reference them individually in each project.

• Automated Updates:

  • If Documentize provides an updated installer, you can easily update your installation by running the new MSI file, which typically handles the update process smoothly.

• Consistency:

  • Using the MSI installer ensures that all required files are installed correctly and consistently across different environments, reducing the risk of missing or misplaced DLLs.

Cons of Using the MSI Installer

• Limited Flexibility:

  • The MSI installer installs Documentize to a system-wide location, which may not be suitable for all development environments. It may lack the flexibility to accommodate project-specific configurations or versions.

• Potential Overhead:

  • Installing DLLs to the GAC can introduce overhead and complexity, particularly in scenarios where multiple versions of Documentize might be needed simultaneously.

• Manual Removal:

  • If you need to uninstall Documentize, you must use the uninstaller provided by the MSI, which may leave residual files or configurations behind if not properly managed.

• Version Conflicts:

  • System-wide installations can lead to version conflicts if different projects require different versions of Documentize. Managing these conflicts may require additional configuration or cleanup.

Installing Documentize via ZIP

How to Install via ZIP Archive

1. Download the ZIP Archive:

   • Click the v24.12 ZIP to download the latest version of Documentize in an archive format.

2. Extract the Contents:

   • After downloading, extract the contents of the ZIP file to a directory of your choice. You can choose to keep these files in a shared directory or within your project structure.

3. Add References to Your Project:

   • Open your project in your IDE (e.g., Visual Studio).
   • Go to Project > Add Reference > Browse and navigate to the directory where you extracted the DLLs.
   • Select the relevant DLL files and add them as references to your project.

4. Manual Updates:

   • If a new version of Documentize is released, you will need to manually download the updated ZIP archive and replace the old DLL files in your project with the new ones.

Pros of Using the ZIP Archive

• Complete Control:

  • You have full control over where and how the DLLs are stored and referenced in your project. This can be beneficial if you prefer a custom setup or need to manage dependencies manually.

• No Dependency on Package Managers:

  • Unlike NuGet, you don’t rely on a package manager to handle installations. This can be advantageous in environments where package managers are not available or preferred.

• Portability:

  • The ZIP archive can be easily shared and moved across different systems, making it ideal for projects that need to be portable or distributed without relying on external tools.

Cons of Using the ZIP Archive

• Manual Management:

  • Unlike NuGet, where updates and dependency management are automated, with the ZIP archive, you must manually manage updates and ensure that all required DLLs are correctly referenced.

• Risk of Version Conflicts:

  • If you’re managing multiple projects or working in a team, there’s a risk of version conflicts if different projects use different versions of the DLLs. This requires careful tracking of versions across projects.

• No Automatic Updates:

  • You won’t receive automatic updates or notifications when a new version is available. This can lead to the risk of using outdated libraries unless you regularly check for updates.

Non-Windows Environment

Working with .NET Core DLLs in Non-Windows Environment

As Documentize for .NET provides .NET Standard 2.0 (.NET Core 2.0) support, it can be used in Core Applications running in Linux-like operating systems. We are constantly working on improving the .NET Core support in our API. However, there are some operations which we recommend our customers perform to get better results while using features of Documentize for .NET. Please install:

• libgdiplus package
• Package with Microsoft-compatible fonts: ttf-mscorefonts-installer (e.g., sudo apt-get install ttf-mscorefonts-installer). These fonts should be placed in /usr/share/fonts/truetype/msttcorefonts directory as Documentize for .NET scans this folder on Linux-like operating systems. In case the operating system has another default folder/directory for fonts, you should use the following line of code before performing any operation using Documentize:

  Documentize.Pdf.Text.FontRepository.Sources.Add(new FolderFontSource("<user's path to ms fonts>"));

v24.12

Added new Plugin: PDF to PNG Converter

• Class PngConverter: Represents Documentize.PngConverter plugin. Used to convert PDF documents into PNG format.
• Class PdfToPngOptions: Represents PDF to PNG converter options for the Documentize.PngConverter plugin.

Example Usage:

// create PngConverter
var plugin = new PngConverter();
// create PdfToPngOptions object to set instructions
var opt = new PdfToPngOptions();
// add input file path
opt.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
// set output file path
opt.AddOutput(new DirectoryDataSource("path_to_results_directory"));
// perform the process
plugin.Process(opt);

Added new Plugin: PDF to TIFF Converter

• Class TiffConverter: Represents Documentize.TiffConverter plugin. Used to convert PDF documents into TIFF format.
• Class PdfToTiffOptions: Represents PDF to TIFF converter options for the Documentize.TiffConverter plugin.

Example Usage:

// create TiffConverter
var plugin = new TiffConverter();
// create PdfToTiffOptions object to set instructions
var opt = new PdfToTiffOptions();
// add input file path
opt.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
// set output file path
opt.AddOutput(new DirectoryDataSource("path_to_results_directory"));
// perform the process
plugin.Process(opt);

Added new Plugin: PDF Table Generator

• Class TableGenerator: Represents Documentize.TableGenerator plugin. Used to add a table to a PDF document.
• Class TableBuilder: Class represents builder for table in pdf page.
• Class TableRowBuilder: Class represents builder for table row.
• Class TableRowBuilder: Class represents builder for table cell.

Example Usage:

// create TableGenerator
var plugin = new TableGenerator();
// create TableOptions object to set instructions
TableOptions opt = new TableOptions().InsertPageBefore(1)
   .AddTable()
        .AddRow()
            .AddCell().AddParagraph("Name")
            .AddCell().AddParagraph("Age")
        .AddRow()
            .AddCell().AddParagraph("Bob")
            .AddCell().AddParagraph("12")
        .AddRow()
            .AddCell().AddParagraph("Sam")
            .AddCell().AddParagraph("20")
        .AddRow()
            .AddCell().AddParagraph("Sandy")
            .AddCell().AddParagraph("26")
        .AddRow()
            .AddCell().AddParagraph("Tom")
            .AddCell().AddParagraph("12")
        .AddRow()
            .AddCell().AddParagraph("Jim")
            .AddCell().AddParagraph("27");
// add input file path
opt.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
// set output file path
opt.AddOutput(new FileDataSource("path_to_the_converted_file.pdf"));
// perform the process
plugin.Process(opt);

Renamed Class PdfDoc to DocConverter

• Class DocConverter: Represents Documentize.DocConverter plugin. Used to convert PDF documents into DOC/DOCX format.

Example Usage:

// create DocConverter
var plugin = new DocConverter();
// create PdfToDocOptions object to set instructions
var opt = new PdfToDocOptions();
// add input file path
opt.AddInput(new FileDataSource(inputPath));
// set output file path
opt.AddOutput(new FileDataSource(outputPath));
// perform the process
plugin.Process(opt);

v24.11

Added new Plugin: PDF to JPEG Converter

• Purpose: The JpegConverter class is designed to convert PDF documents into JPEG format, making it easier for users to handle and share images derived from PDFs.
• Constructor:
  • JpegConverter(): Initializes a new instance of the JPEG converter.

Example Usage:

var plugin = new JpegConverter();
var opt = new PdfToJpegOptions();
opt.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
opt.AddOutput(new DirectoryDataSource("path_to_results_directory"));
plugin.Process(opt);

• Method:
  • Process(PdfToJpegOptions options): Starts the JPEG conversion process using the specified options.

Added Class DirectoryDataSource

• Purpose: The DirectoryDataSource class allows users to manage directory data for loading and saving operations within plugins.
• Constructor:
  • DirectoryDataSource(string path): Initializes a new directory data object with the specified path.

Example Usage:

var directorySource = new DirectoryDataSource("path_to_your_directory");

• Properties:
  • DataType: Retrieves the type of data source.
  • Path: Gets the path of the current data directory.

Added Class PdfToJpegOptions

• Purpose: This class contains options for configuring the JPEG conversion process, allowing users to specify resolution, page lists, and image quality.
• Constructor:
  • PdfToJpegOptions(): Initializes a new options instance for the JPEG converter.

Properties:

• OutputResolution: Specifies the resolution of the resulting JPEG images.
• PageList: A list of pages to convert from the PDF.
• Quality: Sets the quality of the JPEG output.

v24.10

Added new Plugin: PDF/A Converter

• A new PDF/A conversion feature has been introduced, allowing users to easily convert standard PDF files to PDF/A compliant documents.

Example Usage:

var options = new PdfAConvertOptions
{
    PdfAVersion = PdfAStandardVersion.PDF_A_3B
};

options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
options.AddOutput(new FileDataSource("path_to_the_converted_file.pdf"));

var plugin = new PdfAConverter();
plugin.Process(options);

Bug Fixes

• Fixed issues related to the FileResult class that resulted in incorrect output paths.
• Resolved minor bugs affecting the HtmlConverter when handling large files.

Improvements

• Enhanced performance of PdfExtractor and ImageExtractor for faster processing times.
• Updated the RotateOptions class to support additional rotation angles.

v24.9

Released