Lizenzierungsimplementierung

Dieser Dokumentationsabschnitt führt Sie durch die Einbettung der Lizenzierungs-SDK-Bibliothek in Ihr Aktivitätspaket.

Führen Sie die nächsten Schritte aus, je nachdem, ob Ihr Paket mit oder ohne UiPath Activity Creator entwickelt wurde:

• wurde mit dem UiPath Activity Creator entwickelt

• Das Paket wurde nicht mit dem UiPath Activity Creator entwickelt

Wichtig: Ihre VS-Lösung muss mit .Net 4.6.1 kompatibel sein.

Hinweis:

Die Last der Lizenzierungsimplementierung für .NET 6- oder Windows-kompatible benutzerdefinierte Aktivitäten liegt beim Anbieter. UiPath Marketplace bietet keine .NET6-kompatible Lizenzierungsbibliothek. Es bietet eine mit Windows-Legacy kompatible Lizenzierungsbibliothek.

Falls Ihr Paket mit dem UiPath Activity Creator entwickelt wurde

1. Fügen Sie in der ExecuteAsync- Methode jeder Ihrer Aktivitäten die Validierungsprüfung hinzu, es sei denn, Sie haben ein Scope-Aktivitätsszenario.

   Wenn Sie ein Scope-Aktivitätsszenario haben, können Sie die Validierungsprüfung nur zu dieser Aktivität hinzufügen, wenn alle Ihre Aktivitäten der Lizenzierung unterliegen.

   protected override async Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
           {
               // Inputs
               var firstNumber = FirstNumber.Get(context);
               var secondNumber = SecondNumber.Get(context);
               // License validation
               #if !DEBUG
                   //if your package is MyCompany.MyPackageName.Activities.1.0.0.nupkg
                   await Validator.ValidateAsync(context, "MyCompany.MyPackageName.Activities");
               #endif
               ///////////////////////////
               // Add execution logic HERE
               ///////////////////////////
               // Outputs
               return (ctx) => {
               };
           }

   Hinweis:

   • Das Kontextobjekt kann nur einmal übergeben werden und nur in der Methode verwendet werden, an die es übergeben wurde. Beispielsweise kann sie nach dem Validator.ValidateAsync -Aufruf nicht mehr in der ExecuteAsync- Methode verwendet werden.
   • Angesichts der obigen Anforderung bedeutet dies auch, dass die Eingabevariablen gelesen werden müssen, bevor der Kontext an die Lizenzierungsmethode/Bibliothek übergeben wird.

2. Verweisen Sie in Ihrem .Activities- Projekt auf die Licensing.dll -Bibliothek und fügen Sie die using -Anweisung hinzu:

   
   

   

   
   

   using UiPath.Marketplace.License.Validations;

3. Das Setup ist abgeschlossen. Erstellen Sie Ihr Paket und stellen Sie sicher, dass die Licensing.dll -Bibliothek im Paketinhalt (im Ordner lib ) vorhanden ist. Anschließend können Sie es auf UiPath Marketplace einreichen.

Falls Ihr Paket nicht mit dem UiPath Activity Creator entwickelt wurde

Ihre anfängliche Aktivität sieht folgendermaßen aus:

using System;
using System.Activities;
using System.ComponentModel;
    namespace ClassMathCustomActivity
{
    public class SimpleFormula : CodeActivity
    {
        [Category("Input")]
        [RequiredArgument]
        public InArgument<double> FirstNumber { get; set; }
        [Category("Input")]
        public InArgument<double> SecondNumber { get; set; }
        [Category("Output")]
        public OutArgument<double> ResultNumber { get; set; }
        protected override void Execute(CodeActivityContext context)
        {
            var firstNumber = FirstNumber.Get(context);
            var secondNumber = SecondNumber.Get(context);
            var result = System.Math.Pow(firstNumber + secondNumber, 2);
            ResultNumber.Set(context, result);
        }
    }
}

Die wichtigste Änderung, die Sie vornehmen müssen, betrifft die Ausführungsmethode, die ein ExecuteAsync sein muss.

Die vorgeschlagene Lösung besteht darin, die Klasse AsyncTaskCodeActivity.cs zu erstellen, die folgendermaßen aussehen sollte:

using System;
using System.Activities;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
namespace ClassMathCustomActivity
{
  internal struct AsyncTaskCodeActivityImplementation : IDisposable
  {
    private CancellationTokenSource _cancellationTokenSource;
    private bool _tokenDisposed;
    public void Cancel()
    {
      if (!_tokenDisposed)
      {
        _cancellationTokenSource?.Cancel();
        _cancellationTokenSource?.Dispose();
        _tokenDisposed = true;
      }
    }
    public IAsyncResult BeginExecute(AsyncCodeActivityContext context
      , Func<AsyncCodeActivityContext, CancellationToken, Task<Action<AsyncCodeActivityContext>>> onExecute
      , AsyncCallback callback, object state)
    {
      if (!_tokenDisposed)
      {
        _cancellationTokenSource?.Dispose();
      }
      _cancellationTokenSource = new CancellationTokenSource();
      _tokenDisposed = false;
      TaskCompletionSource<Action<AsyncCodeActivityContext>> taskCompletionSource = new TaskCompletionSource<Action<AsyncCodeActivityContext>>(state);
      Task<Action<AsyncCodeActivityContext>> task = onExecute(context, _cancellationTokenSource.Token);
      var cancellationTokenSource = _cancellationTokenSource;
      task.ContinueWith(t =>
      {
        if (t.IsFaulted)
        {
          taskCompletionSource.TrySetException(t.Exception.InnerException);
        }
        else if (t.IsCanceled || cancellationTokenSource.IsCancellationRequested)
        {
          taskCompletionSource.TrySetCanceled();
        }
        else
        {
          taskCompletionSource.TrySetResult(t.Result);
        }
        callback?.Invoke(taskCompletionSource.Task);
      });
      return taskCompletionSource.Task;
    }
    public void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
      Task<Action<AsyncCodeActivityContext>> task = (Task<Action<AsyncCodeActivityContext>>)result;
      if (task.IsFaulted)
      {
        ExceptionDispatchInfo.Capture(task.Exception.InnerException).Throw();
      }
      if (task.IsCanceled)
      {
        context.MarkCanceled();
      }
      task.Result?.Invoke(context);
      if (!_tokenDisposed)
      {
        _cancellationTokenSource?.Dispose();
        _tokenDisposed = true;
      }
    }
    private bool _disposed; // To detect redundant calls
    public void Dispose()
    {
      if (!_disposed)
      {
        if (!_tokenDisposed)
        {
          if (_cancellationTokenSource != null)
            _cancellationTokenSource.Dispose();
          _tokenDisposed = true;
        }
        _disposed = true;
      }
    }
  }
  public abstract class AsyncTaskCodeActivity : AsyncCodeActivity, IDisposable
  {
    private AsyncTaskCodeActivityImplementation _impl = new AsyncTaskCodeActivityImplementation();
    protected override void Cancel(AsyncCodeActivityContext context)
    {
      _impl.Cancel();
      base.Cancel(context);
    }
    protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
    {
      return _impl.BeginExecute(context, ExecuteAsync, callback, state);
    }
    protected override void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
      _impl.EndExecute(context, result);
    }
    protected abstract Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);
    #region IDisposable Support
    private bool _disposed = false; // To detect redundant calls
    protected virtual void Dispose(bool disposing)
    {
      if (!_disposed)
      {
        if (disposing)
        {
        }
        _impl.Dispose(); //structs are not garbage collected so they fit in the unmanaged bucket
        _disposed = true;
      }
    }
    public void Dispose()
    {
      // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
      Dispose(true);
      GC.SuppressFinalize(this);
    }
    #endregion
  }
  public abstract class AsyncTaskCodeActivity<T> : AsyncCodeActivity<T>, IDisposable
  {
    private AsyncTaskCodeActivityImplementation _impl = new AsyncTaskCodeActivityImplementation();
    protected override void Cancel(AsyncCodeActivityContext context)
    {
      _impl.Cancel();
      base.Cancel(context);
    }
    protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
    {
      return _impl.BeginExecute(context, ExecuteAsync, callback, state);
    }
    protected override T EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
      _impl.EndExecute(context, result);
      return Result.Get(context);
    }
    protected abstract Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);
    #region IDisposable Support
    private bool _disposed = false; // To detect redundant calls
    protected virtual void Dispose(bool disposing)
    {
      if (!_disposed)
      {
        if (disposing)
        {
        }
        _impl.Dispose(); //structs are not garbage collected so they fit in the unmanaged bucket
        _disposed = true;
      }
    }
    public void Dispose()
    {
      // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
      Dispose(true);
      GC.SuppressFinalize(this);
    }
    #endregion
  }
}

Die geänderte Aktivität sieht folgendermaßen aus:

using System;
using System.Threading.Tasks;
using UiPath.Marketplace.License.Validations;
using System.ComponentModel;
using System.Activities;
using System.Threading;
namespace ClassMathCustomActivity
{
  public class SimpleFormula : AsyncTaskCodeActivity
  {
    [Category("Input")]
    [RequiredArgument]
    public InArgument<double> FirstNumber { get; set; }
    [Category("Input")]
    public InArgument<double> SecondNumber { get; set; }
    [Category("Output")]
    public OutArgument<double> ResultNumber { get; set; }
    protected override async Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
    {
      var firstNumber = FirstNumber.Get(context);
      var secondNumber = SecondNumber.Get(context);
      // check for license after reading input arguments
      #if !DEBUG
                //if your package is MyCompany.MyPackageName.Activities.1.0.0.nupkg
                await Validator.ValidateAsync(context, "MyCompany.MyPackageName.Activities");
      #endif
      return (ctx) =>
      {
        var result = System.Math.Pow(firstNumber + secondNumber, 2);
        ResultNumber.Set(ctx, result);
      };
    }
  }
}

Hinweis:

Es ist wichtig, dass Zeile 24 direkt nach dem Lesen aller Eingabeargumente ausgeführt wird. Im obigen Beispiel werden die Zeilen 20 und 21 zum Lesen der Eingabeargumente und die Zeilen 26 bis 30 zum Festlegen des Ausgabearguments verwendet.

Eine letzte Sache: Beim Erstellen Ihrer .nupkg stellen Sie sicher, dass die Bibliothek Licensing.dll im Paketinhalt (im Ordner lib ) vorhanden ist.

Häufige Fragen

Was passiert, nachdem Sie diese Änderungen implementiert haben?

Nachdem Sie die Änderungen implementiert und die NUPKG-Datei erstellt haben, müssen Sie es zur Veröffentlichung bei UiPath Marketplace einreichen.

Kann ich die Lizenzdatei zu Testzwecken erhalten?

Nein, um die Aktivitäten zu testen, können Sie die C#-Präprozessoranweisung für das Debuggen verwenden (#if !DEBUG).

Wie erhalten Kunden die Lizenzdatei?

Nachdem jemand etwas gekauft hat, wurde eine .lic- generiert und für sie auf dem UiPath-Marktplatz zur Verfügung gestellt. Er kann die Datei herunterladen und dann die erforderlichen Schritte für die Verwendung der Aktivitäten ausführen.