To add UPS worklist support in C#, register a workitem provider with AddStandardWorklistService, configure search limits, and build a DicomWebApplication. Add a subscription provider when clients need notifications, then connect the application to your HTTP host.

The example covers service configuration. Provider implementations and HTTP hosting are application-specific dependencies; the registration code alone does not create a running server.

Getting Started with Aspose.Medical for .NET

Before you begin, prepare:

• The .NET 10 SDK and a C# project targeting net10.0. The Aspose.Medical 26.10.0 NuGet package targets .NET 10.
• An implementation of IDicomWebWorkitemProvider for workitem storage.
• An implementation of IDicomWebSubscriptionProvider if you need subscriptions and notifications.
• An HTTP host or host adapter to expose the configured DICOMweb application.

Install Aspose.Medical for .NET

Run this command in your project directory to install the version used by the release-note example:

dotnet add package Aspose.Medical --version 26.10.0

Alternatively, use Visual Studio’s Package Manager Console:

Install-Package Aspose.Medical -Version 26.10.0

How to Configure a UPS Worklist in C#

The setup has four steps:

1. Create providers
2. Create the builder
3. Register the service
4. Build the application.

Step 1: Create the Workitem and Subscription Providers

The IDicomWebWorkitemProvider supplies workitem persistence. IDicomWebSubscriptionProvider handles subscription records and notification data.

In the sample, the concrete classes are instantiated directly, so ASP.NET Core dependency injection is not required:

IDicomWebWorkitemProvider workitemProvider = new InMemoryWorkflowDatasets();
IDicomWebSubscriptionProvider subscriptionProvider = new InMemoryWorklistSubscriptions();

The in-memory providers are useful for demonstrating the configuration flow, but their data is not persisted across application restarts.

Step 2: Create the DICOMweb Application Builder

Create a DicomWebApplicationBuilder using DicomWebApplication.CreateBuilder(). This builder collects service registrations before the application is constructed.

DicomWebApplicationBuilder builder = DicomWebApplication.CreateBuilder();

Step 3: Register the Standard UPS Worklist Service

Call AddStandardWorklistService() with your providers and a DicomWebStandardServiceOptions instance:

builder.AddStandardWorklistService(
    workitemProvider,
    subscriptionProvider,
    new DicomWebStandardServiceOptions { MaximumSearchResults = 50 });

MaximumSearchResults = 50 caps the number of returned results for a workitem search. Choose a value that fits how your application presents or processes worklists. The setting does not replace efficient candidate retrieval in your provider.

Step 4: Build the DICOMweb Application

Call Build() to produce the configured application:

DicomWebApplication app = builder.Build();

Build() completes service configuration. It does not open a network port or start an HTTP server.

Complete Program.cs Example

The following Program.cs uses concrete provider instances and requires no undefined CreateWorkitemProvider() or CreateSubscriptionProvider() helpers:

using Aspose.Medical.Dicom.Web;
using Aspose.Medical.Dicom.Web.Providers;

// These concrete provider classes are included in this project.
IDicomWebWorkitemProvider workitemProvider = new InMemoryWorkflowDatasets();
IDicomWebSubscriptionProvider subscriptionProvider = new InMemoryWorklistSubscriptions();

DicomWebApplicationBuilder builder = DicomWebApplication.CreateBuilder();
builder.AddStandardWorklistService(
    workitemProvider,
    subscriptionProvider,
    new DicomWebStandardServiceOptions { MaximumSearchResults = 50 });

DicomWebApplication app = builder.Build();
Console.WriteLine("UPS Worklist application configured successfully.");
Console.WriteLine("This example does not start an HTTP server.");

For this example, use a console project with the following configuration in its .csproj file:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <LangVersion>latest</LangVersion>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Aspose.Medical" Version="26.10.0" />
  </ItemGroup>
</Project>

Run and Check the Configuration

From the project directory, restore packages and run the program:

dotnet restore
dotnet run

If the provider classes and required dependencies are present and the application builds successfully, the program prints:

UPS Worklist application configured successfully.
This example does not start an HTTP server.

This confirms that application construction reached the messages after Build(). It does not verify HTTP routing, workitem searches, or subscription delivery.

How UPS Worklist Providers Work

The standard service depends on your provider implementations for persistence and subscriptions.

Workitem Storage

The workitem provider interface exposes operations such as:

Your implementation must keep stored datasets and revision values consistent, especially if multiple requests update workitems concurrently. See standard services and provider contracts for the division of responsibilities between the engine and providers.

Subscriptions and Notifications

The subscription provider interface includes methods such as UpsertAsync, RemoveAsync, SuspendAsync, PublishAsync, and OpenNotificationsAsync. The service uses this provider to manage subscription state and notification events.

Expose the UPS Worklist Through HTTP

The completed DicomWebApplication is hosting-neutral. To make it available to DICOMweb clients, integrate it with a web host that translates incoming HTTP requests into DicomWebRequest objects, invokes ProcessAsync(), and writes responses back to clients.

The following code illustrates only that processing boundary; CreateRequestFromHost() is a placeholder supplied by your hosting integration:

// Your host integration creates the request from incoming HTTP data.
DicomWebRequest request = CreateRequestFromHost();
DicomWebApplicationResult result = await app.ProcessAsync(request);

For further implementation guidance, consult the hosting-neutral integration guide and ASP.NET Core integration guide. HTTP hosting needs additional integration code or an appropriate adapter; it is not provided by the console example.

After the host is configured and started, you can test a search against the workitems resource beneath your chosen service root. For example, if the host listens at http://localhost:5000 and the service root is /dicom-web:

curl -i -H "Accept: application/dicom+json" "http://localhost:5000/dicom-web/workitems?limit=10"

The /workitems search follows the DICOM UPS search transaction. Compare the returned data with workitems stored by your provider. This request is not applicable to the console-only sample unless you add HTTP hosting.

Conclusion

To configure a DICOMweb UPS worklist in C# with Aspose.Medical, implement or obtain the two providers, register them with AddStandardWorklistService(), configure search limits, and call Build(). The in-memory example makes the configuration straightforward without introducing an ASP.NET Core dependency. If clients need HTTP access, add the hosting integration and test the workitems resource separately.

FAQs

What is a DICOMweb UPS worklist?

A UPS worklist exposes Unified Procedure Step workitems through the DICOMweb Worklist Service, also known as UPS-RS, so clients can coordinate procedure tasks.

Which .NET version does this example require?

The Aspose.Medical 26.10.0 NuGet package targets .NET 10. Use a .NET 10 project and SDK for this version.

Are both provider interfaces required?

IDicomWebWorkitemProvider is required. IDicomWebSubscriptionProvider is optional and enables subscription and notification functionality; the example supplies both.

Can I limit UPS worklist search results?

Yes. Set MaximumSearchResults on DicomWebStandardServiceOptions when registering the service. The example limits each search response to 50 results.

Does builder.Build() start an HTTP server?

No. It creates a DicomWebApplication that processes host-translated requests. Your HTTP host owns the listener and application startup.

How do I verify a hosted UPS worklist search?

Send a GET request to the workitems resource beneath your configured service root, request application/dicom+json, and compare the response with known provider data.

Get a Free License and Explore More

Request a temporary Aspose license to evaluate the library without evaluation limitations.

• DICOMweb developer guide
• DicomWebApplication API reference
• Create a DICOM File in C# with Aspose.Medical for .NET