Build a .NET Core Image Conversion MicroService with LEADTOOLS

      "buildOptions": {
         "emitEntryPoint": true,
         "preserveCompilationContext": true,
         "embed": [ "LEADTOOLS.LIC" ]
      },

using System;
using System.Runtime.InteropServices;
namespace ImageConvertService
{
   public static class LTInterop
   {
      // Update the following with the path to the LEADTOOLS CDLLVC10 DLLs.
      private const string WinX64BinPath = @"LEADTOOLS_BIN_CDLLVC10_x64_PATH_HERE";
      private const string WinX86BinPath = @"LEADTOOLS_BIN_CDLLVC10_Win32_PATH_HERE";
      static LTInterop()
      {
         var architecture = RuntimeInformation.OSArchitecture;
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
            var oldPath = System.Environment.GetEnvironmentVariable("Path");
            if (architecture == Architecture.X86)
            {
               Environment.SetEnvironmentVariable("Path", WinX86BinPath + "; " + oldPath);
               Winx86.Apply();
            }
            else if (architecture == Architecture.X64)
            {
               Environment.SetEnvironmentVariable("Path", WinX64BinPath + "; " + oldPath);
               Winx64.Apply();
            }
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
            Linux.Apply();
         }
         else
         {
            throw new InvalidOperationException("Unsupported architecture");
         }
      }
      // Need to call one of the SetLicense functions only once.
      public delegate int _L_SetLicenseFile(string licenseFile, string developerKey);
      public static _L_SetLicenseFile L_SetLicenseFile;
      public delegate int _L_SetLicenseBuffer(byte[] pLicenseBuffer, IntPtr nSize, string pszDeveloperKey);
      public static _L_SetLicenseBuffer L_SetLicenseBuffer;
      public delegate int _L_FileConvert(string sourceFile, string destFile, int format, int width, int height, int bitsPerPixel, int qfactor, IntPtr loadOptions, IntPtr saveOptions, IntPtr fileInfo);
      public static _L_FileConvert L_FileConvert;
      private static class Winx86
      {
         private const string _ltkrn = "ltkrnu.dll";
         private const string _ltfil = "ltfilu.dll";
         private const CharSet _charset = CharSet.Unicode;
         [DllImport(_ltkrn, CharSet = _charset)]
         public static extern int L_SetLicenseFile(string licenseFile, string developerKey);
         [DllImport(_ltkrn, CharSet = _charset)]
         public static extern int L_SetLicenseBuffer(byte[] pLicenseBuffer, IntPtr nSize, string pszDeveloperKey);
         [DllImport(_ltfil, CharSet = _charset)]
         public static extern int L_FileConvert(string sourceFile, string destFile, int format, int width, int height, int bitsPerPixel, int qfactor, IntPtr loadOptions, IntPtr saveOptions, IntPtr fileInfo);
         
         public static void Apply()
         {
            LTInterop.L_SetLicenseFile = L_SetLicenseFile;
            LTInterop.L_SetLicenseBuffer = L_SetLicenseBuffer;
            LTInterop.L_FileConvert = L_FileConvert;
         }
      }
      private static class Winx64
      {
         private const string _ltkrn = @"ltkrnx.dll";
         private const string _ltfil = @"ltfilx.dll";
         private const CharSet _charset = CharSet.Unicode;
         [DllImport(_ltkrn, CharSet = _charset)]
         public static extern int L_SetLicenseFile(string licenseFile, string developerKey);
         [DllImport(_ltkrn, CharSet = _charset)]
         public static extern int L_SetLicenseBuffer(byte[] pLicenseBuffer, IntPtr nSize, string pszDeveloperKey);
         [DllImport(_ltfil, CharSet = _charset)]
         public static extern int L_FileConvert(string sourceFile, string destFile, int format, int width, int height, int bitsPerPixel, int qfactor, IntPtr loadOptions, IntPtr saveOptions, IntPtr fileInfo);
         
         public static void Apply()
         {
            LTInterop.L_SetLicenseFile = L_SetLicenseFile;
            LTInterop.L_SetLicenseBuffer = L_SetLicenseBuffer;
            LTInterop.L_FileConvert = L_FileConvert;
         }
      }
      private static class Linux
      {
         private const string _ltkrn = "libltkrn.so";
         private const string _ltfil = "libltfil.so";
         private const CharSet _charset = CharSet.Ansi;
         [DllImport(_ltkrn, CharSet = _charset)]
         public static extern int L_SetLicenseFileA(string licenseFile, string developerKey);
         [DllImport(_ltkrn, CharSet = _charset)]
         public static extern int L_SetLicenseBufferA(byte[] pLicenseBuffer, IntPtr nSize, string pszDeveloperKey);
         [DllImport(_ltfil, CharSet = _charset)]
         public static extern int L_FileConvertA(string sourceFile, string destFile, int format, int width, int height, int bitsPerPixel, int qfactor, IntPtr loadOptions, IntPtr saveOptions, IntPtr fileInfo);
         
         public static void Apply()
         {
            LTInterop.L_SetLicenseFile = L_SetLicenseFileA;
            LTInterop.L_SetLicenseBuffer = L_SetLicenseBufferA;
            LTInterop.L_FileConvert = L_FileConvertA;
         }
      }
   }
}

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;

namespace ImageConvertService.Controllers
{
    [Route("api/[controller]")]
    public class ImagingController : Controller
    {
        public async Task<IActionResult> Get(Uri url)
        {
            const int FILE_PNG = 75; // From ltfil.h
            const string mimeType = "image/png";

            if (url == null)
                return Content("url cannot be null");
            if (!url.IsAbsoluteUri)
                return Content("url must be absolute. Make sure to include the protocol.");

            string sourceFile = null;
            string targetFile = null;

            try
            {
                // Download image to a temp file.
                sourceFile = Path.GetTempFileName();
                using (var client = new HttpClient())
                using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString()))
                using (Stream contentStream = await (await client.SendAsync(request)).Content.ReadAsStreamAsync())
                using (Stream fileStream = new FileStream(sourceFile, FileMode.Create, FileAccess.Write, FileShare.None, 3145728, true))
                {
                    await contentStream.CopyToAsync(fileStream);
                }

                // Call native L_FileConvert
                // https://www.leadtools.com/help/leadtools/v19/main/api/l_fileconvert.html
                targetFile = Path.GetTempFileName();
                int ret = LTInterop.L_FileConvert(sourceFile, targetFile, FILE_PNG, 0, 0, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
                if (ret != 1)
                    return Content("Error Converting File : " + ret);

                // Load converted file and return.
                byte[] buffer = System.IO.File.ReadAllBytes(targetFile);
                return File(buffer, mimeType);
            }
            finally
            {
                // Clean up
                if (sourceFile != null && System.IO.File.Exists(sourceFile))
                    System.IO.File.Delete(sourceFile);
                if (targetFile != null && System.IO.File.Exists(targetFile))
                    System.IO.File.Delete(targetFile);
            }
        }
    }
}