XPageDeveloper.com

Recent updates improve document processing, database maintenance, agent administration, debugging, and standalone runtime diagnostics.

ComputeWithForm

Documents can be computed using a Domino form:

var success = document.ComputeWithForm(
    doDataTypes: false,
    raiseError: false);

Console.WriteLine($"Computed successfully: {success}");

Validation failures can be returned to the application:

var success = document.ComputeWithForm(
    doDataTypes: false,
    raiseError: false,
    out string[] failedFields);

foreach (var field in failedFields)
{
    Console.WriteLine($"Validation failed: {field}");
}

Detailed validation information is also available:

var success = document.ComputeWithForm(
    raiseError: false,
    out NotesComputeWithFormError[] errors);

foreach (var error in errors)
{
    Console.WriteLine(
        $"{error.FieldName}: {error.Message} ({error.ErrorCode})");
}

When raiseError is true, a failed validation raises a NotesException.

Database creation and design maintenance

Databases can be created directly through NotesDatabase:

using var database = session.GetDatabase(
    "",
    "data\\NewDatabase.nsf");

if (database.Create())
{
    Console.WriteLine("Database created.");
}
else
{
    Console.WriteLine("Database already exists.");
}

A database can also be created from a template:

using var template = session.GetDatabase("", "template.ntf");
using var database = template.CreateFromTemplate(
    "",
    "data\\NewApplication.nsf",
    inheritFlag: true);

Design refresh is supported as well:

database.RefreshDesign(
    templateServer: "",
    force: true,
    errorIfTemplateNotFound: true);

Full-text index management

Full-text indexes can be created, updated, and deleted:

database.CreateFTIndex(
    NotesFullTextIndexOptions.Attachments |
    NotesFullTextIndexOptions.StemIndex);

database.UpdateFTIndex();

database.DeleteFTIndex();

Options include attachments, binary attachments, encrypted fields, stemming, case sensitivity, summary-only indexing, optimization, and reindexing.

Local database transactions

Local database transactions can be controlled explicitly:

database.TransactionBegin();

try
{
    using var document = database.CreateDocument();
    document.ReplaceItemValue("Subject", "Transactional update");
    document.Save();

    database.TransactionCommit();
}
catch
{
    database.TransactionRollback();
    throw;
}

Named and profile documents

Named documents can be opened directly:

using var namedDocument =
    database.GetNamedDocument(
        "Configuration",
        session.UserName);

if (namedDocument is not null)
{
    Console.WriteLine($"Named document: {namedDocument.NoteID}");
}

A named document collection can also be retrieved:

using var documents =
    database.GetNamedDocumentCollection(
        "Configuration",
        session.UserName);

Console.WriteLine($"Documents found: {documents.Count}");

Profile document collections are supported through:

using var profiles =
    database.GetProfileDocCollection("ApplicationProfile");

Console.WriteLine($"Profiles found: {profiles.Count}");

Agent administration

Agent scheduling information is available through NotesAgent:

foreach (var agent in database.Agents)
{
    Console.WriteLine(
        $"{agent.Name}: " +
        $"Enabled={agent.IsEnabled}, " +
        $"Scheduled={agent.IsScheduled}");
}

Wrapper-specific convenience features

DotNetToDomino adds higher-level convenience methods that are not directly exposed as equivalent operations in the Domino C API.

For example, all scheduled agents can be retrieved in one call:

foreach (var agent in database.ScheduledAgents())
{
    Console.WriteLine(agent.Name);
}

All enabled agents can also be disabled and saved with one operation:

database.DisableAllAgents();

The mutable Schedule property provides a .NET-friendly representation of an agent schedule, including:

• Interval and interval type
• Start and end times
• Start and end dates
• Weekday settings
• Monthly scheduling
• Weekend handling

After modifying the schedule, save the agent:

var agent = database.GetAgent("Nightly Cleanup");

if (agent is not null)
{
    agent.Schedule.SkipWeekends = true;
    agent.Schedule.Interval = 2;
    agent.Save();
}

Debugger-friendly Notes objects

The wrapper provides debugger-friendly display values for Notes objects. Important values such as database title, file name, file path, session information, views, agents, and note IDs are easier to inspect in Visual Studio.

Closed NotesDatabase objects also avoid unnecessary property evaluation errors by returning safe values such as null, empty strings, or empty collections where appropriate.

Standalone Domino runtime diagnostics

Standalone applications can specify the Domino runtime, notes.ini, and ID password explicitly:

using var session = new NotesSession(
    runtimeDirectory: @"C:\Program Files\HCL\Domino",
    notesIni: @"C:\Program Files\HCL\Domino\Data\notes.ini",
    idPassword: password);

Initialization failures now provide clearer diagnostics for common problems such as:

• Missing or inaccessible notes.ini
• Insufficient access to the Domino data directory
• Incorrect Windows service account
• Domino service-mode conflicts
• x86/x64 architecture mismatches
• Incorrect runtime or data directory

A practical .NET API for Domino

These features make it easier to build .NET applications that:

• Compute and validate documents with Domino forms
• Create and maintain databases
• Manage full-text indexes
• Work with named and profile documents
• Use local transactions
• Inspect and modify agent schedules
• Retrieve all scheduled agents
• Disable enabled agents in bulk
• Diagnose standalone Domino runtime problems

DotNetToDomino combines the capabilities of the Domino C API with .NET-friendly convenience methods for common application and administration tasks.

Integrating modern .NET applications with HCL Notes/Domino has traditionally involved Java libraries, or c/c++ code. DotNetToDomino takes a different approach: it provides a .NET object model on top of the HCL Notes/Domino C API.

The goal is to work with familiar Notes objects from C# while communicating directly with the installed Notes/Domino runtime.

Installation

Install the library from NuGet:

dotnet add package DotNetToDomino --prerelease

DotNetToDomino requires:

• .NET 10
• An installed HCL Notes/Domino runtime 64-bit
• A valid Notes ID for authenticated operations
• Access to notes.ini

The HCL native DLLs are not included in the NuGet package.

Creating a Notes session

using DotNetToDomino;

using var session = new NotesSession(
    @"C:\Program Files\HCL\Notes",
    @"C:\Program Files\HCL\Notes\notes.ini",
    Environment.GetEnvironmentVariable("NOTES_TEST_ID_PASSWORD"));

Console.WriteLine($"User: {session.UserName}");
Console.WriteLine($"Platform: {session.Platform}");
Console.WriteLine($"Notes version: {session.NotesVersion}");

The password should be provided through an environment variable or a secure secrets solution rather than being hard-coded.
For Notes client windows platform new NotesSession() can also be used if the Registry values are correct and the client can be found that way.

Opening a database

A local database can be opened with an empty server name or by using local.

using var database = session.GetDatabase(
    server: "",
    filePath: "example.nsf",
    createOnFail: false);

if (database is null)
{
    Console.WriteLine("The database could not be found.");
    return;
}

Console.WriteLine($"Title: {database.Title}");
Console.WriteLine($"File path: {database.FilePath}");
Console.WriteLine($"Replica ID: {database.ReplicaID}");

A remote Domino database can be opened by specifying the server:

using var database = session.GetDatabase(
    "ACME01",
    "apps/example.nsf",
    createOnFail: false);

Creating a database

using var database = session.GetDatabase("",
"new-example.nsf",createOnFail: true);

if (!database.IsOpen)
{
    database.Create();
}

database.Title = "My new database";
database.Categories = "Integration, .NET";

Database metadata such as the title and categories is written directly.
Document changes must be persisted with document.Save().

Creating and saving a document

using var document = database.CreateDocument();

document.ReplaceItemValue("Form", "Main").recycle()
document.ReplaceItemValue("Subject", "Created from .NET").recycle()
document.ReplaceItemValue("Status", "New").recycle()

document.Save();

ReplaceItemValue returns a Notes item that can be recycled immediately after use.

Reading documents from a view

using var view = database.GetView("All Documents")
    ?? throw new InvalidOperationException("The view does not exist.");

using var document = view.GetFirstDocument();

if (document is not null)
{
    Console.WriteLine(document.GetString("Subject"));
}

Objects implementing IDisposable should be used with using or using var. This ensures that native handles are closed and the corresponding Notes objects are recycled.

DotNetToDomino makes it possible to use Notes/Domino from modern C# without Java, JNA, or JNX dependencies. The library currently provides support for:

• Sessions and databases
• Documents and views
• ACL access
• MIME entities and MIME headers
• Rich text
• Document signing
• Database directory enumeration
• Native lifecycle management through IDisposable and Recycle()

The project is still under development, but the core object model and native interop layer are in place.
Check out the project dedicated page https://xpagedeveloper.com/dot-net-to-domino
The project is published on OpenNTF.org Dot Net For Domino
For any suggestions, questions or bugs submit them thru openntf, if possible add a code sample.

And a special thanks to the authors and contributors of
https://github.com/HCL-TECH-SOFTWARE/domino-jnx
And Karstens JNA Project
https://github.com/klehmann/domino-jna

OpenNTF has done it again they have created an interactive class map of LotusScript like the one we all know from the old days as a poster on our office wall. Now you can buy a big touch screen and mount on you office wall displaying the classes. If you do have one post a comment with an image showing the new poster on your office wall.

you can find the map here https://openntf.org/ls/index.html and the annoncement here OpenNTF reintroduce the Lotusscript class map

Views in HCL Domino can look clean or confusing depending on how you handle categories. A common issue is empty categories that appear for some users and disappear for others. This happens when the view depends on documents the user cannot read.

Domino shows a category only when at least one document in that category is visible. If all documents are restricted by Readers or Authors fields, the category stays hidden.

The problem starts when a response document is readable but the main document is not. The user can open the response through a link or lookup. The user cannot see the main document in the view. The category that the main document belongs to stays hidden. Domino treats the category as empty even if the response document exists. The response document does not create a category on its own.

You will notice this when users report that they see a response but cannot find it in the view. They think the category is missing. The real issue is access control on the main document.

You can reduce this problem with some simple checks.

• Keep Readers fields aligned across main and response documents.
• Avoid workflows where main documents are more restricted than their responses.
• Review the view selection so it includes documents users can read.
• Test with different user roles to see how categories collapse.

If you want to expose response documents even when the main document is hidden. Change so response documents is not displayed in a hierarchy . If you want predictable category behavior, give the parent and response documents the same visibility thru the readers and authors fields.

This keeps your views stable. It keeps users from wondering why a category disappears even when they know a response exists.

Check out this great write up by Serdar Basegmez about how to use Domino IQ with an external LLM provider. And you could follow the same guide with any other provider, because almost everybody is using the same API syntax as OpenAI.

https://lotusnotus.com/2025/07/connecting-domino-iq-external-llm-providers

If you are getting this error when adding a SAML or Multi server SSO configuration
HTTP Server: Error loading Web SSO Cookie Names Configuration ‘LtpaToken’ for Web Site ‘xxxx)’ (Single Sign-On configuration is invalid)

There is an technote article about this, but I don’t know if that help so much. Check if the server is added to participating server field in the LTPAToken document, because otherwise will not the server be able to see the document.
For other SAML problems check out my SAML article Debugging SAML setups in HCL Domino

With the ENABLE_SNI=1 notes.ini parameter you can have multiple host names and they can use https with with and without Let’s Encrypt certs. but the good thing is that this is also supported using SAML.

This means that if you company have multiple tenants in Office 365 or if you are using Okta you can add them and use SAML as login thru two different hostnames.

This isn’t a new thing probably worked since the parameter was introduced in Domino 11 only that I haven’t tested this until now 🙂

Once again does Domino simplify admin work in a complex it environment.

Check out my summary post about SAML in Domino if you haven’t