tools/sdk-net/custom-object-function.md

---
title: Custom Object Function - Sage Intacct SDK for .NET | Sage Intacct Developer
url: https://developer.intacct.com/tools/sdk-net/custom-object-function/
---

# Custom Object Function - Sage Intacct SDK for .NET | Sage Intacct Developer

Overview

Getting Started

List AR Invoices

List Vendors (Legacy)

CRUD Customer

Custom Object Function

Troubleshooting

* Prerequisites
* Set up
* Run the example
* Extra credit
  + Get the record by ID
  + Delete the record
* What’s next?

---

The example shows you how to:

* Create a class that extends `AbstractFunction` and implements `IFunction`.
* Implement the `WriteXml` function to generate XML for the API function for the request.
* Call execute on a client and pass in the API function instance to send the request to the gateway.

---

## Prerequisites

* You have downloaded or cloned the Sage Intacct SDK for .NET examples.
* You successfully ran the getting started example—in particular, you set up the `credentials.ini` file required by `Bootstrap.cs`.
* The company you are using has Platform Services enabled and an object definition for your custom object (the example uses `test_object`).
* The user you are using has add, edit, delete, list, and view permissions for the custom object.

---

## Set up

1. Open `AbstractTestObject.cs` and note how it extends `Intacct.SDK.Functions.AbstractFunction`.

   `AbstractFunction` is a helper class provided mainly to generate random control IDs. `AbstractFunction` implements `Intacct.SDK.Functions.IFunction`, and any class whose instances will be executed by a client must implement `IFunction`. If using `ExecuteBatch`, the parameter must be a `List<IFunction>`.
2. Open `TestObjectCreate.cs` and note how it extends `AbstractTestObject`.

   The `IFunction` interface requires that the class implement the `void WriteXml(ref IaXmlWriter xml)` function. This implementation is where you provide the XML that will be processed at the gateway endpoint.
3. Back in `AbstractTestObject.cs`, replace `test_object` with the integration name for your custom object.

   ```xml
   protected const string IntegrationName = "test_object";
   ```

---

## Run the example

1. Run the project, and enter `5` when prompted.

   For example, the following runs the project from the command line:

   ```xml
   cd Intacct.Examples
   "C:\Program Files\dotnet\dotnet.exe" bin/Debug/netcoreappX.X/Intacct.Examples.dll
   ```
2. Observe the terminal output, which should look similar to this:

   ```xml
   Created record ID 10153
   ```

   Note the record ID, which will be used to delete the object later.
3. Type `6` to exit the program.
4. Open the generated `Intacct.Examples/bin/Debug/netcoreappX.X/logs/intacct.log` file in a text editor and review the entries.

   The file provides info and debug entries. The SDK provides a debug entry for each HTTP request/response (with the Sage Intacct endpoint).

   Note that the log file was created by the logger set in the client config.

---

## Extra credit

### Get the record by ID

1. Update `CustomObjectFunction.cs` to execute a `Read` function using the record ID returned by `TestObjectCreate` as the key. For example:

   ```xml
    using Intacct.SDK.Functions.Common;
   ...
    Read read = new Read()
    {
        ObjectName = "test_object",
            Keys =
            {
                10054
            }
    };
       
    Task<OnlineResponse> readTask = client.Execute(read);
    readTask.Wait();
    OnlineResponse readResponse = readTask.Result;
       
    Result readResult = readResponse.Results[0];
    int recordNo = int.Parse(readResult.Data[0].Element("id").Value);
    Console.WriteLine("Read record ID " + recordNo.ToString());
   ```

### Delete the record

1. Create a `TestObjectDelete` class and execute an instance of it that uses the same record ID returned in the `TestObjectCreate` result.

   If you need help, see the example class.

   ```xml
   using Intacct.SDK.Xml;
      
   namespace Intacct.Examples
   {
       public class TestObjectDelete : AbstractTestObject
       {
           public TestObjectDelete(int recordId)
           {
               this.Id = recordId;
           }
              
           public override void WriteXml(ref IaXmlWriter xml)
           {
               xml.WriteStartElement("function");
               xml.WriteAttribute("controlid", this.ControlId, true);
               xml.WriteStartElement("delete");
                  
               xml.WriteElement("object", IntegrationName);
               xml.WriteElement("keys", this.Id);
      
               xml.WriteEndElement(); // delete
               xml.WriteEndElement(); // function
           }
       }
   }
   ```

---

## What’s next?

For more complex examples, you can use the functions in the SDK as models. For example, `AbstractBill` extends `AbstractFunction`, then `BillCreate` and `BillDelete` extend `AbstractBill` and write the XML for creating or deleting bills.

Provide feedback