We're sorry Aspose doesn't work properply without JavaScript enabled.

Free Support Forum - aspose.com

Evaluation watermark despite having a valid license

We’ve been using Aspose Total .net for some time to generate preview images of various filetypes.
For this we purchased developer oem-license and all was well.

Then the free year of support we got when we bought the license expired (03/03/2022) and since then the evaluation watermark got pasted on our preview images.

This should not happen since the license is perpetual and we’re not using a more recent version of any of the dotnet libraries.

A chat with support concluded the problem did not lie in the license. Our code however has not changed in the 8 months prior to this, we did not install any new libraries, rebooted servers or anything in at least the 2 weeks prior.

So we created a temporary license through https://purchase.aspose.com/temporary-license, installed that to our servers and the watermark is gone.

We cannot conclude anything other than that the problem lies with either the licence file or Aspose’s licence check.

What can be done to fix this issue?

We’re using the following dotnet assmeblies, all installed to and used from the Global Assembly Cache, all from before the expiry-date:

  • Aspose.Words, Version=20.2.0.0, Culture=neutral, PublicKeyToken=716fcc553a201e56, processorArchitecture=MSIL
  • Aspose.Cells, Version=19.12.0.0, Culture=neutral, PublicKeyToken=716fcc553a201e56, processorArchitecture=MSIL
  • Aspose.Email, Version=19.10.0.0, Culture=neutral, PublicKeyToken=716fcc553a201e56, processorArchitecture=MSIL
  • Aspose.Imaging, Version=19.12.0.0, Culture=neutral, PublicKeyToken=716fcc553a201e56, processorArchitecture=MSIL
  • Aspose.Imaging, Version=21.4.0.0, Culture=neutral, PublicKeyToken=716fcc553a201e56, processorArchitecture=MSIL
  • Aspose.PDF, Version=20.1.0.0, Culture=neutral, PublicKeyToken=f0262d67fe233d63, processorArchitecture=MSIL
  • Aspose.Slides, Version=19.12.0.0, Culture=neutral, PublicKeyToken=716fcc553a201e56, processorArchitecture=MSIL

The code that sets the license are all variations on the below, unchanged in the last 8 months code:

license_words = new Aspose.Words.License();
license_words.SetLicense(hLicenceFile);
license_cells = new Aspose.Cells.License();
license_cells.SetLicense(hLicenceFile);

This is done for the relevant libraries, based on the filetype and of course for the imaging libraries to save the generated preview and has worked for the previous 8 months.

One thing that might be of interest is the difference between the temporary license and our licence file, see attached image, even though I guess that’s just because of new naming conventions and the fact one is temporary.
licenses.png (29.5 KB)

@alexnot,

This is strange and it should not happen. I do not think a running (previously working) license suddenly stopped working without any change in your source code. It should always and continuously work. Please note, according to our license mechanism, a license cannot be expired if a user continues using relevant Aspose APIs version which should be published/released before the license expiry date.

Moreover, if you do not get license expiry message (exception) and only get watermark in the output files/images, it means your licensing code is not processed at all, so you should debug your code by yourselves and make sure that your licensing code should be processed at first in your program and at least once in whole application life cycle.

It is also possible although your license code is not changed but the processing sequence is changed. For example, you might be using multi-threads and you are initializing threads (which involve reading files and do rendering) prior processing licensing code first.

By the way, you may confirm while initializing file formats or loading the files into APIs’ object model if the license is actually set or not. For example, see the sample lines of code regarding Aspose.Cells to check if the license is set or not:

Workbook workbook = new Workbook();
//Check if the license is set
Console.WriteLine(workbook.IsLicensed);

Also, did you test if you produce the issue in a separate sample project? This way, you may confirm that the issue only lies in your actual project. In any case if you still find the issue or could not evaluate the issue, could you be more precise and provide details on which specific Aspose for .NET APIs are producing the evaluation watermark issue or all the APIs are producing the issue?

Thanks for the quick reply Amjad!

Good to hear the license should be perpetual.

It took some time, but I managed to narrow it down to the actual imaging-part, instead of the conversion-steps.

I took the code from https://docs.aspose.com/imaging/net/converting-images/#binarization-with-fixed-threshold and when I run that with our original license file (see image-attachment in topicstart), the result includes a watermark, when I use the temporary license, no trial-watermark is present.
Simply loading and saving an image adds a watermark based on the supplied licence file:

using System;

namespace makePreview
{
    class Program
    {
        static int Main()
        {
            string hSource = "",
                   hOutputDirectory = "",
                   hLicense = "";
            hSource = "D:\\temp\\lorem ipsum\\Lorem Ipsum.png";
            hOutputDirectory = "D:\\temp\\lorem ipsum\\preview\\";
            hLicense = "D:\\appl\\ais\\src\\bin\\licenties\\Aspose.Total.tijdelijk.alls-11295.lic";     // <- using this license gives no watermark
            hLicense = "D:\\appl\\ais\\src\\bin\\licenties\\Aspose.Total.lic";                          // <- this licence includes a watermark

            Aspose.Imaging.License license_imaging = null;
            license_imaging = new Aspose.Imaging.License();
            license_imaging.SetLicense(hLicense);

            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(hSource))
            {
                image.Save(hOutputDirectory+"image.png");
            }
            return 0;
        }
    }
}

As stated above, we’re using version 19.12.0.0 of Aspose.Imaging, which was released in 2019, and should therefore be used with our license.

@alexnot, we know such bug, it is related to versions 19.12 - 20.6 and prepared hotfixes for versions 20.3 and 20.6, we attached links to msi files with those hotfixes. Starting from 20.7 this bug is not reproducible. Links to msi files:


Thanks for the information! We will upgrade our Aspose assemblies to a more recent version then.