---
title: "Create a custom codeunit with expression functions using the Invokable0 to Invokable10 interface"
slug: "create-custom-codeunit-expression-functions-using-invokable0-to-invokable10-inte"
tags: ["BC", "BIS", "Business Central", "Business Integration Solutions", "Task"]
updated: 2026-06-25T09:59:07Z
published: 2026-06-25T09:59:07Z
canonical: "docs.staedean.com/create-custom-codeunit-expression-functions-using-invokable0-to-invokable10-inte"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.staedean.com/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

```plaintext
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:

```plaintext
// 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:

```plaintext
// <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:

```plaintext
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;
}
```

## Related

- [Create a custom codeunit with expression functions using the Namespaced Invokable interface](/bc-create-custom-codeunit-expression-functions-namespaced-invokable-interface.md)
- [Expose functions to the Function interface](/bc-expose-functions-to-the-function-interface.md)