Wireloom.Dds.Generator 1.0.0

There is a newer version of this package available.
See the version list below for details.
dotnet add package Wireloom.Dds.Generator --version 1.0.0
                    
NuGet\Install-Package Wireloom.Dds.Generator -Version 1.0.0
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Wireloom.Dds.Generator" Version="1.0.0" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="Wireloom.Dds.Generator" Version="1.0.0" />
                    
Directory.Packages.props
<PackageReference Include="Wireloom.Dds.Generator" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add Wireloom.Dds.Generator --version 1.0.0
                    
#r "nuget: Wireloom.Dds.Generator, 1.0.0"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package Wireloom.Dds.Generator@1.0.0
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=Wireloom.Dds.Generator&version=1.0.0
                    
Install as a Cake Addin
#tool nuget:?package=Wireloom.Dds.Generator&version=1.0.0
                    
Install as a Cake Tool

Wireloom.Dds.Generator

Wireloom.Dds.Generator is a Roslyn source generator and MSBuild integration for generating C# types from the RTI Connext DDS IDL subset. Add it to a .NET project that owns DDS data contracts; the package generates source during the normal build and does not invoke Java, native tooling, or rtiddsgen.

Consumer projects can target .NET 8 and higher using C# 12 or later. Support is feature-specific and evidence-driven; successful compilation of one IDL shape is not a blanket claim of RTI or wire compatibility.

Quick start

Create a .NET console project and add the generator, the RTI runtime, and an IDL root to its project file:

dotnet new console --name WireloomQuickStart --framework net10.0
cd WireloomQuickStart

Replace WireloomQuickStart.csproj with:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Rti.ConnextDds" Version="7.7.0" />
    <PackageReference Include="Wireloom.Dds.Generator" Version="1.0.0" PrivateAssets="all" />
    <DdsIdl Include="Telemetry.idl" />
  </ItemGroup>
</Project>

Create Telemetry.idl beside the project file:

module Telemetry {
  struct Sample {
    long id;
    string<64> label;
  };
};

Build the project to generate and compile Telemetry.Sample:

dotnet build

After editing a root or included IDL file, build the project to regenerate its C# contracts. In VS Code, use Ctrl+Shift+B with a build task; IntelliSense may show the previous generated types until you build. If it stays stale, run CSharp: Rerun Source Generators from the Command Palette. See the developer workflow for build-task setup.

The generator runs during the normal build; there is no separate code generation command. To run communicating publisher and subscriber processes, follow the Hello World guide, which also covers RTI runtime and license prerequisites.

The example above uses a .NET 10 target and the latest C# version. Current package integration evidence builds that target using the repository-pinned .NET 10 SDK; the Roslyn hosts in older SDKs are not all qualified. Exact RTI 7.3.1 and 7.7.0 have qualification evidence for documented cases; the minimum-host check uses SDK 8.0.100. See the support policy for scope.

For a project replacing existing RTI-generated C#, follow the migration guide. It maps common rtiddsgen options, identifies known API differences, and gives a validation and rollback procedure.

Repository links below describe current source. For the package you installed, use its exact-version qualification record; later source tests do not retroactively qualify an older release.

From 1.0.0, the 1.x compatibility contract protects supported generated APIs, configuration, behavior, defaults, and consumer minimums. Patch releases correct defects without adding features; corrections to faulty output may require regeneration and coordinated peer upgrades. Review the installed version's release notes before upgrading.

Find your task

Install

Add the generator and the RTI runtime explicitly. The generator package does not add Rti.ConnextDds transitively because the application owns its runtime version and configuration.

Running the DDS application also requires the RTI runtime's native assets and a valid license for the NuGet.org distribution. Follow RTI's license setup and the Hello World prerequisites.

<ItemGroup>
  <PackageReference Include="Rti.ConnextDds" Version="7.7.0" />
  <PackageReference Include="Wireloom.Dds.Generator" Version="1.0.0" PrivateAssets="all" />
</ItemGroup>

The generator selects its API profile from the resolved Rti.ConnextDds assembly. Versions 7.3.1 through versions below 7.7.0 select the 7.3.1 profile; 7.7.0 and later select the 7.7.0 profile. Missing references and versions below 7.3.1 produce DDSG0003. Only exact 7.3.1 and 7.7.0 LTS versions are qualification targets; intermediate and later versions are mapped but not individually qualified. The consumer project must resolve the RTI version whose API and generated contracts it intends to use.

The 7.7.0 profile is selected automatically for a 7.7.0 reference. There is no public profile override because selecting older API code while compiling against a newer RTI package can produce incorrect contracts. Rebuild and review generated code when changing between profiles. See the support and compatibility guide.

The generator itself targets netstandard2.0 for Roslyn host compatibility. The repository's .NET 10 build and test defaults do not impose a .NET 10 requirement on consumer applications.

Declare an IDL generation root

Declare each file that starts generation with a DdsIdl item:

<ItemGroup>
  <DdsIdl Include="Contracts\Telemetry.idl" />
</ItemGroup>

The IDL root can include other files. Included files are tracked inputs and are not independently generated as roots.

module Telemetry {
  struct Sample {
    long id;
    string<64> label;
    sequence<float, 8> values;
  };
};

The generated API follows the IDL module structure. For the example above, the consumer can use the generated Telemetry.Sample data type and, when the selected feature shape has type support, Telemetry.SampleSupport:

var sample = new Telemetry.Sample
{
    id = 42,
    label = "temperature"
};

sample.values.Add(20.5F);
sample.values.Add(21.0F);

var typeSupport = Telemetry.SampleSupport.Instance;

For ordinary typed DDS code, use the generated data type with RTI's normal participant, topic, and writer APIs:

using Rti.Dds.Domain;
using Rti.Dds.Topics;

using var participant = DomainParticipantFactory.Instance.CreateParticipant(domainId: 0);
using var topic = participant.CreateTopic<Telemetry.Sample>("Telemetry");
using var writer = participant.ImplicitPublisher.CreateDataWriter(topic);

var sample = new Telemetry.Sample { id = 42, label = "temperature" };
sample.values.Add(20.5F);
writer.Write(sample);

RTI's typed topic API locates the generated type support for Telemetry.Sample. Use Telemetry.SampleSupport.Instance directly when application code needs its utilities, such as DynamicType, a serializer, or formatted output. The support instance does not create a topic or publish data. This example shows the API handoff; it still requires the RTI runtime, its deployment/licensing prerequisites, matching topic/type/QoS on a peer, and a running DDS domain. See RTI's C# publication examples for the broader publish/subscribe lifecycle.

Generated types include the managed data contract and the RTI-specific support surface where the IDL shape is supported: native companions, type support, interpreted plugins, and DynamicType metadata.

Share generated contracts

For types used by several applications, put the DdsIdl roots in one class library and reference that library from each application. The library's build compiles generated C# into its assembly; consumers of the compiled library do not need the generator package unless they also declare their own IDL roots.


<ItemGroup>
  <PackageReference Include="Rti.ConnextDds" Version="7.7.0" />
  <PackageReference Include="Wireloom.Dds.Generator" Version="1.0.0" PrivateAssets="all" />
</ItemGroup>

<ItemGroup>
  <DdsIdl Include="Contracts\Telemetry.idl" />
</ItemGroup>

<ItemGroup>
  <PackageReference Include="Company.Contracts" Version="1.0.0" />
  
  <PackageReference Include="Rti.ConnextDds" Version="7.7.0" />
</ItemGroup>

The normal Rti.ConnextDds reference in the contracts project is a package dependency when that project is packed. Applications can rely on that dependency or reference the runtime explicitly to control resolution. The generator reference uses PrivateAssets="all", so the contracts package does not configure source generation for downstream projects. Generated .g.cs documents are build intermediates; the compiled contracts assembly is the shareable artifact. Check the contracts package's target frameworks against the application before publishing it.

Common IDL-to-C# mappings

These examples show the public C# API generated by Wireloom and compare it with the retained RTI Connext 7.7.0 C# oracle. The comparison is about generated source shape. Wireloom emits the C# contracts and adapters; RTI supplies the sequence types and DDS runtime. See RTI documentation for behavior owned by its runtime. The effective-limits section describes how bounds relate to mutation and DDS processing.

IDL declaration Wireloom C# API and use RTI C# comparison Evidence
long id; int id { get; set; }<br>Assign with sample.id = 42;. Same member type and accessors. RTI · generated
typedef sequence<long, 4> BoundedLongs; ISequence<int> Value with [Bound(4)].<br>Use var bounded = new BoundedLongs(); bounded.Value.Add(17);. Same generated public shape. RTI · generated
@optional sequence<long, 4> values;<br>@optional long items[2]; ISequence<int>? values; int[]? items.<br>Set items = [1, 2]; set values = new Sequence<int> { 17 } or null for absence. Optional metadata matches. Wireloom adds nullable C# annotations absent from the retained RTI source. RTI · generated
typedef long Scalar;<br>typedef sequence<Scalar> Scalars; ISequence<int> Value; scalar aliases erase in collection elements. Same element mapping as the retained RTI C# output. RTI · generated · C136
union Choice switch(Kind) { case Number: long number; ... }; int number; assigning selects the branch. Reading an inactive branch throws InvalidOperationException. Same generated branch API and guard. RTI · generated · runtime test

This is a quick reference, not a complete mapping catalog. Consult the feature coverage matrix for case-level status and evidence. A difference in generated C# shape does not by itself establish a difference in DDS wire behavior. The runtime contract coverage matrix indexes tested copy, ownership, optional-presence, union, and native-round-trip behavior.

Configure includes and preprocessing

Use project settings and DdsIdl metadata in the project owning the contracts:

<PropertyGroup>
  <DdsIdlIncludeDirectories>$(MSBuildProjectDirectory)/Contracts/Shared</DdsIdlIncludeDirectories>
</PropertyGroup>
<ItemGroup>
  <DdsIdl Include="Contracts/Telemetry.idl" Defines="PRODUCT=Widget" />
</ItemGroup>

Defines, undefines, include directories, and strict validation aggregate across all generating roots. They are not isolated per-root environments. Overrides for mapping, sizes, and unbounded support belong to declarations in each input file. A root's file overrides do not flow into its includes. Use the configuration reference for the complete settings, defaults, precedence, strictness, and identifier rules.

Multiple roots and shared IDL

Use multiple roots when one project owns several types that include shared declarations. For example:

Contracts/
  Telemetry.idl
  Commands.idl
  Shared/
    Common.idl
// Shared/Common.idl
#ifndef WIRELOOM_SHARED_COMMON_IDL
#define WIRELOOM_SHARED_COMMON_IDL
module Shared {
  struct Identity { long id; };
};
#endif
// Telemetry.idl
#include <Common.idl>
module Telemetry { struct Sample { Shared::Identity source; long value; }; };
// Commands.idl
#include <Common.idl>
module Commands { struct Request { Shared::Identity source; long action; }; };

Configure the include directory and declare only the two roots:

<PropertyGroup>
  <DdsIdlIncludeDirectories>$(MSBuildProjectDirectory)\Contracts\Shared</DdsIdlIncludeDirectories>
</PropertyGroup>

<ItemGroup>
  <DdsIdl Include="Contracts\Telemetry.idl" />
  <DdsIdl Include="Contracts\Commands.idl" />
</ItemGroup>

The shared file is a tracked input and contributes Shared.Identity to the same generated assembly. Identical shared include output is emitted once for that project. For types used by several application projects, put the roots in one contracts project and reference its assembly from each application. If separate projects independently generate a shared type, each assembly owns a copy with that type's fully qualified name; avoid referencing both copies from the same consumer. Macro-selected variants require separate builds because root metadata is batch-wide.

Choose the array-of-sequences mapping

The default RtiCSharp mapping flattens a direct array of sequences and reports DDSG0105. Select Idl to preserve the fixed array and each independently sized sequence:

<PropertyGroup>
  <DdsIdlSequenceArrayMapping>Idl</DdsIdlSequenceArrayMapping>
</PropertyGroup>

For struct Sample { sequence<long, 4> values[2]; };, the IDL-preserving API uses sample.values[0].Value.Add(10). Selecting this mapping changes the C# API and wire schema; it differs from flattened RTI C# direct-form bindings. File metadata can override the project setting for declarations in that file. See configuration and compatibility effects and focused wire evidence.

Recursive type support

Direct self-recursive sequence members have scoped typed Wireloom C# / RTI C++ exchange evidence under a TypeObject v1 participant setup. Recursive sequence typedefs are rejected and mutual recursive graphs remain unqualified. See the profile limitations and fixture setup before relying on recursive contracts.

Inspect generated source

Roslyn exposes generated documents through the IDE. To also write physical generated files under obj, use the standard compiler options:

<PropertyGroup>
  <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
  <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)generated</CompilerGeneratedFilesOutputPath>
</PropertyGroup>

The package does not create a separate command-line output directory or run a pre-generation step.

Preprocessor limits

Preprocessing enforces deterministic per-input output, work, and nesting limits. Exceeding one fails generation with a source-located error. See the limits reference and feature matrix for values, scope, and supported constructs.

Annotation reference

This is a reference to behaviors implemented and exercised by the current corpus, not a claim that every OMG or RTI annotation is supported. Annotation effects often appear in RTI DynamicType metadata rather than in the managed C# member signature.

Annotation or group Current behavior and scope Evidence
@topic Marks a struct as a DDS topic data type in generated documentation. It does not create a topic or publish samples. 10-annotations.idl
@key Marks a member as a DDS instance key and is reflected in type support metadata. Key identity is distinct from equality of complete C# samples. 08-keys.idl, 10-annotations.idl
@optional Marks optional members in type support and produces nullable C# members for supported optional shapes. An optional union branch is ignored because a union always selects one branch. 09-optional-collections.idl, 09-optional-aggregate-member.idl
@id, @hashid, @autoid(HASH) Set explicit or hash-derived DDS member IDs in supported aggregate contexts. Other @autoid mappings are not separately qualified here. 09-id-gaps.idl, 09-autoid-hash.idl
@final, @appendable, @mutable Set the corresponding extensibility kind in generated DynamicType metadata for covered declarations. 09-extensibility.idl
@default, @min, @max, @range, @unit Supported on primitive/enum members as applicable. Defaults initialize supported values; ranges and units are represented in generated type support annotations. Ranges require primitive members; defaults also support enums. 09-defaults-ranges.idl, 10-annotations-rti.idl
@value, @default_literal Set explicit enum numeric values and the default enum literal for covered enum shapes. 03-enum-values-prefix.idl, 09-defaults-ranges.idl
@must_understand Preserved as a member property in generated DynamicType metadata with the 7.7.0 profile. The 7.3.1 profile reports DDSG0004 and emits no code because that RTI release does not support the annotation. 09-autoid-hash.idl
@external Accepted in the tested annotation case but does not create a distinct managed C# member shape. Check runtime/wire evidence before relying on any external-member serialization effect. 10-annotations-rti.idl
@language_binding, @transfer_mode, @data_representation, @allowed_data_representation, @nested, @default_nested, @resolve_name Recognized/consumed syntax, but not all have an effect in emitted C# or generated DynamicType. The corpus comparisons establish only the listed case outcomes; do not rely on these annotations to configure wire representation or naming without separate runtime/wire evidence. FLAT_DATA is ignored for C# generation. 10-annotations-rti.idl, 09-data-representation.idl, 09-allowed-data-representation.idl, 10-flat-data-binding.idl
Unknown annotation Emits warning DDSG0101 and continues while ignoring the annotation. Verify that ignoring it does not change the contract you need. 12-unknown-annotation.idl
@position, @bit_bound; invalid @service target Recognized but unsupported uses emit DDSG0102 and reject generation. A @service("DDS") interface is instead ignored with DDSG0103; interfaces do not become C# types. 10-unsupported-annotations.idl, 10-service-annotation.idl

For enum arrays, @default_literal initializes generated managed and native array elements from the declared enum member. See the 10-default-literal-enum-array corpus case.

Unresolved names used as array, sequence, string, or wstring bounds are rejected before C# emission. The C143–C146 corpus cases record the diagnostics and RTI profile outcomes.

An annotation accepted by RTI is not automatically implemented by Wireloom. For a declaration not listed here, check the exact corpus case and diagnostic; use an unknown-annotation warning as a prompt to verify the generated contract, not as evidence that the annotation is harmless.

Diagnostics

ID Meaning Typical action
DDSG0001 IDL generation failed Fix the source-located parse, include, semantic, or unsupported-feature error
DDSG0002 C# 12 or later is required Set the consumer's language version to C# 12 or later
DDSG0003 A compatible RTI runtime was not found Add an explicit Rti.ConnextDds reference at version 7.3.1 or later
DDSG0004 An IDL feature is unavailable in the selected RTI API profile Remove the unsupported feature or use a compatible RTI version; @must_understand requires 7.7.0 or later
DDSG0101 An unknown IDL annotation was ignored Verify the annotation is supported by the managed generator if it affects the generated contract
DDSG0102 A recognized but unsupported annotation use was reported Remove the annotation or use a supported declaration context; this warning accompanies rejected generation
DDSG0103 An IDL interface was ignored because no C# interface type is emitted Names are checked before bindings are omitted; ordinary and DDS-service body rules differ
DDSG0104 A function-like macro was invoked with the wrong number of arguments Correct the macro invocation; RTI-compatible expansion continues after the warning
DDSG0105 A direct array of sequences may not preserve IDL semantics Use a sequence typedef or opt into SequenceArrayMapping="Idl"
DDSG0106 An active #warning directive was encountered Review the warning in the IDL or included file; preprocessing and generation continue
DDSG0107 An active #pragma message directive was encountered Review the informational message in the IDL or included file; generation continues
DDSG0108 An IDL name conflicts with a keyword or another name ignoring case Rename the identifier or exempt the default warning; strict validation rejects the declaration
DDSG0109 An escaped identifier normalizes to TRUE or FALSE Rename it to avoid ambiguity with IDL boolean literals; Wireloom still resolves it as an identifier

Diagnostics are owned by the generator and use the original IDL/include location where one is available. Review the table's typical actions before adoption; ignored annotations or interfaces and mappings flagged as potentially lossy can affect the generated contract. Configure an individual diagnostic's severity through the consumer's .editorconfig, for example:

[*.idl]
dotnet_diagnostic.DDSG0101.severity = error

The default severities are grouped by diagnostic family: DDSG0001–DDSG0004 are errors, DDSG0101–DDSG0106 and DDSG0108–DDSG0109 are warnings, and DDSG0107 is informational. Warnings do not all mean generation continues: DDSG0102 reports an unsupported annotation use and is followed by a generation error. DDSG0101, DDSG0103, DDSG0104, DDSG0105, DDSG0106, DDSG0108, and DDSG0109 report cases where generation continues in default mode. The diagnostics table describes the action for each one.

Diagnostics point to the originating IDL file, including when the problem is inside an included file. For example, if Contracts/Telemetry.idl contains:

#include "shared/Shared.idl"

and Contracts/shared/Shared.idl contains:

struct Shared {
  long values[0];
};

the DDSG0001 error reports that Array dimensions must be a positive Int32, at the array bound in Shared.idl. If the same declaration is placed directly in Telemetry.idl, the error points to the root file instead. Start from the reported path and line, correct the bound, and rebuild; the build fails while a generation error remains.

Supported boundary

The current corpus exercises modules, structs, nested declarations, aliases, enums, unions, constants, primitive values, narrow and wide strings, bounded strings, sequences, arrays, include graphs, conditional preprocessing, keys, annotations, and extensibility. Several of these are supported only for the specific shapes covered by the retained RTI oracle evidence.

Before adopting a feature, consult the diagnostics table, feature coverage matrix, and corpus rules.

Effective limits for unbounded values

With unbounded support disabled (the default), Wireloom assigns finite limits to unbounded IDL values: 255 UTF-8 bytes for narrow strings, 255 UTF-16 code units for wide strings, and 100 elements for sequences. Set project properties DdsIdlSequenceSize and DdsIdlStringSize to change those defaults. SequenceSize and StringSize metadata on a DdsIdl or AdditionalFiles item override the project values for declarations in that file. All settings must be positive Int32 values; explicit IDL bounds take precedence. See the configuration reference for examples and scope details. For example, 128 copies of é use 256 UTF-8 bytes, so they exceed the narrow-string limit even though the C# string contains only 128 characters.

Generated string properties do not enforce their bounds when assigned, and sequence members expose mutable containers whose Add operations do not cap the element count. RTI uses the bound in type metadata when processing DDS data. The runtime contract suite verifies native round trips at the effective limits. It does not establish exactly where or how an over-limit value fails, so consumers should validate values before DDS processing rather than rely on assignment-time checks.

To retain RTI's unbounded metadata and native conversion behavior, enable DdsIdlUnboundedSupport for the project or set UnboundedSupport="true" on the relevant DdsIdl or AdditionalFiles item. The file option controls the declarations originating in that file, including when it is included by a root. Explicit IDL bounds remain finite. In this mode the configured sequence and string sizes remain validated but are ignored for unbounded declarations. Native sequences and strings start with zero capacity and grow to hold the sample. Qualification covers the documented payloads, QoS, and resource limits; it does not establish unrestricted sample-size support. See the configuration reference and the support policy.

The compatibility corpus compares source-generation behavior and generated C# shape. It does not automatically prove serialization-byte equivalence, live DDS behavior, or C++ interoperability.

What this package does not do

  • It does not provide the RTI DDS runtime, transport, or serialization engine.
  • It does not invoke or forward arbitrary arguments to rtiddsgen.
  • It does not implicitly generate every .idl file in a project; roots are explicit DdsIdl items.
  • It does not promise complete Connext IDL coverage or universal drop-in compatibility with RTI-generated C#.
  • It does not silently omit unsupported declarations; accepted exceptions that ignore annotations or interfaces are reported with diagnostics.

Troubleshooting

When generation appears not to run, start with a clean command-line build and follow the symptom table. IDE behavior can depend on its Roslyn host; current package integration evidence covers command-line builds, not every IDE/SDK combination.

Symptom Check and next step
Build succeeds but no generated types appear Confirm the project references Wireloom.Dds.Generator and declares the intended roots as DdsIdl items. Other .idl files are tracked includes, not roots.
Generator package is present but has no effect Restore the project, inspect the resolved package version and analyzer/build assets, then run dotnet build from the project directory. If the build reports an analyzer load or Roslyn assembly error, verify the SDK/compiler host; older SDK hosts are not all qualified.
DDSG0002 Set <LangVersion>12.0</LangVersion> or later. This diagnostic is reported when the generator loads and the compiler language version is too old.
DDSG0003 Add an explicit Rti.ConnextDds reference at a version accepted by the guard; the generator package does not add the runtime transitively.
DDSG0001 Read the diagnostic text and source location. Check IDL syntax, include resolution, semantic rules, and feature coverage. This is also the generation-failure diagnostic for preprocessing limits.
Generated documents are absent in the IDE First confirm the command-line build succeeds. Roslyn generated documents appear in the IDE; to inspect files on disk, enable EmitCompilerGeneratedFiles and set CompilerGeneratedFilesOutputPath as described in Inspect generated source.
Build works but the IDE shows stale generated code In VS Code, build with Ctrl+Shift+B, then run CSharp: Rerun Source Generators if needed. If it stays stale, reload and check the selected SDK and analyzer diagnostics. See the IDE workflow.
Compiler reports duplicate generated type definitions Remove exported generated .g.cs files from explicit <Compile> items. The generator already adds its documents to compilation; do not compile the same emitted source twice.

The generator reports DDSG0003

Add the runtime package to the consuming project. The generator package is private build tooling; the application must reference Rti.ConnextDds itself.

An include cannot be resolved

Check whether the include is quoted or angle-bracketed. Quoted includes are resolved relative to the including file. For angle includes, add the directory to DdsIdlIncludeDirectories or the root's IncludeDirectories metadata.

A shared file is generated twice

Keep the shared file as an included input and declare only the intended root in DdsIdl. A physical IDL file should normally have one generation identity per consumer project.

A feature is rejected

Read the source-located DDSG0001 diagnostic, then check the feature coverage matrix. Rejection is intentional when the current managed compiler does not have evidence for a safe generated contract.

Learn more

RTI-generated reference material in the repository is retained under the applicable RTI license and review rules. It is not redistributed by this NuGet package.

There are no supported framework assets in this package.

Learn more about Target Frameworks and .NET Standard.

This package has no dependencies.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
1.1.0 94 11/14/2026
1.0.0 160 11/3/2026
0.5.0 188 10/26/2026
0.4.0 227 10/17/2026
0.3.0 216 10/5/2026
0.2.0 214 9/27/2026
0.1.0 133 9/25/2026