GithubStar/UA-.NETStandard
1
0
Fork 0
mirror of https://github.com/OPCFoundation/UA-.NETStandard.git synced 2026-10-29 07:07:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
ecc-testing-fixes-2
UA-.NETStandard/Tools/Opc.Ua.SourceGeneration.Core/Templating/Tokens.cs
T
Marc Schier 736b92ac7e Fix #3768: stop emitting unimplemented Optional children on singleton instances (#3828) 
# Description

Singleton instances declared in `StandardTypes.xml` and
`Opc.Ua.NodeSet2.xml` (`Server`, `Server.ServerConfiguration`,
`HistoryServerCapabilities`, `OPCUANamespaceMetadata`, the well-known
role objects, the Part 17 `Aliases` category, etc.) were emitting
Optional Variable/Method children that the SDK does not implement — for
example `ServerConfiguration.ApplicationUri`, `ProductUri`,
`ApplicationType`, `HasSecureElement`, `CancelChanges`,
`ResetToServerDefaults`, `Server.UrisVersion`,
`Server.EstimatedReturnTime`, `Server.LocalTime`,
`Server.ServerCapabilities.ConformanceUnits` and friends.

The cause was the source generator promoting every type-definition
child's modelling rule into the singleton-instance factory whenever
`UseTypeDefinitionModellingRules` was enabled (#3799), which made every
Optional child unconditionally appear in the singleton's `CreateXxx`
body.

This PR fixes the regression at the generator level (without touching
`StandardTypes.xml`) and lets the SDK opt back in to just the Optional
children it actually implements.


## New: chainable `Add{Child}` API with configure-callback overloads

Per review feedback ("the existing predefined node is used. A user adds
optional children using `.AddXY(NodeId? nodeId = default)`. The Add
calls should be possible to chain. … Instead of AddAndGet, emit an Add
overload with a callback to configure the created node state further,
add another Add to take a condition predicate that decides whether the
Create is executed or not"), the source generator now emits **five**
chainable `Add{Child}` overloads per Optional child of every typed state
class. All return the **owner** (`this`) so multi-child wiring collapses
into a single fluent chain:

```csharp
// (1) base — idempotent ensure-child
public TOwner Add{Child}(ISystemContext context, NodeId? nodeId = default);

// (2) Action — always run, mutate the just-created child in-line
public TOwner Add{Child}(ISystemContext context, Action<TChild> configure, NodeId? nodeId = default);

// (3) Action — conditional; when false: no Add, no callback
public TOwner Add{Child}(ISystemContext context, bool condition, Action<TChild> configure, NodeId? nodeId = default);

// (4) Func — always run, transform/replace the typed slot
public TOwner Add{Child}(ISystemContext context, Func<TChild, TChild> configure, NodeId? nodeId = default);

// (5) Func — conditional
public TOwner Add{Child}(ISystemContext context, bool condition, Func<TChild, TChild> configure, NodeId? nodeId = default);
```

The previous `AddAndGet{Child}(context, NodeId?)` helper is **removed**;
every call site is migrated to one of the new overloads. The Action
overloads cover the common "set Value / wire OnCallAsync" case in-line;
the Func overloads allow callers to replace the typed slot with a
wrapper or subclass instance. The boolean overloads short-circuit when
the condition is `false`.

When `nodeId` is `null`: if `context.NodeIdFactory` is non-null the
helper mints a fresh NodeId via `context.NodeIdFactory.New(context,
child)`; otherwise it leaves the type-level NodeId assigned by the
generated factory unchanged (the caller can patch later).

`NodeState.Create(context, source)` stays authoritative (the loaded
NodeSet XML / passive source is the source of truth for what children
exist). The new chainable `Add{Child}` overloads are the
runtime-extension API for SDK code and downstream users that want to add
Optional children programmatically after load.

A new `Tokens.OwnerClassName` carries the owning typed state class name
through the per-child template loop so `Add{Child}` can return `this`
typed as the owner; the template engine's outer-scope lookup cascades
the value from `AddNodeStateClassTypeReplacements` /
`AddNodeStateClassMethodTypeReplacements` into the per-child template
scope.

### SDK migration in `Libraries/Opc.Ua.Server`

- `DiagnosticsNodeManager` add-back helpers collapse into single fluent
chains; the `SetSubscriptionDurable` conditional folds into the Server
chain via the bool-condition overload
(`AddSetSubscriptionDurable(context, m_durableSubscriptionsEnabled, _ =>
{ }, MethodIds.Server_SetSubscriptionDurable)`); the `OperationLimits`
add-back inlines via
`.AddOperationLimits(...).OperationLimits!.AddMax...()`.
- `ConfigurationNodeManager` chains
`AddGetCertificates(context).AddCreateSelfSignedCertificate(context)`
before `Create(context, passiveNode)`.
- `HistoricalDataConfigurationInstaller.PopulateProperties` is now a
single fluent chain using the conditional Action overload —
`.AddMaxTimeInterval(context, capabilities.MaxTimeInterval > 0, c =>
c.Value = capabilities.MaxTimeInterval)` replaces the `if (cond) {
config.AddAndGetMaxTimeInterval(context).Value = ...; }` ceremony.
- `KeyCredentialPushSubject` folds `OnCall = null; OnCallAsync = ...`
into Action callbacks on the chain: `state.AddUpdateCredential(context,
c => { c.OnCall = null; c.OnCallAsync = OnUpdateCredentialAsync;
}).AddDeleteCredential(...)`.
- `WotConnectivityNodeManager.WireManagementMethods` chains
`.AddDiscoverAssets(ctx, c => c.OnCallAsync =
...).AddCreateAssetForEndpoint(...).AddConnectionTest(...).AddSupportedWoTBindings(...)`.
- `AssetRegistry` and `AlarmConditionTypeHolder` updated from `state.X
??= state.AddX(context)` to plain `state.AddX(context)` + null-forgiving
access on the typed slot (idempotent `Add{Child}` makes the `??=`
ceremony obsolete).

## Generator fix

`Tools/Opc.Ua.SourceGeneration.Core/Generators/NodeStateGenerator.cs`:

`NodeToGenerate` gains a structural `IsUnderSingletonInstance` flag, set
`true` on the singleton-instance root in `CollectNodesToGenerate` and
propagated to every descendant in `GetChildren`. Mirrors the existing
`RootIsTypeDefinition` propagation pattern; the gate becomes an O(1)
lookup.

```csharp
bool isSingletonInstanceContext =
    m_context.Options.UseTypeDefinitionModellingRules &&
    node.IsUnderSingletonInstance &&
    node.Parent != null &&
    instance is VariableDesign or MethodDesign;

ModellingRule effectiveRule = isSingletonInstanceContext
    ? GetEffectiveModellingRule(node, instance)
    : instance.ModellingRule;
```

The `topLevelInstanceException` is preserved for **TYPE-DEF** roots —
its `UseTypeDefinitionModellingRules` gate only fires when the parent is
an `InstanceDesign` singleton. Without this, the type-def factories
(e.g. `CreateNamespaceMetadataType`) stop emitting their Optional
children which breaks deep code paths that rely on the type-def factory
shape (e.g.
`ConfigurationNodeManager.CreateNamespaceMetadataStateAsync`).

### Why the gate is transitive but narrowed to Variables/Methods

The gate applies **transitively** to every Variable/Method descendant of
a singleton-instance subtree. Deep Optional Variable/Method descendants
such as `Server.ServerCapabilities.MaxArrayLength`,
`Server.ServerCapabilities.OperationLimits.MaxNodesPerRead`,
`Server.ServerRedundancy.RedundantServerArray`, `Server.UrisVersion`,
`Server.EstimatedReturnTime`, `Server.LocalTime`,
`PublishSubscribe.AddConnection` / `RemoveConnection`, the Optional
methods on every well-known role, the OPCUANamespaceMetadata Default*
properties, and `Aliases.LastChange` are now all suppressed by the
generator.

Optional **Object** instances under singletons are intentionally exempt:
they are still emitted by the singleton-specific factory with their
correct instance-level NodeIds. Their subtrees use well-known descendant
NodeIds (e.g.
`ServerConfiguration.CertificateGroups.DefaultHttpsGroup.TrustList.Open
= NodeId 14095`) that the SDK and `ConfigurationNodeManager` bind
against directly. Optional Variable/Method children of those Objects are
still gated transitively (e.g. `OperationLimits.MaxNodesPerRead` is
suppressed even though `OperationLimits` itself stays emitted).

### EURange regression analysis

The earlier attempt at this fix regressed `AnalogItemType.EURange`
(which is `Mandatory` on `AnalogItemType` per the OPC UA spec — a
type-level promotion of `BaseAnalogType.EURange`).
`IsUnderSingletonInstance` is `false` on type-def and synthetic
type-instance roots, so the gate cannot fire on either type-template
tree. Combined with the topLevelInstanceException preserved for type-def
roots, every type-def factory continues to emit its full child set.

## SDK programmatic Add* (Opc.Ua.Server)

`DiagnosticsNodeManager.AddSdkImplementedOptionalChildren` now
dispatches per loaded predefined node type. Each lazy-add call patches
the resulting NodeId (and Method `InputArguments` / `OutputArguments`
NodeIds where applicable) to the well-known singleton-instance value via
`ObjectIds.*` / `MethodIds.*` / `VariableIds.*`. The generator-emitted
`Add{Child}` extension uses the type-level factory which assigns the
type NodeId; the SDK overrides each NodeId after construction.

- **`Server` (ServerObjectState)**: `GetMonitoredItems`, `ResendData`,
`SetSubscriptionDurable` (when enabled), `Namespaces`, `UrisVersion`,
`EstimatedReturnTime`, `LocalTime`.
- **`Server.ServerCapabilities`** (14 Properties): `MaxArrayLength`,
`MaxStringLength`, `MaxByteStringLength`, `MaxSessions`,
`MaxSubscriptions`, `MaxMonitoredItems`, `MaxSubscriptionsPerSession`,
`MaxMonitoredItemsPerSubscription`, `MaxSelectClauseParameters`,
`MaxWhereClauseParameters`, `MaxMonitoredItemsQueueSize`,
`ConformanceUnits`, `RoleSet`, `OperationLimits`. Required to keep
`ServerInternalData.CreateServerObjectAsync`'s non-null assertions
working and to keep `Session.FetchOperationLimitsAsync` round-trip
values matching master.
- **`Server.ServerCapabilities.OperationLimits`** (12 Properties): every
`MaxNodesPerXxx` and `MaxMonitoredItemsPerCall`.
- **`Server.ServerRedundancy.RedundantServerArray`**: re-added for
`DefaultServerRedundancyHandler` (client-side) compatibility.
- **`HistoryServerCapabilities.ServerTimestampSupported`**.
- **6 modifiable well-known roles** (Observer, Operator, Engineer,
Supervisor, ConfigureAdmin, SecurityAdmin) × 11 RoleType children
(`ApplicationsExclude`, `Applications`, `EndpointsExclude`, `Endpoints`,
`CustomConfiguration`, `AddIdentity`, `RemoveIdentity`,
`AddApplication`, `RemoveApplication`, `AddEndpoint`, `RemoveEndpoint`).
The three immutable roles (Anonymous, AuthenticatedUser,
TrustedApplication) have no well-known instance NodeIds for these
methods in the spec and are left untouched.
- **`OPCUANamespaceMetadata`** (i=15957, standard Part 6 namespace
metadata loaded from `Opc.Ua.NodeSet2.xml`): `DefaultRolePermissions`,
`DefaultUserRolePermissions`, `DefaultAccessRestrictions`.
- **Part 17 `Aliases`** (i=23470): `LastChange`. Required by
`AliasNameResolverRefreshMode.AutoOnLastChangeMonitoredItem` in
`Opc.Ua.Client` which subscribes to LastChange to invalidate its cache.

`ConfigurationNodeManager` continues to assign
`CreateSelfSignedCertificate = new
CreateSelfSignedCertificateMethodState(activeNode)` before `Create(...)`
(it is no longer emitted by the singleton factory).

## Related Issues

- Fixes #3768
- Follow-up to #3799

## Verification

- **Generated code inspection**: `CreateServerConfiguration` does
**not** emit `ApplicationUri` / `ProductUri` / `ApplicationType` /
`HasSecureElement` / `CancelChanges` / `ResetToServerDefaults` at
`forInstance=true`. `CreateServer_ServerCapabilities` no longer emits
the 14 SDK-handled Optional Properties at `forInstance=true`; the SDK
re-adds them with the correct instance NodeIds.
`CreateServerConfiguration_CertificateGroups` still emits
`DefaultHttpsGroup` and `DefaultUserTokenGroup` (Object exemption)
preserving the subtree NodeIds that `ConfigurationNodeManager` binds
against. `CreateNamespaceMetadataType` (the type-def factory) emits all
Optional Properties unconditionally so
`ConfigurationNodeManager.CreateNamespaceMetadataStateAsync` keeps
working for runtime-created metadata instances.
- **Strengthened regression test**
`ServerConfiguration_OptionalUnimplementedChildren_NotInAddressSpaceAsync`:
- Negative: 8 expected-suppressed Variable/Method NodeIds
(ServerConfiguration + PublishSubscribe) are absent.
- Positive: all SDK-added children resolve at their well-known
singleton-instance NodeIds — 14 ServerCapabilities Properties + 12
OperationLimits Properties + RedundantServerArray + 3 Server Optional
Variables + the existing Server.Namespaces / GetMonitoredItems /
ResendData / HistoryServerCapabilities.ServerTimestampSupported set.
- Regression guard:
`Server_ServerConfiguration_CertificateGroups_DefaultApplicationGroup_CertificateTypes`
resolves at its well-known NodeId, and the Optional `DefaultHttpsGroup`
/ `DefaultUserTokenGroup` roots remain emitted (Object exemption).
- WellKnownRole regression guard: one method per modifiable role
resolves at its well-known NodeId (Observer.AddIdentity,
Observer.ApplicationsExclude, Observer.AddApplication,
Operator.AddEndpoint, Engineer.RemoveIdentity,
Supervisor.RemoveApplication, ConfigureAdmin.RemoveEndpoint,
SecurityAdmin.AddIdentity).
- `Opc.Ua.Server.Tests`: **1683 / 1683** pass on net10 (5 pre-existing
skips).
- `Opc.Ua.Core.Security.Tests`: **547 / 547** pass on net10 (68
pre-existing skips). Includes the RoleManagementTests,
SecurityRoleServerBase2Tests, and SecurityRoleServerDefaultPermsTests
fixtures.
- `Opc.Ua.Features.Tests`: **128 / 128** pass on net10 (22 pre-existing
skips). Includes the RoleManagementClient and
MonitoredItemAliasNameRefreshStrategySignAndEncryptTests fixtures.
- `Opc.Ua.InformationModel.Tests`: **1052 / 1052** pass on net10 (24
pre-existing skips).
- `Opc.Ua.Gds.Tests`: **875 / 875** pass on net10 (29 pre-existing
skips).
- `Opc.Ua.SourceGeneration.Core.Tests`: **3514 / 3514** pass on net10 (8
long-running compile-cycle integration tests skipped by the framework).
- No `AnalogItemType.EURange` regression.

## Checklist

- [x] I have signed the
[CLA](https://opcfoundation.org/license/cla/ContributorLicenseAgreementv1.0.pdf)
and read the
[CONTRIBUTING](https://github.com/OPCFoundation/UA-.NETStandard/blob/master/CONTRIBUTING.md)
doc.
- [x] I have added tests that prove my fix is effective or that my
feature works and increased code coverage.
- [ ] I have added all necessary documentation.
- [x] I have verified that my changes do not introduce (new) build or
analyzer warnings.
- [x] I ran **all** tests locally using the **UA.slnx** solution against
at least .net **framework** and .net **10**, and all passed.
- [ ] I fixed **all** failing and flaky tests in the CI pipelines and
**all** CodeQL warnings.
- [ ] I have addressed **all** PR feedback received.
2026-06-12 15:13:41 +02:00

238 lines
16 KiB
C#
Raw Permalink Blame History

/* ========================================================================
* Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
*
* OPC Foundation MIT License 1.00
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* The complete license agreement can be found here:
* http://opcfoundation.org/License/MIT/1.00/
* ======================================================================*/
namespace Opc.Ua.SourceGeneration
{
internal static class Tokens
{
public static string ArrayDimensions => nameof(ArrayDimensions);
public static string BaseClassName => nameof(BaseClassName);
public static string BaseInterfaces => nameof(BaseInterfaces);
public static string BaseType => nameof(BaseType);
public static string BaseTypeNamespacePrefix => nameof(BaseTypeNamespacePrefix);
public static string BaseTypeNamespaceUri => nameof(BaseTypeNamespaceUri);
public static string BinaryEncodingId => nameof(BinaryEncodingId);
public static string BrowseName => nameof(BrowseName);
public static string BrowseNameLiteral => nameof(BrowseNameLiteral);
public static string BrowseNameNamespacePrefix => nameof(BrowseNameNamespacePrefix);
public static string BrowseNameNamespaceUri => nameof(BrowseNameNamespaceUri);
public static string BrowseNameSymbol => nameof(BrowseNameSymbol);
public static string SymbolicNameSymbol => nameof(SymbolicNameSymbol);
public static string BuiltInTypes => nameof(BuiltInTypes);
public static string ChildDataType => nameof(ChildDataType);
public static string ValueWrite => nameof(ValueWrite);
public static string ValueComparison => nameof(ValueComparison);
public static string ChildName => nameof(ChildName);
public static string ChildBrowseName => nameof(ChildBrowseName);
public static string ChildBrowseNameLiteral => nameof(ChildBrowseNameLiteral);
public static string ChildPath => nameof(ChildPath);
public static string ClassName => nameof(ClassName);
public static string ClassFactory => nameof(ClassFactory);
public static string ClientApi => nameof(ClientApi);
public static string ClientMethod => nameof(ClientMethod);
public static string CodeName => nameof(CodeName);
public static string CollectionType => nameof(CollectionType);
public static string DataType => nameof(DataType);
public static string StructureType => nameof(StructureType);
public static string FirstExplicitFieldIndex => nameof(FirstExplicitFieldIndex);
public static string DataTypeNamespacePrefix => nameof(DataTypeNamespacePrefix);
public static string DataTypeNamespaceUri => nameof(DataTypeNamespaceUri);
public static string DefaultValue => nameof(DefaultValue);
public static string Description => nameof(Description);
public static string DictionaryUri => nameof(DictionaryUri);
public static string Documentation => nameof(Documentation);
public static string EmitDefaultValue => nameof(EmitDefaultValue);
public static string EncodingMaskModifier => nameof(EncodingMaskModifier);
public static string EnumerationName => nameof(EnumerationName);
public static string EventNotifier => nameof(EventNotifier);
public static string FieldIndex => nameof(FieldIndex);
public static string ExtraInterfaces => nameof(ExtraInterfaces);
public static string FieldName => nameof(FieldName);
public static string ListOfChildOperations => nameof(ListOfChildOperations);
public static string Historizing => nameof(Historizing);
public static string Identifier => nameof(Identifier);
public static string IdType => nameof(IdType);
public static string Imports => nameof(Imports);
public static string InitializeOptionalChildren => nameof(InitializeOptionalChildren);
public static string InvokeServiceAsync => nameof(InvokeServiceAsync);
public static string Purpose => nameof(Purpose);
public static string IsAbstract => nameof(IsAbstract);
public static string IsOptionSet => nameof(IsOptionSet);
public static string IsRequired => nameof(IsRequired);
public static string LengthInBits => nameof(LengthInBits);
public static string ListOfBrowseNames => nameof(ListOfBrowseNames);
public static string ListOfChildInitializers => nameof(ListOfChildInitializers);
public static string ListOfChildMethods => nameof(ListOfChildMethods);
public static string ListOfClonedFields => nameof(ListOfClonedFields);
public static string ListOfAppendStringFields => nameof(ListOfAppendStringFields);
public static string ListOfComparedFields => nameof(ListOfComparedFields);
public static string ListOfDecodedFields => nameof(ListOfDecodedFields);
public static string ListOfEncodedFields => nameof(ListOfEncodedFields);
public static string ListOfEncodingMaskFields => nameof(ListOfEncodingMaskFields);
public static string ListOfFieldInitializers => nameof(ListOfFieldInitializers);
public static string ListOfFields => nameof(ListOfFields);
public static string ListOfSwitchFieldNames => nameof(ListOfSwitchFieldNames);
public static string ListOfEncodingMaskFieldNames => nameof(ListOfEncodingMaskFieldNames);
public static string ListOfFindChildCase => nameof(ListOfFindChildCase);
public static string ListOfFindChildren => nameof(ListOfFindChildren);
public static string ListOfIdentifiers => nameof(ListOfIdentifiers);
public static string ListOfIdentifersToNames => nameof(ListOfIdentifersToNames);
public static string ListOfNamesToIdentifiers => nameof(ListOfNamesToIdentifiers);
public static string ListOfImports => nameof(ListOfImports);
public static string ListOfInputArguments => nameof(ListOfInputArguments);
public static string ListOfNamespaceUris => nameof(ListOfNamespaceUris);
public static string ListOfNodeIds => nameof(ListOfNodeIds);
public static string ListOfOutputArguments => nameof(ListOfOutputArguments);
public static string ListOfOutputArgumentsFromResult => nameof(ListOfOutputArgumentsFromResult);
public static string ListOfOutputDeclarations => nameof(ListOfOutputDeclarations);
public static string ListOfProperties => nameof(ListOfProperties);
public static string ListOfNonMandatoryChildren => nameof(ListOfNonMandatoryChildren);
public static string ListOfRemoveChild => nameof(ListOfRemoveChild);
public static string ListOfChildCopies => nameof(ListOfChildCopies);
public static string ListOfChildHashes => nameof(ListOfChildHashes);
public static string ListOfEqualityComparers => nameof(ListOfEqualityComparers);
public static string ListOfCreateOrReplaceChild => nameof(ListOfCreateOrReplaceChild);
public static string ListOfResultProperties => nameof(ListOfResultProperties);
public static string ListOfSwitchFields => nameof(ListOfSwitchFields);
public static string ListOfTypes => nameof(ListOfTypes);
public static string ListOfTypeActivators => nameof(ListOfTypeActivators);
public static string ListOfDataTypeDefinitions => nameof(ListOfDataTypeDefinitions);
public static string ListOfUpdateChildrenChangeMasks => nameof(ListOfUpdateChildrenChangeMasks);
public static string ListOfValues => nameof(ListOfValues);
public static string ListOfActivatorRegistrations => nameof(ListOfActivatorRegistrations);
public static string ListOfChildren => nameof(ListOfChildren);
public static string MethodList => nameof(MethodList);
public static string Name => nameof(Name);
public static string IsOptional => nameof(IsOptional);
public static string Namespace => nameof(Namespace);
public static string NamespacePrefix => nameof(NamespacePrefix);
public static string NamespaceUri => nameof(NamespaceUri);
public static string NodeManagerClassName => nameof(NodeManagerClassName);
public static string NodeManagerFactoryClassName => nameof(NodeManagerFactoryClassName);
public static string Nillable => nameof(Nillable);
public static string NodeClass => nameof(NodeClass);
public static string OnCallAsyncDeclaration => nameof(OnCallAsyncDeclaration);
public static string OnCallAsyncImplementation => nameof(OnCallAsyncImplementation);
public static string OnCallDeclaration => nameof(OnCallDeclaration);
public static string OnCallImplementation => nameof(OnCallImplementation);
public static string Prefix => nameof(Prefix);
public static string PropertyName => nameof(PropertyName);
public static string OwnerClassName => nameof(OwnerClassName);
public static string RequestParameters => nameof(RequestParameters);
public static string ResponseParameters => nameof(ResponseParameters);
public static string ServerApi => nameof(ServerApi);
public static string ServerStubs => nameof(ServerStubs);
public static string ServiceSet => nameof(ServiceSet);
public static string ServiceSets => nameof(ServiceSets);
public static string SymbolicId => nameof(SymbolicId);
public static string SymbolicName => nameof(SymbolicName);
public static string TypedVariableType => nameof(TypedVariableType);
public static string TypeName => nameof(TypeName);
public static string ValueRank => nameof(ValueRank);
public static string VariableTypeValue => nameof(VariableTypeValue);
public static string Version => nameof(Version);
public static string Tool => nameof(Tool);
public static string XmlEncodingId => nameof(XmlEncodingId);
public static string VariantFrom => nameof(VariantFrom);
public static string VariantTryGet => nameof(VariantTryGet);
public static string XmlIdentifier => nameof(XmlIdentifier);
public static string XmlNamespaceUri => nameof(XmlNamespaceUri);
public static string XmlnsS0ListOfNamespaces => nameof(XmlnsS0ListOfNamespaces);
public static string TypeList => nameof(TypeList);
public static string BasicType => nameof(BasicType);
public static string Flags => nameof(Flags);
public static string AddKnownType => nameof(AddKnownType);
public static string ModelUri => nameof(ModelUri);
public static string TargetPublicationDate => nameof(TargetPublicationDate);
public static string TargetVersion => nameof(TargetVersion);
public static string BaseT => nameof(BaseT);
public static string XsRestrictionBaseType => nameof(XsRestrictionBaseType);
public static string AccessorSymbol => nameof(AccessorSymbol);
public static string ServerMethodAsync => nameof(ServerMethodAsync);
public static string ClientMethodAsync => nameof(ClientMethodAsync);
public static string ClientMethodSync => nameof(ClientMethodSync);
public static string ClientMethodBegin => nameof(ClientMethodBegin);
public static string ClientMethodEnd => nameof(ClientMethodEnd);
public static string CodeHeader => nameof(CodeHeader);
public static string XmlHeader => nameof(XmlHeader);
public static string ResourceName => nameof(ResourceName);
public static string Resource => nameof(Resource);
public static string ListOfResourceGroups => nameof(ListOfResourceGroups);
public static string ListOfResourceDeclarations => nameof(ListOfResourceDeclarations);
public static string ListOfModelDependencies => nameof(ListOfModelDependencies);
public static string ModelVersion => nameof(ModelVersion);
public static string ModelPublicationDate => nameof(ModelPublicationDate);
public static string ModelName => nameof(ModelName);
public static string ModelPayload => nameof(ModelPayload);
public static string AccessModifier => nameof(AccessModifier);
public static string IdentifierReflection => nameof(IdentifierReflection);
public static string ListOfNodeStateInitializers => nameof(ListOfNodeStateInitializers);
public static string ListOfNodeStateTypeFactories => nameof(ListOfNodeStateTypeFactories);
public static string ListOfNodeStateInstanceFactories => nameof(ListOfNodeStateInstanceFactories);
public static string ListOfChildNodeStates => nameof(ListOfChildNodeStates);
public static string ListOfOptionalChildNodeStates => nameof(ListOfOptionalChildNodeStates);
public static string ListOfReferences => nameof(ListOfReferences);
public static string NodeIdConstant => nameof(NodeIdConstant);
public static string SuperTypeId => nameof(SuperTypeId);
public static string TypeDefinitionId => nameof(TypeDefinitionId);
public static string ReferenceTypeId => nameof(ReferenceTypeId);
public static string ModellingRuleId => nameof(ModellingRuleId);
public static string StateClassName => nameof(StateClassName);
public static string StateClassFactory => nameof(StateClassFactory);
public static string DisplayName => nameof(DisplayName);
public static string DataTypeDefinition => nameof(DataTypeDefinition);
public static string DescriptionValue => nameof(DescriptionValue);
public static string ValueCode => nameof(ValueCode);
public static string DataTypeIdConstant => nameof(DataTypeIdConstant);
public static string InverseNameValue => nameof(InverseNameValue);
public static string SymmetricValue => nameof(SymmetricValue);
public static string ReleaseStatusValue => nameof(ReleaseStatusValue);
public static string CategoriesValue => nameof(CategoriesValue);
public static string SpecificationValue => nameof(SpecificationValue);
public static string WriteMaskValue => nameof(WriteMaskValue);
public static string UserWriteMaskValue => nameof(UserWriteMaskValue);
public static string NumericIdValue => nameof(NumericIdValue);
public static string AccessRestrictionsValue => nameof(AccessRestrictionsValue);
public static string ListOfRolePermissions => nameof(ListOfRolePermissions);
public static string RoleIdConstant => nameof(RoleIdConstant);
public static string PermissionsValue => nameof(PermissionsValue);
public static string ContainsNoLoopsValue => nameof(ContainsNoLoopsValue);
public static string ExecutableValue => nameof(ExecutableValue);
public static string MethodDeclarationId => nameof(MethodDeclarationId);
public static string MinimumSamplingIntervalValue => nameof(MinimumSamplingIntervalValue);
public static string HistorizingValue => nameof(HistorizingValue);
public static string AccessLevelValue => nameof(AccessLevelValue);
public static string UserAccessLevelValue => nameof(UserAccessLevelValue);
public static string ListOfInitOnlyBackingFields => nameof(ListOfInitOnlyBackingFields);
public static string ListOfPooledExtensions => nameof(ListOfPooledExtensions);
public static string ListOfFieldResets => nameof(ListOfFieldResets);
}
}
Reference in New Issue View Git Blame Copy Permalink