---
title: "DocuVieware integration in a .NET Core 2.0 web application"
canonical_url: "https://www.nutrient.io/guides/docuvieware/asp-dotnet-core/docuvieware-integration-in-dotnet-core-2-0-web-application/"
md_url: "https://www.nutrient.io/guides/docuvieware/asp-dotnet-core/docuvieware-integration-in-dotnet-core-2-0-web-application.md"
last_updated: "2026-05-18T15:55:45.954Z"
description: "Integrate DocuVieware into your .NET Core 2.0 MVC application. This guide covers project setup and essential references."
---
# DocuVieware integration in a .NET Core 2.0 web application
This guide explains how to integrate DocuVieware in a newly created C#.NET Core MVC web application project with Razor view engine.
**Legacy guide notice**
This guide describes a legacy integration approach using ASP.NET Core 2.0 and Visual Studio 2017 with GdPicture.NET 14. ASP.NET Core 2.0 has reached end of life and is no longer recommended for new applications.
**Requirements** —.NET Framework 4.6 or above
**Note** — Screenshots and version-specific details may differ from the current release.
This guide is intended for maintaining existing applications within environments that have fixed legacy constraints.
## Empty project creation
Start with the **File** > **New** > **Project...** menu. Then, in Visual C#, choose **.NET Core** > **ASP.NET Core Web Application**. In this guide, you’ll be working on `DocuViewareNetCore`, a new ASP.NET Core MVC project.
Make sure to target the application to.NET Framework, as shown in the screenshot below, as this legacy integration relies on.NET Framework assemblies.
The image below shows the resulting structure.
Now that the project structure is ready, the next step is to add project references.
## Adding mandatory references
Below are the references and prerequisites needed to properly integrate DocuVieware in the.NET Core MVC project.
### DocuVieware references and prerequisites
1. Add **GdPicture.NET.14.WEB.DocuVieware.dll**, which is found in `[INSTALLATION FOLDER]\Redist\DocuVieware (.NET Framework 4.6)`.
2. Add a reference to **System.Web**, which is part of the.NET Framework.
3. Add the **Microsoft.AspNetCore.Mvc.WebApiCompatShim** NuGet package to enable ASP.NET Web API support in.NET Core.
### Additional resources
Add DocuVieware JavaScript and CSS to the project using `docuvieware-min.js` and `docuvieware-min.css`, both of which can be found in `[INSTALLATION FOLDER]\Redist\DocuVieware (Resources)`. Add them to the `css` and `js` folders of the project.
## Licensing and configuring
Now that the references are properly set, go to the `Startup.cs` file of the project to add mandatory imports and handle the licensing and configuration of DocuVieware.
Import the following DLLs:
```csharp
using System.IO;
using GdPicture14.WEB;
```
To unlock DocuVieware, add a call to the `RegisterKEY()` method in the `Configure` method. Replace the placeholder with your actual license key.
```csharp
DocuViewareLicensing.RegisterKEY("XXXX"); // Unlocking DocuVieware
// Replace "XXXX" with your actual license key.
```
To set up the configuration of DocuVieware, add a call to the `DocuViewareManager.SetupConfiguration()` method in the same `Configure` method. Create a new folder in the project for cache and name it `Cache`.
```csharp
// DocuVieware Core Configuration
DocuViewareManager.SetupConfiguration(true, DocuViewareSessionStateMode.File, Path.Combine(Directory.GetCurrentDirectory(), "Cache"), "/", "api/docuvieware3");
```.NET Core 2.0’s DependencyContext — which MVC uses to discover compile-time references for views — doesn’t have a resolver for referenced binaries. To avoid runtime errors, you need to modify how MVC locates reference assembly paths.
Create the `ReferencesMetadataReferenceFeatureProvider` class below. This workaround shouldn’t be necessary in.NET Core 2.0.1 and later. For more information, refer to the [GitHub issue](https://github.com/aspnet/Home/issues/2126#issuecomment-322325498).
```csharp
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection.PortableExecutable;
using Microsoft.AspNetCore.Mvc.ApplicationParts;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.DependencyModel;
namespace Microsoft.AspNetCore.Mvc.Razor.Compilation
{
public class ReferencesMetadataReferenceFeatureProvider : IApplicationFeatureProvider
{
public void PopulateFeature(IEnumerable parts, MetadataReferenceFeature feature)
{
var libraryPaths = new HashSet(StringComparer.OrdinalIgnoreCase);
foreach (var assemblyPart in parts.OfType())
{
var dependencyContext = DependencyContext.Load(assemblyPart.Assembly);
if (dependencyContext!= null)
{
foreach (var library in dependencyContext.CompileLibraries)
{
if (string.Equals("reference", library.Type, StringComparison.OrdinalIgnoreCase))
{
foreach (var libraryAssembly in library.Assemblies)
{
libraryPaths.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, libraryAssembly));
}
}
else
{
foreach (var path in library.ResolveReferencePaths())
{
libraryPaths.Add(path);
}
}
}
}
else
{
libraryPaths.Add(assemblyPart.Assembly.Location);
}
}
foreach (var path in libraryPaths)
{
feature.MetadataReferences.Add(CreateMetadataReference(path));
}
}
private static MetadataReference CreateMetadataReference(string path)
{
using (var stream = File.OpenRead(path))
{
var moduleMetadata = ModuleMetadata.CreateFromStream(stream, PEStreamOptions.PrefetchMetadata);
var assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
return assemblyMetadata.GetReference(filePath: path);
}
}
}
}
```
Finally, add this code to the `ConfigureServices` method to enable the DocuVieware reference in Razor views:
```csharp
services.AddMvc()
// Enabling Web API 2 projects compatibility layout support for.NET Core.AddWebApiConventions()
//.NET Core 2.0 DependencyContext doesn't have a resolver for referenced binaries.
// More information: https://github.com/aspnet/Home/issues/2126#issuecomment-322325498.ConfigureApplicationPartManager(manager =>
{
var oldMetadataReferenceFeatureProvider = manager.FeatureProviders.First(f => f is MetadataReferenceFeatureProvider);
manager.FeatureProviders.Remove(oldMetadataReferenceFeatureProvider);
manager.FeatureProviders.Add(new ReferencesMetadataReferenceFeatureProvider());
})
// Add DocuVieware reference to Razor compilation using RazorViewEngineOptions.CompilationCallback.AddRazorOptions(options =>
{
var previous = options.CompilationCallback;
options.CompilationCallback = context =>
{
previous?.Invoke(context);
context.Compilation = context.Compilation.AddReferences(Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(typeof(DocuVieware).Assembly.Location));
};
});
```
The image below illustrates what the `Startup.cs` file should look like at this point.
> You can find the sample source code available here: `[INSTALLATION FOLDER]\Samples\ASP.NET\DocuVieware\aspnetcore-mvc\_razor\_app\docuvieware\_demo\Startup.cs`.
## DocuVieware integration
First, create an additional controller to handle and route DocuVieware actions. Create a new controller called `DocuVieware3Controller.cs` in the project’s `Controllers` folder:
```csharp
using Microsoft.AspNetCore.Mvc;
using GdPicture14.WEB;
using System.Net.Http;
using System.Net;
namespace DocuViewareNetCore.Controllers
{
[Route("api/docuvieware3")]
public class DocuVieware3Controller : Controller
{
[HttpGet("ping")]
public string ping()
{
return "pong";
}
[HttpPost("baserequest")]
public string baserequest([FromBody] object jsonString)
{
return DocuViewareControllerActionsHandler.baserequest(jsonString);
}
[HttpGet("print")]
public HttpResponseMessage Print(string sessionID, string pageRange, bool printAnnotations)
{
return DocuViewareControllerActionsHandler.print(sessionID, pageRange, printAnnotations);
}
[HttpGet("getresource")]
public IActionResult GetResource(string resourceID, string version)
{
DocuViewareControllerActionsHandler.getresource(resourceID, version, out HttpStatusCode statusCode, out byte[] content, out string contentType, out string fileName, out string reasonPhrase);
if (statusCode == HttpStatusCode.OK)
{
return File(content, contentType, fileName);
}
else
{
return StatusCode((int)statusCode, reasonPhrase);
}
}
[HttpGet("save")]
public IActionResult Save(string sessionID, string fileName, string format, string pageRange, bool dropAnnotations, bool flattenAnnotations)
{
DocuViewareControllerActionsHandler.save(sessionID, ref fileName, format, pageRange,dropAnnotations, flattenAnnotations, out HttpStatusCode statusCode, out string reasonPhrase, out byte[] content, out string contentType);
if (statusCode == HttpStatusCode.OK)
{
return File(content, contentType, fileName);
}
else
{
return StatusCode((int)statusCode, reasonPhrase);
}
}
[HttpGet("twainservicesetupdownload")]
public IActionResult TwainServiceSetupDownload(string sessionID)
{
DocuViewareControllerActionsHandler.twainservicesetupdownload(sessionID, out HttpStatusCode statusCode, out byte[] content, out string contentType, out string fileName, out string reasonPhrase);
if (statusCode == HttpStatusCode.OK)
{
return File(content, contentType, fileName);
}
else
{
return StatusCode((int)statusCode, reasonPhrase);
}
}
[HttpPost("formfieldupdate")]
public string FormfieldUpdate([FromBody]object jsonString)
{
return DocuViewareControllerActionsHandler.formfieldupdate(jsonString);
}
[HttpPost("annotupdate")]
public string AnnotUpdate([FromBody]object jsonString)
{
return DocuViewareControllerActionsHandler.annotupdate(jsonString);
}
[HttpPost("loadfromfile")]
public string LoadFromFile([FromBody]object jsonString)
{
return DocuViewareControllerActionsHandler.loadfromfile(jsonString);
}
[HttpPost("loadfromfilemultipart")]
public string LoadFromFileMultipart()
{
return DocuViewareControllerActionsHandler.loadfromfilemultipart(Request);
}
}
}
```
Integrate a DocuVieware instance in the `Index` view. The same approach applies to any other view or content.
For the sake of clarity, replace the entire content of the `Index` view. Remove other views and the shared layouts as well; you won’t use them in this guide.
Create a `div` in `Index.cshtml` and insert the DocuVieware control in it. Then create a new DocuVieware object in the `div` and set its properties.
Below is what the `Index.cshtml` finally looks like after the integration is complete:
```html
@using GdPicture14.WEB
@using System.Web.UI.WebControls
DocuVieware ASP.NET Core demo application
@{
DocuVieware docuVieware = new DocuVieware
{
ID = "DocuVieware1",
Height = new Unit("100%"),
Width = new Unit("100%"),
DisableAnnotationDrawingModePanel = true,
EnableMultipleThumbnailSelection = false,
EnableFormFieldsEdition = true
};
docuVieware.RenderControl(Output);
docuVieware.Dispose();
}
```
> You can find the sample source code available here: `[INSTALLATION FOLDER]\Samples\ASP.NET\DocuVieware\aspnetcore-mvc\_razor\_app\docuvieware\_demo\Views\Home\Index.cshtml`.
That’s it! You can start the project and load documents in your brand-new DocuVieware.
---
## Related pages
- [DocuVieware integration in a .NET Core 2.2 web application](/guides/docuvieware/asp-dotnet-core/docuvieware-integration-in-dotnet-core-2-2-web-application.md)
- [DocuVieware integration in a .NET Core 3.0 web application](/guides/docuvieware/asp-dotnet-core/docuvieware-integration-in-dotnet-core-3-0-web-application.md)
- [ASP.NET Core integration](/guides/docuvieware/asp-dotnet-core.md)