Getting Started with .NET¶

Hyland Document Filters provides robust document processing capabilities that can be easily integrated into your .NET applications. Follow these instructions to set up your environment.

Installing the Bindings¶

The Document Filters .NET bindings are available on NuGet under the package name Hyland.DocumentFilters, which provides the easiest and recommended way to integrate Document Filters into your .NET applications.

If needed, you can also access the source code for the bindings in the bindings/dotnet directory of the Document Filters GitHub repository. This allows for modifications and manual builds when customization is required.

Using Published Bindings¶

To use the official Document Filters .NET bindings, you can add the Hyland.DocumentFilters package from NuGet to your project using Visual Studio or the command line.

Via the Command Line:

Run the following command in your terminal:

dotnet add package Hyland.DocumentFilters

Via Visual Studio:

Follow these steps to add the bindings via Visual Studio:

1. Open your project in Visual Studio.
2. In the Solution Explorer, right-click on your project and select Manage NuGet Packages.
3. In the NuGet Package Manager window, select the Browse tab.
4. In the search box, type Hyland.DocumentFilters.
5. Once found, click on the Hyland.DocumentFilters package and select the desired version.
6. Click Install to add the package to your project.
7. After installation, the package will be listed under your project’s Dependencies in Solution Explorer, and you can start using the Document Filters API.

This ensures that you always have the latest stable version of the bindings, making integration and updates straightforward.

Building the Bindings¶

If you need to modify the .NET bindings or build them manually, follow these steps:

1. Clone the Document Filters GitHub repository.
2. Navigate to the bindings/dotnet directory.
3. Open the solution file in Visual Studio or another preferred IDE.
4. Make any necessary changes to the code.
5. Build the project to generate the custom .NET bindings for your application.

Once built, you can reference the custom bindings in your .NET project manually, or package them into a local NuGet package for reuse.

Initializing and calling Document Filters¶

1
2
3
4

using Hyland.DocumentFilters;

var api = new Hyland.DocumentFilters.Api();
api.Initialize("YOUR_LICENSE_KEY_HERE", ".");

The preceding code loads the DocumentFilters package into global scope, then creates a new Api singleton and Initializes it with a license key. Replace "YOUR_LICENSE_KEY_HERE" with your actual license key.

The second argument controls where DocFilters should look for resources, such as configuration files and fonts. The . tells it to look in the same directory as the DocFilter's shared libraries.

Note: ISYSdf11.dll must be either in same folder as the currently executing Assembly or found by Default Probing rules for Unmanaged (native) libraries.

Extracting Text¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

using Hyland.DocumentFilters;

var api = new Hyland.DocumentFilters.Api();
api.Initialize("YOUR_LICENSE_KEY_HERE", ".");

using var doc = api.GetExtractor("filename.doc");
doc.Open(Hyland.DocumentFilters.OpenType.BodyAndMeta)

while (!doc.EndOfStream)
{
    var text = doc.GetText(4096);
    Console.Out.WriteLine(text);
}

The preceding code loads the file filename.doc into an extractor doc. By using a scoped using block, the extractor will be closed when doc goes out of scope.

It then opens the extractor with BodyAndMeta indicating that we want to extract both the text (body) and the metadata of the document.

Finally, it loops over calling GetText until the extractor reports EndOfStream.

Converting a Document¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

using Hyland.DocumentFilters;

var api = new Hyland.DocumentFilters.Api();
api.Initialize("YOUR_LICENSE_KEY_HERE", ".");

using var doc = api.GetExtractor("filename.doc");
using var canvas = api.MakeOutputCanvas("output.pdf", Hyland.DocumentFilters.CanvasType.PDF);

doc.Open(Hyland.DocumentFilters.OpenType.FormatImage)

canvas.RenderPages(doc);

The preceding code loads the file filename.doc into an extractor doc. By using a scoped using block, the extractor will be closed when doc goes out of scope.

It also creates a new canvas object of type CanvasType.PDF and stores it as canvas. The canvas will also be automatically closed when it goes out of scope.

It then opens the extractor with FormatImage indicating that we want to convert the file to an image based output. This triggers the file to be paginated.

Finally, it calls RenderPages to output every page from doc into the canvas. You could also manually iterate of over the pages and call RenderPages.