Business Integration Solutions SaaS

How to: Create a Custom Codeunit with Expression Functions using the Invokable0 to Invokable10 interface

Steps

This scenario is based on a single codeunit holding a single Invoke method with a possible number of arguments from zero up to 10. Create your own InvokableN extension based on how many arguments your library needs. The example below shows an enum extension for libraries that need three arguments. Do the same for other invokables if needed.

enumextension 50000 "My Invokable 3 Enum Ext" extends TICInvokable3
{
    value(50000; "My custom invokable 3 library")
    {
        Implementation = TICIInvokeRegistrable = "My custom invokable 3 library", TICIInvokable3 = "My custom invokable 3 library";
    }
}

Your codeunit must implement both interfaces: TICIInvokableN and TICIInvokeRegistrable.

The TICIInvokableN interface gives you access to the Invoke method that each interface has:

// Invokable0 Invoke
procedure Invoke(var return: Variant)

// Invokable1 Invoke
procedure Invoke(var return: Variant; arg1: Variant)

// Invokable2 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant)

// Invokable3 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant)

// Invokable4 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant)

// Invokable5 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant; arg5: Variant)

// Invokable6 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant; arg5: Variant; arg6: Variant)

// Invokable7 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant; arg5: Variant; arg6: Variant; arg7: Variant)

// Invokable8 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant; arg5: Variant; arg6: Variant; arg7: Variant; arg8: Variant)

// Invokable9 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant; arg5: Variant; arg6: Variant; arg7: Variant; arg8: Variant; arg9: Variant)

// Invokable10 Invoke
procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant; arg4: Variant; arg5: Variant; arg6: Variant; arg7: Variant; arg8: Variant; arg9: Variant; arg10: Variant)

The TICIInvokeRegistrable interface exposes the RegisterInvokableMethods method, where you register the functions to make available:

// <Registrar>Library that exposes ways of registering methods and arguments</Registrar>
procedure RegisterInvokableMethods(var Registrar: Codeunit TICInvokableRegistrar);

// <MethodName>The method name to register</MethodName>
// <MethodDescription>The method description to register</MethodDescription>
// <ReturnType>The method return type</ReturnType>
// <Namespace>The enum value linked to the codeunit library to register</Namespace>
procedure RegisterMethod(MethodName: Text[245]; MethodDescription: Text[150]; ReturnType: Enum TICInvokableReturnType; Namespace: Enum TICNSInvokable)

// <ArgName>The argument name to register</ArgName>
// <ArgType>The argument type to register</ArgType>
procedure AddArguments(ArgName: Text[120]; ArgType: Enum TICInvokableParameterType)

// <MethodName>The method name to look up</MethodName>
// <Namespace>The namespace to look up</Namespace>
// The var variables fill with the method metadata based on the method name and namespace
procedure GetMethodMetadata(MethodName: Text[245]; Namespace: Text; var MethodDescription: Text[150]; var ReturnType: Enum TICInvokableReturnType; var ArgumentsList: Codeunit TICInvokableMethodParamColl): Boolean

Example

A full example of an InvokableN library:

codeunit 50000 "My Invokable3 Library" implements TICIInvokeRegistrable, TICIInvokable3
{
  procedure Invoke(var return: Variant; arg1: Variant; arg2: Variant; arg3: Variant)
  var
      ArgInt: Integer;
      ArgDec: Decimal;
  begin
      ArgInt := arg1;
      ArgDec := arg2;
      ArgDec := Round(ArgDec);
      return := Format(arg3) + Format(ArgInt / ArgDec);
  end;

  procedure RegisterInvokableMethods(var Registrar: Codeunit TICInvokableRegistrar)
  var
    ReturnType: Enum TICInvokableReturnType;
    ParameterType: Enum TICInvokableParameterType;
  begin
    Registrar.RegisterMethod('Invoke', 'Invokable 3 method description.', ReturnType::Text);
    Registrar.AddArguments('arg1', ParameterType::Integer);
    Registrar.AddArguments('arg2', ParameterType::Decimal);
    Registrar.AddArguments('arg3', ParameterType::Decimal);
  end;
}